[Docker]-Docker基础

第1章 Docker容器介绍

1.docker是什么

Docker是Docker.Inc 公司开源的一个基于 LXC技术之上构建的Container容器引擎,源代码托管在 GitHub 上,基于Go语言并遵从Apache2.0协议开源。
Docker是通过内核虚拟化技术（namespaces及cgroups等）来提供容器的资源隔离与安全保障等。
由于Docker通过操作系统层的虚拟化实现隔离，所以Docker容器在运行时，不需要类似虚拟机（VM）额外的操作系统开销，提高资源利用率。

2.容器与虚拟机对比

传统虚拟化和Docker分层对比:

VM虚拟化和Docker特性对比

3.docker的三个重要概念

Image(镜像):

那么镜像到底是什么呢？Docker 镜像可以看作是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。

Container(容器):

容器(Container)的定义和镜像(Image)几乎一模一样，也是一堆层的统一视角，唯一区别在于容器的最上面那一层是可读可写的。

Repository(仓库):

镜像仓库是 Docker 用来集中存放镜像文件的地方，类似于我们之前常用的代码仓库。
通常，一个仓库会包含同一个软件不同版本的镜像，而标签就常用于对应该软件的各个版本 。
我们可以通过<仓库名>:<标签>的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 Latest 作为默认标签。

镜像和容器图解:

4.docker的组成部分

Docker是传统的CS架构分为docker client和docker server
Docker 客户端是 Docker 用户与 Docker 交互的主要方式。
当您使用 Docker 命令行运行命令时，Docker 客户端将这些命令发送给服务器端，服务端将执行这些命令。
Docker 命令使用 Docker API 。
Docker 客户端可以与多个服务端进行通信。

第2章 Docker安装部署

1.国内源安装docker-ce

这里我们使用清华源：

https://mirrors.tuna.tsinghua.edu.cn/help/docker-ce/

操作步骤：

yum remove docker docker-common docker-selinux docker-engine
yum install -y yum-utils device-mapper-persistent-data lvm2
wget -O /etc/yum.repos.d/docker-ce.repo https://download.docker.com/linux/centos/docker-ce.repo
sed -i 's+download.docker.com+mirrors.tuna.tsinghua.edu.cn/docker-ce+' /etc/yum.repos.d/docker-ce.repo
yum makecache fast
yum install docker-ce
systemctl start docker

2.国内远镜像加速配置

cat >/etc/docker/daemon.json << 'EOF'
{
    "registry-mirrors": ["http://hub-mirror.c.163.com"]
}
EOF
systemctl restart docker

3.运行第一个容器

运行一个Hello world

docker run alpine /bin/echo "Hello world"

第3章 Docker镜像和容器管理

1.镜像相关命令

1.1 搜索镜像

选择镜像建议：

1.优先选择官方的
2.选择星星多的

搜索命令：

docker search centos

使用curl命令获取镜像版本号：

yum install jq
curl -s https://registry.hub.docker.com/v1/repositories/centos/tags|jq

1.2 获取镜像

docker pull centos
docker pull busybox
docker pull busybox:1.29

1.3 查看镜像

docker images

1.4 删除镜像

docker rmi centos

1.5 导出镜像

docker save -o centos.tar centos:latest

1.6 导入镜像

docker load  < centos.tar

2.容器相关命令

2.1 启动容器

docker run -d -p 80:80 nginx 
docker run --name mydocker -t -i centos /bin/bash

2.2 停止容器

docker stop 

2.3 查看容器

docker ps 
docker ps -a 
docker ps -q
docker ps -aq

2.4 进入容器

docker exec会分配一个新的终端tty
docker exec -it 容器ID  /bin/bash 
docker attach会使用同一个终端
docker attach 容器ID

2.5 删除容器

删除单个容器

docker rm 容器ID

批量删除容器

docker stop $(docker ps -q)
docker rm $(docker ps -aq)

第4章 Docker网络管理

1.随机映射端口

docker run -P 

2.指定映射端口

-p 宿主机端口:容器端口

-p 80:80 -p 443:443
-p 宿主机IP:宿主机端口:容器端口

如果想多个容器使用8080端口，可以通过添加多个IP地址实现

ifconfig eth0:1 10.0.0.13 up
docker run -d -p 10.0.0.11:8080:80 nginx:latest
docker run -d -p 10.0.0.13:8080:80 nginx:latest

进入容器里修改站点目录，然后访问测试

docker exec -it bdb2a4e7e24d /bin/bash
echo "web01" > /usr/share/nginx/html/index.html
docker exec -it 31c1de138dda /bin/bash
echo "web02" > /usr/share/nginx/html/index.html

访问测试：

[root@docker01 ~]# curl 10.0.0.11:8080
web02
[root@docker01 ~]# curl 10.0.0.13:8080
web01

第5章 Docker数据目录管理

1.映射容器目录

-v 宿主机目录:容器内目录

1.1 创建游戏代码目录

mkdir /data/xiaoniao -p
cd /data/
unzip xiaoniaofeifei.zip  -d xiaoniao /

1.2 创建容器并映射数据目录

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

1.3 访问游戏页面

10.0.0.11

2.实验-访问不同端口展示不同页面

需求：

访问8080端口，展示xiaoniao首页
访问8090端口，展示shenjingmao的首页

2.1 准备nginx配置文件

[root@docker01 ~]# cat /data/game.conf 
server {
    listen       8080;
    server_name  localhost;
    location / {
        root   /opt/game/;
        index  index.html index.htm;
    }
}

server {
    listen       8090;
    server_name  localhost;
    location / {
        root   /opt/xiaoniao/;
        index  index.html index.htm;
    }
}

2.2 上传代码目录

[root@docker01 /data]# ll 
总用量 18896
drwxr-xr-x 5 root root       73 9月   7 23:03 game
-rw-r--r-- 1 root root      309 9月   7 22:57 game.conf
-rw-r--r-- 1 root root 19248295 8月  28 09:48 html5.zip
drwxr-xr-x 3 root root       92 9月   7 22:15 xiaoniao
-rw-r--r-- 1 root root    91014 9月   7 22:11 xiaoniaofeifei.zip

2.3 创建容器并挂载

需要挂载的内容：

1.nginx配置文件
2.游戏目录

创建容器命令:

docker run  
-p 8080:8080 
-p 8090:8090 
-v /data/game:/opt/game 
-v /data/xiaoniao:/opt/xiaoniao 
-v /data/game.conf:/etc/nginx/conf.d/game.conf 
-d nginx:latest   

2.4 访问测试

10.0.0.11:8080
10.0.0.11:8090

第6章 Docker镜像手动构建

1.手动制作游戏镜像

下面我们基于centos容器制作一个新镜像，并安装nginx服务

1.1 启动一个容器并安装nginx

[root@docker01 ~]# docker run -it centos /bin/bash
[root@0ede2760ba65 /]# yum install wget install openssh-clients -y 
[root@0ede2760ba65 /]# wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
[root@0ede2760ba65 /]# wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
[root@0ede2760ba65 /]# sed -i -e '/mirrors.cloud.aliyuncs.com/d' -e '/mirrors.aliyuncs.com/d' /etc/yum.repos.d/CentOS-Base.repo
[root@0ede2760ba65 /]# cat /etc/yum.repos.d/nginx.repo  
[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
[root@0ede2760ba65 /]# yum makecache fast
[root@0ede2760ba65 /]# yum install nginx -y

1.2 上传代码目录并配置nginx配置文件

[root@0ede2760ba65 /]# scp -r 10.0.0.11:/data/* /opt/
[root@0ede2760ba65 /]# ll /opt/
total 18896
drwxr-xr-x 5 root root       73 Sep  7 16:02 game
-rw-r--r-- 1 root root      303 Sep  7 16:02 game.conf
-rw-r--r-- 1 root root 19248295 Sep  7 16:02 html5.zip
drwxr-xr-x 3 root root       92 Sep  7 16:02 xiaoniao
-rw-r--r-- 1 root root    91014 Sep  7 16:02 xiaoniaofeifei.zip
[root@0ede2760ba65 /]# cp /opt/game.conf /etc/nginx/conf.d/

1.3 将容器提交为新的镜像

[root@docker01 ~]# docker ps -aq
0ede2760ba65
[root@docker01 ~]# docker commit 0ede2760ba65 game:v1
sha256:a61d28fbfe27ebe36d4b73825b55e5f94097083273ab56dccce0453ce2bd6d38

1.4 测试镜像功能是否可用

[root@docker01 ~]# docker run -d -p 8080:8080 -p 8090:8090 game:v1  nginx -g 'daemon off;'
f58f209d4761c4bdd9bb164c0050a94a3273b1ee0e57eafe29e48b1517c72950

1.5 将新镜像导出

docker save -o game_v1.tar game:v1

2.手动制作云盘镜像

2.1 创建容器

docker run -d -p 80:80 --name clould game:v1  nginx -g 'daemon off;'

2.2 进入容器安装php并求改运行用户

[root@d0c987bcefa2 /]# yum install php-fpm -y
[root@d0c987bcefa2 /]# php-fpm -v
PHP 5.4.16 (fpm-fcgi) (built: Oct 30 2018 19:32:20)
Copyright (c) 1997-2013 The PHP Group
Zend Engine v2.4.0, Copyright (c) 1998-2013 Zend Technologies
[root@d0c987bcefa2 /]# sed -i '/^user/c user = nginx' /etc/php-fpm.d/www.conf
[root@d0c987bcefa2 /]# sed -i '/^group/c group = nginx' /etc/php-fpm.d/www.conf
[root@d0c987bcefa2 /]# sed -i '/daemonize/s#no#yes#g' /etc/php-fpm.conf     
[root@d0c987bcefa2 /]# php-fpm -c /etc/php.ini -y /etc/php-fpm.conf
[root@d0c987bcefa2 /]# php-fpm -c /etc/php.ini -y /etc/php-fpm.conf                                   
[root@d0c987bcefa2 /]# ps -ef|grep php
root         77      0  0 21:43 ?        00:00:00 php-fpm: master process (/etc/php-fpm.conf)
nginx        78     77  0 21:43 ?        00:00:00 php-fpm: pool www
nginx        79     77  0 21:43 ?        00:00:00 php-fpm: pool www
nginx        80     77  0 21:43 ?        00:00:00 php-fpm: pool www
nginx        81     77  0 21:43 ?        00:00:00 php-fpm: pool www
nginx        82     77  0 21:43 ?        00:00:00 php-fpm: pool www

2.3 配置nginx

[root@d0c987bcefa2 /]# cat /etc/nginx/conf.d/cloud.conf   
server {
    listen 80;
    server_name localhost;
    root /code;
    index index.php index.html;

    location ~ .php$ {
        root /code;
        fastcgi_pass 127.0.0.1:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}
[root@d0c987bcefa2 /]# nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
[root@d0c987bcefa2 /]# nginx -s reload

2.4 下载代码目录

[root@d0c987bcefa2 /]# mkdir /code
[root@d0c987bcefa2 /]# cd /code/
[root@d0c987bcefa2 code]# scp -r 10.0.0.11:/data/kod/* /code/
[root@d0c987bcefa2 code]# ls
ChangeLog.md  README.MD  app  config  data  index.php  plugins  static
[root@d0c987bcefa2 code]# chown -R nginx:nginx /code/

2.5 测试

[root@d0c987bcefa2 code]# curl -I 127.0.0.1
HTTP/1.1 302 Moved Temporarily
Server: nginx/1.16.1
Date: Sat, 07 Sep 2019 21:53:17 GMT
Content-Type: text/html; charset=utf-8
Connection: keep-alive
X-Powered-By: PHP/5.4.16
Set-Cookie: KOD_SESSION_ID_9d6d9=ljq63o0tmcscon6eb3gdpqscf4; path=/
Set-Cookie: KOD_SESSION_ID_9d6d9=ljq63o0tmcscon6eb3gdpqscf4; path=/
Set-Cookie: KOD_SESSION_ID_9d6d9=ljq63o0tmcscon6eb3gdpqscf4; path=/
Set-Cookie: KOD_SESSION_SSO=bboh1p0h1uc50tfibrg67dnra7; path=/
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
Set-Cookie: KOD_SESSION_ID_9d6d9=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT; path=/
Set-Cookie: kod_name=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT
Set-Cookie: kodToken=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT
Set-Cookie: X-CSRF-TOKEN=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT
Location: ./index.php?user/login

2.6 提交新的镜像

[root@docker01 ~]# docker commit d0c987bcefa2 kod:v1
sha256:169df6e8db11bd044e3e05237f2947783f9cc7a65b643dc9206ecf05fdc4a3ea

2.7 编写启动脚本并提交新镜像

[root@docker01 ~]# docker exec -it c14835183fb5 /bin/bash
[root@c14835183fb5 /]# cat init.sh     
#!/bin/bash
php-fpm -c /etc/php.ini -y /etc/php-fpm.conf
nginx -g 'daemon off;'
[root@c14835183fb5 /]# chmod +x init.sh 
[root@docker01 ~]# docker commit c14835183fb5 kod:v2
sha256:c05ebdf400aa7f7a27aa857df0d9c75c42943db89abca66f79101771db8e9585

2.8 启动测试

[root@docker01 ~]# docker stop $(docker ps -qa)
[root@docker01 ~]# docker run -d -p 80:80 kod:v2 /bin/bash /init.sh
dccf4aea5471713872e4fefaca45f7fac3bffec8f5f602570863ed14231dea1a
[root@docker01 ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                            NAMES
dccf4aea5471        kod:v2              "/bin/bash /init.sh"     36 seconds ago      Up 35 seconds       0.0.0.0:80->80/tcp                               magical_napier

2.9 添加GD库

此时打开页面提示缺少GD库，进入容器内安装php支持插件
[root@dccf4aea5471 /]yum install php-mbstring php-gd -y
然后重启容器
[root@docker01 ~]# docker restart dccf4aea5471

2.10 访问测试没问题后提交新镜像

[root@docker01 ~]# docker commit dccf4aea5471 kod:v2
sha256:23051ce545a2eb6bb50bb2307bd9cfbaf6139e52f205a4126fb1d8d974c417f4

第7章 Dockerfile自动构建Docker镜像

1.Dockerfile操作命令说明

Docker通过对于在Dockerfile中的一系列指令的顺序解析实现自动的image的构建
　　通过使用build命令，根据Dockerfiel的描述来构建镜像
　　通过源代码路径的方式
　　通过标准输入流的方式
Dockerfile指令：
　　只支持Docker自己定义的一套指令，不支持自定义
　　大小写不敏感，但是建议全部使用大写
　　根据Dockerfile的内容顺序执行
FROM：
　　FROM {base镜像}
　　必须放在DOckerfile的第一行，表示从哪个baseimage开始构建
MAINTAINER：
　　可选的，用来标识image作者的地方
RUN：
　　每一个RUN指令都会是在一个新的container里面运行，并提交为一个image作为下一个RUN的base
　　一个Dockerfile中可以包含多个RUN，按定义顺序执行
　　RUN支持两种运行方式：
　　　　RUN <cmd> 这个会当作/bin/sh -c “cmd” 运行
　　　　RUN [“executable”，“arg1”，。。]，Docker把他当作json的顺序来解析，因此必须使用双引号，而且executable需要是完整路径
　　RUN 都是启动一个容器、执行命令、然后提交存储层文件变更。第一层 RUN command1 的执行仅仅是当前进程，一个内存上的变化而已，其结果不会造成任何文件。而到第二层的时候，启动的是一个全新的容器，跟第一层的容器更完全没关系，自然不可能继承前一层构建过程中的内存变化。而如果需要将两条命令或者多条命令联合起来执行需要加上&&。如：cd /usr/local/src && wget xxxxxxx
CMD：
　　CMD的作用是作为执行container时候的默认行为（容器默认的启动命令）
　　当运行container的时候声明了command，则不再用image中的CMD默认所定义的命令
　　一个Dockerfile中只能有一个有效的CMD，当定义多个CMD的时候，只有最后一个才会起作用 
CMD定义的三种方式：
　　CMD <cmd> 这个会当作/bin/sh -c "cmd"来执行
　　CMD ["executable","arg1",....]
　　CMD ["arg1","arg2"]，这个时候CMD作为ENTRYPOINT的参数 
EXPOSE 声明端口
　　格式为 EXPOSE <端口1> [<端口2>...]。
　　EXPOSE 指令是声明运行时容器提供服务端口，这只是一个声明，在运行时并不会因为这个声明应用就会开启这个端口的服务。在 Dockerfile 中写入这样的声明有两个好处，一个是帮助镜像使用者理解这个镜像服务的守护端口，以方便配置映射；另一个用处则是在运行时使用随机端口映射时，也就是 docker run -P 时，会自动随机映射 EXPOSE 的端口。
ENTRYPOINT：
　　entrypoint的作用是，把整个container变成了一个可执行的文件，这样不能够通过替换CMD的方法来改变创建container的方式。但是可以通过参数传递的方法影响到container内部
　　每个Dockerfile只能够包含一个entrypoint，多个entrypoint只有最后一个有效
　　当定义了entrypoint以后，CMD只能够作为参数进行传递
entrypoint定义方式：
　　entrypoint ["executable","arg1","arg2"]，这种定义方式下，CMD可以通过json的方式来定义entrypoint的参数，可以通过在运行container的时候通过指定command的方式传递参数
　　entrypoint <cmd>，当作/bin/bash -c "cmd"运行命令
ADD & COPY：
　　当在源代码构建的方式下，可以通过ADD和COPY的方式，把host上的文件或者目录复制到image中
　　ADD和COPY的源必须在context路径下
　　当src为网络URL的情况下，ADD指令可以把它下载到dest的指定位置，这个在任何build的方式下都可以work
　　ADD相对COPY还有一个多的功能，能够进行自动解压压缩包
ENV：
　　ENV key value
　　用来设置环境变量，后续的RUN可以使用它所创建的环境变量
　　当创建基于该镜像的container的时候，会自动拥有设置的环境变量 
WORKDIR：
　　用来指定当前工作目录（或者称为当前目录）
　　当使用相对目录的情况下，采用上一个WORKDIR指定的目录作为基准 
USER：
　　指定UID或者username，来决定运行RUN指令的用户 
ONBUILD：
　　ONBUILD作为一个trigger的标记，可以用来trigger任何Dockerfile中的指令
　　可以定义多个ONBUILD指令
　　当下一个镜像B使用镜像A作为base的时候，在FROM A指令前，会先按照顺序执行在构建A时候定义的ONBUILD指令
　　ONBUILD <DOCKERFILE 指令> <content>
VOLUME：
　　用来创建一个在image之外的mount point，用来在多个container之间实现数据共享
　　运行使用json array的方式定义多个volume
　　VOLUME ["/var/data1","/var/data2"]
　　或者plain text的情况下定义多个VOLUME指令

2.使用Dockerfile创建云盘镜像

3.使用Dockerfile创建wordpress博客镜像

4.使用Dockerfile创建KVM图形化管理工具镜像

第8章 企业级私有仓库Docker-harbor

1.部署步骤

第一步：安装docker和docker-compose
第二步：下载harbor-offline-installer-v1.9.0-rc1.tgz
第三步：上传到/opt,并解压
第四步：修改harbor.yml配置文件 hostname = 10.0.0.11 harbor_admin_password = 123456
第五步：执行install.sh

2.安装docker-compose

1.安装docker-compose

yum install -y docker-compose

2.检查

docker-compose version

3.上传解压docker-harbor

[root@docker01 ~]# cd /opt/
[root@docker01 /opt]# ls
harbor-offline-installer-v1.9.0-rc1.tgz
[root@docker01 /opt]# tar zxf harbor-offline-installer-v1.9.0-rc1.tgz 
[root@docker01 /opt]# ls
harbor  harbor-offline-installer-v1.9.0-rc1.tgz
[root@docker01 /opt]# cd harbor/

4.修改配置文件

修改2个地方：

[root@docker01 /opt/harbor]# egrep "10.0.0.11|123456" harbor.yml 
hostname: 10.0.0.11
harbor_admin_password: 123456

5.安装

[root@docker01 /opt/harbor]# ./install.sh

6.修改docker信任仓库

[root@docker01 /opt/harbor]# cat /etc/docker/daemon.json    
{
      "registry-mirrors": ["http://hub-mirror.c.163.com"],
      "insecure-registries": ["http://10.0.0.11"] 
}

7.重启docker

systemctl restart docker  

8.给镜像打标签并提交到harbor

docker登陆harbor

[root@docker01 /opt/harbor]# docker login 10.0.0.11           
Username: zhangya 
Password: 
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded

运行一个容器：

[root@docker01 ~]# docker run -d -p 8080:80 centos_kod:v1          
78be80f7c2029b68e8943e38fa99131ec6709f798e63c94afb5a7fdfa4a8047c

查看容器ID:

[root@docker01 ~]# docker ps|grep kod
78be80f7c202        centos_kod:v1                                       "/bin/bash /init.sh"     15 seconds ago      Up 13 seconds            0.0.0.0:8080->80/tcp        tender_dirac

将容器提交为新镜像并且更改为harbor仓库的地址

[root@docker01 ~]# docker commit 78be80f7c202 10.0.0.11/linux/centos_kod:v1
sha256:6bf1e1eef1969bcd4c82472aed945d4dda74a923c0d7dae91e38539676f8c240

查看镜像

[root@docker01 ~/dockerfile/kod]# docker images
REPOSITORY                      TAG                        IMAGE ID            CREATED             SIZE
10.0.0.11/linux/centos_kod      v1                         6bf1e1eef196        13 minutes ago      465MB

将新镜像推送到harbor上

[root@docker01 /opt/harbor]# docker push 10.0.0.11/linux/centos_kod:v1

9.在docker-harbor上查看

10.0.0.11
账号:admin
密码:123456

10.其他主机上下载镜像

配置docker信任仓库

[root@docker02 ~]# cat /etc/docker/daemon.json 
{
      "registry-mirrors": ["http://hub-mirror.c.163.com"],
      "insecure-registries": ["http://10.0.0.11"],
      "insecure-registries": ["https://10.0.0.11"] 
}

从Harbor仓库拉取镜像

[root@docker02 ~]# docker pull 10.0.0.11/linux/centos_kod:v1

第9章 Docker容器编排工具

1.docker-compose介绍

Compose 是用于定义和运行多容器 Docker 应用程序的工具。
通过Compose，您可以使用YML文件来配置应用程序需要的所有服务。
写好yaml文件之后，只需要运行一条命令，就会按照资源清单里的配置运行相应的容器服务。

Compose 使用的三个步骤：

1.使用 Dockerfile 定义应用程序的环境。
2.使用 docker-compose.yml 定义构成应用程序的服务，这样它们可以在隔离环境中一起运行。
3.最后，执行 docker-compose up 命令来启动并运行整个应用程序。

2.安装docker-compose

方法1:直接yum安装

yum install docker-compose

方法2:使用官方脚本安装

curl -L "https://github.com/docker/compose/releases/download/1.24.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

3.docker-compose语法介绍

version: '2.2'
services:
  服务名称:
    image: 容器镜像
    container_name: 容器名称
    environment:
      - 环境变量1=值1
      - 环境变量2=值2
    volumes:
      - 存储驱动1:容器内的数据目录路径
      - 宿主机目录路径:容器内的数据目录路径
    ports:
      - 宿主机端口:映射到容器内的端口
    networks:
      - 自定义网络的名称
  服务名称:
    image: 容器镜像
    container_name: 容器名称
    environment:
      - 环境变量1=值1
      - 环境变量2=值2
    volumes:
      - 存储驱动2:对应容器内的数据目录路径
    ports:
      - 宿主机端口:映射到容器内的端口
    networks:
      - 自定义网络的名称

volumes:
  存储驱动1:
    driver: local
  存储驱动2:
    driver: local

networks:
  自定义网络名称:
    driver: bridge

4.使用docker-compose部署zabbix

5.使用docker-compose部署gitlab

6.使用docker-compose部署LNMP

第10章 Docker网络模式

1.Docker网络的四种模式

Host		  容器将不会虚拟出自己的网卡，配置自己的IP等，而是使用宿主机的IP和端口。
Bridge	  此模式会为每一个容器分配、设置IP等，并将容器连接到一个docker0虚拟网桥，通过docker0网桥以及Iptables nat表配置与宿主机通信。
None		  此模式关闭了容器的网络功能。
Container	创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享IP、端口范围。

查看网络模式命令:

[root@node-51 ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
3791e4fc9c18        bridge              bridge              local
b494337929ef        host                host                local
a153ac0003e3        none                null                local

查看网卡命令:

[root@node-51 ~]# ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 00:0c:29:11:6b:18 brd ff:ff:ff:ff:ff:ff
    inet 10.0.0.51/24 brd 10.0.0.255 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::20c:29ff:fe11:6b18/64 scope link 
       valid_lft forever preferred_lft forever
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default 
    link/ether 02:42:bb:96:63:c7 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

查看桥接网卡命令

yum install bridge-utils -y
brctl show

2.Bridge模式介绍

1.当Docker Daemon第一次启动时会创建一个虚拟的网桥，默认名称是Docker0
2.创建完后会给这个网桥分配一个子网,默认是172.17.0.1/16
3.由Docker创建的每一个容器,都会创建一个一个Veth设备对,其中一端关联到网桥上,另一端放在容器里映射为eth0,然后从网桥的地址段内给容器内的eth0分配一个IP地址,这样容器之间就可以互通了。

流程图:

第11章 Docker容器夸主机通信

1.Docker跨主机网络类型

Overlay
macvlan
flannel
calico

2.macvlan模式

2.1 创建网络

docker network create -d macvlan --subnet 10.0.0.0/24 --gateway 10.0.0.2 -o parent=eth0 macvlan_1

2.2 启动容器

docker01启动容器

docker run -it --network macvlan_1 --ip 10.0.0.100 alpine

docker02启动容器

docker run -it --network macvlan_1 --ip 10.0.0.200 alpine

启动后互相ping发现可以正常通讯

ping 10.0.0.100
ping 10.0.0.200

3.跨主机通信-Consul实现

3.1 Consul介绍

Consul是一个服务网格（微服务间的 TCP/IP，负责服务之间的网络调用、限流、熔断和监控）解决方案，它是一个一个分布式的，高度可用的系统，而且开发使用都很简便。
它提供了一个功能齐全的控制平面，主要特点是：服务发现、健康检查、键值存储、安全服务通信、多数据中心。

3.2 二进制安装步骤

wget https://releases.hashicorp.com/consul/1.4.4/consul_1.4.4_linux_amd64.zip 
unzip consul_1.4.4_linux_amd64.zip 
mv consul /usr/bin/
chmod +x /usr/bin/consul
nohup consul agent -server -bootstrap -ui -data-dir /var/lib/consul -client=10.0.0.11 -bind=10.0.0.11 &>/var/log/consul.log &
tail -f /var/log/consul.log

3.3 修改docker01启动文件

[root@docker01 ~]# vim /lib/systemd/system/docker.service
#ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock --cluster-store consul://10.0.0.11:8500 --cluster-advertise 10.0.0.11:2375

3.4 重启docker01

systemctl daemon-reload     
systemctl restart docker.service

3.5 同样方法修改docker02的配置

[root@docker02 ~]# vim /lib/systemd/system/docker.service
#ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock --cluster-store consul://10.0.0.11:8500 --cluster-advertise 10.0.0.12:2375

3.6 重启docker2

systemctl daemon-reload     
systemctl restart docker.service

3.7 在docker主机上创建overlay网络

在docker1上创建网络，然后会自动同步到docker2上

docker network create -d overlay overlay_net

3.8 分别在两个节点上创建容器

docker1上运行命令

docker run -it --net=overlay_net --name busybox01 busybox:latest

docker2上运行命令

docker run -it --net=overlay_net --name busybox02 busybox:latest

3.9 测试联通性

docker run -it --net=overlay_net --name busybox01 busybox:latest
#ping 10.0.0.3

4.跨主机通信-flannel实现

4.1 flannel介绍

Flannel是一种基于overlay网络的跨主机容器网络解决方案，即将TCP数据包封装在另一种网络包里面进行路由转发和通信，Flannel是CoreOS开发,专门用于docker多机互联的一个工具,让集群中的不同节点主机创建的容器都具有全集群唯一的虚拟ip地址

4.2 flannel通信原理

流程图解

文字说明

1.数据从源容器中发出后，经由所在主机的docker0虚拟网卡转发到flannel0虚拟网卡。

2.源主机的flanneld服务将原本的数据内容UDP封装后根据自己的路由表投递给目的节点的flanneld服务，数据到达目标主机后被解包，然后直接进入目的节点的flannel0虚拟网卡，然后被转发到目的主机的docker0虚拟网卡，最后就像本机容器通信一样由docker0路由到达目标容器。 

3.使每个结点上的容器分配的地址不冲突。Flannel通过Etcd分配了每个节点可用的IP地址段后，再修改Docker的启动参数。“--bip=X.X.X.X/X”这个参数，它限制了所在节点容器获得的IP范围。

4.3 实验环境

10.0.0.11  etcd,flannel,docker
10.0.0.12  flannel,docker

4.2 安装配置etcd

安装etc:

yum install etcd -y

编辑配置文件:

cat > /etc/etcd/etcd.conf << 'EOF'
# [member]
ETCD_NAME=default
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_CLIENT_URLS="http://10.0.0.11:2379,http://127.0.0.1:2379"

# #[cluster]
ETCD_INITIAL_CLUSTER_STATE="new"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_ADVERTISE_CLIENT_URLS="http://10.0.0.11:2379"
EOF

启动etcd

systemctl start etcd
systemctl enable etcd

测试etcd功能

etcdctl -C http://10.0.0.11:2379 cluster-health
etcdctl -C http://10.0.0.11:2379 set /testdir/testkey "Hello world"   
etcdctl -C http://10.0.0.11:2379 get /testdir/testkey

防火墙

iptables -A INPUT -p tcp -m tcp --dport 2379 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -p tcp -m tcp --dport 2380 -m state --state NEW,ESTABLISHED -j ACCEPT

4.3 安装配置Flannel-两台机器都操作

安装Flannel

yum install flannel

配置Flannel

cp /etc/sysconfig/flanneld /opt/flanneld.bak
cat > /etc/sysconfig/flanneld << 'EOF'
# Flanneld configuration options  

# etcd url location.  Point this to the server where etcd runs
FLANNEL_ETCD_ENDPOINTS="http://10.0.0.11:2379"

# etcd config key.  This is the configuration key that flannel queries
# For address range assignment
FLANNEL_ETCD_PREFIX="/atomic.io/network"

# Any additional options that you want to pass
#FLANNEL_OPTIONS=""
EOF

配置etcd数据库

etcdctl mk /atomic.io/network/config '{ "Network": "192.168.0.0/16" }'

启动docker

systemctl start flanneld.service
systemctl enable flanneld.service

检查端口

netstat -lntup|grep flannel

4.4 配置Docker关联Flannel网络

配置好flannel之后，我们只需要重启docker即可，然后查看网卡会发现docker0变成了我们配置的flannel网段。

systemctl restart docker

4.5 创建容器测试

docker01创建容器:

docker run -it busybox /bin/sh

查看IP地址:

/ # ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
17: eth0@if18: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue 
    link/ether 02:42:c0:a8:3a:03 brd ff:ff:ff:ff:ff:ff
    inet 192.168.58.3/24 brd 192.168.58.255 scope global eth0
       valid_lft forever preferred_lft forever

Docker02创建容器:

docker run -it busybox /bin/sh

查看IP地址:

/ # ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
13: eth0@if14: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1472 qdisc noqueue 
    link/ether 02:42:c0:a8:48:02 brd ff:ff:ff:ff:ff:ff
    inet 192.168.72.2/24 brd 192.168.72.255 scope global eth0
       valid_lft forever preferred_lft forever    

测试容器间可否通讯:

ping 192.168.72.2
ping 192.168.58.3

4.6 网卡地址没变的处理方法

修改docker配置文件:

vim /usr/lib/systemd/system/docker.service
.................
EnvironmentFile=/run/flannel/docker
ExecStart=/usr/bin/dockerd -H fd:// $DOCKER_NETWORK_OPTIONS
.................
systemctl daemon-reload 
systemctl restart docker

4.7 容器间网络不通的解决方法

iptables -P INPUT ACCEPT
iptables -P FORWARD ACCEPT

第12章 Docker监控

1.docker自带的监控命令

docker container ps  :查看正在运行的容器
docker container top  :知道某个容器运行了哪些进程
docker container stats :显示每个容器各种资源使用情况 

2.cAdvisor+ prometheus+ grafana组件介绍

2.1 cAdvisor介绍

1.cAdvisor是google开发的容器监控工具，cAdvisor会显示当前host的资源使用情况，包括CPU，内存，网络，文件系统。
2.不过cAdvisor提供的操作界面略显简陋，而且需要在不同页面之间跳转，并且只能监控一个host，这不免让人质疑他的实用性，但cAdvisor有一个亮点是可以将监控到的数据导出给第三方工具，有这些工具进一步加工处理。
3.所以我们可以把cAdvisor定位为一个监控数据收集器，收集和导出数据是他的强项，而非展示数据。
cAdvisor支持很多第三方工具，其中就包含prometheus

2.2 prometheus

Prometheus是一个非常优秀的监控工具。提供了监控数据搜集，存储，处理，可视化和告警一系列完整的解决方案。
包含组件:
Node Exporter :负责收集host硬件和操作系统数据，以容器的形式运行在所有host上
cAdvisor :负责收集容器数据，以容器的形式运行在所有host上

2.3 grafana

grafana是一款支持多种数据源的图形展示工具

3.使用docker-compose部署

3.1 地址规划

10.0.0.11   cAdvisor+ Node Exporter +prometheus+ grafana
10.0.0.12   cAdvisor+ Node Exporter

3.2 编写prometheus配置文件

cat > prometheus.yml << 'EOF'
scrape_configs:
- job_name: cadvisor
  scrape_interval: 5s
  static_configs:
  - targets:
    - 10.0.0.11:8080
    - 10.0.0.12:8080

- job_name: prometheus
  scrape_interval: 5s
  static_configs:
  - targets: 
    - 10.0.0.11:9090

- job_name: node_exporter
  scrape_interval: 5s
  static_configs:
  - targets: 
    - 10.0.0.11:9100
    - 10.0.0.12:9100
EOF

3.2 编写docker-compose文件

docker01配置

cat >docker-compose.yml<<EOF
version: '3.2'
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
    - 9090:9090
    command:
    - --config.file=/etc/prometheus/prometheus.yml
    volumes:
    - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
    depends_on:
    - cadvisor

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node_exporter
    ports:
    - 9100:9100

  cadvisor:
    image: google/cadvisor:latest
    container_name: cadvisor
    ports:
    - 8080:8080
    volumes:
    - /:/rootfs:ro
    - /var/run:/var/run:rw
    - /sys:/sys:ro
    - /var/lib/docker/:/var/lib/docker:ro

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
    - 3000:3000
EOF

docker02配置：

cat >docker-compose.yml<<EOF
version: '3.2'
services:
  node-exporter:
    image: prom/node-exporter:latest
    container_name: node_exporter
    ports:
    - 9100:9100

  cadvisor:
    image: google/cadvisor:latest
    container_name: cadvisor
    ports:
    - 8080:8080
    volumes:
    - /:/rootfs:ro
    - /var/run:/var/run:rw
    - /sys:/sys:ro
    - /var/lib/docker/:/var/lib/docker:ro
EOF

运行命令：

docker-compose -f docker-compose.yml up -d

4.web页面操作

访问地址:

10.0.0.11:3000
admin admin

添加数据源：

DataSources
Name:Prometheus
URL:http://10.0.0.11:9090

下载监控面板文件:

https://grafana.com/api/dashboards/10619/revisions/1/download

查看执行效果:

第13章 Jenkins自动化部署Docker

1.部署流程

部署流程：

1.下载代码
2.编译镜像
3.推送镜像
4.停止正在运行的容器
5.启动新容器
6.清理jenkins主机上的镜像

回滚流程：

1.选择需要回滚的版本
2.停止正在运行的容器
3.启动新容器

2.pipeline脚本

pipeline{ 
    agent any 

    parameters {
        gitParameter name: 'git_version', 
                     branchFilter: 'origin/(.*)',
                     type: 'PT_TAG',
                     defaultValue: 'v1.0',
                     description: '发布新版本'
        choice(name: 'base_image', choices: ['nginx:1.16','nginx:1.17'],description: '请选择基础镜像版本')
        choice(name: 'deploy_env', choices: ['deploy','rollback'],description: 'deploy: 发布版本
rollback: 回滚版本')               
             
    }

    stages{
        stage("下载代码"){ 
            steps{
                checkout([$class: 'GitSCM', 
                                   branches: [[name: '*/master']], 
                                   doGenerateSubmoduleConfigurations: false, 
                                   extensions: [[$class: 'RelativeTargetDirectory', 
                                   relativeTargetDir: 'game']], 
                                   submoduleCfg: [], 
                                   userRemoteConfigs: [[credentialsId: 'b8c1f793-47ed-4903-995d-2273673d8f87', 
                                   url: 'git@10.0.0.200:dev/docker-pipeline.git']]])
            }
        } 

        stage("编译镜像"){
            when {
                environment name: 'deploy_env', value: 'deploy'
            }
            steps{
                writeFile file: "Dockerfile", text: """FROM 10.0.0.205/base_image/${params.base_image}
ADD game /usr/share/nginx/html/"""
                sh "docker build -t 10.0.0.205/image/game:${params.git_version} . && docker push 10.0.0.205/image/game:${params.git_version}"               
            } 
        }

        stage("推送镜像"){
            when {
                environment name: 'deploy_env', value: 'deploy'
            }
            steps{
                sh "docker build -t 10.0.0.205/image/game:${params.git_version} . && docker push 10.0.0.205/image/game:${params.git_version}"               
            }         
        }

        stage("部署容器"){
            when {
                environment name: 'deploy_env', value: 'deploy'
            }         
            steps{
                sh 'ssh 10.0.0.204 "docker stop game && docker rm game && docker run --name game -p 80:80 -d 10.0.0.205/image/game:${git_version} && docker ps"'
            }
        } 

        stage("清理构建镜像"){
            when {
                environment name: 'deploy_env', value: 'deploy'
            }        
            steps{
                sh "docker rmi 10.0.0.205/image/game:${params.git_version}"
            }
        }

        stage("回滚镜像"){
            when {
                environment name: 'deploy_env', value: 'rollback'
            }

            steps{
                sh 'ssh 10.0.0.204 "docker stop game && docker rm game && docker run --name game -p 80:80 -d 10.0.0.205/image/game:${git_version} && docker ps"'
            }         
        }         
    }
}