docker，来自大佬分享，仅存档。

官方镜像仓库

https://hub.docker.com/

docker官方仓库

https://www.docker.com/get-started

第一章 docker介绍

1.什么是容器

容器是隔离的环境中运行的一个进程,如果进程结束,容器就会停止,容器的隔离环境,拥有自己的ip地址,系统文件,主机名,进程管理

2:容器和虚拟机的区别

1.文字描述

虚拟机: 
    硬件cpu支持(vt虚拟化),模拟计算硬件,走正常的开机启动
    bios开机自检--根据bios启动项--读取硬盘第一个扇区grub,uefi,  centos7, 加载内核,启动系统第一个进程/sbin/init  systemd
容器: 
    不需要硬件cpu的支持,共用宿主机内核,启动容器的第一个进程
    容器优势: 
    启动快,性能高,损耗少,轻量级
    100虚拟机  100个服务     10宿主机
    100容器     100个服务      6宿主机

2.图形描述

3.docker的三个主要概念

1.镜像

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

2.容器

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

3.仓库

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

4.docker的组成部分

Docker是传统的CS架构分为docker client和docker server 
Docker客户端是 Docker 用户与 Docker 交互的主要方式。 
当您使用 Docker 命令行运行命令时，Docker 客户端将这些命令发送给服务器端，服务端将执行这些 命令。 Docker 命令使用 Docker API 。 
Docker 客户端可以与多个服务端进行通信。
​
docker是一个cs架构, docker主要:镜像  容器   仓库  网络  存储   监控
docker是一个软件的打包技术

第二章 docker-ce安装

1.环境准备

主机名	ip	内存
docker01	10.0.0.21	2G
docker02	10.0.0.22	2G

2.安装docker-ce

1.安装docker清华源

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

2.安装docker

[root@docker01 ~]# yum remove docker docker-common docker-selinux docker-engine
[root@docker01 ~]# yum -y install docker-ce 

3.启动docker

[root@docker01 ~]# systemctl enable docker
[root@docker01 ~]# systemctl start docker

4.查看版本

[root@docker01 ~]# docker version 
Client: Docker Engine - Community
 Version:           19.03.13
 API version:       1.40
 Go version:        go1.13.15

3.国内源镜像加速器

[root@docker01 ~]# cat> /etc/docker/daemon.json <<'EOF'
{
    "registry-mirrors": [
        "https://registry.docker-cn.com"
    ]
}
EOF
​
systemctl restart docker

第三章 docker镜像常用命令

1.搜索镜像

1.普通搜索

docker search  mirror-name      #优先选官方,好评多
NAME           DESCRIPTION      STARS       OFFICIAL    AUTOMATED
镜像名称       镜像描述        好评数量      官方的      是否自动构建

2.使用curl获取镜像版本号

yum -y install jq
curl -s https://registry.hub.docker.com/v1/repositories/镜像名称/tags|jq | grep name

2.拉取镜像

 docker  image pull   mirror-name           #默认最新版
 docker  image pull   mirror-name:版本号     #指定版本

3.推送镜像

docker image push 

4.导入镜像

docker image load -i 镜像包          #会导入标签和名字，推荐使用
docker image import  镜像包          #不会导入标签和名字
​
for i in `ls|xargs -n1`;do docker load -i $i;done    #批量导入镜像

5.导出镜像

1.导出一个镜像打包
两种方式
docker image save  mirror-name:版本号 -o  名字.tar.gz
docker image save  mirror-name:版本号  >  名字.tar.gz
​
2.导出多个镜像打成一个包
docker image save 镜像名:版本号  镜像名:版本号  镜像名:版本号 -o 名字.tar.gz

6.查看镜像列表

docker image  ls
docker images

7.删除镜像

docker rmi 镜像:版本号
docker rmi 镜像ID
​
#批量删除镜像

8.给镜像打标签

docker image tag 镜像id  镜像名字:版本号           #(自己起名字和版本号)

9.查看镜像属性

docker inspect 镜像名字:版本号

第五章 docker容器的常用命令

1.创建并启动容器

docker  run 创建并启动容器
例子:docker run  -d -it -p 80:80  nginx:latest
     run 创建并启动一个容器
     -d  放后台启动
     -p  端口映射
     nginx:latest docker镜像名称

2.创建容器

docker create   --name 自定义名字  镜像名:版本号

3.启动容器

docker start 容器ID
#批量启动容器
docker start $(docker ps -a)

4.停止容器

docker  stop  容器ID

5.重启容器

docker  restart  容器ID

6.强制停止容器

docker  kill

7.查看容器列表

docker  ps
参数：
    -a      查看所有容器
    -l      查看未启动的容器(好像不是，待修改)
    -q      查看容器ID
    不加    查看正在运行的容器

8. 删除容器

#单个删除容器
docker  rm
​
#批量删除容器
docker rm -f `docker ps -a -q`

9.进入正在运行的容器

1.进入正在运行的容器(分配一个新终端)

docker  exec
例子: docker exec  -it  容器id/容器名字   /bin/bash(/bin/sh)

2.进入正在运行的容器(使用相同的终端)

docker attach 容器ID
ctrl +p,ctrl +q           ##几个窗口会同步操作，使用同一个中端

10.自定义容器名字

docker run --name 名字  镜像名:版本号

11.查看容器属性

docker inspect 容器ID

12.前台运行

#启动的容器需要有一个PID为 1 的进程卡住，不然进程会关闭
#容器前台运行可以在起容器的时候加个命令杠住
#容器后面可以加查询，及其他命令
例：
docker run -it centos:7 /bin/bash
#nginx 卡进程的命令
nginx -g 'daemon off;'
/usr/sbin/php-fpm --nodaemonize

第六章 端口映射

1.指定端口映射

docker run
    -p  宿主机端口:容器端口          #指定单端口映射
    -p  80:80  -p 3306:3306         #指定多端口映射
    -p  1111-1119:1111-1119         #端口范围映射
    -p  宿主机ip1:宿主机端口:容器端口 #(多个容器同时使用多端口)
    -p  宿主机ip1::容器端口/udp      #使用udp协议做随机端口映射
​
#指定端口映射
docker run -d -p 81:81 centos:7      #注意：-d 要放在端口前，不然报错
​
#多个容器使用8080端口
1.宿主机添加网卡
ifconfig eth0:1 10.0.0.23 up
#查看网卡是否创建成功
ifconfig eth0:1
eth0:1: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 10.0.0.23  netmask 255.0.0.0  broadcast 10.255.255.255
        
2.启容器并映射
docker run -d -p 10.0.0.21:8080:80 nginx:latest 
docker run -d -p 10.0.0.23:8080:80 nginx:latest

2.随机端口映射

docker run  
    -p  宿主机ip1::容器端口          #随机端口映射
    -p  宿主机ip1::容器端口/udp      #使用udp协议做随机端口映射
    -P  自动随机端口映射

3.范围端口映射

docker run
    -p  1111-1119:1111-1119         #端口范围映射

第七章 docker数据卷

1.参数

docker run
    -v  宿主机绝对目录:容器目录
    
    -v  容器目录                  #创建一个随机卷,来持久化容器的目录下的数据
    -v  卷名:容器目录             #创建一个固定名字的卷,来持久化容器的目录下的数据
    --volumes-from               #跟某一个容器挂载所有相同的卷

2.举例

​

第八章 制作docker镜像

1.手动制作docker镜像

1.启动并进入容器

#以制作nginx镜像为例
​
docker run -it -d  --name nginx_mk centos:7 
docker exec -it nginx_mk /bin/bash

2.安装nginx

1.安装nginx源
vi /etc/yum.repos.d/nginx.repo
[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=0
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true
​
2.安装nginx
yum makecache fast
yum -y install nginx

3.优化镜像

yum clean all

4.退出容器

exit

5.制作镜像

docker commit  nginx_mk nginx_cts:v1     #(nginx_cts是自己定义的)

6.查看

docker images | grep nginx_cts

7.启动制作的镜像并运行

docker run -it -d -p 80:80 nginx_cts:v1 nginx -g "daemon off;"
在浏览器测试：
10.0.0.21

8.将镜像导出

docker save nginx_cts:v1 -o nginx_v1.tar

2.自动制作docker镜像

需求:
1.访问宿主机的8080端口,跳转到小鸟游戏
2.访问宿主机的8090端口,跳转到神经猫
3.每个游戏单独的一个nginx配置文件
4.nginx记录的日志分开
5.小鸟的日志名为xiaoniao.access
6.神经猫的日志名为sjm.access 
7.使用目录映射和配置文件把代码和配置文件映射到容器里
8.容器内日志持久化到宿主机的目录/opt/nginx/
9.nginx日志格式为json格式
10.不允许进入到容器里(允许调试进入)

1.创建代码目录、配置文件目录

mkdir -p /data/{conf..code}

2.配置游戏访问界面

vim /data/conf/sjm.conf
server {
    listen       8090;
    server_name  localhost;
    access_log  /var/log/nginx/sjm.log  json;
​
    location / {
        root   /usr/share/nginx/html/sjm;
        index  index.html index.htm;
    }
}
​
vim /data/conf/xiaoniao.conf
server {
    listen       8080;
    server_name  localhost;
    access_log  /var/log/nginx/xiaoniao.log  json;
​
    location / {
        root   /usr/share/nginx/html/xiaoniao;
        index  index.html index.htm;
    }
}

3.配置nginx.conf日志格式为 json

vim /data/conf/nginx.conf
user  nginx;
worker_processes  1;
​
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;
​
events {
    worker_connections  1024;
}
​
http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;
​
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
​
log_format json '{ "time_local": "$time_local", '
                          '"remote_addr": "$remote_addr", '
                          '"referer": "$http_referer", '
                          '"request": "$request", '
                          '"status": $status, '
                          '"bytes": $body_bytes_sent, '
                          '"agent": "$http_user_agent", '
                          '"x_forwarded": "$http_x_forwarded_for", '
                          '"up_addr": "$upstream_addr",'
                          '"up_host": "$upstream_http_host",'
                          '"upstream_time": "$upstream_response_time",'
                          '"request_time": "$request_time"'
    ' }';
#    access_log  /var/log/nginx/access.log  json;
#    access_log  /var/log/nginx/access.log  main;
​
    sendfile        on;
    #tcp_nopush     on;
​
    keepalive_timeout  65;
​
    #gzip  on;
​
    include /etc/nginx/conf.d/*.conf;
}

4.拉取代码

上传代码
cd /data/code
rz sjm.zip  xiaoniaofeifei.zip
​
解压代码
unzip sjm.zip
unzip xiaoniaofeifei.zip -d xiaoniao

5.自动启动容器

docker run 
-p 8080:8080 
-p 8090:8090  
-v /data/conf/sjm.conf:/etc/nginx/conf.d/sjm.conf 
-v /data/conf/xiaoniao.conf:/etc/nginx/conf.d/xiaoniao.conf 
-v /data/conf/nginx.conf:/etc/nginx/nginx.conf 
-v /data/code/sjm:/usr/share/nginx/html/sjm 
-v /data/code/xiaoniao:/usr/share/nginx/html/xiaoniao 
-v /opt/nginx/:/var/log/nginx/ 
-d nginx:latest 
​
###注意路径，搞错了容器起不来

6.启动代码测试

浏览器：
http://10.0.0.21:8080
http://10.0.0.21:8090

3.制作kod云盘镜像站

1.创建容器

docker run -it -d -p 80:80 --name kod_cts centos:7  

2.进入容器

docker exec -it kod_cts /bin/bash

3.创建www用户

容器：
groupadd -g 1000 www
    useradd -u1000 -g1000 -M -s /sbin/nologin www
宿主机：
groupadd -g 1000 www
useradd -u1000 -g1000 -M -s /sbin/nologin          ##容器跟宿主机用户id最好一致

4.创建代码目录

mkdir /code

5.安装nginx

1.配置Nginx源

 vi /etc/yum.repos.d/nginx.repo
[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=0
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

2.下载Nginx

yum -y install nginx

3.配置Nginx配置文件

vi /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; 
    } 
}

4.修改nginx.conf

#修改nginx启动用户为www
user  www;
worker_processes  1;
​
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;
​
​
events {
    worker_connections  1024;
}
​
http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;
​
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
​
    access_log  /var/log/nginx/access.log  main;
​
    sendfile        on;
    #tcp_nopush     on;
​
    keepalive_timeout  65;
​
    #gzip  on;
​
    include /etc/nginx/conf.d/*.conf;
}

6.安装PHP

1.安装php-fpm

yum -y install php-fpm
php-fpm -v

2.修改php-fpm配置文件

sed -i '/^user/c user = www' /etc/php-fpm.d/www.conf 
sed -i '/^group/c group = www' /etc/php-fpm.d/www.conf

7.下载代码到宿主机/code

cd /code
rz  D:kodexplorer4.40.zip
unzip kodexplorer4.40.zip -d kod

8.将kod软件cp到容器

docker cp /code/kod kod_cts:/code

9.添加GD库

yum install php-mbstring php-gd -y

10.授权/code

chown -R www.www /code

11.编写启动脚本并授权

1.写启动脚本
vi /code/init.sh
#!/bin/bash
nginx
php-fpm
​
2.添加执行权限
chmod +x /code/init.sh

12.提交镜像

 docker commit kod_cts kod:v1

13.启动测试

 docker stop $(docker ps -qa)
 docker run -d -p 80:80 kod:v1
 docker ps
 
 浏览器
 http://10.0.0.21
 跳出来界面即可

14.导出镜像

docker save kod:v1 -o kod_v1.tar.gz

第九章 Dockerfile自动构建镜像

1.Dockfile 操作说明

Docker通过对于在Dockerfile中的一系列指令的顺序解析实现自动的image的构建
    通过使用build命令，根据Dockerfiel的描述来构建镜像 
    通过源代码路径的方式 
    通过标准输入流的方式
    
 指令： 
    只支持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自动部署kod容器

1.kod需要的配置文件及代码

tree /data/ -L 2
/data
├── code
│   └── nginx-1.18.0-1.el7.ngx.x86_64.rpm
├── conf
│   ├── cloud.conf
│   ├── nginx.conf
│   └── www.conf
├── Dockerfile
├── init.sh
├── kod
│   ├── kod.tar.gz
└── kodexplorer4.40.zip
​

2.启动kod容器dockerfile文件

#安装基础镜像
FROM centos:7
​
#创建用户
RUN groupadd -g 1000 www
RUN useradd -u 1000 -g 1000 www
​
#安装php
RUN yum -y install php-fpm
​
#修改php配置文件
COPY conf/www.conf /etc/php-fpm.d/www.conf
​
#创建代码目录
RUN mkdir /code
​
#安装nginx依赖
RUN yum install openssl -y
​
#安装nginx
COPY code/nginx-1.18.0-1.el7.ngx.x86_64.rpm /code
RUN rpm -ivh /code/nginx-1.18.0-1.el7.ngx.x86_64.rpm
​
#修改配置文件
COPY conf/cloud.conf /etc/nginx/conf.d/cloud.conf
COPY conf/nginx.conf /etc/nginx/nginx.conf
​
#将kod代码拉取到溶器
ADD kod/kod.tar.gz /code
​
#添加GD库
RUN yum install php-mbstring php-gd -y
​
#写启动脚本并授权
COPY init.sh /code/
RUN chmod +x /code/init.sh
​
#给/code目录授权
RUN chown -R www.www /code
​
#启动命令
CMD ["/bin/bash","/code/init.sh"]

3.构建容器

cd /code
docker build -t kod:v1 .

3.Dockerfile自动构建小游戏

 

4.Dockerfile自动构建 wordpress

 

第十章 Docker-compose容器编排工具

1.docker-compose介绍

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

Compose 使用的三个步骤

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

2.安装docker-compose

1.方法1:直接yum安装

yum install docker-compose

2.方法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语法介绍

1.语法

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

2.参数解释

1.为什么要做link
centos7-1   ping 172.17.0.2     ping centos7-2
centos7-2   ping 172.17.0.3     ping centos7-1
​
zabbix-mysql      
- mysql
​
zabbix-server     
--link mysql 
配置数据库IP地址:
DBHOSt: mysql
​
zabbix-web 
DBHOSt: mysql
​
​
2.用户参数
user: 2000:2000
          2000:999
         mysql:mysql
-v /data/mysql:/var/lib/mysql 
​
3.参数哪里找/环境变量哪里找
官网找:https://hub.docker.com/_/mysql
--character-set-server=utf8
--collation-server=utf8_bin
​
4.服务启动顺序控制
depends_on:
  - mysql 
​
1 mysql
​
2 zabbix-server
  depends_on:
    - mysql
    
3 zabbix-web
  depends_on:
    - zabbix-server
​
5.版本号
​
4.参数的含义不理解
environment:
  MYSQL_DATABASE: zabbix        #启动mysql容器的时候创建的新数据库名称
  MYSQL_USER: zabbix            #启动mysql容器的时候创建的新数据库的管理用户
  MYSQL_PASSWORD: zabbix        #启动mysql容器的时候创建的新数据库的管理用户的密码
  MYSQL_ROOT_PASSWORD: zabbix   #启动mysql容器的时候root账户的密码
volumes:
  - /data/mysql:/var/lib/mysql  #把容器里的数据目录挂载到宿主机的目录
  
5.参数作用
services:
  mysql:  
 
1.可以自定义
2.docker-compose里links连接时候用的
3.docker-compose想单独停止或启动某个服务时候用的名字
​
6.参数的意义
user: 2000:2000
​
如果不添加这个参数的结果:
1.容器内mysql用户是999
2.挂载之后,宿主机目录显示的也是999
3.要求你宿主机的mysql和容器内的mysql用户的UID和GID保持完全一致
​
但是假如我宿主机的UID和GID为999的已经被占用了怎么?
那么就添加user: 2000:2000参数,可以达到什么效果呢?
1.宿主机显示的是2000用户,容器内依然是999用户
2.但是两边可以互相写入
3.前提是你宿主机提前创建好目录并且更改好授权为2000用户
​
7.环境变量意义
environment:
  MYSQL_DATABASE: zabbix    #作用是,启动mysql容器的时候自动创建一个数据库
  MYSQL_USER: zabbix        #作用是,给刚才创建的新的数据库授权用户
  MYSQL_PASSWORD: zabbix    #作用是,给刚才创建的普通用户赋予一个密码
  MYSQL_ROOT_PASSWORD: zabbix #作用是,给root账户创建一个密码叫zabbix
​
前三个参数的作用:
启动容器的时候
1.自动创建一个用户名字叫zabbix
2.给zabbix用户创建个密码
3.创建数据库叫zabbix
4.赋权zabbix用户对zabbix数据库拥有所有的权限
​
8.links作用
links:    
  - mysql
​
为什么要用links???
如果不用的话,两个容器互相通讯必须通过IP地址
那么为配置文件就不能提前配了
​
​
如果用了Links呢?
两个容器互相通讯,只需要知道对方的容器名称即可,不需要知道IP地址
​
​
9.mysql变量从哪里获取的?
docker-hub是什么?
docker-hub是docker官方的镜像仓库地址,全球都可以访问,朝鲜除外
大家都会把官方镜像放在docker-hub上
​
来源地址:
https://hub.docker.com/_/mysql
​
​
10.依靠什么名字来通讯
​
依靠的是容器之间的名字
不是docker-compose里的service名称
​
如果使用的是docker-compose启动的,并且配置文件里加了网卡的bridge,可以通过service名称
如果只是用run启动,则必须是容器的name名称
​
links:    
  - mysql
​

4.使用docker-compose部署zabbix

1.docker-run命令

docker run --name mysql-server -t 
      -e MYSQL_DATABASE="zabbix" 
      -e MYSQL_USER="zabbix" 
      -e MYSQL_PASSWORD="zabbix" 
      -e MYSQL_ROOT_PASSWORD="zabbix" 
      -d mysql:5.7 
      --character-set-server=utf8 --collation-server=utf8_bin
      
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" 
      -e MYSQL_ROOT_PASSWORD="zabbix" 
      --link mysql-server:mysql 
      -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" 
      -e MYSQL_ROOT_PASSWORD="zabbix" 
      --link mysql-server:mysql 
      --link zabbix-server-mysql:zabbix-server 
      -p 80:8080 
      -d zabbix/zabbix-web-nginx-mysql:latest

2.docker-compose

version: '2.2'
services:
  mysql:
    image: mysql:5.7
    container_name: mysql-server
    user: 2000:2000
    environment:
      MYSQL_DATABASE: zabbix
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbix
      MYSQL_ROOT_PASSWORD: zabbix
    volumes:
      - /data/mysql:/var/lib/mysql
    command:
      --character-set-server=utf8 
      --collation-server=utf8_bin      
          
  zabbix-server-mysql:
    image: zabbix/zabbix-server-mysql:latest
    container_name: zabbix-server-mysql
    environment:
      DB_SERVER_HOST: mysql-server
      MYSQL_DATABASE: zabbix
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbix
      MYSQL_ROOT_PASSWORD: zabbix
    ports:
      - 10051:10051
    links:
      - mysql
    depends_on:
      - mysql 
  
  zabbix-server-web:
    image: zabbix/zabbix-web-nginx-mysql:latest
    container_name: zabbix-web-nginx-mysql
    environment:
      DB_SERVER_HOST: mysql-server
      MYSQL_DATABASE: zabbix
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbix
      MYSQL_ROOT_PASSWORD: zabbix
    ports:
      - 80:8080
    links:
      - mysql
      - zabbix-server-mysql 
    depends_on:
      - zabbix-server-mysql 

5.使用docker-compose部署jenkins+gitlab

docker-compose

version: '2.2'
services:
  gitlab:
    image: 'gitlab/gitlab-ce:latest'
    restart: always
    hostname: '10.0.0.11'
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        external_url 'http://10.0.0.11'
    ports:
      - '8000:80'
      - '443:443'
      - '2222:22'
    volumes:
      - '/data/gitlab/config:/etc/gitlab'
      - '/data/gitlab/logs:/var/log/gitlab'
      - '/data/gitlab/data:/var/opt/gitlab'
   
  jenkins:
    image: 'jenkins/jenkins:lts'
    restart: always
    hostname: '10.0.0.11'
    user: root
    ports:
      - '8080:8080'
      - '50000:50000'
    volumes:
      - /data/jenkins/:/var/jenkins_home

第十一章 Docker网络模式

1.Docker网络的四种模式

1.四种模式

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

2.查看网络模式命令

    docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
3791e4fc9c18        bridge              bridge              local
b494337929ef        host                host                local
a153ac0003e3        none                null                local

3.查看网卡命令

ip a

4.查看桥接网卡命令

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地址,这样容器之间就可以互通了。

流程图:

第十二章 Docker容器跨主机通信

1.Docker跨主机网络类型

自带:
macvlan
​
第三方:
flannel
Consul
calico

2.macvlan模式

1.创建网络

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

2.启动容器

1.docker01启动容器
docker run -it --network macvlan_1 --ip 10.0.0.100 alpine
​
2.docker02启动容器
docker run -it --network macvlan_1 --ip 10.0.0.200 alpine

3.启动后进入容器测试IP通讯

docker01容器  ping 10.0.0.100
docker02容器  ping 10.0.0.200

3.跨主机通信-Consul实现

1. Consul介绍

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

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.修改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

4.重启docker01

systemctl daemon-reload     
systemctl restart docker.service

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

6.重启docker2

systemctl daemon-reload     
systemctl restart docker.service

7.在docker主机上创建overlay网络

在docker1上创建网络，然后会自动同步到docker2上
docker network create -d overlay overlay_net

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

1.docker01运行命令

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

2.docker02运行命令

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

9.测试联通性

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

4.跨主机通信-flannel实现

1.flannel介绍

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

2. flannel通信原理

流程图解

 

文字说明

3.实验环境

10.0.0.11  etcd,flannel,docker
10.0.0.12  flannel,docker

4. 安装配置etcd

1.安装etd:

yum install etcd -y

2.编辑配置文件

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

3.启动etcd

systemctl start etcd
systemctl enable etcd

4.测试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

5.防火墙

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

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

1.安装Flannel

yum install flannel

2.配置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.21: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

3.配置etcd数据库

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

4.启动flannel

systemctl start flanneld.service
systemctl enable flanneld.service

5.检查端口

[root@docker01 ~]#netstat -lntup|grep flannel
udp        0      0 10.0.0.21:8285          0.0.0.0:*                           2202/flanneld 
[root@docker02 ~]#netstat -lntup|grep flannel
udp        0      0 10.0.0.22:8285          0.0.0.0:*                           1963/flanneld

6. 配置Docker关联Flannel网络

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

7. 创建容器测试

1.docker01创建容器

docker run -it busybox /bin/sh

2.查看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

3.Docker02创建容器

docker run -it busybox /bin/sh

4.查看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   

5.测试容器间可否通讯

ping 192.168.72.2
ping 192.168.58.3

6.docker地址没变处理方法

修改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

7. 修改防火墙

iptables -P INPUT ACCEPT
iptables -P FORWARD ACCEPT