docker基本应用

docker

安装

#下载Centos 7 基础镜像源
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.cloud.tencent.com/repo/centos7_base.repo
#下载epel源
wget -O /etc/yum.repos.d/epel.repo http://mirrors.cloud.tencent.com/repo/epel-7.repo
#下载docker-ce源
wget -O /etc/yum.repos.d/docker-ce.repo https://download.docker.com/linux/centos/docker-ce.repo

#执行安装
yum remove -y docker-ce  docker-common  docker-selinux docker-engine container-selinux containerd.io
yum -y install docker-ce

#启动
systemctl start docker
systemctl enable docker

#配置镜像加速器
#docker中国官方加速器
cat > /etc/docker/daemon.json <<EOF
{
  "registry-mirrors": ["https://registry.docker-cn.com"]
}
EOF

#重新加载配置
systemctl reload docker

#确认安装
docker --version
docker info

docker基本使用

docker是一个软件打包技术，架构为C/S架构，包含客户端和服务端。

仓库：自定义镜像仓库

镜像：一次镜像处处运行

容器：运行镜像

[root@oldboy ~]# docker --version
Docker version 19.03.10, build 9424aeaee9

[root@oldboy ~]# docker info 
Client:
 Debug Mode: false

Server:
 Containers: 4
  Running: 1
  Paused: 0
  Stopped: 3
 Images: 4
 Server Version: 19.03.10
 Storage Driver: overlay2
  Backing Filesystem: xfs
  Supports d_type: true
  Native Overlay Diff: true
 Logging Driver: json-file
 Cgroup Driver: cgroupfs
 Plugins:
  Volume: local
  Network: bridge host ipvlan macvlan null overlay
  Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog
 Swarm: inactive
 Runtimes: runc
 Default Runtime: runc
 Init Binary: docker-init
 containerd version: 7ad184331fa3e55e52b890ea95e65ba581ae3429
 runc version: dc9208a3303feef5b3839f4323d9beb36df0a9dd
 init version: fec3683
 Security Options:
  seccomp
   Profile: default
 Kernel Version: 3.10.0-957.el7.x86_64
 Operating System: CentOS Linux 7 (Core)
 OSType: linux
 Architecture: x86_64
 CPUs: 1
 Total Memory: 972.6MiB
 Name: oldboy
 ID: TZWK:GEIN:LZGW:CRL3:6K5K:MVQ5:QVGQ:EEX5:QYHP:NYNK:G4QD:AI5L
 Docker Root Dir: /var/lib/docker
 Debug Mode: false
 Registry: https://index.docker.io/v1/
 Labels:
 Experimental: false
 Insecure Registries:
  127.0.0.0/8
 Registry Mirrors:
  https://registry.docker-cn.com/
 Live Restore Enabled: false

使用

#容器的打包技术：在不安装nginx的情况下，启用nginx容器，就可以正常使用nginx服务。
docker run -d -p 80:80 nginx:lastest

docker images

docker images 列出本机上的镜像

repository --表示镜像的仓库源

tag --表示镜像的标签

image id --镜像的ID

create --镜像的创建时间

size --镜像的大小

参数

-a 列出本地的所有镜像及子镜像

-q 只显示镜像ID

–digests 显示镜像的摘要信息

–no-trunc 显示完整的镜像信息

docker search

从docker仓库中查找镜像，默认从/etc/docker/daemo.json文件中定义的路径中查找。

[root@oldboy ~]# cat /etc/docker/daemon.json 
{
"registry-mirrors":["https://registry.docker-cn.com"]
}

[root@oldboy ~]# docker search  nginx
NAME   DESCRIPTION               STARS      OFFICIAL            AUTOMATED
nginx  Official build of Nginx.    13914       ok                   

NAME ：镜像名称

DESCRIPTION ：描述

STARS ：星级

OFFICIAL ：是否官方

AUTOMATED ：自定义

参数

–no-trunc 显示完整的镜像描述

-s 数字，列出收藏数字

–automated 只列出automated build类型构建的镜像

docker pull

docker search alpine                   #在线查找镜像
docker pull alpine                     #在线下载镜像
docker pull alpine:3.9
docker image ls  或者  docker images    #查看本地镜像列表

不标记镜像版本，默认下载最新的镜像（latest）,镜像都是压缩文件，可以解压查看文件。可以将其导出，然后分析该镜像的文件内容和设置。

docker save

docker save  nginx:latest -o docker_nginx.tar.gz

-o 导出镜像的名称

导出的镜像也可以执行导入

docker load -i docker_nginx.tar.gz

镜像加速

为了永久性保留更改，您可以修改 /etc/docker/daemon.json 文件并添加上 registry-mirrors 键值。

vim /etc/docker/daemon.json
{
  "registry-mirrors": ["https://registry.docker-cn.com"]
}
 systemctl restart docker

docker tag

docker tag centos  centos:v01

docker run

docker run -d -it centos:6.9  [初始命令]
docker run  -it --name oldboy  --rm  alpine:latest /bin/bash

• 运行一个在后台执行的容器，同时，还能用控制台管理：docker run -i -t -d ubuntu:latest
• 运行一个带命令在后台不断执行的容器，不直接展示容器内部信息：docker run -d ubuntu:latest ping www.docker.com
• 运行一个在后台不断执行的容器，同时带有命令，程序被终止后还能重启继续跑，还能用控制台管理，docker run -d --restart=always ubuntu:latest ping www.docker.com
• 为容器指定一个名字，docker run -d --name=ubuntu_server ubuntu:latest
• 容器暴露80端口，并指定宿主机80端口与其通信(: 之前是宿主机端口，之后是容器需暴露的端口)，docker run -d --name=ubuntu_server -p 80:80 ubuntu:latest
• 指定容器内目录与宿主机目录共享(: 之前是宿主机文件夹，之后是容器需共享的文件夹)，docker run -d --name=ubuntu_server -v /etc/www:/var/www ubuntu:latest

run参数说明

run 有两个作用，创建并启动容器

-d 后台运行容器, 指定容器运行于前台还是后台，默认为false

-it 分配一个交互式的终端

–name 不指定名称的时候，容器启动是会产生随机的名称

–rm 表示运行退出之后执行容器删除操作

-v, --volume=[] ， 给容器挂载存储卷，挂载到容器的某个目录

–volumes-from=[] ，给容器挂载其他容器上的存储卷

-e, --env 指定环境变量， 容器中可以使用该环境变量

–net=host 容器网络设置

• ​ bridge:使用docker daemon指定的网络桥接
• ​ host：使用容器主机网络
• ​ container： NAME_or_ID 使用其他容器的网络
• ​ none： 容器使用自己的网络（类似–net=bridge），但是不进行配置

–name="" ,指定容器的名称

–privileged=false ,指定容器是否为特权容器，特权容器拥有所有的capabilities

–restart=always 重启策略

• ​ no
• ​ on-failure
• ​ always

-u, --user 指定容器的用户

-a, --attach 登录容器（必须是以docker run -d启动的容器）

-w, --workdir 指定容器的工作目录

-c, --cpu-shares=0 ,设置容器CPU权重，在CPU共享场景使用

-m, --memory=“” ，指定容器使用内存的上限

-P, --publish-all=false ，容器自动暴露的端口(大写P)

-p, --publish=[] 指定容器暴露的端口

-h，–hostname="" ,指定容器的主机名称

–cidfile="" ， 运行容器后，在指定文件中写入容器PID值，一种典型的监控系统用法

–cpuset="",设置容器可以使用那些CPU，此参数可以用来让容器独占CPU

–device=[] ，添加主机设备给容器，相当于设备直通，

–dns=[] ,指定容器的DNS服务器

–dns-search=[] ， 指定容器的dns搜索域名，写入到容器的/etc/resolv.conf文件

–expose=[] ， 指定容器暴露的端口，即修改镜像的暴露端口

–link=[] ， 指定容器间的关联，使用其他容器的IP、env等信息

–rm=false, 指定容器停止后自动删除容器(不支持以docker run -d启动的容器)

–entrypoint="" ，覆盖images的入口点。

不加参数就是在前台运行。CTRL+C可以结束容器。

宿主机

容器共用宿主机的内核。因此docker只支持linux内核的发行版本。

宿主机是centos6.9的系统，而运行的容器不一定都是，因为会出现有些容器运行的命令可能会没有。但是所有的linux操作系统的内核都是一样的，因此可以正常运行，按照linux的发行版本的固有命令来执行。

centos  yum
debian  apt-get
ubuntu  apt-get
alpine  apk
suse    zypper

容器

docker container ls
docker ps                   #默认只现实运行中的容器
docker ps --all  或者  docker ps -a
docker ps -l                #-l只显示最后一个启动的容器

默认按照启动时间排序

create

docker create --name oldboy centos:6.9          #固定一个容器的名称
docker run -d -it --name oldgril centos:latest  #固定一个镜像的名称

start

可以启动create的容器，也可以启动run的容器

docker start [容器id/name]
docker start oldgril


docker run --name container_01 -i -t ubuntu:latest  /bin/bash
exit
docker start -i  container_01

stop

正常停止容器

docker  stop  [容器id/name]

restart

docker  stop  [容器id/name]

kill

能够强制关闭容器（进程）。

docker kill 
docker kill `docker ps -a -q`

删除容器rm

docker rm  [容器id/name]             #删除指定容器
docker rm  `docker ps -a -q`        #删除所有容器
docker rm -f  `docker ps -a -q`     #强制删除所有容器

attach再次进入运行中容器的方法

容器的ID默认为容器的主机名称

docker attach  #画面同步，在同一个终端运行，ctrl+p,ctrl+q离开。

docker run -it   #重启分配一个终端进入，画面不同步，相互操作不影响。
docker exec -it containerID  /bin/bash #使用docker exec命令，可以在容器中执行命令。

如何让容器持续运行

容器启动完成初始命令和任务之后，将会自动退出，可以继续start，相当于重新执行初始命令。如果没有初始命令，运行即停止。

docker -d -it centos:6.9  #可以持续运行，因为终端等待前台交互，终端运行也能满足容器持续运行

nginx -g ‘daemon off’ #前台运行全局命令

[root@oldboy ~]# docker run -d centos:6.9
80ca84fc204fb4e06868b8c080de6558b922b22e66f0e26db21e42fb21ab1b6e
[root@oldboy ~]# docker run -d centos:6.9 sleep 300
3f6909603a96ff02c6374cd2e56428b45f57863809deeac11760aa25002df572
[root@oldboy ~]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
3f6909603a96        centos:6.9          "sleep 300"         4 seconds ago       Up 3 seconds                            cool_williams
2fe21bc92b70        centos:6.9          "sleep 3600"        5 minutes ago       Up 5 minutes                            eager_hawking
[root@oldboy ~]# docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                      PORTS               NAMES
3f6909603a96        centos:6.9          "sleep 300"         40 seconds ago      Up 39 seconds                                   cool_williams
80ca84fc204f        centos:6.9          "/bin/bash"         48 seconds ago      Exited (0) 47 seconds ago                       pensive_burnell
7bcd76128143        centos:6.9          "/bin/bash"         5 minutes ago       Exited (0) 5 minutes ago                        eager_noether
2fe21bc92b70        centos:6.9          "sleep 3600"        6 minutes ago       Up 6 minutes                                    eager_hawking
f2e0e9c2f83c        centos:6.9          "/bin/bash"         7 minutes ago       Exited (0) 6 minutes ago                        great_ellis

端口映射

安装完成docker-ce之后，会多一个docker0的网卡

5: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default 
    link/ether 02:42:b6:fc:e0:f6 brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
       valid_lft forever preferred_lft forever
    inet6 fe80::42:b6ff:fefc:e0f6/64 scope link 
       valid_lft forever preferred_lft forever

端口映射是nat地址转化的一种，让内网某台服务映射到外网能够访问。docker自己会完成端口映射规则的配置。

iptables -nL -t nat         #查看端口映射规则

docker 通过-p参数来设置端口映射。容器的端口映射只能在启动时添加，后续添加不太方便。

docker run -d -p 90:80 nginx   #将宿主机的90端口映射到容器的80端口上。
docker run -d -p 10.0.0.11:80:80 nginx:latest   #特定IP的80->80
docker run -d -p 10.0.0.11::80 nginx:latest   #随机端口访问到容器的80
docker run -d -p 10.0.0.11::80/udp nginx:latest
docker run -d -p 100-110：500-510 nginx:latest  #范围映射

-P (大写)：会自动分配端口。

docker run -d -P nginx:latest

docker logs

docker 运行命令

docker run --name=container_01 -d ubuntu:latest /bin/sh  -c "while true; do echo hello world; sleep 1;done"
docker logs container_01 -f
docker logs container_01 -t

-f #持续跟进运行中的容器的输出日志

-t #显示出log日志每条记录的输出时间

docker exec

在运行中的容器中执行一段进程

docker exec -i -t container_01 /bin/bash
docker  top container_01

可以通过Ctrl + P和Ctrl + Q的组合键来跳出容器，然后通过attach再次进入容器中。

通过docker top 命令来查看运行中的容器的进程情况。

docker cp

#将本地文件复制到容器中
#docker  cp   lcoalfile   containerID:/dest
docker cp kodexplorer4.40.zip c2bbbc24d4ff:/code

paas平台即服务

数据卷

把代码挂在到容器上，-v 挂载目录到容器

docker run -d -p 80:80 -v /opt/xiaoniao:/usr/share/nginx/html nginx:latest

代码在解压在/opt/xiaoxiao/目录下

容器中nginx服务目录： /usr/share/nginx/html/

[root@oldboy ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                NAMES
4d8056d88a67        nginx:latest        "nginx -g 'daemon of…"   5 minutes ago       Up 5 minutes        0.0.0.0:83->80/tcp   nervous_hawking
7145c2acf6d8        nginx:latest        "nginx -g 'daemon of…"   10 minutes ago      Up 10 minutes       0.0.0.0:81->80/tcp   unruffled_poincare

如果要更新代码，修改宿主机上的代码就可以，不再容器上修改。

容器数据的持久化

独立于容器生命周期

-v 容器启动，并在宿主机中创建一个持久化卷（/var/lib/docker/volumes/）

#创建一个数据卷
docker create  volume demo

固定卷到宿主机

随机卷名

docker run -d -p 80:80 -v /usr/share/nginx/html nginx:latest

指定数据卷名称

docker create volume  nginx
docker run -d -p 80:80 -v nginx:/usr/share/nginx/html nginx:latest

将宿主机的指定目录或者文件挂载到容器中。

docker run -d -p 80:80 -v /opt/xiaoniao/:/usr/share/nginx/html nginx:latest

跟随一个已经存在的容器的挂载目录 --volumes-from,实现容器之间的数据共享。

docker run -d -p 80:80 --volumes-from [前一个容器ID] nginx:latest

docker volumes ls
[root@oldboy ~]# docker volume ls
DRIVER              VOLUME NAME
local               4050497a519ce30cb72ad1b91a1eb69e9c9570a1df773f7c371bacac8e316d90
local               aeebf6a7fe109a9571f7846494c1b0796f39ea74023be7fc0c9f2bd9257a111e
local               d9c2a9ccefc6a427b91946aabd5d6d001fda015ac376956288633f944497c229
local               d24e50cc007f99a1ca5682c1b973f3c4997b088741cd9539e67f0bef21c32c75
local               nginx_v1
local               nginx_v2
local               nginx_v3

小实验

80访问默认首页，81访问小鸟飞飞。

一下三种方法都是将小鸟菲菲的代码挂栽到容器中。并修改容器中nginx的配置文件。

#1.将代码挂栽到容器的目录中。
docker run -it -p 80-81:80-81 -v /opt/xiaoniao/:opt/xiaonian nginx:latest
#2.通过echo 或者 cat来完成多行配置文件的导入
#3.重启容器

方法1：
docker run -d -p 80:80 -p 81:81 -v /opt/xiaoniao:/opt/xiaoniao nginx:latest
docker ps -a -l
docker exec -it 06f69f50b04a /bin/bash
cd /etc/nginx/conf.d/
echo '    server {
        listen       81;
        server_name  _;
        root         /opt/xiaoniao;
        index index.html index.htm;
        location / {
        }
    }' >xiaoniao.conf

exit
docker restart 06f69f50b04a

方法2：
docker run -d -p 82:80 -p 83:81 -v /opt/xiaoniao:/opt/xiaoniao nginx:latest
vim  xiaoniao.conf
    server {
        listen       81;
        server_name  _;
        root         /opt/xiaoniao;
        index index.html index.htm;
        location / {
        }
    }
docker ps -a -l
docker cp xiaoniao.conf bb915ba7a8ac:/etc/nginx/conf.d/

docker restart bb915ba7a8ac

方法3：
docker run -d -p 84:80 -p 85:81  -v /root/xiaoniao.conf:/etc/nginx/conf.d/xiaoniao.conf  -v /opt/xiaoniao:/opt/xiaoniao nginx:latest

制作docker镜像

启动一个基础容器，在容器中安装服务，然后将安装好服务的容器提交为镜像。

测试生成的镜像是否可用。

手动制作docker镜像步骤：

1：基于镜像，启动基础容器，在容器中安装服务

docker run -it -p 80:80 centos:6.9 /bin/bash
curl -o /etc/yum.repos.d/epel.repo http://mirrors.cloud.tencent.com/repo/epel-6.repo
yum install nginx -y
yum install php-fpm php-gd php-mbstring -y

2.修改配置文件

编辑一个一次性启动的脚本/init.sh

vi /init.sh

#!/bin/bash
#/bin/bash
php-fpm -D
nginx -g 'daemon off;'

chmod -x /init.sh

vi /etc/nginx/conf.d/default.conf

server {
              listen 80;
              server_name localhost;
              root    /code;
              location / {
              index index.php  index.html index.htm;
              }
      location ~ \.php$ {
        fastcgi_pass 127.0.0.1:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
      }
}

3.上传代码到容器，通过docker cp

mkdir /code
docker cp kodexplorer4.40.zip c2bbbc24d4ff:/code
yum install unzip -y
unzip kodexplorer4.40.zip
chown -R nginx:nginx /code
chmod -R 777 /code/
su -c 'setenforce 0'

测试访问：10.0.0.21

4.提交容器为镜像

docker commit  [容器ID] kod:v1

5.通过提交的镜像完成创建新容器测试kod服务。

[root@oldboy ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED              SIZE
kod                 v1                  c008fe8aedd8        About a minute ago   729MB
alpine              latest              a24bb4013296        40 hours ago         5.57MB
nginx               latest              9beeba249f3e        2 weeks ago          127MB
centos              6.9                 adf829198a7f        22 months ago        195MB

docker run -d -p 80:80 kod:v1 sh /init.sh

[root@oldboy ~]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                NAMES
02b0f2e0dc7d        kod:v1              "sh /init.sh"       34 seconds ago      Up 33 seconds       0.0.0.0:80->80/tcp   nifty_swartz

#保存镜像：
docker save  nginx:latest -o docker_nginx.tar.gz
#导入镜像
docker load -i docker_nginx.tar.gz

自动构建镜像

dockerfile文件编写规则:

FROM  基础镜像,定制的镜像都是基于FROM的镜像，可以是从公有仓库的镜像，也可以是本地的镜像路径

RUN   用于执行后面跟着的命令行命令（安装服务需要执行的命令）

CMD   容器启动的时候执行的初始命令，容易被替换(启动服务)

ENTRYPOINT  容器启动的时候执行的初始命令，不能被替换，如果同时使用CMD和ENTRYPOINT，cmd命令将作为ENTRYPOINT命令的参数

ADD   把dockerfile当前目录下的文件拷贝到容器中（自动解压tar包）

COPY  把dockerfile当前目录下的文件拷贝到容器中（不解压tar包）

WORKDIR 指定容器的默认工作目录

EXPOSE  镜像要暴露的端口

VOLUME  持久化卷

ENV     环境变量(ssh的密码,数据库的密码)

LABEL       镜像的属性标签

MAINTAINER  管理者标识

RUN ["可执行文件", "参数1", "参数2"]
# 例如：
# RUN ["./test.php", "dev", "offline"] 等价于 RUN ./test.php dev offline

dockerfile示例

###dockerfile单服务例子1：

FROM centos:6.9
RUN echo '192.168.19.200  mirrors.aliyun.com' >>/etc/hosts
RUN curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-6.repo
RUN curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-6.repo
RUN yum install nginx -y
CMD ["nginx","-g","daemon off;"]

###dockerfile多服务例子2：

FROM centos6.9_nginx:v1
RUN yum install php-fpm php-gd php-mbstring -y
ADD www.conf /etc/php-fpm.d/www.conf
ADD default.conf /etc/nginx/conf.d/default.conf 
RUN mkdir /html
WORKDIR /html
RUN curl -o kodexplorer4.40.zip http://192.168.19.200/191127/kodexplorer4.40.zip
RUN yum install unzip -y
RUN unzip kodexplorer4.40.zip 
RUN chown -R nginx:nginx .
ADD init.sh   /init.sh
CMD ["/bin/bash","/init.sh"]

vi /init.sh
#!/bin/bash
service php-fpm start
nginx -g 'daemon off;'

###dockerfile使用环境变量的例子：

FROM centos:7
RUN curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
RUN curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
RUN yum install nginx openssh-server initscripts -y
RUN /usr/sbin/sshd-keygen
ADD init.sh  /init.sh
ENTRYPOINT ["/bin/bash","/init.sh"]

vi  init.sh
#!/bin/bash
if [ -z $SSH_PWD ];then
    SSH_PWD=$1
fi

echo $SSH_PWD|passwd --stdin root
nginx
/usr/sbin/sshd -D

执行构建镜像。

 docker build -t  centos:v3 .

-t 执行自动创建的镜像名称

docker-compose.yml

容器部署zabbix服务

导入镜像

cd zabbix
for n in $(ls *);do docker load -i $n;done

启动容器

docker run --name mysql-server -it \
      -e MYSQL_DATABASE="zabbix" \
      -e MYSQL_USER="zabbix" \
      -e MYSQL_PASSWORD="zabbix_pwd" \
      -e MYSQL_ROOT_PASSWORD="root_pwd" \
      -d mysql:5.7 \   
      --character-set-server=utf8 --collation-server=utf8_bin
     
docker run --name zabbix-java-gateway -t \
      -d zabbix/zabbix-java-gateway:latest
      
docker run --name zabbix-server-mysql -t \
      -e DB_SERVER_HOST="mysql-server" \
      -e MYSQL_DATABASE="zabbix" \
      -e MYSQL_USER="zabbix" \
      -e MYSQL_PASSWORD="zabbix_pwd" \
      -e MYSQL_ROOT_PASSWORD="root_pwd" \
      -e ZBX_JAVAGATEWAY="zabbix-java-gateway" \
      --link mysql-server:mysql \
      --link zabbix-java-gateway:zabbix-java-gateway \
      -p 10051:10051 \
      -d zabbix/zabbix-server-mysql:latest
      
docker run --name zabbix-web-nginx-mysql -t \
      -e DB_SERVER_HOST="mysql-server" \
      -e MYSQL_DATABASE="zabbix" \
      -e MYSQL_USER="zabbix" \
      -e MYSQL_PASSWORD="zabbix_pwd" \
      -e MYSQL_ROOT_PASSWORD="root_pwd" \
      --link mysql-server:mysql \
      --link zabbix-server-mysql:zabbix-server \
      -p 80:80 \
      -d zabbix/zabbix-web-nginx-mysql:latest

-t 启用一个tty终端。

overlay网络的原理图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hy8eAIOK-1610093951145)(D:\zhanghaibo\老男孩linux 64期\云计算课程\docker容器\docker基础应用.assets\image-20200607175955254.png)]

consul主要是实现跨容器的网络通信，防止overlay动态分配的IP地址不冲突。

安装部署docker私有仓库

官方默认的 私有仓库registry

#启动私有仓库
docker run -d -v /opt/registry:/var/lib/registry -p 5000:5000 --restart always --name registry registry:latest

-v /opt/registry #持久化容器卷

–restart always #保持容器一直运行，开机自启动

–name #自定义容器的名称

#1.从docker客户端添加对私有仓库的信任
vim /etc/docker/daemon.json
{
	"registry-mirrors": ["https://registry.docker-cn.com"],
	"insecure-registries": ["40.73.17.117:5000"]
}
systemctl  restart docker

#2.将容器生成镜像，并给镜像设置标签
docker  commit [ImageID] ubuntu:16.04
docker tag docker.io/library/ubuntu:latest 40.73.17.117:5000/ubuntu:zhb

#3.上传镜像到私有仓库中
docker  push  40.73.17.117:5000/ubuntu:zhb

#4.下载镜像到本地
docker pull 40.73.17.117:5000/ubuntu:zhb

“registry-mirrors”: [“https://registry.docker-cn.com”], 镜像加速

“insecure-registries”: [“40.73.17.117:5000”] 添加信任仓库

企业版私有仓库harbor

#下载安装器
https://github.com/goharbor/harbor/releases/download/v1.10.0/harbor-offline-installer-v1.10.0.tgz

安装harbor，harbor也是使用docker-registry，并且依赖docker-compose。

#解压
tar xf harbor-offline-installer-v1.8.0.tgz
cd  harbor
#编辑harbor.yml文件，修改hostname:域名和登陆密码harbor_admin_password：123456
	hostname: docker.mightytech.cn
	harbor_admin_password: 123456
#安装依赖包（依赖epel源）
yum -y install docker-compose
#安装harbor
./install.sh

提示信息：

✔ ----Harbor has been installed and started successfully.----

Now you should be able to visit the admin portal at http://public.mightytech.cn. 
For more details, please visit https://github.com/goharbor/harbor .

✔ ----已成功安装并启动Harbor----
现在您应该可以访问管理门户http://public.mightytech.cn。
更多详情请访问https://github.com/goharbor/harbor.

默认情况下是通过https协议来上传和下载镜像。跟上面的默认registry一样，可以修改/etc/docker/daemon.json文件

docker login docker.mightytech.cn
docker tag  名称/镜像ID:v1   docker.mightytech.cn/镜像ID:v1
docker push  docker.mightytech.cn/镜像ID:v1
docker pull  docker.mightytech.cn/镜像ID:v1

容器间的互联

不同容器之间如果需要通信，需要知道对方的IP地址，那如何才能知道对方的IP地址呢。从我们常规的主机使用中。指定某一台物理服务的IP地址，后续如果需要与之通信，相对来说很方便。但是在docker容器之间，IP地址是动态分配的。需要知道一个IP地址，需要进入容器查看才会知道。为了解决这个问题呢，docker提供了link工具，通过写入对应的hosts文件来与对方通信。

docker run -it --name mysql01 mysql:latest /bin/bash
docker run -it --link mysql01:mysql01 --name nginx nginx:latest /bin/bash
#这样，nginx容器就能通过mysql名称与之通讯了。当然这只是单向的，只能从nginx容器到mysql容器。所以在使用link是，一般都是先创建后端服务，再前端服务。

这种用法一般在后面的编排工具中经常被用到，比如docker-compose等

docker-compose容器批处理工具

安装docker-compose编排工具，需要用到epel源.

yum -y install docker-compose

用途，在很多容器需要启动和关闭的时候，就可以使用docker-compose来管理这些容器。并且关联启动顺序。在docker-compose中，每个容器都是一个服务。并且实现容器间的双向连接。

相关参数可以参考run命令的使用。

• 批量启动
• 批量停止
• 批量重启:docker-compose restart #批量重启所有docker-compose管理的容器

常用命令：

docker-compose up 批量创建并运行容器

docker-compose down 批量停止并删除容器

docker-compose start 批量启动容器

docker-compose restart 批量重启容器

安装zabbix服务

docker-compose有好几个版本，每个版本的语法不同。这里使用version 3，docker-compose根据yaml文件启动容器。

编辑文件docker-compose.yml文件

version: '3'

services:
        mysql-server:
                image: mysql:5.7
                restart: always
                environment:
                        MYSQL_ROOT_PASSWORD: root_pwd
                        MYSQL_DATABASE: zabbix
                        MYSQL_USER: zabbix
                        MYSQL_PASSWORD: zabbix_pwd
                command: --character-set-server=utf8 --collation-server=utf8_bin
        zabbix-java-gateway:
                image: zabbix/zabbix-java-gateway:latest
                restart: always
        
        zabbix-server:
                depends_on:
                        - mysql-server
                image: zabbix/zabbix-server-mysql:latest
                restart: always
                environment:
                        DB_SERVER_HOST: mysql-server
                        MYSQL_DATABASE: zabbix
                        MYSQL_USER: zabbix
                        MYSQL_PASSWORD: zabbix_pwd
                        MYSQL_ROOT_PASSWORD: root_pwd
                        ZBX_JAVAGATEWAY: zabbix-java-gateway
                ports:
                        - "10051:10051"
                
        zabbix-web-nginx-mysql:
                depends_on:
                        - zabbix-server
                image: zabbix/zabbix-web-nginx-mysql:latest
                ports:
                        - "80:80"
                restart: always
                environment:
                        DB_SERVER_HOST: mysql-server
                        MYSQL_DATABASE: zabbix
                        MYSQL_USER: zabbix
                        MYSQL_PASSWORD: zabbix_pwd
                        MYSQL_ROOT_PASSWORD: root_pwd

执行结果：

[root@oldboy zabbix]#cd  /opt/docker-compose/zabbix/
[root@oldboy zabbix]# vim docker-compose.yml 
Creating zabbix_mysql-server_1           ... done
Creating zabbix_zabbix-java-gateway_1    ... done
Creating zabbix_mysql-server_1           ... 
Creating zabbix_zabbix-server_1          ... done
Creating zabbix_zabbix-server_1          ... 
Creating zabbix_zabbix-web-nginx-mysql_1 ... done
[root@oldboy zabbix]#docker ps

docker-compose.yml文件中指定了启动容器的映射端口，docker默认的网络为bridge，可通过宿主机的IP地址访问zabbix

http://10.0.0.21/index.php

Admin:zabbix

docker-compose.yml编写规则

service部分

compose文件是一个定义服务、网络和卷的YAML文件。

默认的模板文件是docker-compose.yml,其中定义的每个服务都是通过image指定镜像或者build指令（需要dockerfile）来自动构建。其他大部分都跟run命令的参数类似。

如果使用build的指令，在dockerfile中设置的选项（例如：CMD,EXPOSE,VOLUME,ENV等）将自动被获取，无需docker-compose.yml中再次设置。

指定的镜像名称或者镜像ID，如果本地不存在，compose将会尝试去从官方仓库拉取该镜像。

contarner_name: 容器名称

image:启动容器的镜像。

restart ：always 总是启动状态。

ports :指定暴露的端口号。

environment: 设置环境环境变量。

depend_on:决定启动的顺序。

build :指定dockerfile所在的文件夹路径。compose将会利用它自动构建这个镜像，然后使用这个镜像

command :覆盖容器启动之后默认执行的命令

links:links属性来做docker容器内访问的网络别名。

deploy：指定启动容器的数目

volumes部分

指令用于设置数据卷挂载路径，数据卷挂在路径可以是一个目录或者一个已经存在的数据卷容器，可以设置宿主机路径（HOST:CONTAINER）,或者加上访问模式（HOST:CONTAINER:ro）

volumes:
  # 指定一个容器内的路径，Docker会自动创建一个数据卷。
  - /var/lib/mysql
  # 使用绝对路径挂载数据卷
  - /opt/data:/var/lib/mysql
  # 以compose配置文件所在目录为根的相对路径作为数据卷挂载到容器
  - ./cache:/tmp/cache
  # 使用用户的相对路径
  - ~/configs:/etc/configs:ro

服务 services 定义包含应用于为该服务启动的每个容器的配置，类似传递命令行参数一样 docker container create 。同样，网络 networks 和卷 volumes 的定义类似于 docker network create 和 docker volume create

docker网络

docker默认使用bridge模式，可以在启动容器的时候指定使用的网络模式：–network bridge

bridge模式为内网地址：172.17.0.0/16

网络模式：

bridge:内网模式，不是桥接宿主机的网络

host：共用宿主机的网络，共用宿主机的IP地址，共用宿主机的主机名、hosts解析等。（如果宿主机的22好端口被占用，容器就不能再使用22号端口）

container: 可以指定使用某一个容器的网络。共用容器的网络、hosts解析、主机名等。一般用作负载均衡。

none:没有网络

docker run -d -it --network bridge  alpine:latest
docker run -d -it --network host  alpine:latest
docekr run -d -it --network container:ContainerID alpine:latest

自定义网络

docker network

Commands:
  connect     Connect a container to a network
  create      Create a network
  disconnect  Disconnect a container from a network
  inspect     Display detailed information on one or more networks
  ls          List networks
  prune       Remove all unused networks
  rm          Remove one or more networks

docker network create -d bridge --gateway 172.18.0.1 --subnet 172.18.0.0/16  oldboy

-d 指定创建的网络模式，如果不指定，默认bridge

–gateway 指定网关

–subnet 指定子网掩码

oldboy 指定自定义网络的名称

跨宿主的网络macvlan

类似于kvm的桥接模式，让容器有宿主机网段的IP地址。让容器更想一台虚拟机。

需要指定固定的IP地址。也只有macvlan网络能指定固定IP地址。

#1.首先创建一个macvlan网络
docker network create -d macvlan --subnet 10.0.0.0/24 --gateway 10.0.0.254 -o parent=eth0 macvlan_1
#2.启动容器，并指定该网络
docker run -it --network macvlan_1 --ip 10.0.0.106 alpine:latest

-o 指定特定的网卡驱动。

不同的宿主机都需要创建。后面会有另外一个跨宿主机的网络overlay，整个群集中只需要创建一个即可。

跨宿主机的网络overlay

容器使用overlay网络，必须指定容器名称，因为owerlay就是使用link主机名来完成的通讯。

可以自动分配IP地址，而且不会冲突，会有数据库存储IP地址。更适合大型的网络架构

使用overlay需要使用consul服务（启动一个容器来运行consul服务），用来独立管理overlay网络。使用端口8500

consul就是一个key/value类型的数据库（可以是用web访问：http://10.0.0.13）

#1.克隆一台虚拟机，启动一个新的容器，安装consul服务。
yum  -y install docker
systemctl enable docker
systemctl start docker
docker run -d -it --name consul -h consul --restart always progrium/consul -server-bootstrap

–name 容器的名称

-h 容器的主机名称

–restart always 保持持续运行

progrium/consul consul的镜像

-server-bootstrap 初始运行命令

#2.在其他节点指定consul服务地址
vim  /etc/docker/daemon.json
{
	"registry-mirrors":["https://registry.docker-cn.com"],
    "cluster-store": "consul://10.0.0.13:8500",
	"cluster-advertise": "10.0.0.11:2376"
}
systemctl  restart docker

“registry-mirrors” docker加速

“cluster-store” consul服务器

“cluster-advertise” 集群节点的信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vDuM075j-1610093951150)(D:\zhanghaibo\老男孩linux 64期\云计算课程\docker容器\docker基础应用.assets\image-20200618004405687.png)]

#3.创建overlay网络，只需要在任意一个节点上创建，这个网络是全局的。所有节点都能发现。
docker network create -d overlay --subnet 172.26.0.0/16  --gateway  172.26.0.254  ol1
#4.在节点启动容器，指定到ol1网络测试连通性
docker run -it --network ol1 --name oldboy01 alpine:latest /bin/sh
docker run -it --network ol1 --name oldboy02 alpine:latest /bin/sh

原理：

通过overlay实现跨容器的访问，如果需要外网访问，就需要做端口映射。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bJgdJElX-1610093951152)(D:\zhanghaibo\老男孩linux 64期\云计算课程\docker容器\docker基础应用.assets\image-20200618005425301.png)]

每个容器有两块网卡,eth0实现容器间的通讯,eth1实现容器访问外网

docker-container-shim containerd runC的关系

从docker 1.11之后，docker daemon（docker的守护进程）拆分成了多个模块来适应OCI标准，拆分之后包括：containerd shim runC

containerd:独立负责容器运行时和容器的生命周期（如创建、启动、停止、中止、信号处理、删除等）

shim:容器运行的真实的载体，每启动一个容器就对应一个shim进程，该进程对应三个参数：容器ID、对应容器生成的目录、runC模块

runC: 实现了容器启停、资源隔离等功能 。

containerd-shim 是什么 docker-container-shim是docker容器运行真是的载体，每启动一个容器都会起一个新的docker-skim的进程。shim进程包含容器ID、boundle目录（containerd对应的某个容器生成的目录）、runC

runtime-runC 是什么 runC是docker容器运行的格式标准，比如创建容器都会通过调用runC的api来拼接，runC create 。runC是用来实现容器的启停、资源隔离。

简单说，一个容器运行，containerd container-shim runc是必须的模块。

dockerd 负责上层的封装编排

containerd 负责容器操作，其挂掉或升级，不影响容器的运行，以前是会将所有的容器都挂掉

containerd-shim 调用runc启动容器，监控容器进程状态，回收容器中的相关进程等

docker-shim 适配器，将k8s cri接口与各种容器实现的接口进行适配

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FKAl7j2E-1610093951154)(C:/Users/HaiboZhang/AppData/Roaming/Typora/typora-user-images/1606792062765.png)]