## Docker 架构

Docker 架构是基于客户端-服务器模式的，其中包括多个关键组件，确保容器化应用的高效构建、管理和运行。

Docker 的架构设计使得开发者能够轻松地将应用程序与其所有依赖封装在一个可移植的容器中，并在不同的环境中一致地运行。

Docker 使用客户端-服务器 (C/S) 架构模式，使用远程 API 来管理和创建 Docker 容器。

Docker 容器通过 Docker 镜像来创建。

容器与镜像的关系类似于面向对象编程中的对象与类。

| Docker | 面向对象 |
| --- | --- |
| 容器 | 对象 |
| 镜像 | 类 |

### Docker 架构示意图

![](https://www.runoob.com/wp-content/uploads/2016/07/docker-architecture.webp)

### Docker 架构的工作流程

+   **构建镜像**：使用 `Dockerfile` 创建镜像。
+   **推送镜像到注册表**：将镜像上传到 Docker Hub 或私有注册表中。
+   **拉取镜像**：通过 `docker pull` 从注册表中拉取镜像。
+   **运行容器**：使用镜像创建并启动容器。
+   **管理容器**：使用 Docker 客户端命令管理正在运行的容器（例如查看日志、停止容器、查看资源使用情况等）。
+   **网络与存储**：容器之间通过 Docker 网络连接，数据通过 Docker 卷或绑定挂载进行持久化。

接下来让我们深入探讨 Docker 的核心组件及其工作机制。

### 1、**Docker 客户端（Docker Client）**

Docker 客户端是用户与 Docker 守护进程交互的命令行界面（CLI）。它是用户与 Docker 系统的主要交互方式，用户通过 Docker CLI 发出命令，这些命令被发送到 Docker 守护进程，由守护进程执行相应的操作。

+   **功能**：允许用户使用命令与 Docker 守护进程通信，如创建容器、构建镜像、查看容器状态等。
+   **交互方式**：Docker 客户端与 Docker 守护进程之间通过 REST API 或 Unix 套接字通信。常用的命令行工具是 `docker`，通过它，用户可以发出各种 Docker 操作命令。

#### 常用命令：

+   `docker run`：运行容器。
+   `docker ps`：列出正在运行的容器。
+   `docker build`：构建 Docker 镜像。
+   `docker exec`：在容器中执行命令。

### 2、**Docker 守护进程（Docker Daemon）**

Docker 守护进程（通常是 `dockerd`）是 Docker 架构的核心，负责管理容器生命周期、构建镜像、分发镜像等任务。

守护进程通常以后台进程的方式运行，等待来自 Docker 客户端的 API 请求。

**功能**：

+   启动和停止容器。
+   构建、拉取和推送镜像。
+   管理容器的网络和存储。
+   启动、停止、查看容器日志等。
+   与 Docker 注册表进行通信，管理镜像的存储与分发。

Docker 守护进程监听来自 Docker 客户端的请求，并且通过 Docker API 执行这些请求。守护进程将负责容器、镜像等 Docker 对象的管理，并根据请求的参数启动容器、删除容器、修改容器配置等。

启动 Docker 守护进程（通常是自动启动的）：

```
sudo systemctl start docker
```

### 3、**Docker 引擎 API（Docker Engine API）**

Docker 引擎 API 是 Docker 提供的 RESTful 接口，允许外部客户端与 Docker 守护进程进行通信。通过这个 API，用户可以执行各种操作，如启动容器、构建镜像、查看容器状态等。API 提供了 HTTP 请求的接口，支持跨平台调用。

**功能**：

+   向 Docker 守护进程发送 HTTP 请求，实现容器、镜像的管理。
+   提供 RESTful 接口，允许通过编程与 Docker 进行交互。

可以通过 `curl` 或其他 HTTP 客户端访问 Docker 引擎 API。例如，查询当前 Docker 守护进程的版本：

```
curl --unix-socket /var/run/docker.sock http://localhost/version
```

### 4、**Docker 容器（Docker Containers）**

容器是 Docker 的执行环境，它是轻量级、独立且可执行的软件包。容器是从 Docker 镜像启动的，包含了运行某个应用程序所需的一切——从操作系统库到应用程序代码。容器在运行时与其他容器和宿主机共享操作系统内核，但容器之间的文件系统和进程是隔离的。

**功能**：

+   提供独立的运行环境，确保应用程序在不同的环境中具有一致的行为。
+   容器是临时的，通常在任务完成后被销毁。

容器的生命周期是由 Docker 守护进程管理的。容器可以在任何地方运行，因为它们不依赖于底层操作系统的配置，所有的运行时依赖已经封装在镜像中。

启动一个容器：

```
docker run -d ubuntu
```

### 5、**Docker 镜像（Docker Images）**

Docker 镜像是容器的只读模板。每个镜像都包含了应用程序运行所需的操作系统、运行时、库、环境变量和应用代码等。镜像是静态的，用户可以根据镜像启动容器。

**功能**：

+   镜像是构建容器的基础，每个容器实例化时都会使用镜像。
+   镜像是只读的，不同容器使用同一个镜像时，容器中的文件系统层是独立的。

Docker 镜像可以通过 `docker pull` 从 Docker Hub 或私有注册表拉取，也可以通过 `docker build` 从 Dockerfile 构建。

拉取 Ubuntu 镜像：

```
docker pull ubuntu
```

### 6\. **Docker 仓库（Docker Registries）**

Docker 仓库是用来存储 Docker 镜像的地方，最常用的公共仓库是 **Docker Hub**。用户可以从 Docker Hub 下载镜像，也可以上传自己的镜像分享给其他人。除了公共仓库，用户也可以部署自己的私有 Docker 仓库来管理企业内部的镜像。

**功能**：

+   存储 Docker 镜像。
+   提供镜像的上传和下载功能。

Docker Hub 提供了大量官方和社区维护的镜像，如 Ubuntu、Nginx、MySQL 等。

推送镜像到 Docker Hub：

```
docker push <username>/<image_name>
```

### 7、**Docker Compose**

Docker Compose 是一个用于定义和运行多容器 Docker 应用的工具。通过 Compose，用户可以使用一个 `docker-compose.yml` 配置文件定义多个容器（服务），并可以通过一个命令启动这些容器。Docker Compose 主要用于开发、测试和部署多容器的应用。

**功能**：

+   定义和运行多个容器组成的应用。
+   通过 YAML 文件来配置应用的服务、网络和卷等。

创建一个简单的 `docker-compose.yml` 文件来配置一个包含 Web 服务和数据库服务的应用：

```
version: '3'
services:
  web:
    image: nginx
    ports:
      - "8080:80"
  db:
    image: mysql
    environment:
      MYSQL_ROOT_PASSWORD: example
```

启动 Compose 定义的所有服务：

```
docker-compose up
```

### 8、**Docker Swarm**

Docker Swarm 是 Docker 提供的集群管理和调度工具。它允许将多个 Docker 主机（节点）组织成一个集群，并通过 Swarm 集群管理工具来调度和管理容器。Swarm 可以实现容器的负载均衡、高可用性和自动扩展等功能。

**功能**：

+   管理多节点 Docker 集群。
+   通过调度器管理容器的部署和扩展。

初始化 Swarm 集群：

```
docker swarm init
```

### 9、**Docker 网络（Docker Networks）**

Docker 网络允许容器之间相互通信，并与外部世界进行连接。Docker 提供了多种网络模式来满足不同的需求，如 `bridge` 网络（默认）、`host` 网络和 `overlay` 网络等。

**功能**：

+   管理容器间的网络通信。
+   支持不同的网络模式，以适应不同场景下的需求。

创建一个自定义网络并将容器连接到该网络：

```
docker network create my_network
docker run -d --network my_network ubuntu
```

### 10\. **Docker 卷（Docker Volumes）**

Docker 卷是一种数据持久化机制，允许数据在容器之间共享，并且独立于容器的生命周期。与容器文件系统不同，卷的内容不会随着容器的销毁而丢失，适用于数据库等需要持久存储的应用。

**功能**：

+   允许容器间共享数据。
+   保证数据持久化，独立于容器的生命周期。

创建并挂载卷：

```
docker volume create my_volume
docker run -d -v my_volume:/data ubuntu
```

Docker 架构

## Docker 教程




![](https://www.runoob.com/wp-content/uploads/2016/04/docker01.png)

Docker 是一个开源的应用容器引擎，基于 [Go 语言]并遵从 Apache2.0 协议开源。

Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。

Docker 从 17.03 版本之后分为 CE（Community Edition: 社区版） 和 EE（Enterprise Edition: 企业版），我们用社区版就可以了。

* * *

## 谁适合阅读本教程？

本教程适合运维工程师及后端开发人员，通过本教程你可以一步一步了解 Docker 的使用。

* * *

## 阅读本教程前，您需要了解的知识

在阅读本教程前，你需要掌握 Linux 的常用命令。你可以通过本站的 [Linux 教程]来学习相关命令。

* * *

## Docker的应用场景

+   Web 应用的自动化打包和发布。
    
+   自动化测试和持续集成、发布。
    
+   在服务型环境中部署和调整数据库或其他的后台应用。
    
+   从头编译或者扩展现有的 OpenShift 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。
    

* * *

## Docker 的优点

Docker 是一个用于开发，交付和运行应用程序的开放平台。Docker 使您能够将应用程序与基础架构分开，从而可以快速交付软件。借助 Docker，您可以与管理应用程序相同的方式来管理基础架构。通过利用 Docker 的方法来快速交付，测试和部署代码，您可以大大减少编写代码和在生产环境中运行代码之间的延迟。

### 1、快速，一致地交付您的应用程序

Docker 允许开发人员使用您提供的应用程序或服务的本地容器在标准化环境中工作，从而简化了开发的生命周期。

容器非常适合持续集成和持续交付（CI / CD）工作流程，请考虑以下示例方案：

+   您的开发人员在本地编写代码，并使用 Docker 容器与同事共享他们的工作。
+   他们使用 Docker 将其应用程序推送到测试环境中，并执行自动或手动测试。
+   当开发人员发现错误时，他们可以在开发环境中对其进行修复，然后将其重新部署到测试环境中，以进行测试和验证。
+   测试完成后，将修补程序推送给生产环境，就像将更新的镜像推送到生产环境一样简单。

### 2、响应式部署和扩展

Docker 是基于容器的平台，允许高度可移植的工作负载。Docker 容器可以在开发人员的本机上，数据中心的物理或虚拟机上，云服务上或混合环境中运行。

Docker 的可移植性和轻量级的特性，还可以使您轻松地完成动态管理的工作负担，并根据业务需求指示，实时扩展或拆除应用程序和服务。

### 3、在同一硬件上运行更多工作负载

Docker 轻巧快速。它为基于虚拟机管理程序的虚拟机提供了可行、经济、高效的替代方案，因此您可以利用更多的计算能力来实现业务目标。Docker 非常适合于高密度环境以及中小型部署，而您可以用更少的资源做更多的事情。

* * *

## 相关链接

Docker 官网：[https://www.docker.com](https://www.docker.com/)

Github Docker 源码：[https://github.com/docker/docker-ce](https://github.com/docker/docker-ce)

Docker 教程

Linux 常用命令集合

## 文本处理

目录

+   文本处理
    +   [find] 文件查找
        +   定制搜索
        +   找到后的后续动作
        +   \-print的定界符
    +   [grep] 文本搜索
    +   xargs 命令行参数转换
    +   sort 排序
    +   uniq 消除重复行
    +   用tr进行转换
    +   cut 按列切分文本
    +   paste 按列拼接文本
    +   wc 统计行和字符的工具
    +   sed 文本替换利器
    +   [awk]数据流处理工具
        +   print 打印当前行
        +   特殊变量： NR NF $0 $1 $2
        +   传递外部变量
        +   用样式对awk处理的行进行过滤
        +   设置定界符
        +   读取命令输出
        +   在awk中使用循环
        +   awk结合grep找到指定的服务，然后将其kill掉
        +   awk实现head、tail命令
        +   打印指定列
        +   打印指定文本区域
        +   awk常用内建函数
    +   迭代文件中的行、单词和字符
        +   1\. 迭代文件中的每一行
        +   2.迭代一行中的每一个单词
        +   3\. 迭代每一个字符

本节将介绍Linux下使用[shell]处理文本时最常用的工具： find、grep、xargs、sort、uniq、tr、cut、paste、wc、sed、awk； 提供的例子和参数都是常用的； 我对shell脚本使用的原则是命令单行书写，尽量不要超过2行； 如果有更为复杂的任务需求，还是考虑python吧；

## 3.1. find 文件查找

查找txt和pdf文件:

```
find . $ -name "*.txt" -o -name "*.pdf" $ -print
```

正则方式查找.txt和pdf:

```
find . -regex  ".*$\.txt|\.pdf$$"
```

\-iregex： 忽略大小写的正则

否定参数 ,查找所有非txt文本:

```
find . ! -name "*.txt" -print
```

指定搜索深度,打印出当前目录的文件（深度为1）:

```
find . -maxdepth 1 -type f
```

### 定制搜索

+   按类型搜索

```
find . -type d -print  //只列出所有目录
```

\-type f 文件 / l 符号链接 / d 目录

find支持的文件检索类型可以区分普通文件和符号链接、目录等，但是[二进制]文件和文本文件无法直接通过find的类型区分出来；

file命令可以检查文件具体类型（二进制或文本）:

```
$file redis-cli  # 二进制文件
redis-cli: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.9, not stripped
$file redis.pid  # 文本文件
redis.pid: ASCII text
```

所以,可以用以下命令组合来实现查找本地目录下的所有二进制文件:

```
ls -lrt | awk '{print $9}'|xargs file|grep  ELF| awk '{print $1}'|tr -d ':'
```

+   按时间搜索
    
    +   \-atime 访问时间 (单位是天，分钟单位则是-amin，以下类似）
    +   \-mtime 修改时间 （内容被修改）
    +   \-ctime 变化时间 （元数据或权限变化）
    

最近第7天被访问过的所有文件:

```
find . -atime 7 -type f -print
```

最近7天内被访问过的所有文件:

```
find . -atime -7 -type f -print
```

查询7天前被访问过的所有文件:

```
find . -atime +7 type f -print
```

+   按大小搜索：

w字 k M G 寻找大于2k的文件:

```
find . -type f -size +2k
```

按权限查找:

```
find . -type f -perm 644 -print //找具有可执行权限的所有文件
```

按用户查找:

```
find . -type f -user weber -print// 找用户weber所拥有的文件
```

### 找到后的后续动作

+   删除

删除当前目录下所有的swp文件:

```
find . -type f -name "*.swp" -delete
```

另一种语法:

```
find . type f -name "*.swp" | xargs rm
```

+   执行动作（强大的exec）

将当前目录下的所有权变更为weber:

```
find . -type f -user root -exec chown weber {} \;
```

注：{}是一个特殊的字符串，对于每一个匹配的文件，{}会被替换成相应的文件名；

将找到的文件全都copy到另一个目录:

```
find . -type f -mtime +10 -name "*.txt" -exec cp {} OLD \;
```

+   结合多个命令

如果需要后续执行多个命令，可以将多个命令写成一个脚本。然后 -exec 调用时执行脚本即可:

```
-exec ./commands.sh {} \;
```

### \-print的定界符

默认使用’\\n’作为文件的定界符；

\-print0 使用’\\0’作为文件的定界符，这样就可以搜索包含空格的文件；

## 3.2. grep 文本搜索

```
grep match_patten file // 默认访问匹配行
```

常用参数

+   \-o 只输出匹配的文本行 **VS** -v 只输出没有匹配的文本行
+   \-c 统计文件中包含文本的次数
    
    grep -c “text” filename
    
+   \-n 打印匹配的行号
+   \-i 搜索时忽略大小写
+   \-l 只打印文件名

在多级目录中对文本递归搜索(程序员搜代码的最爱）:

```
grep "class" . -R -n
```

匹配多个模式:

```
grep -e "class" -e "vitural" file
```

grep输出以0作为结尾符的文件名（-z）:

```
grep "test" file* -lZ| xargs -0 rm
```

综合应用：将日志中的所有带where条件的sql查找查找出来:

```
cat LOG.* | tr a-z A-Z | grep "FROM " | grep "WHERE" > b
```

查找中文示例：工程目录中utf-8格式和gb2312格式两种文件，要查找字的是中文；

1.  查找到它的utf-8编码和gb2312编码分别是E4B8ADE69687和D6D0CEC4
    
2.  查询:
    
    ```
    grep：grep -rnP "\xE4\xB8\xAD\xE6\x96\x87|\xD6\xD0\xCE\xC4" *即可
    ```
    


## 3.3. xargs 命令行参数转换

xargs 能够将输入数据转化为特定命令的命令行参数；这样，可以配合很多命令来组合使用。比如grep，比如find； – 将多行输出转化为单行输出

```
cat file.txt| xargs
```

n 是多行文本间的定界符

+   将单行转化为多行输出

```
cat single.txt | xargs -n 3
```

\-n：指定每行显示的字段数

xargs参数说明

+   \-d 定义定界符 （默认为空格 多行的定界符为 n）
+   \-n 指定输出为多行
+   \-I {} 指定替换字符串，这个字符串在xargs扩展时会被替换掉,用于待执行的命令需要多个参数时
+   \-0：指定0为输入定界符

示例:

```
cat file.txt | xargs -I {} ./command.sh -p {} -1

#统计程序行数
find source_dir/ -type f -name "*.cpp" -print0 |xargs -0 wc -l

#redis通过string存储数据，通过set存储索引，需要通过索引来查询出所有的值：
./redis-cli smembers $1  | awk '{print $1}'|xargs -I {} ./redis-cli get {}
```

## 3.4. sort 排序

字段说明

+   \-n 按数字进行排序 VS -d 按字典序进行排序
+   \-r 逆序排序
+   \-k N 指定按第N列排序

示例:

```
sort -nrk 1 data.txt
sort -bd data // 忽略像空格之类的前导空白字符
```

## 3.5. uniq 消除重复行

+   消除重复行

```
sort unsort.txt | uniq
```

+   统计各行在文件中出现的次数

```
sort unsort.txt | uniq -c
```

+   找出重复行

```
sort unsort.txt | uniq -d
```

可指定每行中需要比较的重复内容：-s 开始位置 -w 比较字符数

## 3.6. 用tr进行转换

+   通用用法

```
echo 12345 | tr '0-9' '9876543210' //加解密转换，替换对应字符
cat text| tr '\t' ' '  //制表符转空格
```

+   tr删除字符

```
cat file | tr -d '0-9' // 删除所有数字
```

\-c 求补集

```
cat file | tr -c '0-9' //获取文件中所有数字
cat file | tr -d -c '0-9 \n'  //删除非数字数据
```

+   tr压缩字符

tr -s 压缩文本中出现的重复字符；最常用于压缩多余的空格:

```
cat file | tr -s ' '
```

+   字符类

tr中可用各种字符类：

+   alnum：字母和数字
+   alpha：字母
+   digit：数字
+   space：空白字符
+   lower：小写
+   upper：大写
+   cntrl：控制（非可打印）字符
+   print：可打印字符

使用方法：tr \[:class:\] \[:class:\]

```
tr '[:lower:]' '[:upper:]'
```

## 3.7. cut 按列切分文本

+   截取文件的第2列和第4列

```
cut -f2,4 filename
```

+   去文件除第3列的所有列

```
cut -f3 --complement filename
```

+   \-d 指定定界符

```
cat -f2 -d";" filename
```

+   cut 取的范围
    
    +   N- 第N个字段到结尾
    +   \-M 第1个字段为M
    +   N-M N到M个字段
    
+   cut 取的单位
    
    +   \-b 以字节为单位
    +   \-c 以字符为单位
    +   \-f 以字段为单位（使用定界符）
    

示例:

```
cut -c1-5 file //打印第一到5个字符
cut -c-2 file  //打印前2个字符
```

截取文本的第5到第7列

```
$echo string | cut -c5-7
```

## 3.8. paste 按列拼接文本

将两个文本按列拼接到一起;

```
cat file1
1
2

cat file2
colin
book

paste file1 file2
1 colin
2 book
```

默认的定界符是制表符，可以用-d指明定界符:

```
paste file1 file2 -d ","
1,colin
2,book
```

## 3.9. wc 统计行和字符的工具

```
$wc -l file // 统计行数

$wc -w file // 统计单词数

$wc -c file // 统计字符数
```

## 3.10. sed 文本替换利器

+   首处替换

```
sed 's/text/replace_text/' file   //替换每一行的第一处匹配的text
```

+   全局替换

```
sed 's/text/replace_text/g' file
```

默认替换后，输出替换后的内容，如果需要直接替换原文件,使用-i:

```
sed -i 's/text/repalce_text/g' file
```

+   移除空白行

```
sed '/^$/d' file
```

+   变量转换

已匹配的字符串通过标记&来引用.

```
echo this is en example | sed 's/\w+/[&]/g'
$>[this]  [is] [en] [example]
```

+   子串匹配标记

第一个匹配的括号内容使用标记 1 来引用

```
sed 's/hello$[0-9]$/\1/'
```

+   双引号求值

sed通常用单引号来引用；也可使用双引号，使用双引号后，双引号会对表达式求值:

```
sed 's/$var/HLLOE/'
```

当使用双引号时，我们可以在sed样式和替换字符串中指定变量；

```
eg:
p=patten
r=replaced
echo "line con a patten" | sed "s/$p/$r/g"
$>line con a replaced
```

+   其它示例

字符串插入字符：将文本中每行内容（ABCDEF） 转换为 ABC/DEF:

```
sed 's/^.\{3\}/&\//g' file
```

## 3.11. awk 数据流处理工具

+   awk脚本结构

```
awk ' BEGIN{ statements } statements2 END{ statements } '
```

+   工作方式

1.执行begin中语句块；

2.从文件或stdin中读入一行，然后执行statements2，重复这个过程，直到文件全部被读取完毕；

3.执行end语句块；

### print 打印当前行

+   使用不带参数的print时，会打印当前行

```
echo -e "line1\nline2" | awk 'BEGIN{print "start"} {print } END{ print "End" }'
```

+   print 以逗号分割时，参数以空格定界;

```
echo | awk ' {var1 = "v1" ; var2 = "V2"; var3="v3"; \
print var1, var2 , var3; }'
$>v1 V2 v3
```

+   使用-拼接符的方式（”“作为拼接符）;

```
echo | awk ' {var1 = "v1" ; var2 = "V2"; var3="v3"; \
print var1"-"var2"-"var3; }'
$>v1-V2-v3
```

### 特殊变量： NR NF $0 $1 $2

NR:表示记录数量，在执行过程中对应当前行号；

NF:表示字段数量，在执行过程总对应当前行的字段数；

$0:这个变量包含执行过程中当前行的文本内容；

$1:第一个字段的文本内容；

$2:第二个字段的文本内容；

```
echo -e "line1 f2 f3\n line2 \n line 3" | awk '{print NR":"$0"-"$1"-"$2}'
```

+   打印每一行的第二和第三个字段

```
awk '{print $2, $3}' file
```

+   统计文件的行数

```
awk ' END {print NR}' file
```

+   累加每一行的第一个字段

```
echo -e "1\n 2\n 3\n 4\n" | awk 'BEGIN{num = 0 ;
print "begin";} {sum += $1;} END {print "=="; print sum }'
```

### 传递外部变量

```
var=1000
echo | awk '{print vara}' vara=$var #  输入来自stdin
awk '{print vara}' vara=$var file # 输入来自文件
```

### 用样式对awk处理的行进行过滤

```
awk 'NR < 5' #行号小于5
awk 'NR==1,NR==4 {print}' file #行号等于1和4的打印出来
awk '/linux/' #包含linux文本的行（可以用正则表达式来指定，超级强大）
awk '!/linux/' #不包含linux文本的行
```

### 设置定界符

使用-F来设置定界符（默认为空格）:

```
awk -F: '{print $NF}' /etc/passwd
```

### 读取命令输出

使用getline，将外部shell命令的输出读入到变量cmdout中:

```
echo | awk '{"grep root /etc/passwd" | getline cmdout; print cmdout }'
```

### 在awk中使用循环

<

pre>for(i=0;i<10;i++){print $i;}  
for(i in array){print array\[i\];}

eg:以下字符串，打印出其中的时间串:

```
2015_04_02 20:20:08: mysqli connect failed, please check connect info
$echo '2015_04_02 20:20:08: mysqli connect failed, please check connect info'|awk -F ":" '{ for(i=1;i<=;i++) printf("%s:",$i)}'
>2015_04_02 20:20:08:  # 这种方式会将最后一个冒号打印出来
$echo '2015_04_02 20:20:08: mysqli connect failed, please check connect info'|awk -F':' '{print $1 ":" $2 ":" $3; }'
>2015_04_02 20:20:08   # 这种方式满足需求
```

而如果需要将后面的部分也打印出来(时间部分和后文分开打印):

```
$echo '2015_04_02 20:20:08: mysqli connect failed, please check connect info'|awk -F':' '{print $1 ":" $2 ":" $3; print $4;}'
>2015_04_02 20:20:08
>mysqli connect failed, please check connect info
```

以逆序的形式打印行：(tac命令的实现）:

```
seq 9| \
awk '{lifo[NR] = $0; lno=NR} \
END{ for(;lno>-1;lno--){print lifo[lno];}
} '
```

### awk结合grep找到指定的服务，然后将其kill掉

```
ps -fe| grep msv8 | grep -v MFORWARD | awk '{print $2}' | xargs kill -9;
```

### awk实现head、tail命令

+   head

```
awk 'NR<=10{print}' filename
```

+   tail

<

pre>awk '{buffer\[NR%10\] = $0;} END{for(i=0;i<11;i++){ \\  
print buffer\[i %10\]} } ' filename

### 打印指定列

+   awk方式实现

```
ls -lrt | awk '{print $6}'
```

+   cut方式实现

```
ls -lrt | cut -f6
```

### 打印指定文本区域

+   确定行号

```
seq 100| awk 'NR==4,NR==6{print}'
```

+   确定文本

打印处于start\_pattern 和end\_pattern之间的文本:

```
awk '/start_pattern/, /end_pattern/' filename
```

示例:

```
seq 100 | awk '/13/,/15/'
cat /etc/passwd| awk '/mai.mail/,/news.news/'
```

### awk常用内建函数

index(string,search\_string):返回search\_string在string中出现的位置

sub(regex,replacement\_str,string):将正则匹配到的第一处内容替换为replacement\_str;

match(regex,string):检查正则表达式是否能够匹配字符串；

length(string)：返回字符串长度

```
echo | awk '{"grep root /etc/passwd" | getline cmdout; print length(cmdout) }'
```

printf 类似c语言中的printf，对输出进行格式化:

```
seq 10 | awk '{printf "->%4s\n", $1}'
```

## 3.12. 迭代文件中的行、单词和字符

### 1\. 迭代文件中的每一行

+   while 循环法

```
while read line;
do
echo $line;
done < file.txt

改成子shell:
cat file.txt | (while read line;do echo $line;done)
```

+   awk法

```
<pre>cat file.txt| awk '{print}'
```

### 2.迭代一行中的每一个单词

```
for word in $line;
do
echo $word;
done
```

### 3\. 迭代每一个字符

${string:start\_pos:num\_of\_chars}：从字符串中提取一个字符；(bash文本切片）

${#word}:返回变量word的长度

```
for((i=0;i<${#word};i++))
do
echo ${word:i:1);
done
```

以ASCII字符显示文件:

```
$od -c filename
```

Linux 文本处理

##### 系统符号

+   基础符号
    
    +   `$`
        
        +   取出变量中的内容
            
        +   取出指定列的信息（[awk]）
            
            ```
            awk '{print $3}' /old.txt
            取出第三列的信息 
            ```
            
        +   表示用户命令提示符号
            
        +   表示一行的结尾
            
    +   `!`
        
        +   表示取反或者排除
        +   命令行中表示取出最近命令
        +   用于表示强制操作处理
            +   vim底行模式强制保存退出：`!wq`
    +   `|`
        
        +   前一个命令执行结果交给后面命令处理
        +   xargs配合使用：将信息进行分组显示
+   引号符号系列
    
    +   `''`：sed和awk要使用单引号
        
        +   所见即所得
    +   `""`
        
        +   对特殊信息会做解析
    +   “或$()：
        
        +   先执行里面的内容然后交给前面的命令，并且执行的结果如果是多行交给前面的命令变成了一行
    +   没有引号：
        
        +   和双引号功能类似
        +   但是可以直接识别通配符信息
        
        ```
        echo {00..5}.txt
        输出5个txt
        
        echo "{00..5}.txt"
        输出原样
        ```
        
+   定向符号系列
    
    +   `>`：标准输出重定向符号
        
        +   `2>`：错误输出重定向符号（只输出错误的）
    +   `>>`：标准输出追加重定向符号
        
        +   `2>>`：错误输出追加重定向符号
    +   `<`：标准输入重定向符号
        
        ```
        tr < xargs <
        ```
        
        +   `<<`：标准输入追加重定向符号
            
            ```
            cat >> /old.txt <<EOF
            xxx
            xxx
            EOF
            ```
            
        +   如何将正确和错误的信息都可以放进去(都是追加)
            
            ```
            echo old >> /var/1.log 2>> /var/1.log
            
            或
            echo old &>> /var/1.log
            
            或
            echo old >> /var/1.log 2>&1
            ```
            
+   路径信息系列
    
    +   `../`：上一级目录
    +   `./`：当前路径
    +   `~`：返回到家目录
    +   `-`：两个目录之间进行快速切换
+   逻辑符号
    
    +   `&&`：与逻辑符号，前一个命令执行成功了才执行后面的命令
        
    +   `||`：
        
        +   如果前面命令执行失败就执行后面的命令。
        +   如果前面命令执行成功就不执行后面的命令
    +   `;`：不管前面执行是否成功都执行后面的命令（所有命令都执行）
        
    +   `&&\`：可以将要执行的命令重新一行开始写
        

##### 通配符号：根据文件名称进行匹配

+   `*`：模糊匹配所有内容
    
    +   在[grep]命令里使用的是正则符号：匹配前一个字符出现了0次或多次
+   `{}`：
    
    +   生成序列信息（生成一行序列）
        
        ```
        echo {1..10}
        echo {01..10}
        echo {a..z}
        ```
        
    +   生成连续序列
        
        ```
        echo {1..10..2}
        1 3 5 7 9
        ```
        
    +   生成不连续序列
        
        ```
        echo {www,bbs,ccc}
        www bbs ccc
        ```
        
    +   生成组合序列
        
        ```
        echo {a..c}{01..03}
        a01 a02 a03 b01 b02 b03 c01 c02 c03
        
        echo A{01..03}
        A01 A02 A03
        ```
        
    +   快速备份文件数据
        
        ```
        echo old.txt{,.bak}
        old.txt old.txt.bak
        
        cp old.txt{,.bak}等价于cp old.txt old.txt.bak
        ```
        
    +   快速还原
        
        ```
        mv /old/1.txt{.bak,}等价于mv /old/1.txt.bak /old/1.txt
        ```
        

##### 正则符号：进行内容进行匹配

+   用处
    
    +   利用正则符号匹配文件内容信息
        
    +   正则符号经常出现在各种开发与研制
        
    +   正则符号经常被三剑客命令使用
        
+   分类
    
    +   基础正则符号：base
    +   扩展正则符号：extended

##### 基础符号

+   `^`：匹配以什么开头的
    
    ```
    匹配当前路径下的目录
    ll | grep "^d"
    ```
    
+   `$`：以什么结尾的信息
    
    ```
    匹配以/结尾的
    ll -F | grep "/$"
    
    -F 目录后面有一个/
    ```
    
+   不匹配空行
    
    ```
    grep -v "^$"
    ^$：匹配空行
    -v：取反
    ```
    
+   `.`：匹配任意一个字符且只有一个字符
    
    ```
    grep -o '.' 1.txt
    
    -o：显示匹配过程
    发现每次匹配的都是一个字符一个字符匹配且如果行为空的话不匹配。会对文件所有内容都进行匹配
    ```
    
+   `*`：匹配前一个字符出现了0次或多次
    
    ```
    grep -o '01*' 1.txt
    
    会对文件所有内容都进行匹配
    先匹配1 然后匹配1
    ```
    
+   `.*`：匹配任意所有信息
    
    ```
    #这匹配的是以mm开头mm结尾中间没内容的行。就是一行的内容为mm
    grep "^mm$" 1.txt
    
    #这匹配的是以mm开头，mm结尾但中间有内容
    grep "^mm.*mm$" 1.txt
    ```
    
+   贪婪匹配问题：指定具体的匹配信息
    
+   转义符号：`\`
    
    ```
    grep "\.$" 1.txt
    
    匹配以.结尾的行
    ```
    
    +   将有特殊意义的符号，转义成普通信息进行识别
        
    +   将没有意义的信息转为有特殊意义的信息
        
        ```
        \n：换行符号
        \t：制表符号
        ```
        
+   括号符号：`[]`：匹配多个信息。**括号里面的的每个字符都是独立的**
    
    ```
    grep "oldb[oe]y" 1.txt
    匹配oldboy和oldbey的信息。
    
    grep "^[a-Z]" 1.txt
    ```
    
    +   括号中的排除：`^`
        
        ```
        grep "^[^a-Z]" 1.txt
        
        匹配不以a-Z开头的行，不包含空行
        ```
        

##### 扩展符号：默认grep、sed不能直接识别。grep需要加-E，sed需要加-r

+   `+`：匹配前一个字符一次或多次
    
    ```
    grep -E "0+" 1.txt
    ```
    
+   `|`：并且符号，用于匹配多个信息
    
    ```
    grep -E "oldboy|blog" 1.txt
    匹配oldboy或blog信息的数据
    ```
    
+   `()`： 指定信息进行整体匹配；进行后项引用前项使用
    
    +   批量创建用户
        
        ```
        echo oldboy{01..10} | xargs -n1 | sed -r 's#(.*)#useradd \1#g' | bash
        
        ehco oldboy{01..10}:一行输出oldboy01到oldboy10
        |xargs -1：将每一块变成一列一列
        |sed -r 's#(.*)#useradd \1#g':
        -r：识别高级正则符号
        s：substitute替换
        #要修改的内容#修改后的内容#：修改规则
        (.*)：一行的所有内容作为一个整体，也就是前项
        useradd \1：
        useradd：创建用户命令
        \1：调用前项，也就是(.*)匹配的内容
        |bash：执行命令 useradd .*
        ```
        
    +   批量创建并且修改密码
        
        ```
        seq -w 10 | sed -r 's#(.*)#useradd oldboy\1#g';echo 123456 | passwd --stdin oldboy\1 | bash
        
        seq -w 10:
        01
        02
        ...
        10
        
        |sed -r 's#(.*)#useradd oldboy\1#g':
        useradd oldboy01
        useradd oldboy02
        ...
        useradd oldboy10
        
        #要修改的内容#修改后的内容#：修改规则
        (.*)：一行的所有内容作为一个整体，也就是前项
        useradd \1：
        useradd：创建用户命令
        \1：调用前项，也就是(.*)匹配的内容
        ;:不管前面命令是否执行成功都执行后面的命令
        echo 123456 | pwsswd --stdin oldboy01:免交互设置密码
        |bash：执行命令 useradd .*
        ```
        
+   `{}`：指定字符连续匹配的次数
    
    ```
    x{n,m}：x字符至少出现n次，最多匹配m次
    grep -E "0{2,3}" 1.txt
    如果有连续的3个0，就会只匹配三个0
    如果有连续的5个0，就会先匹配3个在匹配2个。五个都会匹配出来
    
    x{n,}：最少匹配n次，最多不限制
    
    x{n}：指定匹配n次
    ```
    
+   `?`：匹配前一个字符出现0次或1次
    
    ```
    ifconfig | grep "([0-9]+\.?){4}" -0
    [0-9]出现了多次 .出现0次或一次。 这个整体匹配4次
    ```

Docker 架构

Docker 教程

系统信息

文本处理

系统符号