张博奇

Docker及DockerSwarm讲解

Docker

Docker的特点

更快的交付和部署
更高效的虚拟化
更轻松的迁移和扩展
更简单的管理

Docker和虚拟机的区别

虚拟机是运行在每个应用层级的客户端操作系统上的，对操作系统依赖性强
Docker容器是基于进程的隔离，多个容器可以共享单个内核，并且创建Docker容器的镜像所需要的配置不依赖于宿主机系统，真是因为这种隔离性，使Docker的应用可以运行在任何地方

Docker的安装

配置阿里云yum源

配置阿里云Docker Yum源
# Set up repository
sudo yum install -y yum-utils device-mapper-persistent-data lvm2

# Use Aliyun Docker
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

查看Docker版本：

yum list docker-ce --showduplicates

安装yumutils库

$ yum install -y yum-utils

安装docker

$ yum install docker-ce-19.03.12 docker-ce-cli-19.03.12 containerd.io
#启动docker
$ systemctl start docker

Docker compose安装

#下载docker-compose并写入到/usr/local/bin/docker-compose
$ curl -L "https://github.com/docker/compose/releases/download/1.27.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
#这里可能下载会很慢，可直接到ftp下载：ftp://[email protected]/home/share/开发环境/软件/docker-compose
#赋予可执行权限
$ chmod +x /usr/local/bin/docker-compose

Docker运行机制

docker engine是docker的核心部分，使用的是C/S架构模式，包含三大核心组件：

docker cli

docker命令行接口，可以在命令行中使用docker相关命令与docker守护进程交互，从而管理如images，container, network, data volumes等实体
rest api

应用程序api接口，开发者可以使用该api接口与docker守护进程交互，从而指示后台进行相关操作
docker daemon

Docker的服务端组件，他是docker架构中运行在后台的一个守护进程，可以接收并处理来自命令行接口及api接口的命令，然后进行相应的后台操作

Docker架构

docker架构主要包括Client，Docker Host, Registry三个部分

Client

即Docker客户端，也就是上面提到的docker cli，开发者使用这个客户端相关指令与docker守护进程进行交互，从而进行docker镜像的创建，拉去和运行
Docker Host (docker主机)

即docker内部引擎运行的主机，主要值docker daemon，可以通过docker守护进程与客户端还有docker的镜像仓库Registry进行交互，从而管理images,container等
Registry(仓库)

docker的镜像仓库，默认使用docker hub官方仓库，也可以使用开发者本地的私有仓库
Images(镜像)

docker镜像是一个只读的模版，包含了创建docker容器的操作指令，通常情况下一个docker镜像是基于另一个基础镜像构建的，并且新创建的镜像会额外包含一些功能配置

例如：开发者可以依赖一个centos的基础镜像创建一个新镜像，并可以在新镜像中安装python，java等软件
Container(容器)

Docker容器属于镜像的一个可运行实例，类似java中的类和对象的关系，可以使用cli 命令行进行容器的创建，运行，停止，移动，删除等，也可以将一个容器连接到一个或者多个网络中，将数据存储与容器进行关联

Dockerfile

创建一个docker镜像一般从Dockerfile开始。Dockerfile包含了我们创建镜像的指令，如一个基本的dockerfile文件：

#基础镜像
FROM python:3
# 设置工作目录
WORKDIR /app
# 复制当前目录下的所有内容到容器内的/app目录下
ADD . /app
# 安装python依赖库
RUN pip install -r requirements.txt
# 设置容器暴漏端口80
EXPOSE 8080
#定义环境变量
ENV NAME World
# 容器启动后运行脚本 使用exec方式执行
CMD ["python","app.py"]

#使用exec方式执行，推荐方式
#CMD ["executable", "param1", "param2"]
# 在/bin/sh中执行
#CMD command param1 param2
# 提供给ENTRYPOINT的参数
#CMD ["param1","param2"]

Dockerfile基本结构

dockerfile是一个普通的文本文件，一般情况下dockerfile可分为四个部分：基础镜像信息，维护者信息，镜像操作指令和容器启动时的执行指令

常用指令

FROM

FROM指令用于初始化一个新的镜像构建阶段，同时为之后的指令设置一个基础镜像，设置的基础镜像可以从DockerHub仓库中或者本地镜像列表获取，如果本地镜像列表中已经存在则直接使用本地镜像，否则从镜像仓库中拉取

语法格式：
```
FROM 
FROM :
```
在使用FROM指令时，需要注意以下几点：
- 一个有效的Dockerfile必须以FROM指令开头
- 为了创建多重镜像或者相互依赖的镜像，在同一个Dockerfile中可能出现多个FROM指令
- 参数是可选的,主要用来区分基础镜像的版本，默认是latest
MAINTAINER

指定当前镜像的维护这信息，没有格式要求，一般使用用户名和邮箱进行标识，如：
```
MAINTAINER 'zhangsan"
```
RUN

RUN指令用于执行指定的脚本命令，有两种格式，语法如下：
```
# 这种将在shell终端中运行命令，即/bin/sh -c ""
RUN 
#这种使用exec执行，指定使用其他终端可以使用这种方式，例如：
# RUN ["/bin/bash","-c","echo hello"]
RUN ["executable", "param1", "param2"]
```
其中每条RUN指令都将在当前镜像基础上执行指定命令并提交为新的镜像，如果要执行多条RUN指令，通常会将多条RUN指令合成一条，并使用斜杠” \ “来换行，这样可以减少构建镜像的体积
CMD

CMD指令用于指定启动容器时执行的命令，有三种格式：
```
# 使用exec执行，推荐方式
CMD ["executable", "param1", "param2"]
# 在/bin/sh中执行，提供给需要交互的应用
CMD command param1 param2
# 提供给ENTRYPOINT的默认参数
CMD ["param1", "param2"]
```
每个Dockerfile只能有一条CMD指令，如果有多条只有最后一条生效，如果启动容器时指定了运行指令，则会覆盖掉CMD指定的命令
EXPOSE

用于声明容器内部暴露的端口号，供容器访问连接使用，如法格式如下：
```
EXPOSE  [...]
```
ENV

ENV指令用于为上下文设定一个环境变量，该指令在后续指令或内联文件中都可以使用，语法如下：
```
ENV  
ENV = =
```
第一种格式为属性设置唯一的属性值，属性第一个空格之后的所有字符串(包括空格，引号)都将被视为该属性的值；第二种格式允许同时为多个属性赋值，而这种方式里面的引号，反斜杠等都将被解析掉
ARG

ARG指令和ENV指令的效果一样，都是设置环境变量，不同的是，ARG设置的是构建环境的环境变量，在将来容器运行时是不会存在这些环境变量的，格式如下：
```
ARG <参数名>[=<默认值>]
```
dockerfile中的ARG指令是定义参数名以及定义其默认值，该默认值可以通过在构建命令docker build中使用–build-arg <参数名>=<值>来覆盖。
ADD

ADD指令用于赋值src资源文件到容器的dest目录下，复制的资源可以是文件，目录以及远程URLs资源，格式如下：
```
ADD ... 
```
在使用ADD指令时，复制的src资源必须是当前上下文目录或者子目录，复制的内容实际上是该目录下的所有内容，其中包括文件系统的元数据，而目录本身不会被复制，当dest目录不存在时，会在复制文件时自动创建，需要注意的是，当使用ADD指令复制一个压缩包时，ADD指令会在复制后自动解压该文件
COPY

作用和ADD指令类似，区别在于不能赋值Urls路径文件，也不能解压文件，语法如下：
```
COPY ... 
```
ENTRYPOINT

ENTRYPOINT指令是配置容器启动后执行的命令，每一个dockerfile只能有一个entrypoint，有两种语法格式，如下：

# exec格式，推荐
ENTRYPOINT ["executable","param1","param2"]
# shell格式
ENTRYPOINT command param1 param

WORKDIR

用于为后续的指令(如：RUN, CMD, ENTRYPOINT, COPY, ADD)指定工作目录, 在同一个dockerfile中可以多次使用WORKDIR指令，语法格式如下：
```
WORKDIR /path/to/workdir
```

.dockerignore

docker在读取应用上下文中的Dockerfile文件之前，会先查看应用上下文是否包含一个.dockerignore文件，如果该文件存在，则Docker会先将.dockerignore文件中盛声明的文件或目录排除，然后在构建镜像，使用.dockerignore有助于进行文件复制过程中避免加入过大或者敏感的无用的文件和目录，如：

*/temp*
*/*/temp*
temp?

Docker客户端常用指令

列出镜像

查看本地镜像列表已有的镜像，格式如下：
```
$ docker images
```
结果列：
- REPOSITORY：镜像名称
- TAG：镜像标签，版本号，默认latest
- IMAGE ID：镜像ID，显示12位，实际是64位，这里显示缩写形式
- CREATED：距今创建镜像的时间
- SIZE：镜像大小
搜索镜像

搜索docker hub上的镜像，格式如下：
```
$ docker search ubuntu
```
结果列:
- NAME：镜像的名称，这里有两种格式，其中不带"/"的表示官方镜像，带”/“表示其他用户公开的镜像，公开镜像”/“前面是用户在dockerhub上的用户名(唯一),后面是对应的镜像名
- DESCRIPTION：镜像的描述
- STARS：该镜像的收藏数
- OFFICAL：表示是否为官方镜像
- AUTOMETED：表示是否自动构建镜像，例如，用户可以将docker hub绑定到git hub，当代码提交更新后，可以自动构建镜像
拉取镜像

docker pull 可以拉取镜像到本地，格式如下：
```
$ docker pull ubuntu
```
构建镜像

除了使用docker pull拉取镜像外，还可以使用docker build构建镜像，通常情况下都是通过Dockerfile文件来构建镜像，格式如下：
```
$ docker build -t hellodocker .
```
上面命令通过 ”.“ 使用当前应用的上下文的Dockerfile文件来构建镜像，也可以指定Dockerfile目录
删除镜像

再删除镜像时，需要指定镜像名或者镜像ID，格式如下：
```
$ docker rmi -f hellodocker
```
需要注意，再删除镜像之前，必须先删除和停止由该镜像创建的容器，另外通过镜像名操作镜像时，如果操作的不是默认latest镜像，需要在镜像名称后面指定镜像tag标签参数来确保镜像的唯一性
创建并启动容器

可以使用docker run来创建并运行容器，格式如下：
```
$ docker run -d -p 5000:8080 --name test hellodocker
```
- docker run : 表示创建并启动一个容器，而后面的hellodocker表示要运行的镜像名称
- -d : 表示容器启动时在后台运行
- -p 5000:8080：表示将容器暴露的8080端口映射到宿主机的5000端口，也可以使用-P（大写）来映射主机的随机端口
- –name ：表示为创建后的容器指定名称为test，如果没有该参数，则生成一个随机的容器名
列出容器

生成容器后可以通过docker ps指令查看当前运行的容器，格式如下：
```
$ docker ps 
```
结果列:
- CONTAINER ID：表示容器的ID
- IMAGE：表示生成该容器的镜像名称
- COMMAND：表示容器启动时运行的命令，Docker要求在容器启动时必须运行一个命令
- CREATED：表示容器创建的时间
- STATUS：容器运行状态，Up表示运行中，Exited表示已停止
- PORTS：表示内部暴漏的端口映射到主机的端口
- NAMES：表示生成容器的名称，自动生成，可以使用–name指定
执行命令

生成容器后，客户端可用通过docker exec指令与运行的容器进行通信，在通信时需要指定容器ID或名称，格式如下：
```
$ docker exec e82f0de93902 ls -l
```
上述命令会将容器中的文件列举出来
停止容器

当不需要容器运行时，可以使用docker stop指令停止指定的容器，在停止容器时需要指定容器ID或名称，格式如下：
```
$ docker stop e82f0de93902
```
使用该指令停止容器会有略微的延迟，停止成功后会返回该容器的ID，可以使用docker kill e82f0de93902立即杀死运行的容器进程
启动容器

容器停止后，如果需要重新访问该容器中的程序，则需要重启该容器，格式如下:
```
docker start e82f0de93902
```
除了docker start指令可以启动已经停止的容器之外，还可以使用docker restart指令重启容器，docker restart既可以重新启动已经停止的容器，也可以重启当前正在运行的容器 docker restart e82f0de93902

Docker Hub远程镜像管理

Docker除了提供常用的镜像，容器的操作指令外，还提供了一些管理指令

管理指令	说明
docker container	用于管理容器
docker image	用于管理镜像
docker network	用于管理Docker网络
docker node	用于管理Swarm集群节点
docker plugin	用于管理插件
docker secret	管理Docker密钥
docker service	管理docker的一些服务
docker stack	管理docker堆栈
docker swarm	管理swarm
docker system	管理docker
docker volume	管理数据卷

需要说明的是，管理指令中的docker container和docker image与上一节中讲的常用操作指令是相同的，只是上一节的常用指令省略了container和image关键字，因为docker默认是对镜像和容器进行操作的。

Docker镜像管理

上面我们通过docker 引擎提供的客户端工具实现了创建镜像，生成并启动容器，存储镜像和搜索镜像等，对于Docker镜像管理Docker提供了一些工具，如Docker Hub和Docker Registry

Docker Hub远程镜像管理

Docker hub是一个基于云的注册服务，来提供镜像的管理。

下面演示如果通过DockerHub来管理我们的镜像

首先你需要先在docker hub官网注册一个账号，注册成功以后即可以登录到docker hub中心，可以在上面创建一个仓库用于存放我们的镜像
当有了镜像仓库之后，就可以将本地的镜像推送到docker hub仓库进行保存了，例如我们的hellodocker镜像，我们要将hellodocker镜像推送到远程仓库，该镜像名就必须符合DockerID/repository的形式规范，其中DockerID为docker hub上的账户名，repository为镜像名，我们需要先通过docker tag指令修改我们的镜像名，具体指令如下(这里假设我们的docker hub账号是zhangsan):
```
$ docker tag hellodocker:latest zhangsan/hellodocker:latest
```
使用上述的命令会复制一份名为zhangsan/hellodocker的镜像，而原名称hellodocker的镜像不变
登录认证，要想把客户端镜像推送到远程仓库需要先登录认证，指令如下：
```
$ docker login
```
运行上面的命令，会要求输入用户名密码进行认证登录，认证成功之后就会返回Login Successed的消息
推送镜像

我们在客户端使用docker push指令向远程仓库推

送镜像，格式如下：
```
$ docker push zhangsan/hellodocker:latest
```
完成后就可以在docker hub上进行查看了，docker hub会定时对上传的公开镜像仓库进行索引，一段时间之后，任何人都可以搜索到公开镜像仓库

Docker Registry私有仓库

相比Docker hub而言，docker registry功能就不够全面了，如果开发者想要严格控制镜像的存储位置，完全拥有自己的镜像分配渠道，或者想要将镜像存储和分步紧密嵌入到自己的开发中，则使用Docker Registry更加合适，下面针对Docker Registry本地私有仓库管理进行讲解

启动Docker Registry

使用Docker官方提供的Registry镜像就可以搭建本地私有镜像仓库，具体指令如下：
```
$ docker run -d -p 5000:5000 --restart=always --name registry \
  -v /mnt/registry:/var/lib/registry \
  registry:2
```
参数说明:
- -d :表示后台运行
- -p 5000:5000：表示将私有镜像仓库内部暴露的端口5000映射到宿主机的5000端口
- –restart=always：表示本地私有镜像仓库宕机后始终会自动重启
- –name=registry：容器的名称
- -v /mnt/registry:/var/lib/registry：表示将容器内的默认存储位置/var/lib/registry中的数据挂在到宿主机/mnt/registry目录下，这样当容器销毁后，在容器中/var/lib/registry目录下的数据会自动备份到宿主机的指定目录
重命名镜像

之前推送镜像时，都是默认推送到远程镜像仓库，而本次是将镜像推送到本地私有镜像仓库，由于推送本地私有镜像仓库的镜像名必须符合”仓库IP:端口号/repositry“的形式，因此需要修改镜像的名称，具体指令如下：
```
$ docker tag hellodocker:latest localhost:5000/hellodocker
```
配置docker忽略TLS

其他docker机器如果想要与配置有自签名证书和账号认证的私有仓库进行通信，就必须在各自Docker主机上配置该私有仓库地址，进行使用登记, 在Docker机器终端使用vim /etc/docker/daemon.json 命令编辑daemon.json文件，添加以下内容：
```
"insecure-registries":["10.9.225.198:5000"]
```
上述内容就是私有仓库的地址，配置完后记得重启docker

注意：即使是没有配置自签名和账号认证，在跨主机访问Docker Registry也要在daemon.json配置文件中配置该私有仓库地址。
推送镜像

本地私有镜像仓库搭建完成，且要推送的镜像已经准备就绪后，就可以将指定镜像推送到私有仓库了，具体指令如下：
```
$ docker push localhost:5000/hellodocker
```
执行上述指令后，就可以完成镜像的推送，为了验证推送结果，我们可以在宿主机浏览器上输入地址：http://localhost:5000/v2/hellodocker/tags/list进行查看，也可以到本地私有镜像仓库指定的镜像目录下查看是否有我们的镜像(/mnt/registry/docker/registry/v2/repositories)

经过上面的配置，我们的私有仓库基本上已经完成，但是我们还需要保护我们的仓库，不是谁都可以访问的，而是需要用户名密码的，下面我们会配置私有仓库的密钥和用户名密码。

保护Docker Registry
1. 生成签名证书
  
  下面的命令会生成一个csr证书申请。
```
# 在/home目录下创建对应的文件夹，用于存放证书文件
$ mkdir registry && cd registry && mkdir certs && cd certs
# 生成一个私钥
$ openssl genrsa -out private.key 1024
# 生成证书申请，按照实际情况填写信息
$ openssl req -new -key private.key -out my.csr
```
  CA颁发证书（需要先配置CA证书，具体可以参考openssl）：
```
openssl ca -in my.csr -out my.crt -days 365
```
  执行上面的命令就会生成一个my.crt文件，这个就是我们的证书文件，把证书文件放到上面创建的目录下(/home/registry/certs/)
2. 生成用户名和密码
  
  生成自签名证书之后，为了确保Docker机器与Docker Registry本地镜像仓库的交互，还需要生成一个连接认证的用户名和密码，使其他docker用户只有通过用户名和密码登录后才允许连接到Docker Registry私有镜像仓库,生成连接认证的具体指令如下：
```
$ cd /home/registry && mkdir auth
# 使用htpasswd生成密码 -B bcrypt算法，-b 直接在命令行上输入密码 -n display results on stdout.
$ htpasswd -Bbn neteye neteye > auth/htpasswd
```
  执行上述命令后，首先会在前面的registry目录下再创建一个auth目录，然后使用htpasswd命令生成用于访问docker registry仓库服务的用户名和密码(用户名是neteye，密码是neteye)
3. 启动Docker Registry镜像服务
  
  完成上面的准备工作后，就可以正式部署带有安全认证的私有镜像仓库了(需要将前面小节中运行的Docker Registry删除)，具体指令如下：
```
$ docker run -d \
	-p 5000:5000 \
	--restart=always \
	--name registry \
	-v /mnt/registry:/var/lib/registry \
	-v "$(pwd)/auth:/auth" \
	-e "REGISTRY_AUTH=htpasswd" \
	-e "REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd" \
    -e "REGISTRY_AUTH_HTPASSWD_REALM=Registry Realm" \
    -v "$(pwd)/certs:/certs" \
    -e "REGISTRY_HTTP_TLS_CERTIFICATE=/certs/my.crt" \
    -e "REGISTRY_HTTP_TLS_KEY=/certs/private.key" \
    registry:2
```
4. 登录Docker Registry私有仓库
  
  在Docker主机上通过docker login指令先登录docker registry私有仓库，指令如下
```
$ docker login 10.9.225.198:5000
```
  使用上述指令就可以进行镜像仓库的登录了，登录成功就会返回“Login Successed”提示信息
5. 再次推送并验证是否推送成功
  
  登录成功之后就可以再次使用docker push指令推送镜像到私有仓库，推送成功之后就会有提示信息，当然最严谨和直观的方法就是在Docker Registry服务挂载的镜像目录上进行验证，在私有仓库磁盘的/mnt/registry/docker/registry/v2/repositories目录进行查看,效果如下：
```
$ ls /mnt/registry/docker/registry/v2/repositories/
busybox
```
  可以看到busybox镜像已经成功的推送到了私有仓库，或者也可以直接在浏览器访问接口https://10.9.225.198:5000/v2/busybox/tags/list 查看私有仓库busybox镜像的tag列表。

Docker Network

Docker默认使用bridge(单主机互联)和overlay(跨主机互联)两种网络驱动来进行容器的网络管理，如果需要还可以自定义网络驱动进行网络管理。

Docker默认网络管理

Docker在安装之后默认安装了三种网络，可以使用docker network ls查看，如下：

$ docker network ls
NETWORK ID          NAME                   DRIVER              SCOPE
7432201b99cc        bridge                 bridge              local
a3bbe8e1266a        host                   host                local
b88805eac801        none                   null                local

可以看出来默认的三种网络分别是bridge，host和none，其中bridge的网络就是默认的bridge驱动网络，也是容器创建时默认的网络管理方式，配置后可以与宿主机通信从而实现与互联网通信功能，而host和none属于无网络，容器添加到这两个网络时不能与外界网络通信。

下面演示默认的bridge网络管理方式

创建并启动容器，执行如下指令：

$ docker run -itd --name networktest hellodocker

使用网络查看指令查看网络详情，执行如下指令

$ docker network inspect bridge

上述指令用于核查名称为bridge的网络详情，需要指定网络名称或者是网络ID，执行之后效果如下：

$ docker network inspect bridge
[
    {
        "Name": "bridge",
        "Id": "7432201b99ccc137cb4a923174a6931a5ad8876274b8b650c00743fbe60d0fa8",
        "Created": "2020-09-15T14:52:28.874222377+09:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": null,
            "Config": [
                {
                    "Subnet": "172.17.0.0/16"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "d7deaeeede00b5ce9a7571ea96bbbd8d7a20c0ddb786c75153c6027b7f5cddab": {
                "Name": "networktest",
                "EndpointID": "aa90388cc2436791ec7fa16edc7af9026ae2fded96760e67f603471751eb41f3",
                "MacAddress": "02:42:ac:11:00:02",
                "IPv4Address": "172.17.0.2/16",
                "IPv6Address": ""
            }
        },
        "Options": {
            "com.docker.network.bridge.default_bridge": "true",
            "com.docker.network.bridge.enable_icc": "true",
            "com.docker.network.bridge.enable_ip_masquerade": "true",
            "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
            "com.docker.network.bridge.name": "docker0",
            "com.docker.network.driver.mtu": "1500"
        },
        "Labels": {}
    }
]

从图中可以看出，其中就包括了使用默认的bridge网络管理方式启动的名称为networktest的容器，

需要注意的是，这里介绍的三种网络bridge，host，none都是在非集群环境下Docker提供的默认网络，而在Docker Swarm集群环境下，Docker还提供了docker_gwbridge和ingress两种默认网络

自定义网络

虽然Docker提供的默认网络使用比较简单，但是为了保证容器中应用的安全性，在实际开发中更推荐使用自定义网络进行容器管理。

在Docker中可以自定义bridge网络，overlay网络，也可以创建network plugin（网络插件）或者远程网络以实现容器网络的完全定制和控制，下面分别对几种自定义网络进行讲解

Bridge networks(桥接网络)

为了保证容器的安全性，我们可以使用基于bridge的驱动创建新的bridge网络，这种基于bridge驱动的自定义网络可以较好的实现容器的隔离，

需要说明的是，这种自定义的基于bridge驱动的网络对于单主机的小型网络环境管理是一个不错的选择，但是对于大型的网络环境管理(如集群)就需要考虑使用自定义overlay集群网络
Overlay network in swarm mode(Swarm集群中的覆盖网络)

在docker swarm集群环境下可以创建基于overlay驱动的自定义网络，为了保证安全性，swarm集群使自定义的overlay网络只适用于需要服务的集群中的节点，而不会对外部其他服务后者docker主机开放。
Custom network plugins(定制网络插件)

自定义网络插件会在Docker进程所在的主机上作为另一个运行的进程，由于自定义网络插件使用较少，这里不做详解

自定义Bridge网络

下面对自定义Bridge网络进行讲解

创建自定义网络

在docker主机上可以使用docker network create指令来创建网络，指令如下：
```
$ docker network create --driver bridge mybridgenw
```
执行上面的命令可以创建一个基于bridge驱动名为mybridgenw的网络，其中–driver(可简写为-d)用于指定网络驱动类型，mybridgenw就是新创建的网络的名称，需要说明的是–driver可以省略，默认使用bridge驱动。

创建完成后可以使用docker network ls查看网络是否创建成功，指令如下：
```
$ docker network ls
NETWORK ID          NAME                   DRIVER              SCOPE
7432201b99cc        bridge                 bridge              local
a3bbe8e1266a        host                   host                local
b7304d4b790d        mybridgenw             bridge              local
b88805eac801        none                   null                local
```
可以看到新创建的名为mybridgenw的网络已经在网络列表中，还可以你用docker network inspect mybridgenw查看新建网络的详细信息
使用自定义网络启动容器

自定义网络创建成功后就可以使用该网络启动一个容器了，具体指令如下：
```
$ docker run --network=mybridgenw -itd --name=nwtest hellodocker
```
执行上述指令后，会创建一个名为nwtest的容器，指令中的–network参数指定了该容器的网络连接为自定义的mybridgenw网络。

通过docker inspect nwtest指令可以查看启动后的容器的网络详情，来查看其网络管理方式，效果如下：

从图中可以看出名称为nwtest的容器使用的就是自定义的mybridgenw网络进行容器网络管理的。

为容器添加网络管理

名为nwtest的容器使用的只有自定义的mybridgenw一种网络管理方式，我们还可以继续为该容器添加其他的网络管理方式，指令如下：
```
$ docker network connect bridge nwtest
```
执行上述指令后，会为容器nwtest另添加一种默认的bridge网络管理方式，再次使用docker inspect nwtest指令查看该容器网络情况，效果如下：

可以看到执行完容器添加网络管理的指令后，容器nwtest就拥有了两种网络管理方式，分别为默认的bridge网络和自定义的mybridgenw网络。

断开容器网络连接

容器即可以连接网络，也可以断开网络。这里以断开nwtest容器的自定义网络mybridgenw为例进行演示，断开网络连接的指令如下：
```
$ docker network disconnect mybridgenw nwtest
```
断开网络连接的指令与连接网络的指令类似，在使用时需要指定网络名称和容器名称。
移除自定义网络

当不再需要某个网络时，可以将该网络移除，但在网络移除之前一定要先将所有与该网络连接的容器断开，移除自定义网络的指令如下：
```
$ docker network rm mybridgenw
```
执行上面的指令就可以移除名为mybridgenw的自定义网络

容器之间的网络通信

Docker中不同容器之间需要通过网络来进行通信，那么各个容器之间具体是如何实现通信的呢？接下来我们以非集群环境下的容器通信为例，对docker容器之间的通信进行讲解。具体步骤如下：

创建容器

（1）创建两个使用默认的bridge网络的容器，指令如下
```
$ docker run -itd --name=container1 busybox
$ docker run -itd --name=container2 busybox
```
执行上面的指令，会创建两个名为container1和container2的容器，同时他们都使用默认的bridge进行网络管理。

（2）创建一个使用自定义的mybridgenw网络的容器，具体指令如下：
```
$ docker run --network=mybridgenw -itd --name=container3 busybox
```
执行上述指令，会创建一个名为container3的容器，使用–network参数指定了该容器的网络管理为自定义的mybridgenw。

（3）为container2容器新增一个自定以的mybridgenw网络连接，指令如下：
```
$ docker network connect mybridgenw container2
```
执行上述指令后，container2容器就同时拥有了bridge和mybridgenw两种网络管理方式。

执行完前面3个步骤后，container1使用的是默认的bridge网络，container3使用的是自定义的mybridgenw网络，而container2使用的是默认的bridge网络和自定义的mybridgenw网络，这三个容器的具体网络管理如下图所示：

从图中可以看出，container1和container2在同一个默认的bridge网络下，这俩个容器可以相互通信，而container2又和container3在同一个自定义的mybridgenw网络下，这两个容器也可以相互通信，但是container1和container3属于不同的网络，所以这两个容器无法通信。

容器地址查看

为了演示不同容器之间的网络通信情况，这里需要先查看各个容器的网络地址。

首先进入container2容器，具体指令如下：

$ docker attach container2

然后使用ifconfig指令查看当前容器被动态分配的IP地址，如下所示：

/ # ifconfig
eth0      Link encap:Ethernet  HWaddr 02:42:AC:11:00:04
          inet addr:172.17.0.4  Bcast:172.17.255.255  Mask:255.255.0.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:8 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:656 (656.0 B)  TX bytes:0 (0.0 B)

eth1      Link encap:Ethernet  HWaddr 02:42:AC:14:00:04
          inet addr:172.20.0.4  Bcast:172.20.255.255  Mask:255.255.0.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:8 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:656 (656.0 B)  TX bytes:0 (0.0 B)

lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

从运行结果可以看出，在container2容器内部有两个网卡eth0和eth1（这就是使用了两种网络管理方式自动产生的），并分别对应的IP地址为：172.17.0.4和172.20.0.4。

接下来分别进入container1和container3，并通过ifconfig查看对应容器的IP地址，效果如下：

$ docker attach container1
/ # ifconfig
eth0      Link encap:Ethernet  HWaddr 02:42:AC:11:00:03
          inet addr:172.17.0.3  Bcast:172.17.255.255  Mask:255.255.0.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:8 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:656 (656.0 B)  TX bytes:0 (0.0 B)

lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

$ docker attach container3
/ # ifconfig
eth0      Link encap:Ethernet  HWaddr 02:42:AC:14:00:03
          inet addr:172.20.0.3  Bcast:172.20.255.255  Mask:255.255.0.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:8 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:656 (656.0 B)  TX bytes:0 (0.0 B)

lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

可以看出container1的ip地址为：172.17.0.3，container3的IP地址为：172.20.0.3

说明：当使用docker attach指令进入容器后，可以使用exit命令或者快捷键CTRL+p+q组合键退出当前容器，只不过exit退出容器后，该容器就会停止运行，而CTRL+p+q组合键退出，容器会继续运行

容器通信测试

首先使用docker attach container1指令进入container1容器内部，使用ping命令连接container3查看是否能够通信，如下所示：
```
$ docker attach container1
/ # ping -w 4 172.20.0.3
PING 172.20.0.3 (172.20.0.3): 56 data bytes

--- 172.20.0.3 ping statistics ---
5 packets transmitted, 0 packets received, 100% packet loss
/ # ping -w 4 container3
ping: bad address 'container3'
```
从上面结果可以看出，无论我们ping ip地址还是ping 容器名称都无法连通container3，这也就验证了两个容器不在同一个网络环境下，无法通信的判断。

接着使用docker attach container2指令进入container2容器，使用容器IP分别连接container1和container3进行通信测试，效果如下：
```
$ docker attach container2
/ # ping -w 4 172.17.0.3
PING 172.17.0.3 (172.17.0.3): 56 data bytes
64 bytes from 172.17.0.3: seq=0 ttl=64 time=0.153 ms
64 bytes from 172.17.0.3: seq=1 ttl=64 time=0.078 ms
64 bytes from 172.17.0.3: seq=2 ttl=64 time=0.089 ms
64 bytes from 172.17.0.3: seq=3 ttl=64 time=0.077 ms

--- 172.17.0.3 ping statistics ---
5 packets transmitted, 4 packets received, 20% packet loss
round-trip min/avg/max = 0.077/0.099/0.153 ms

/ # ping -w 4 172.20.0.3
PING 172.20.0.3 (172.20.0.3): 56 data bytes
64 bytes from 172.20.0.3: seq=0 ttl=64 time=0.221 ms
64 bytes from 172.20.0.3: seq=1 ttl=64 time=0.098 ms
64 bytes from 172.20.0.3: seq=2 ttl=64 time=0.092 ms
64 bytes from 172.20.0.3: seq=3 ttl=64 time=0.085 ms

--- 172.20.0.3 ping statistics ---
5 packets transmitted, 4 packets received, 20% packet loss
round-trip min/avg/max = 0.085/0.124/0.221 ms
```
从上面运行结果可以看到，在container2内部使用“ping IP”指令可以同时连通container1和container3，这也与前面的分析结果相同。

最后，再在container2容器内部使用容器名称分别连接contaienr1和container3进行通信测试，如下所示：
```
/ # p ping -w 4 container1
ping: bad address 'container1'
/ # ping -w 4 container3
PING container3 (172.20.0.3): 56 data bytes
64 bytes from 172.20.0.3: seq=0 ttl=64 time=0.155 ms
64 bytes from 172.20.0.3: seq=1 ttl=64 time=0.119 ms
64 bytes from 172.20.0.3: seq=2 ttl=64 time=0.097 ms
64 bytes from 172.20.0.3: seq=3 ttl=64 time=0.105 ms

--- container3 ping statistics ---
5 packets transmitted, 4 packets received, 20% packet loss
round-trip min/avg/max = 0.097/0.119/0.155 ms
```
从上面运行结果可以看出，在container2内部使用”ping 容器名称“的指令可以连通container3,而连接container1却显示“bad address ‘container1’”错误。

通过前面的测试，我们可以得出一个结论：不同容器之间想要相互通信必须在同一网络环境下；使用默认的bridge网络管理的容器可以使用容器ip通信，但无法使用容器名称通信；而使用自定义网络管理的容器则同时可以使用容器IP和容器名称进行通信。

补充： 默认bridge网络下可以使用–link参数通过容器名称进行通信

在默认网络下，可以使用–link参数的具体指令如下：
```
$ docker run -itd --name=container4 --link container1:c1 busybox
```
执行上述的指令后，会创建一个名为container4的容器，-itd参数用于指定后台交互式运行，–name指定容器名称，而–link container1:c1则将新建的container4容器连接到了container1容器且为container1容器定义了别名c1.

这种使用了–link参数创建的默认网络下的容器就可以使用容器名号称或别名与指定连接的容器进行通信了，所以这里contaienr4可以使用容器名container1或者别名c1与container1进行通信，但容器container1仍不可以使用容器名称与container4进行通信。

不过根据docker官方声明，–link属于低版本的遗留功能，这里只有容器需要在默认网络下使用容器名进行通信的情况下才会使用–link功能，官方更推荐使用用户自定义网络进行容器管理。

Docker Swarm集群

上一节我们对Docker中的网络管理进行了讲解，同时也对非集群环境下基于bridge驱动的自定义网络的使用进行了讲解，然而Docker中还涉及到另一种网络overlay必须在Docker Swarm集群环境下才能使用，接下来我们针对Docker Swarm集群进行详细讲解

Docker Swarm概述

Docker Swarm是一个用于创建和管理Docker集群的工具，Docker1.12以及以后的版本集成了swarmkit工具，该工具主要用于Docker集群管理和容器编排，因此开发者可以不用安装额外的软件包，只需要简单的命令就可以创建并管理DockerSwarm集群。

DockerSwarm集群的特点如下：

方便创建和管理集群

DockerSwarm是docker原生的集群管理工具，可以直接使用docker客户端来创建并管理一个Docker Swarm集群，然后在其中部署应用程序服务，而不需要额外的编配软件。
可扩展

对于集群中的每个服务，都可以声明要运行的副本任务的数量，当向下或向上进行扩展时，集群管理器将通过添加或删除副本任务来自动适应所需的状态
可实现期望的状态调节

集群管理器节点不断监视集群状态，并协调实际状态和所期望状态之间的任何差异，例如，如果启动一个服务的10个副本任务，当一个Docker节点承载其中两个副本崩溃时，那么管理器将创建两个新的副本来替换崩溃的副本。
集群中多主机网络自动扩展管理

Docker Swarm为集群服务提供了一个覆盖网络，当它初始化或更新应用程序时，集群管理器会自动将在工作节点闯将或更新网络来管理服务。
提供服务发现功能

集权管理器节点为集群中的每个服务分配一个唯一的dns名称，通过docker swarm集群提供的负载均衡功能，可以通过嵌入在集群中的dns服务器来查询集群中运行的每个容器
可实现负载均衡

可以将容器中服务的端口暴露给外部负载均衡器，而在内部，集群允许指定如何在节点之间分配服务容器。
安全性强

集群中的每个节点强制使用TLS相互认证和加密，以确保自身和其他节点之间的通信安全。除此之外，集群还支持使用自定义的自签名证书来保证安全。
支持延迟更新和服务会滚

在进行服务更新时，可以将服务更新逐步延伸到每个节点上，集群管理器允许服务部署到不同节点组之间时出现延迟，如果某个节点出现问题，还可以将服务回滚到以前的版本。

Docker Swarm使用

Docker Swarm是Docker原生的，同时也是最简单，最易学，最节省资源的，下面使用一个具体的示例演示Docker Swarm集群的基本使用

使用Docker Swarm集群的具体步骤如下。

环境搭建
- 准备三台主机(即用于搭建集群的3个Docker机器)，每台机器都需要安装Docker并且可以链接网络。
- 集群管理节点Docker机器的IP地址必须固定，集群中所有节点都能够访问该管理节点
- 集群节点之间必须使用相应的协议并保证其以下端口号可用：
  
  (1) 用于集群管理通信的TCP端口2377；
  
  (2) TCP和UDP端口7946，用于节点间的通信；
  
  (3) UDP端口4789，用于覆盖网络流量；
  
  为了进行本实例的演示，此处准备了三台主机分别为localhost1(作为管理节点)，localhost2(作为工作节点)，localhost3(作为工作节点)，其ip地址分别如下：
```
localhost1 192.168.56.101
localhost2 192.168.56.102
localhost3 192.168.56.103
```

创建docker swarm集群

（1）在名为manager1的docker机器上创建docker swarm集群，指令如下：

$ docker swarm init --advertise-addr 192.168.56.101

执行上述指令后，docker就会自动在ip为192.168.56.101的机器上(manager1)创建一个Swarm集群，并将该ip地址的机器设置为集群管理节点。说明：如果只是测试单节点的集群，只需要执行docker swarm init指令即可

执行之后输出以下信息表示创建成功：

Swarm initialized: current node (2f7osqpdu8x35basubj1wvern) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-5mhurlyodmb45yldg1qt21m84svgmvjylug1s7l7tbwnswxmfl-7psx06fpll5yantnv99e0n02r 192.168.56.101:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

上面的运行结果，显示了两条指令，这两条指令分别是添加工作节点和管理节点时使用的。

（2）在管理节点上，使用docker node ls指令查看集群节点的信息，如下：

$ docker node ls
ID                            HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
2f7osqpdu8x35basubj1wvern *   localhost1          Ready               Active              Leader              19.03.12

从上面运行结果可以看出，此时只是创建了一个集群节点（默认为管理节点），而没有其他工作节点，因此只显示一条节点信息。

向Docker Swarm集群添加工作节点

（1）启动另外两台Docker机器worker1和worker2，分别打开终端窗口，执行向集群中加入工作节点的指令，指令如下：

$ docker swarm join --token SWMTKN-1-5mhurlyodmb45yldg1qt21m84svgmvjylug1s7l7tbwnswxmfl-7psx06fpll5yantnv99e0n02r 192.168.56.101:2377

需要注意的是，上面–token参数表示向指定集群中加入工作节点的认证信息，一定要使用你对应集群的token，如果忘记该token可以在集群管理节点上执行“docker swarm join-token worker"指令进行查看。

（2）再次在集群管理节点上使用docker node ls指令查看集群节点信息，如下：

$ docker node ls
ID                            HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
2f7osqpdu8x35basubj1wvern *   localhost1          Ready               Active              Leader              19.03.12
5h484ur5b1xoo9ukoy8on55h6     localhost2          Ready               Active                                  19.03.12
ms1v49hz127zksxzrn4sumyp6     localhost3          Ready               Active                                  19.03.12

上面执行结果显示了1个管理节点(Manager Status为Leader),和2个工作节点，这说明Swarm集群搭建成功。

向Docker Swarm集群部署服务

在Docker Swarm集群中部署服务时，既可以使用Docker hub上自带的镜像来启动服务，也可以使用我们自己通过Dockerfile构建的镜像来启动服务，如果使用自己通过Dockerfile构建的镜像来启动服务必须先将镜像推送到docker hub中心仓库。

下面我们直接使用docker hub上自带的alpine镜像为例来部署集群服务，指令如下：
```
$ docker service create --replicas 1 --name helloworld alpine ping docker.com
```
上述部署服务指令中参数说明如下：
- docker service create：用于在swarm集群中创建一个基于alpine镜像的服务
- –replicas：指定了该服务只有一个副本实例
- –name：指定服务的名称
- ping docker.com：表示服务启动后执行的命令
  
  Docker Swarm集群中的服务管理与容器操作基本类似，只不过服务管理指令是以“docker service”开头，而容器管理指令是以“docker container”开头，个别指令除外，如–replicas。
查看Swarm集群中的服务

（1）当服务部署完成后，在管理节点上可以通过docker service ls指令查看当前集群中的服务列表信息，指令如下：
```
$ docker service ls
```
（2）可以使用docker service inspect指令，查看部署的服务的具体详情信息，指令如下：
```
$ docker service inspect helloworld
```
（3）可以使用docker service ps指令查看指定服务在集群节点上的分配和运行情况，指令如下：
```
$ docker service ps helloworld
ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE           ERROR                         PORTS
jdnht71ll8k7        helloworld.1        alpine:latest       localhost1          Running             Running 3 minutes ago
```

更改Swarm集群服务副本数量

在集群中部署的服务，如果只运行一个副本，就无法体现出集群的优势，并且一旦该机器或者副本崩溃，该服务将无法访问你，所以通常一个服务会启动多个服务副本。

在管理节点manager1上，更改服务副本数量，指令如下：

$ docker service scale helloworld=5

更改完成后，就可以使用docker service ps指令查看5个服务副本在3个节点上的具体分布和运行情况，如下：

 $ docker service ps helloworld
ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE           ERROR                         PORTS
jdnht71ll8k7        helloworld.1        alpine:latest       localhost1          Running             Running 3 minutes ago                           
x50pmqm7nhku        helloworld.2        alpine:latest       localhost3          Running             Running 2 minutes ago                           
wlprn1wd290g        helloworld.3        alpine:latest       localhost3          Running             Running 2 minutes ago                           
asswpoe1nqm4        helloworld.4        alpine:latest       localhost2          Running             Running 3 minutes ago                           
uwrpc5ln1pp2        helloworld.5        alpine:latest       localhost1          Running             Running 3 minutes ago

从上面可以看出，helloworld服务的5个副本实例被随机的分配到了localhost1,localhost2,localhost3这三个节点上运行，并且状态都是Running，表示服务正常运行。

在管理节点上执行“docker service ps helloworld”指令查看服务的运行情况后，我们还可以在有服务副本分配的节点上使用docker ps指令查看任务运行的情况。

删除服务

对于不需要的服务，我们还可以进行删除，具体操作指令如下：
```
$ docker service rm helloworld
```
在集群管理节点上(localhost1)执行上述删除服务指令后，该服务就会从集群中彻底删除，需要说明是，执行上述删除删除服务指令后，在集群中有该副本的节点上，这些服务需要一定的时间清除，此时我们可以使用docker ps查看具体清除情况。
访问服务

前面部署的服务都没有直接向外界暴露服务端口，外界也无法正常访问服务，接下来我们就通过自定义overlay驱动网络为例来讲解集群下网络管理与服务访问，具体实现如下：

（1）在集群管理节点localhost1上，执行docker network ls指令查看网络列表，效果如下：
```
$ docker network ls
NETWORK ID          NAME                      DRIVER              SCOPE
8460e3c9d01b        bridge                    bridge              local
8c02e38be99b        docker_gwbridge           bridge              local
b089ff71a13d        host                      host                local
x1u2rhvxuprj        ingress                   overlay             swarm
dcbe6766a388        none                      null                local
```
从结果可以看出，与非集群环境下的Docker网络对比，Swarm集群网络列表中分别增加了一个以bridge和overlay为驱动的网络，在集群中发布服务时，如果没有指定网络，那么默认都是使用名为ingress网络连接的，而在实际开发中，则会使用自定义的overlay驱动网络进行管理。

（2）在集群管理节点localhost1上,创建以overlay为驱动的自定义网络，指令如下：
```
$ docker network create --driver overlay my-multi-host-nw
```
上述指令以overlay为驱动创建了一个名为my-multi-host-nw的网络。

（3）在集群管理节点localhost1上，再次部署服务，指令如下：
```
$ docker service create \
	--network my-multi-host-nw \
	--name my-web \
	--publish 8080:80 \
	--replicas 2 \
	nginx
```
上述部署服务的指令中，–network参数用于指定服务使用自定义的overlay驱动网络my-multi-host-nw连接；–name参数用于指定服务的名称；–publish(也可以使用-p)参数用于映射对外服务的端口；–replicas参数用于指定该服务的副本数量；nginx表示是基于nginx镜像构建的服务。

提示：前面几步虽然只是在集群管理节点上创建了自定义的overlay驱动网络，但是当管理节点的任务分配到某个集群中的工作节点时，该工作节点会自动创建对应的自定以网络；而当该工作节点上的任务被移除后，该自定义网络也会随之移除。

（4）在集群管理节点localhost1上，使用docker service ps my-web指令查看服务的两个副本的运行情况，结果如下：
```
$ docker service ps my-web
ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE                ERROR               PORTS
us4zof9paylv        my-web.1            nginx:latest        localhost2          Running             Running about a minute ago                      
nhn1wy3562q4        my-web.2            nginx:latest        localhost3          Running             Running about a minute ago 
```
从结果可以看到，该服务的两个副本任务被随机分配到了localhost2和localhost3两台节点上，并已正常运行。

（5）外界访问服务

打开浏览器，使用任意一台节点机器的"ip+8080"端口进行服务访问，都可以正常显示，效果如下：

从图中可以看出，当在任意节点上访问服务时，都可以正常访问部署的服务，这时由于集群负载均衡将请求路由到一个活动容器，从而实现容器内部服务的正常访问，这也体现了docker swarm集群的负载均衡这一特点。

Docker 数据管理

当我们对容器进行相关操作时，产生的一系列数据都会存储到容器中，而docker内部又是如何管理这些数据的呢？下面针对docker的数据管理的一些知识进行讲解

Docker数据存储机制

docker镜像是通过读取Dockerfile文件中的指令构建的，Dockerfile中每条指令都会创建一个镜像层，并且每层都是只读的，这一系列的镜像层就构成了Docker镜像, 通过镜像构建容器时，会在镜像层上增加一个容器层(即可写层), 所有对容器的更改都会写入容器层，这也是docker默认的数据存储方式。

下面通过一个效果图进行说明：

从图可以看出，Docker容器和镜像之间的主要区别是顶部的容器层，而所有对容器中数据的添加，修改等操作都会被存储在容器层中，当容器被删除时，容器层也会被删除，其中存储的数据会被一同删除，而下面的镜像层却保持不变。

由于所有的容器都是通过镜像构建的，所以每个容器都有各自的容器层，对于容器数据的更改就会保存在各自的容器层中，也就是说，由同一个镜像构建的多个容器，他们会拥有相同的底部镜像层，而拥有不同的容器层，多个容器可以访问相同的镜像层，并且有自己独立的数据状态，也就是说多个容器要共享相同的数据，就需要将这些数据存储到容器之外的地方，而这种方式就是下面要提到的Docker volume数据外部挂载机制。

Docker数据存储方式

默认情况下，Docker中的数据存放在容器层，但是这样存储数据有一定的缺陷，比如：

容器中数据无法永久保存，如果另一个容器需要这些数据，那么将很难从容器中获取数据
容器层与正在运行的主机紧密耦合，不能轻易地移动数据
容器层需要一个存储驱动程序来管理文件系统，存储驱动程序提供了一个使用linux内核的联合文件系统，这种额外的抽象化降低了性能

基于上述种种原因，多数情况下Docker数据管理都不会直接将数据写入容器层，而是使用另一种叫做docker volume数据外部挂载的机制进行数据管理。

针对Docker volume数据外部挂载机制，docker提供了三种不同的方式将数据从容器映射到Docker宿主机，分别为：volumes(数据卷), bind mounts(绑定挂载)和tmpfs mounts(tmpfs挂载)，这三种方式要根据实际情况选择，其中volumes最常用也是官方推荐的数据管理方式。

Docker提供的3种数据管理方式略有不同，具体分析如下：

volumes：存储在主机文件系统中（在linux系统下是存在/var/lib/Docker/volumes/目录），并有Docker管理，非Docker进程无法修改该文件系统的部分
bind mounts：可以存储在主机的任何位置，甚至可能是重要的系统文件和目录，在Docker主机或容器上的非Docker进程可以对他们进行任意的修改
tmpfs mounts：只存储在主机系统的内存中，并没有写入主机的文件系统中。

volumes数据卷管理方式

volumes方式完全由Docker管理，是官方想对推荐的数据管理方式，volumes有以下几点优势。

数据卷比绑定挂载更容易备份和迁移
可以使用docker cli指令或docker api来管理数据卷
在linux和windows容器上都可以使用数据卷
在多个容器间可以更安全的共享数据卷
数据卷驱动器允许在远程主机或云提供商上存储数据卷，并且加密数据卷的内容或添加其他功能
一个新的数据卷的内容可以由一个容器预填充

此外在容器的可写层中，数据卷通常是持久化数据更好的选择，因为使用数据卷并不会增加使用容器的大小，而且数据卷的内容存在于给定容器的声明周期之外，如果我们的容器生成了非持久性状态的数据，那么可以考虑使用tmpfs mounts,因为他可以避免永久存储数据，以及写入容器的可写层时增加容器的负担。

volumes数据卷使用

接下来以数据卷为例，演示Docker如何进行数据管理

创建并管理数据卷

（1）创建数据卷

在docker主机终端上，通过docker volume create 指令创建一个名为my-vol的数据卷，指令如下：

$ docker volume create my-vol

（2）查看数据卷

使用docker volume ls指令查看本地数据卷列表，指令如下:

$ docker volume ls

运行上述指令后，会列举出本地Docker机器上的所有数据卷，效果如下：

$ docker volume ls
DRIVER              VOLUME NAME
local               my-vol

（3）核查数据卷

使用docker volume inspect指令查看指定数据卷详情，效果如下：

$ docker volume inspect my-vol
[
    {
        "CreatedAt": "2020-12-08T15:19:31+08:00",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/my-vol/_data",
        "Name": "my-vol",
        "Options": {},
        "Scope": "local"
    }
]

（4）删除数据卷

$ docker volume rm my-vol

启动容器并加载数据卷

下面演示如果在容器创建时配置并管理docker volume数据卷。

（1）查看本机容器和数据卷

首先我们进入/var/lib/docker目录，即docker默认在本机上的文件系统目录，效果如下：
```
$ cd /var/lib/docker/
$ ll
总用量 24
drwx------.  2 root root   24 8月  24 17:38 builder
drwx--x--x.  4 root root   92 8月  24 17:38 buildkit
drwx------.  2 root root    6 12月  8 14:21 containers
drwx------.  3 root root   22 8月  24 17:38 image
drwxr-x---.  3 root root   19 8月  24 17:38 network
drwx------. 47 root root 8192 12月  8 14:21 overlay2
drwx------.  4 root root   32 8月  24 17:38 plugins
drwx------.  2 root root    6 12月  8 14:10 runtimes
drwx------.  5 root root   95 12月  8 14:11 swarm
drwx------.  2 root root    6 12月  8 14:35 tmp
drwx------.  2 root root    6 8月  24 17:38 trust
drwx------. 53 root root 8192 12月  8 15:19 volumes
```
本机docker机器的文件系统中包含了两个重要的文件目录，分别为containers和volumes，这两个目录就是用于存放用户创建的容器和数据卷的。

（2）启动容器并挂载数据卷

使用docker run指令创建并启动一个容器，同时挂载一个数据卷，指令如下：
```
$ docker run -itd \
	--name devtest \
	--mount source=myvol,target=/app \
	busybox:latest
```
也可以使用-v参数挂载数据卷，指令如下：
```
$ docker run -itd \
	--name devtest2 \
	-v myvol:/app \
	busybox:latest
```
在上述指令中，分别通过–mount和-v两种参数来实现数据卷的挂载，这两个容器共享了同一个数据卷myvol，并将该数据卷挂载到了各自容器中的app目录下。

上述指令中出现的两个参数–mount和-v，需要进一步说明，具体如下所示：

–mount参数

由多个key=value形式的键值对组成，键值对之间用英文逗号分隔，–mount参数语法比-v参数语法更为详细，键的顺序可随意，标记的值也更容易理解，关于–mount的键值说明如下：
- type(挂载的类型)：可以是bind，volume或tmpfs，当前使用的是数据卷，因此类型是volume
- source(挂载源)：对于命名的数据卷来说，这就是数据卷的名称，而对于匿名卷，该字段被省略，该字段可以用source或src表示
- destination(挂载点)：就是将文件或目录挂载到容器中的具体路径，该字段可以用destination，dst或target表示
- readonly参数：如果出现了该参数，则挂载到容器中的数据就表示是只读的
-v(–volumn的缩写)参数

有三个字段组成，分别有冒号（:）分隔，字段必须以正确的顺序排列，而且每个字段的含义都特别明确，关于-v参数属性值的说明如下：
- 在命名券的情况下，第一个字段是数据卷的名称，在给定的主机上是唯一的，对于匿名卷，将会省略第一个字段
- 第二个字段是在容器中挂载数据的文件或目录的路径
- 第三个字段是可选的，是一个逗号分隔的列表，如ro（readonly,即只读）
需要注意的是，在本小节讲解的是使用Volumes进行数据管理，不管是–mount source=myvol 还是 -v myvol，前面第一个参数都是设置的数据卷名称，执行完指令后，会自动在docker文件系统的数据卷目录/var/lib/docker/volumes下创建一个myvol子目录来保存数据，如果是使用Bind mounts进行数据管理，那么第一个参数就是宿主机保存数据的具体地址（如 -v /src/myvolume/data:/app）。

（3）查看本机容器和数据卷列表

在docker主机终端使用docker ps 和docker volume ls指令查看本地docker机器上的容器和数据卷，效果如下：
```
docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                       PORTS               NAMES
7469b8526be3        busybox:latest      "sh"                     29 minutes ago      Exited (255) 2 minutes ago                       devtest2
be050467da4e        busybox:latest      "sh"                     29 minutes ago      Exited (255) 2 minutes ago                       devtest
[root@localhost1 ~]# docker volume ls
DRIVER              VOLUME NAME
local               myvol
```
值得一提的是，如果容器在创建时数据卷不存在，则docker会自动创建。

（4）检查容器详情

使用docker inspect指令查看容器详情（主要查看挂载信息部分），指令如下：
```
$ docker inspect devtest
```
效果如下（仅挂载信息部分）：
```
"Mounts": [
    {
    "Type": "volume",
    "Name": "myvol",
    "Source": "/var/lib/docker/volumes/myvol/_data",
    "Destination": "/app",
    "Driver": "local",
    "Mode": "z",
    "RW": true,
    "Propagation": ""
    }
],
```
可以看出，其中挂载类型为volume,数据卷名称为myvol,数据在本地Docker机器上对应的存储地址，数据在容器中对应地址app目录以及容器中数据是可读写(RW: true)等.

（6）再次确认本机docker文件系统中容器和数据卷

再次进入/var/lib/docker/volumes目录查看内容，结果如下：
```
$ ll volumes/
-rw-------. 1 root root 65536 12月  8 15:58 metadata.db
drwxr-xr-x. 3 root root    19 12月  8 15:31 myvol
```
可以看到新建的数据卷已经自动生成在本地docker文件目录中，此时如果我们将两个容器都删除，则本地docker文件目录中的容器也会自动消失，但数据卷却可以保留，除非数据卷也被删除。
```
       COMMAND                  CREATED             STATUS                       PORTS               NAMES
```
7469b8526be3 busybox:latest “sh” 29 minutes ago Exited (255) 2 minutes ago devtest2
be050467da4e busybox:latest “sh” 29 minutes ago Exited (255) 2 minutes ago devtest
[root@localhost1 ~]# docker volume ls
DRIVER VOLUME NAME
local myvol
```
值得一提的是，如果容器在创建时数据卷不存在，则docker会自动创建。

（4）检查容器详情

使用docker inspect指令查看容器详情（主要查看挂载信息部分），指令如下：

```bash
$ docker inspect devtest
```
效果如下（仅挂载信息部分）：
```
"Mounts": [
    {
    "Type": "volume",
    "Name": "myvol",
    "Source": "/var/lib/docker/volumes/myvol/_data",
    "Destination": "/app",
    "Driver": "local",
    "Mode": "z",
    "RW": true,
    "Propagation": ""
    }
],
```
可以看出，其中挂载类型为volume,数据卷名称为myvol,数据在本地Docker机器上对应的存储地址，数据在容器中对应地址app目录以及容器中数据是可读写(RW: true)等.

（6）再次确认本机docker文件系统中容器和数据卷

再次进入/var/lib/docker/volumes目录查看内容，结果如下：
```
$ ll volumes/
-rw-------. 1 root root 65536 12月  8 15:58 metadata.db
drwxr-xr-x. 3 root root    19 12月  8 15:31 myvol
```
可以看到新建的数据卷已经自动生成在本地docker文件目录中，此时如果我们将两个容器都删除，则本地docker文件目录中的容器也会自动消失，但数据卷却可以保留，除非数据卷也被删除。

你可能感兴趣的:(docker,docker)

PHP环境搭建详细教程好看资源平台前端 php
PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
docker igotyback eureka 云原生
Docker容器的文件系统是隔离的，但是可以通过挂载卷（Volumes）或绑定挂载（BindMounts）将宿主机的文件系统目录映射到容器内部。要查看Docker容器的映射路径，可以使用以下方法：查看容器配置：使用dockerinspect命令可以查看容器的详细配置信息，包括挂载的卷。例如：bashdockerinspect在输出的JSON格式中，查找"Mounts"部分，这里会列出所有的挂载信息
06选课支付模块之基于消息队列发送支付通知消息 echo 云清学成在线 java rabbitmq 消息队列支付通知学成在线
消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
Ubuntu18.04 Docker部署Kinship(Django)项目过程 Dante617
1Docker的安装https://blog.csdn.net/weixin_41735055/article/details/1003551792下载镜像dockerpullprogramize/python3.6.8-dlib下载的镜像里包含python3.6.8和dlib19.17.03启动镜像dockerrun-it--namekinship-p7777:80-p3307:3306-p55
docker from指令的含义_多个FROM-含义 weixin_39722188 docker from指令的含义
小编典典什么是基本图片？一组文件，加上EXPOSE端口ENTRYPOINT和CMD。您可以添加文件并基于该基础图像构建新图像，Dockerfile并以FROM指令开头：后面提到的图像FROM是新图像的“基础图像”。这是否意味着如果我neo4j/neo4j在FROM指令中声明，则在运行映像时，neo数据库将自动运行并且可在端口7474的容器中使用？仅当您不覆盖CMD和时ENTRYPOINT。但是图像
Dockerfile FROM 两个 redDelta
Docker相关视频讲解：什么是容器Docker介绍实现"DockerfileFROM两个"的步骤步骤表格步骤操作1创建一个Dockerfile文件2写入FROM指令3构建第一个镜像4创建第二个Dockerfile文件5写入FROM指令6构建第二个镜像7合并两个镜像操作步骤说明步骤1：创建一个Dockerfile文件使用任意文本编辑器创建一个名为Dockerfile的文件。登录后复制#Docker
Dockerfile命令详解之 FROM 清风怎不知意容器化 java 前端 javascript
许多同学不知道Dockerfile应该如何写，不清楚Dockerfile中的指令分别有什么意义，能达到什么样的目的，接下来我将在容器化专栏中详细的为大家解释每一个指令的含义以及用法。专栏订阅传送门https://blog.csdn.net/qq_38220908/category_11989778.html指令不区分大小写。但是，按照惯例，它们应该是大写的，以便更容易地将它们与参数区分开来。(引用
Dockerfile（1） - FROM 指令详解小菠萝测试笔记 docker python java cmd 大数据
FROM指明当前的镜像基于哪个镜像构建dockerfile必须以FROM开头，除了ARG命令可以在FROM前面FROM[--platform=][AS]FROM[--platform=][:][AS]FROM[--platform=][@][AS]小栗子FROMalpine:latest一个dockerfile可以有多个FROM可以有多个FROM来创建多个镜像，或区分构建阶段，将一个构建阶段作为另
【从问题中去学习k8s】k8s中的常见面试题（夯实理论基础）（二十八）向往风的男子 k8s 学习 kubernetes 容器
本站以分享各种运维经验和运维所需要的技能为主《python零基础入门》：python零基础入门学习《python运维脚本》：python运维脚本实践《shell》：shell学习《terraform》持续更新中：terraform_Aws学习零基础入门到最佳实战《k8》从问题中去学习k8s《docker学习》暂未更新《ceph学习》ceph日常问题解决分享《日志收集》ELK+各种中间件《运维日常》
【K8s】专题十一：Kubernetes 集群证书过期处理方法行者Sun1989 Kubernetes kubernetes 云原生容器
本文内容均来自个人笔记并重新梳理，如有错误欢迎指正！如果对您有帮助，烦请点赞、关注、转发、订阅专栏！专栏订阅入口Linux专栏|Docker专栏|Kubernetes专栏往期精彩文章【Docker】（全网首发）KylinV10下MySQL容器内存占用异常的解决方法【Docker】（全网首发）KylinV10下MySQL容器内存占用异常的解决方法（续）【Docker】MySQL源码构建Docker镜
Docker学习十一：Kubernetes概述爱打羽球的程序猿 Docker学习系列 docker kubernetes 学习
一、Kubernetes简介2006年，Google提出了云计算的概念，当时的云计算领域还是以虚拟机为代表的云平台。2013年，Docker横空出世，Docker提出了镜像、仓库等核心概念，规范了服务的交付标准，使得复杂服务的落地变得更加简单，之后Docker又定义了OCI标准，Docker在容器领域称为事实的标准。但是，Docker诞生只是帮助定义了开发和交付标准，如果想要在生产环境中大批量的使
安装 `privoxy` 将 Socks5 转换为 HTTP 代理 MonkeyKing.sun 网络
(base)shgbitai@shgbitai-C9X299-PGF:~/tools$curl-xhttp://127.0.0.1:1080https://registry-1.docker.io/v2/curl:(56)ProxyCONNECTaborted(base)shgbitai@shgbitai-C9X299-PGF:~/tools$curl-xhttps://127.0.0.1:108
Halo 开发者指南——容器私有化部署 SHENHUANJIE Docker Halo 华为云 SWR Registry
华为云SWR私有化部署镜像构建dockerbuild-thalo-dev/halo:2.20.0.上传镜像镜像标签sudodockertag{镜像名称}:{版本名称}swr.cn-south-1.myhuaweicloud.com/{组织名称}/{镜像名称}:{版本名称}sudodockertaghalo-dev/halo:2.20.0swr.cn-south-1.myhuaweicloud.co
SpringBoot整合ES搜索引擎实现网站热搜词及热度计算码踏云端 springboot Elasticsearch spring boot elasticsearch 后端热搜词热度计算 java
博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
小白 | 华为云docker设置镜像加速器伏一工具安装华为云 docker 容器
一、操作场景通过dockerpull命令下载镜像中心的公有镜像时，往往会因为网络原因而需要很长时间，甚至可能因超时而下载失败。为此，容器镜像服务提供了镜像下载加速功能，帮助您获得更快的下载体验。二、约束与限制构建镜像的客户端所安装的容器引擎（Docker）版本必须为1.11.2及以上。“华北-乌兰察布一”、“亚太-雅加达”、“拉美-墨西哥城一”、“拉美-墨西哥城二”和“拉美-圣保罗一”区域不支持该
docker改容器IP的两种方法 redmond88 linux docker tcp/ip 容器
最简单实用的方法：docker默认的内网网段为172.17.0.0/16，如果公司内网网段也是172.17.x.x的话，就会发生路由冲突。解决办法改路由比较办法，可以一开始就将docker配置的bip改成169.254.0.1/24，可以避免冲突。在daemon配置文件里加个"bip":“169.254.0.1/24”，重启docker就可以了1234[root@st-dev6~]#vim/etc
docker 安装、运行nginx shell脚本三希 docker nginx 容器
以下是一个简单的用于安装和运行DockerNginx的shell脚本：bash#!/bin/bash#安装Docker（如果还未安装）#请根据实际情况调整安装命令#拉取Nginx镜像dockerpullnginx#运行Nginx容器dockerrun-d--namemynginx-p80:80nginx
docker项目切换（nginx）、重启shell 脚本懒惰的小蜗牛 docker docker nginx 容器
docker项目切换、重启脚本背景具体操作nginx配置配置文件1配置文件2编写nginx替换脚本(用来执行端口替换)编写启动脚本dockerfile文件正常编写给脚本授权执行./start脚本背景项目部署docker中，更新项目时，需要将原原来的容器停止，再启动新的容器，这样会有一个空窗期，导致不可用解决方案：映射不同的端口并启动新的容器，将nginx转发到新容器，停止旧容器具体操作说明ngin
FastCGI结合docker下的Nginx执行shell脚本南波波 nginx docker
1使用docker下载Nginx下面展示一些内联代码片。a.#dockerpullnginx#dockerrun--namerunoob-php-nginx-p8088:80-d\-v~/nginx/www:/usr/share/nginx/html:ro\-v~/nginx/conf/conf.d:/etc/nginx/conf.d:ro\nginxb.在~/nginx/conf/conf.d创
【docker npm】npm 私库琴韵 docker npm 容器
1.部署环境window11x64DockerDesktop4.34.1(166053)DockerEnginev27.2.01.1.Docker镜像源1.1.1.DockerEngine配置{"builder":{"features":{"buildkit":true},"gc":{"defaultKeepStorage":"32GB","enabled":true}},"experimenta
Docker安装Kafka和Kafka-Manager 阿靖哦
本文介绍如何通过Docker安装kafka与kafka界面管理界面一、拉取zookeeper由于kafka需要依赖于zookeeper，因此这里先运行zookeeper1、拉取镜像dockerpullwurstmeister/zookeeper2、启动dockerrun-d--namezookeeper-p2181:2181-eTZ="Asia/Shanghai"--restartalwayswu
主流行架构 rainbowcheng 架构架构
nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
单节点canal的介绍和搭建（对接mysql和rocketMQ）汀风中间件阿里云 mysql java
单节点canal-server+canal-admin的介绍和搭建（对接mysql和rocketMQ）一、简介1、Canal1、工作原理2、MySQL主从复制实现3、canal架构4、binarylog1、新增binlog2、更新binglog3、增加字段bin-log4、删除字段bin-log5、修改字段bin-log二、使用2.1安装1、本地安装2、docker安装canal-admincan
【大模型】triton inference server idiotyi 大模型自然语言处理语言模型人工智能
前言：tritoninferenceserver常用于大模型部署，可以采用http或GRPC调用，支持大部分的backend，单GPU、多GPU都可以支持，CPU也支持。本文主要是使用tritoninferenceserver部署大模型的简单流程示例。目录1.整体流程2.搭建本地仓库3.服务端代码4.启动服务5.客户端调用1.整体流程搭建模型仓库模型配置服务端调用代码docker启动服务客户端调用
基于Prometheus和Grafana的现代服务器监控体系构建 golove666 运维 prometheus grafana 服务器
构建一个基于Prometheus和Grafana的现代服务器监控体系涉及多个步骤。以下是大体的流程和步骤说明：1.Prometheus监控系统Prometheus是一个开源的系统监控和报警工具，专门设计用于抓取时间序列数据。1.1Prometheus的安装Docker安装Prometheusdockerrun-d--name=prometheus-p9090:9090prom/prometheus
手把手教你企业微信SCRM源码下载和私有化部署教程 MoChat-1号 php 微信微信公众平台微信开放平台
服务器要求MoChat对系统环境有一些要求，仅可运行于Linux和Mac环境下，但由于Docker虚拟化技术的发展，在Windows下也可以通过DockerforWindows来作为运行环境，通常来说Mac环境下，我们更推荐本地环境部署，以避免Docker共享磁盘缓慢导致MoChat启动速度慢的问题。提示MoChat基于Docker-compose方式的安装视频https://www.bilibi
Docker 常用命令 C语言扫地僧 Linux专栏 docker 容器
1Docker镜像命令1.1dockerimages#语法dockerimages[OPTIONS][REPOSITORY[:TAG]]#别名dockerimagels,dockerimagelist功能列出本地镜像。关键参数-a:列出本地所有的镜像（含中间映像层，默认情况下，过滤掉中间映像层）；--digests:显示镜像的摘要信息；-f:显示满足条件的镜像；--format:指定返回值的模板文
Docker 安装配置和基本命令详解以及案例示范 J老熊 docker 容器运维面试 linux
1.引言容器化技术的快速发展给软件开发和运维带来了革命性的变化，Docker作为这一领域的领军者，已经成为软件开发和部署流程中的重要工具。Docker的轻量化、快速启动和高效资源利用让开发者能够在不同的环境中实现一致的开发体验。本篇文章将详细讲解如何在CentOS系统中安装Docker，如何配置阿里云镜像加速，Docker的基本命令和语法，以及通过实际的电商交易系统案例来演示如何在Docker环境
docker镜像的批量备份和加载小卡车555 docker
随着微服务的不断发展，docker在微服务的部署中也占着不可缺少的角色，有这样一种场景，需要将服务器上的若干个最新的镜像打成tar.gz做一个备份或者异地部署。针对此问题尝试写了如下shell脚本#vimsaveImages.sh脚本内容如下：#当前需要打包的版本号version=xxx.0.0.1-RELEASE#仓库rep=defaultRep#名称name=defaultNameforiin
docker Pulling fs layer 含义潇锐killer eureka java spring cloud
在使用Docker时，当你执行dockerpull命令来获取一个新的镜像，控制台输出中可能会出现"Pullingfslayer"的信息。这是Docker拉取镜像过程中的一个步骤，下面是对这一过程的解释：Docker镜像是由一系列的层（layers）组成的。每个层代表了镜像构建过程中的一个步骤，比如安装一个软件包或复制一些文件。这种层式结构使得Docker镜像既轻便又高效，因为它允许多个镜像共享相同
PHP如何实现二维数组排序？ IT独行者二维数组 PHP 排序　
二维数组在PHP开发中经常遇到，但是他的排序就不如一维数组那样用内置函数来的方便了，（一维数组排序可以参考本站另一篇文章【PHP中数组排序函数详解汇总】）。二维数组的排序需要我们自己写函数处理了，这里UncleToo给大家分享一个PHP二维数组排序的函数：代码： functionarray_sort($arr,$keys,$type='asc'){ $keysvalue= $new_arr
【Hadoop十七】HDFS HA配置 bit1129 hadoop
基于Zookeeper的HDFS HA配置主要涉及两个文件,core-site和hdfs-site.xml。测试环境有三台 hadoop.master hadoop.slave1 hadoop.slave2 hadoop.master包含的组件NameNode, JournalNode, Zookeeper，DFSZKFailoverController
由wsdl生成的java vo类不适合做普通java vo darrenzhu VO wsdl webservice rpc
开发java webservice项目时，如果我们通过SOAP协议来输入输出，我们会利用工具从wsdl文件生成webservice的client端类，但是这里面生成的java data model类却不适合做为项目中的普通java vo类来使用，当然有一中情况例外，如果这个自动生成的类里面的properties都是基本数据类型，就没问题，但是如果有集合类，就不行。原因如下： 1)使用了集合如Li
JAVA海量数据处理之二（BitMap）周凡杨 java 算法 bitmap bitset 数据
路漫漫其修远兮，吾将上下而求索。想要更快，就要深入挖掘 JAVA 基础的数据结构，从来分析出所编写的 JAVA 代码为什么把内存耗尽，思考有什么办法可以节省内存呢？啊哈！算法。这里采用了 BitMap 思想。首先来看一个实验：指定 VM 参数大小： -Xms256m -Xmx540m
java类型与数据库类型 g21121 java
很多时候我们用hibernate的时候往往并不是十分关心数据库类型和java类型的对应关心，因为大多数hbm文件是自动生成的，但有些时候诸如：数据库设计、没有生成工具、使用原始JDBC、使用mybatis(ibatIS)等等情况，就会手动的去对应数据库与java的数据类型关心，当然比较简单的数据类型即使配置错了也会很快发现问题，但有些数据类型却并不是十分常见，这就给程序员带来了很多麻烦。 &nb
Linux命令 510888780 linux命令
系统信息 arch 显示机器的处理器架构(1) uname -m 显示机器的处理器架构(2) uname -r 显示正在使用的内核版本 dmidecode -q 显示硬件系统部件 - (SMBIOS / DMI) hdparm -i /dev/hda 罗列一个磁盘的架构特性 hdparm -tT /dev/sda 在磁盘上执行测试性读取操作 cat /proc/cpuinfo 显示C
java常用JVM参数墙头上一根草 java jvm参数
-Xms：初始堆大小，默认为物理内存的1/64(<1GB)；默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制 -Xmx：最大堆大小，默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时，JVM会减少堆直到 -Xms的最小限制 -Xmn：新生代的内存空间大小，注意：此处的大小是（eden+ 2
我的spring学习笔记9-Spring使用工厂方法实例化Bean的注意点 aijuans Spring 3
方法一： <bean id="musicBox" class="onlyfun.caterpillar.factory.MusicBoxFactory" factory-method="createMusicBoxStatic"></bean> 方法二：
mysql查询性能优化之二 annan211 UNION mysql 查询优化索引优化
1 union的限制有时mysql无法将限制条件从外层下推到内层，这使得原本能够限制部分返回结果的条件无法应用到内层查询的优化上。如果希望union的各个子句能够根据limit只取部分结果集，或者希望能够先排好序在合并结果集的话，就需要在union的各个子句中分别使用这些子句。例如想将两个子查询结果联合起来，然后再取前20条记录，那么mys
数据的备份与恢复百合不是茶 oracle sql 数据恢复数据备份
数据的备份与恢复的方式有: 表,方案 ,数据库; 数据的备份: 导出到的常见命令; 参数说明 USERID 确定执行导出实用程序的用户名和口令 BUFFER 确定导出数据时所使用的缓冲区大小，其大小用字节表示 FILE 指定导出的二进制文
线程组 bijian1013 java 多线程 thread java多线程线程组
有些程序包含了相当数量的线程。这时，如果按照线程的功能将他们分成不同的类别将很有用。线程组可以用来同时对一组线程进行操作。创建线程组：ThreadGroup g = new ThreadGroup(groupName); &nbs
top命令找到占用CPU最高的java线程 bijian1013 java linux top
上次分析系统中占用CPU高的问题，得到一些使用Java自身调试工具的经验，与大家分享。 (1)使用top命令找出占用cpu最高的JAVA进程PID:28174 (2)如下命令找出占用cpu最高的线程 top -Hp 28174 -d 1 -n 1 32694 root 20 0 3249m 2.0g 11m S 2 6.4 3:31.12 java
【持久化框架MyBatis3四】MyBatis3一对一关联查询 bit1129 Mybatis3
当两个实体具有1对1的对应关系时，可以使用One-To-One的进行映射关联查询 One-To-One示例数据以学生表Student和地址信息表为例，每个学生都有都有1个唯一的地址(现实中，这种对应关系是不合适的，因为人和地址是多对一的关系)，这里只是演示目的学生表 CREATE TABLE STUDENTS (
C/C++图片或文件的读写 bitcarter 写图片
先看代码： /*strTmpResult是文件或图片字符串 * filePath文件需要写入的地址或路径 */ int writeFile(std::string &strTmpResult,std::string &filePath) { int i,len = strTmpResult.length(); unsigned cha
nginx自定义指定加载配置 ronin47
进入 /usr/local/nginx/conf/include 目录，创建 nginx.node.conf 文件，在里面输入如下代码： upstream nodejs { server 127.0.0.1:3000; #server 127.0.0.1:3001; keepalive 64; } server { liste
java-71-数值的整数次方.实现函数double Power(double base, int exponent)，求base的exponent次方 bylijinnan double
public class Power { /** *Q71-数值的整数次方 *实现函数double Power(double base, int exponent)，求base的exponent次方。不需要考虑溢出。 */ private static boolean InvalidInput=false; public static void main(
Android四大组件的理解 Cb123456 android 四大组件的理解
分享一下，今天在Android开发文档-开发者指南中看到的: App components are the essential building blocks of an Android
[宇宙与计算]涡旋场计算与拓扑分析 comsci 计算
怎么阐述我这个理论呢？。。。。。。。。。首先：宇宙是一个非线性的拓扑结构与涡旋轨道时空的统一体。。。。我们要在宇宙中寻找到一个适合人类居住的行星，时间非常重要，早一个刻度和晚一个刻度，这颗行星的
同一个Tomcat不同Web应用之间共享会话Session cwqcwqmax9 session
实现两个WEB之间通过session 共享数据查看tomcat 关于 HTTP Connector 中有个emptySessionPath 其解释如下： If set to true, all paths for session cookies will be set to /. This can be useful for portlet specification impleme
springmvc Spring3 MVC，ajax，乱码 dashuaifu spring jquery mvc Ajax
springmvc Spring3 MVC @ResponseBody返回，jquery ajax调用中文乱码问题解决 Spring3.0 MVC @ResponseBody 的作用是把返回值直接写到HTTP response body里。具体实现AnnotationMethodHandlerAdapter类handleResponseBody方法，具体实
搭建WAMP环境 dcj3sjt126com wamp
这里先解释一下WAMP是什么意思。W:windows，A：Apache，M：MYSQL，P：PHP。也就是说本文说明的是在windows系统下搭建以apache做服务器、MYSQL为数据库的PHP开发环境。工欲善其事，必须先利其器。因为笔者的系统是WinXP，所以下文指的系统均为此系统。笔者所使用的Apache版本为apache_2.2.11-
yii2 使用raw http request dcj3sjt126com http
Parses a raw HTTP request using yii\helpers\Json::decode() To enable parsing for JSON requests you can configure yii\web\Request::$parsers using this class: 'request' =&g
Quartz-1.8.6 理论部分 eksliang quartz
转载请出自出处：http://eksliang.iteye.com/blog/2207691 一.概述基于Quartz-1.8.6进行学习，因为Quartz2.0以后的API发生的非常大的变化，统一采用了build模式进行构建；什么是quartz? 答：简单的说他是一个开源的java作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。并且还能和Sp
什么是POJO？ gupeng_ie java POJO 框架 Hibernate
POJO--Plain Old Java Objects(简单的java对象) POJO是一个简单的、正规Java对象，它不包含业务逻辑处理或持久化逻辑等，也不是JavaBean、EntityBean等，不具有任何特殊角色和不继承或不实现任何其它Java框架的类或接口。 POJO对象有时也被称为Data对象，大量应用于表现现实中的对象。如果项目中使用了Hiber
jQuery网站顶部定时折叠广告 ini JavaScript html jquery Web css
效果体验：http://hovertree.com/texiao/jquery/4.htmHTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>网页顶部定时收起广告jQuery特效 - HoverTree<
Spring boot内嵌的tomcat启动失败 kane_xie spring boot
根据这篇guide创建了一个简单的spring boot应用，能运行且成功的访问。但移植到现有项目（基于hbase）中的时候，却报出以下错误： SEVERE: A child container failed during start java.util.concurrent.ExecutionException: org.apache.catalina.Lif
leetcode: sort list michelle_0916 Algorithm linked list sort
Sort a linked list in O(n log n) time using constant space complexity. ====analysis======= mergeSort for singly-linked list ====code======= /** * Definition for sin
nginx的安装与配置,中途遇到问题的解决 qifeifei nginx
我使用的是ubuntu13.04系统，在安装nginx的时候遇到如下几个问题，然后找思路解决的，nginx 的下载与安装 wget http://nginx.org/download/nginx-1.0.11.tar.gz tar zxvf nginx-1.0.11.tar.gz ./configure make make install 安装的时候出现
用枚举来处理java自定义异常 tcrct java enum exception
在系统开发过程中，总少不免要自己处理一些异常信息，然后将异常信息变成友好的提示返回到客户端的这样一个过程，之前都是new一个自定义的异常，当然这个所谓的自定义异常也是继承RuntimeException的，但这样往往会造成异常信息说明不一致的情况，所以就想到了用枚举来解决的办法。 1，先创建一个接口，里面有两个方法，一个是getCode, 一个是getMessage public
erlang supervisor分析 wudixiaotie erlang
当我们给supervisor指定需要创建的子进程的时候，会指定M,F,A,如果是simple_one_for_one的策略的话，启动子进程的方式是supervisor:start_child(SupName, OtherArgs),这种方式可以根据调用者的需求传不同的参数给需要启动的子进程的方法。和最初的参数合并成一个数组，A ++ OtherArgs。那么这个时候就有个问题了，既然参数不一致，那

Docker及DockerSwarm讲解

Docker

Docker的特点

Docker和虚拟机的区别

Docker的安装

Docker compose安装

Docker运行机制

Docker架构

Dockerfile

Dockerfile基本结构

常用指令

.dockerignore

Docker客户端常用指令

Docker Hub远程镜像管理

Docker镜像管理

Docker Hub远程镜像管理

Docker Registry私有仓库

保护Docker Registry

Docker Network

Docker默认网络管理

自定义网络

自定义Bridge网络

容器之间的网络通信

Docker Swarm集群

Docker Swarm概述

Docker Swarm使用

Docker 数据管理

Docker数据存储机制

Docker数据存储方式

volumes数据卷管理方式

volumes数据卷使用

你可能感兴趣的:(docker,docker)