Docker

docker的安装

一、如果之前安装过docker，卸载

yum remove docker docker-common docker-selinux docker-engine -y

二、更新yum源

curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo

三、如果是新安装的系统，可以更新操作系统和内核

yum update -y

四、添加docker-ce yum源

wget -O /etc/yum.repos.d/docker-ce.repo https://repo.huaweicloud.com/docker-ce/linux/centos/docker-ce.repo# 清除rpm包及headeryum clean all# 重新缓存远端服务器rpm包信息yum makecache

五、添加阿里云镜像加速器

mkdir -p /etc/dockertee /etc/docker/daemon.json <<-'EOF'{  "registry-mirrors": ["https://qi3pe2qe.mirror.aliyuncs.com"]}EOFsystemctl daemon-reload

六、安装Docker

yum install docker-ce -y

七、启动并设置开机自启

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

八、检查docker是否启动成功

[root@docker01 ~]# docker info[root@docker01 ~]# docker version

tips:建议按照官方文档安装，阿里云内部镜像：http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

Docker的常用命令

docker镜像命令

tips:https://docs.docker.com/engine/reference/commandline/

一、常用镜像仓库

官方仓库：hub.docker.com自己的私有仓库：Harbor阿里云私有仓库：registry.cn-hangzhou.aliyuncs.com

二、docker镜像常用命令

    1、docker search [镜像名称]                     #搜索镜像, 优先选官方,stars数量多
    2、docker pull [镜像名称]                     #拉取镜像(下载镜像)，注意版本
    3、docker push [镜像标签]                     #推送镜像(上传镜像)
    4、docker load < [包名称]                      #将包导入镜像
       例子: docker load  -i  docker_nginx.tar.gz
    5、docker save [镜像名称|镜像ID] > [包名称]    #将包导出镜像导出镜像
       例子:docker save centos:7 -o docker_centos7.tar.gz
    6、docker image  ls                           #查看镜像列表
    7、docker rmi [镜像名称或者镜像ID]            #删除镜像
    8、docker tag [镜像ID]  镜像标签                 #给镜像打标签

三、docker镜像命令使用及进阶

1、搜索镜像search

    格式
        docker search [镜像名称]
    #参数
        -f 筛选
    #搜索收藏大于等于600
    [root@docker01 ~]# docker search mysql -f stars=600
    #搜索官方镜像
    [root@docker01 ~]# docker search -f is-official=true mysql

2、拉取镜像pull

    格式
        docker pull [镜像名称]

    实例
    [root@docker01 ~]# docker pull redis
    Using default tag: latest
    latest: Pulling from library/redis
    #镜像层：
    a076a628af6f: Pull complete 
    f40dd07fe7be: Pull complete 
    ce21c8a3dbee: Pull complete 
    ee99c35818f8: Pull complete 
    56b9a72e68ff: Pull complete 
    3f703e7f380f: Pull complete 
    #镜像ID号，全球唯一
    Digest: sha256:0f97c1c9daf5b69b93390ccbe8d3e2971617ec4801fd0882c72bf7cad3a13494
    #镜像下载状态
    Status: Downloaded newer image for redis:latest
    #镜像的全称（镜像的tag）
    docker.io/library/redis:latest

3、查看当前镜像列表images

    # 格式
        docker images 或者 docker image ls
    # 参数
        -q : 只显示镜像ID
        [root@docker01 ~]# docker images -q
        621ceef7494a

4、获取镜像详细信息inspect

    # 格式
        docker inspect [镜像名称或镜像ＩＤ]
    # 参数
    -f : 格式化输出
    [root@Centos7 ~]# docker inspect -f '{ {.Id} }' 621ceef7494a
    sha256:621ceef7494adfcbe0e523593639f6625795cc0dc91a750629367a8c7b3ccebb
    [root@Centos7 ~]# docker inspect -f '{ {.ContainerConfig.Hostname} }' redis
    16535cfaf84a

5、登录镜像仓库login

    # 格式
        docker login 
        注： 默认情况下，docker login登录的是官方仓库，如果登录其他镜像仓库则需要指定镜像仓库的URL连接。
    # 参数
    --username|-u : 指定用户名
    --password|-p : 指定密码
    [root@docker01 ~]# docker login -u 1426115933
    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 login --username=武宜帅 registry.cn-hangzhou.aliyuncs.com
    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 ~]# cat .docker/config.json 
    {
        "auths": {
            "https://index.docker.io/v1/": {
                "auth": "MTQyNjExNTkzMzpXdTE1NTg4MTk4OTA5LjA="
            },
            "registry.cn-hangzhou.aliyuncs.com": {
                "auth": "5q2m5a6c5biFOld1MTU1ODgxOTg5MDkuMA=="
            }
        }
    }[root@docker01 ~]#

6、镜像标签tag

    # 镜像标签的构成
    docker.io/library/redis:latest
    docker.io  : 镜像仓库的URL
    library    ：镜像仓库命名空间
    redis       : 镜像名称
    latest       : 镜像版本号
    # 打标签
        # 格式
            docker tag [镜像ID]  镜像标签
    # 实例
    [root@docker01 ~]# docker tag 621ceef7494a registry.cn-hangzhou.aliyuncs.com/wxyuan/test/redis:v1
    [root@docker01 ~]# docker images -a
    REPOSITORY                                            TAG       IMAGE ID       CREATED        SIZE
    redis                                                 latest    621ceef7494a   2 months ago   104MB
    registry.cn-hangzhou.aliyuncs.com/wxyuan/test/redis   v1        621ceef7494a   2 months ago   104MB

7、镜像上传push

    # 格式
        docker push [镜像标签]
    # 注：要想上传镜像，首先得登录镜像仓库,其次设置对应镜像仓库的tag
    [root@docker01 ~]# docker push registry.cn-hangzhou.aliyuncs.com/wxyuan/test/redis:v1 
    The push refers to repository [registry.cn-hangzhou.aliyuncs.com/wxyuan/test/redis]
    3480f9cdd491: Pushed 
    a24a292d0184: Pushed 
    f927192cc30c: Pushed 
    1450b8f0019c: Pushed 
    8e14cb7841fa: Pushed 
    cb42413394c4: Pushed 
    v1: digest: sha256:7ef832c720188ac7898dbd8d1e237b0738e94f94fc7e981cb7b8efe84555e892 size: 1572

8、镜像删除 rmi

    # 格式
        docker rmi [镜像名称或者镜像ID]
    # 实例
        [root@docker01 ~]# docker rmi redis
        Untagged: redis:latest
        Untagged: redis@sha256:0f97c1c9daf5b69b93390ccbe8d3e2971617ec4801fd0882c72bf7cad3a13494
    # 参数
        -f  : 强制删除
    # 实例
        [root@docker01 ~]# docker rmi -f 621ceef7494a

9、清空镜像image prune

    docker image prune命令用于删除未使用的映像。 如果指定了-a，还将删除任何容器未引用的所有映像。
# 格式
    docker image prune
 # 参数
 -a : 删除所有镜像
# 实例
[root@docker01 ~]# docker image prune 
WARNING! This will remove all dangling images.
Are you sure you want to continue? [y/N] y
Total reclaimed space: 0B
docker rmi -f $( docker images -q )
oot@docker01 ~]# docker image prune -a
WARNING! This will remove all images without at least one container associated to them.
Are you sure you want to continue? [y/N] y
Deleted Images:
untagged: nginx:latest
untagged: nginx@sha256:10b8cc432d56da8b61b070f4c7d2543a9ed17c2b23010b43af434fd40e2ca4aa
deleted: sha256:f6d0b4767a6c466c178bf718f99bea0d3742b26679081e52dbf8e0c7c4c42d74
deleted: sha256:4dfe71c4470c5920135f00af483556b09911b72547113512d36dc29bfc5f7445
deleted: sha256:3c90a0917c79b758d74b7040f62d17a7680cd14077f734330b1994a2985283b8
deleted: sha256:a1c538085c6f891424160d8db120ea093d4dda393e94cd4713e3fff3c82299b5
deleted: sha256:a3ee2510dcf02c980d7aff635909612006fd1662084d6225e52e769b984abeb5
untagged: redis:latest
untagged: redis@sha256:0f97c1c9daf5b69b93390ccbe8d3e2971617ec4801fd0882c72bf7cad3a13494
deleted: sha256:621ceef7494adfcbe0e523593639f6625795cc0dc91a750629367a8c7b3ccebb
deleted: sha256:de66cfbf4712b8ba9ef292e08ef7487be26d9d21b350548e400ae351405d820e
deleted: sha256:79b2381e35429e8fc04d31b3445f069c22d288bf5c4cba7b7c10004ff78ae201
deleted: sha256:1d047d19be363b00139990d4d7f392dabdb0809dbc9d0fbe67c1f15b8caed27a
deleted: sha256:8c41f4e708c37059df28ae1cabc200a6db2fee45bd3a2cadcf70f2765bb68730
deleted: sha256:b51317bef36fe1900be48402c8a41fcd9cdb6b8950c10209f764473cb8323371
deleted: sha256:cb42413394c4059335228c137fe884ff3ab8946a014014309676c25e3ac86864
Total reclaimed space: 168MB

10、查看镜像构建历史 history

    # 格式
        docker history [镜像ID或镜像名称]
    # 实例
    [root@docker01 ~]# docker pull alpine
    Using default tag: latest
    latest: Pulling from library/alpine
    596ba82af5aa: Pull complete 
    Digest: sha256:d9a7354e3845ea8466bb00b22224d9116b183e594527fb5b6c3d30bc01a20378
    Status: Downloaded newer image for alpine:latest
    docker.io/library/alpine:latest
    [root@docker01 ~]# docker history alpine:latest 
    IMAGE          CREATED        CREATED BY                                      SIZE      COMMENT
    7731472c3f2a   2 months ago   /bin/sh -c #(nop)  CMD ["/bin/sh"]              0B        
    <missing>      2 months ago   /bin/sh -c #(nop) ADD file:edbe213ae0c825a5b…   5.61MB

11、保存容器为镜像commit

    # 保存正在运行的容器直接为镜像
    # 格式：
        docker commit [容器ID|容器名称] 保存名称:版本
    # 参数
        -a 镜像作者
        -p 提交期间暂停容器
        -m 容器说明
    # 实例
        [root@docker01 ~]# docker ps
        CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                   NAMES
        ebb852aefe0a   nginx     "/docker-entrypoint.…"   3 minutes ago   Up 3 minutes   0.0.0.0:49153->80/tcp   wizardly_shamir
        [root@docker01 ~]# docker commit -a "xiaowu" -m "小武的容器" -p ebb852aefe0a test:v1
        sha256:a9297902755a4ede3ce38c2717515626c678b6deae50206071a0a29ebcd208a9
        [root@docker01 ~]# docker images
        REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
        test         v1        a9297902755a   4 seconds ago   133MB
        alpine       latest    7731472c3f2a   2 months ago    5.61MB
        nginx        latest    f6d0b4767a6c   2 months ago    133MB

12、保存容器为镜像包（export/import）

    # export保存正在运行的容器为镜像包
    ## 保存容器为镜像
        docker export [容器的ID] > [包名称]
    # 实例
        [root@docker01 ~]# docker ps
    CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                   NAMES
    ebb852aefe0a   nginx     "/docker-entrypoint.…"   6 minutes ago   Up 6 minutes   0.0.0.0:49153->80/tcp   wizardly_shamir
    [root@docker01 ~]# docker export ebb852aefe0a > nginx:v1.tar
    [root@docker01 ~]# ll
    -rw-r--r--  1 root root 135403008 Mar 18 21:05 nginx:v1.tar

    # import 将镜像包解为镜像
    ## docker import [包名称] [自定义镜像名称]
        # 实例
        [root@docker01 ~]# docker import nginx\:v1.tar  nginx:v2
        sha256:59bde51898fa443281782320b194d5e139c37ece32528843bb26d444800265ab
        [root@docker01 ~]# docker images
        REPOSITORY   TAG       IMAGE ID       CREATED          SIZE
        nginx        v2        59bde51898fa   10 seconds ago   131MB
        test         v1        a9297902755a   6 minutes ago    133MB
        alpine       latest    7731472c3f2a   2 months ago     5.61MB
        nginx        latest    f6d0b4767a6c   2 months ago     133MB

13、保存镜像为镜像包（save/load）

# save保存镜像为镜像包
# 保存镜像的格式：
    docker save [镜像名称|镜像ID] > [包名称]
# 实例
    [root@docker01 ~]# docker images
    REPOSITORY   TAG       IMAGE ID       CREATED              SIZE
    nginx        v2        59bde51898fa   About a minute ago   131MB
    test         v1        a9297902755a   8 minutes ago        133MB
    alpine       latest    7731472c3f2a   2 months ago         5.61MB
    nginx        latest    f6d0b4767a6c   2 months ago         133MB
    [root@docker01 ~]# docker save alpine > alpine.tar
    [root@docker01 ~]# ll
    -rw-r--r--  1 root root   5889024 Mar 18 21:10 alpine.tar
    -rw-r--r--  1 root root 135403008 Mar 18 21:05 nginx:v1.tar

# load 将镜像包导入为镜像
    docker load < [包名称]
# 实例
    [root@docker01 ~]# ll
    -rw-r--r--  1 root root   5889024 Mar 18 21:10 alpine.tar
    -rw-------. 1 root root      1718 Nov 17 20:34 anaconda-ks.cfg
    -rw-r--r--  1 root root 135403008 Mar 18 21:05 nginx:v1.tar
    [root@docker01 ~]# docker load < alpine.tar 
    Loaded image: alpine:latest
    [root@docker01 ~]# docker images
    REPOSITORY   TAG       IMAGE ID       CREATED          SIZE
    nginx        v2        59bde51898fa   5 minutes ago    131MB
    test         v1        a9297902755a   12 minutes ago   133MB
    alpine       latest    7731472c3f2a   2 months ago     5.61MB
    nginx        latest    f6d0b4767a6c   2 months ago     133MB
# 注：save/load保存镜像无法自定义镜像名称，save保存镜像时如果使用ID保存则load导入镜像无名称，使用名称导入时才有名称。

以上三种保存镜像的区别

1、export保存的镜像体积要小于save(save保存更完全，export保存会丢掉一些不必要的数据)
2、export可以重命名镜像名称而save则不行
3、save可以同时保存多个镜像而export则不行

docker容器命令

一、容器介绍

1、容器就是对外提供服务的一个实例。2、容器启动的必要条件：容器内至少有一个进程运行在前台

二、容器命令

1、docker ps查看容器列表2、docker run创建容器

三、容器命令的使用及进阶

1、docker ps查看容器列表

    # 格式    
        docker ps [参数]
    # 默认
        docker ps         # 查看正在运行的容器列表
    # 参数
        -a : 查看系统中所有的容器。
        -q : 仅显示容器的ID
    # 实例

2、docker run创建容器

# 格式    docker run [参数] [镜像名称] [运行容器的启动命令]

参数

1）-d 守护进程方式运行

    # 格式
        docker run -d [镜像名称] [cmd]
     #如果没有前台应用，j
    # 实例
        docker run -d nginx

2）—name指定容器名称

    # 格式
        docker run -d --name [容器名称] [镜像的名称] [cmd]
    # 实例
        docker run -d --name nginx nginx

3）-p指定端口映射

    # 格式
        docker run -d -p 宿主机IP:宿主主机端口:容器内端口 [镜像的名称] [cmd]
        不使用宿主机IP默认本机全网段端口开放
    # 实例
        端口映射
        docker run -d -p 80:80 nginx
        docker run -d -p 10.0.0.210:81:80 nginx
        端口范围映射
        docker run -d -p 81-89:81-89 nginx
        使用UDP协议做端口映射
        docker run -d -p 90:80/udp nginx
        使用UDP协议做端口随机映射
        docker run -d -p ::80/udp nginx
        随机端口映射
        docker run -d -p ::80 nginx

4）-P随机端口映射

    # 格式
        docker run -d -P [镜像名称] [cmd]
    # 实例
        docker run -d -P nginx

5）-it以交互式方式打开一个伪终端

    -i        #以交互式运行容器
    -d        #创建一个为终端
    # 格式
        docker run -it [镜像名称] [cmd]
    # 实例
        以交互式方式打开一个伪终端
        docker run -it nginx bash
        以交互式方式打开一个终端在后台运行
        docker run -dit centos

6）-v 给容器挂载数据卷

    # 格式
        docker run -v 宿主主机绝对目录:容器内目录  [镜像名称] [cmd]
        在宿主机创建一个固定名字的目录,来持久化容器的目录下的数据
        docker run -v 宿主主机绝对目录:容器内目录  [镜像名称] [cmd]
    # 实例
        docker run -dit -v /root/test:/root centos7
        docker run -dit -v /root/test1:/root centos7

7）—rm容器生命周期结束立即删除

    # 格式
        docker run --rm [镜像名称] [cmd]
    # 实例
        docker run -d --rm nginx

8）-e在容器中创建一个环境变量

    #格式
        docker run -e 环境变量 -d [镜像名称] [cmd]
    # 实例
        [root@docker01 ~]# docker run -it -e NAME=abc centos:7
        [root@5288ff59ea57 /]# printenv
        NAME=abc

9）—link连上一个容器，实现网络互通

    # 格式
        docker run --link 被连接的容器的名称:连接别名 [镜像名称] [cmd]
    # 实例
        [root@docker01 ~]# docker run -it --link dc1dab96297a:nginx centos
        [root@6044ef9f8bbe /]# ping nginx
        64 bytes from nginx (172.17.0.5): icmp_seq=1 ttl=64 time=0.158 ms

10）-h设置容器主机名

    # 格式
        docker run -h "主机名"  [镜像名称] [cmd]
    # 实例
        [root@docker01 ~]# docker run -it -h "xiaowu" nginx bash
    root@xiaowu:/#

补充

    容器想要放在后台一直运行的化,那么容器的初始命令,必须夯住(前台运行),否则容器就会退出.
    前台运行
    nginx -g 'daemon off;'
    /usr/sbin/php-fpm --nodaemonize
    /usr/sbin/sshd -D

3、docker create创建容器不启动

    docker create [参数] [镜像名称] [运行容器的启动命令]
    #参数
    大部分参数与docker run相同
    区别：
    1、无-d参数
    # docker run和docker create运行流程
    1、检查本地是否用指定镜像，如果没有则去对应的仓库下载镜像
    2、启动容器，如果指定了命令则使用指定的命令，如果没有则使用默认的命令
    3、返回容器ID

4、start/stop启停容器

    # 启动（该容器必须是系统已经存在的容器）
        docker start [容器的ID|名称]
    # 停止
        docker stop [容器的ID|名称]

5、docker rm删除容器

    # 格式
        docker rm [容器名称|ID]
    # 参数
        -f : 强制删除
        docker rm -f [容器名称|ID]
    # 清空容器
        正在运行的不会删除
        docker rm $(docker ps -a -q)
        正在运行的也会被删除
        docker rm -f $(docker ps -a -q)

6、docker inspect查看容器信息

    # 格式
        docker inspect [容器名称|ID]
    #查看容器运行状态
        #格式
        docker inspect -f '{ {信息名称} }' [容器名称|ID]
        #实例
        docker inspect -f '{ {.State.Running} }' nginx

7、docker cp复制命令

    #宿主机文件复制到容器内
        docker cp [宿主主机文件路径]  容器ID:容器内路径
    2、复制到容器外
        docker cp 容器ID:容器内路径 [宿主主机文件路径]

8、docker exec/attach进入容器

    1. exec : 进入正在运行的容器(分配一个新终端)（官方推荐）
        docker exec [参数] [容器的名称|ID] [cmd]
        #实例
            docker exec -it nginx bash
    2. attach : 进入正在运行的容器(使用相同的终端)
        docker attach [容器ID|名称]
        直接离开会关掉容器
        偷偷离开的快捷键ctrl +p,ctrl +q

9、其他进入容器的方法

    3、nsenter : 建立一个管道连接上容器主ID
        nsenter --target $( docker inspect -f { {.State.Pid} } [容器名|ID]) --mount --uts --ipc --net --pid
    4、ssh : 通过ssh连接  (麻烦不推荐)

10、保存容器为镜像commit

    # 保存正在运行的容器直接为镜像
    # 格式：
        docker commit [容器ID|容器名称] 保存名称:版本
    # 参数
        -a 镜像作者
        -p 提交期间暂停容器
        -m 容器说明
    # 实例
        [root@docker01 ~]# docker ps
        CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                   NAMES
        ebb852aefe0a   nginx     "/docker-entrypoint.…"   3 minutes ago   Up 3 minutes   0.0.0.0:49153->80/tcp   wizardly_shamir
        [root@docker01 ~]# docker commit -a "xiaowu" -m "小武的容器" -p ebb852aefe0a test:v1
        sha256:a9297902755a4ede3ce38c2717515626c678b6deae50206071a0a29ebcd208a9
        [root@docker01 ~]# docker images
        REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
        test         v1        a9297902755a   4 seconds ago   133MB
        alpine       latest    7731472c3f2a   2 months ago    5.61MB
        nginx        latest    f6d0b4767a6c   2 months ago    133MB

11、保存容器为镜像包（export/import）

    # export保存正在运行的容器为镜像包
    ## 保存容器为镜像
        docker export [容器的ID] > [包名称]
    # 实例
        [root@docker01 ~]# docker ps
    CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                   NAMES
    ebb852aefe0a   nginx     "/docker-entrypoint.…"   6 minutes ago   Up 6 minutes   0.0.0.0:49153->80/tcp   wizardly_shamir
    [root@docker01 ~]# docker export ebb852aefe0a > nginx:v1.tar
    [root@docker01 ~]# ll
    -rw-r--r--  1 root root 135403008 Mar 18 21:05 nginx:v1.tar

    # import 将镜像包解为镜像
    ## docker import [包名称] [自定义镜像名称]
        # 实例
        [root@docker01 ~]# docker import nginx\:v1.tar  nginx:v2
        sha256:59bde51898fa443281782320b194d5e139c37ece32528843bb26d444800265ab
        [root@docker01 ~]# docker images
        REPOSITORY   TAG       IMAGE ID       CREATED          SIZE
        nginx        v2        59bde51898fa   10 seconds ago   131MB
        test         v1        a9297902755a   6 minutes ago    133MB
        alpine       latest    7731472c3f2a   2 months ago     5.61MB
        nginx        latest    f6d0b4767a6c   2 months ago     133MB

Docker镜像讲解

镜像是什么

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内
容,包括代码、运行时、库、环境变量和配置文件。所有应用，直接打包docker镜像，就可以跑起来！！

如何得到镜像

从远程仓库下载
朋友拷贝给你
自己制作一个镜像 DockerFile

Docker镜像加载原理

UnionFS (联合文件系统)

下载的时候看到的一层层就是这个

Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

Docker镜像加载原理

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。
bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs (root file system) ，在bootfs之上。包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。

平时我们安装进虚拟机的CentOS都是好几个G，为什么docker这里才200M？？

对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供 rootfs 就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。虚拟机是分钟级别，容器时秒级

分层的镜像

以我们的pull为例，在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载

为什么 Docker 镜像要采用这种分层结构呢

最大的一个好处就是 - 共享资源

比如：有多个镜像都从相同的 base 镜像构建而来，那么宿主机只需在磁盘上保存一份base镜像，
同时内存中也只需加载一份 base 镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享。

 "Layers": [                "sha256:764055ebc9a7a290b64d17cf9ea550f1099c202d83795aa967428ebdf335c9f7",                "sha256:245c9d23f65373415922e53424032cabe7b282c5cf8f9f8070a7d1830fca6871",                "sha256:ebef6caacb966ed54c0c3facf2288fa5124452f2c0a17faa1941625eab0ceb54",                "sha256:0b7b774038f08ec329e4dd2c0be440c487cfb003a05fce87cd5d1497b602f2c1",                "sha256:a71d36a87572d637aa446110faf8abb4ea74f028d0e0737f2ff2b983ef23abf3",                "sha256:9e1fddfb3a22146392a2d6491e1af2f087da5e6551849a6174fa23051ef8a38f"            ]

如何提交自己的镜像 commit镜像

docker commit 提交容器成为一个新的副本#命令和git原理类似docker commit -m=“提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG]

实战测试

#1.启动tomcat发现没有页面显示，因为官方的webapps里面是没有文件的所以说我们要从webapps.dist文件里面拷贝进去#但是自己是很难受的#2.拷贝 操作root@ed8e9ece8550:/usr/local/tomcat/# cp -r webapps.dist/* webapps/#3.看下是否进去root@ed8e9ece8550:/usr/local/tomcat/webapps# lsROOT  docs  examples  host-manager  manager#4.把他放进到镜像中去 用commit操作将容器提交成为一个镜像  我们以后可以使用修改后的即可# -m -a 位置随便 docker commit -m=“提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG][root@bogon ~]# docker commit -a="SxrTj" -m="webapps app" ed8e9ece8550 tomcat01:1.0

镜像：就是从docker下载的相当于一个模板而容器它会在所有的镜像层之上增加一个可写层 这个可写层有运行在CPU上的进程 而且有两个不同的状态：运行态（Running）和退出态（Exited）。这就是Docker容器。

容器数据卷

将容器中的数据持久化在本地，不会因为容器的删除而丢失。也可以当作容器之间的数据共享作用。卷技术，目录的挂载，将我们容器内的目录，挂载到Linux上面。总结：容器的持久化和同步操作，可以用作容器间数据共享

使用数据卷

方式一：直接使用命令来挂载 -v

docker run -it -v 【主机目录】：【容器内目录】

在容器内对应的数据变化会同步到挂载的主机目录之中，同时对主机中的文件进行修改变化也会同步到容器中。

方式二：匿名挂载

docker run -d -p --name [NAME] -v [容器内目录]

方法三：具名挂载

docker run -d -p --name [NAME] -v [卷名]:[容器内路径]

tips：没有指定宿主机中的目录位置，会默认放至/var/lib/docker/volumes/xxx/_data中

参考进阶：https://blog.csdn.net/weixin_43591980/article/details/106316094

初始Dockerfile

Dockerfile就是用来构建docker镜像的构建文件！命令脚本！通过这个脚本可以生成镜像，镜像是一层一层的，脚本一个个的命令，每个命令都是一层！

# 创建一个dockerfile文件，名字可以随便 建议Dockerfile
# 文件中的内容： 指令(大写) + 参数
$ vim dockerfile1
    FROM centos 					# 当前这个镜像是以centos为基础的

    VOLUME ["volume01","volume02"] 	# 挂载卷的卷目录列表(多个目录)

    CMD echo "-----end-----"		# 输出一下用于测试
    CMD /bin/bash					# 默认走bash控制台

# 这里的每个命令，就是镜像的一层！
# 构建出这个镜像 
-f dockerfile1 			# f代表file，指这个当前文件的地址(这里是当前目录下的dockerfile1)
-t caoshipeng/centos 	# t就代表target，指目标目录(注意caoshipeng镜像名前不能加斜杠‘/’)
. 						# 表示生成在当前目录下
$ docker build -f dockerfile1 -t caoshipeng/centos .
Sending build context to Docker daemon   2.56kB
Step 1/4 : FROM centos
latest: Pulling from library/centos
8a29a15cefae: Already exists 
Digest: sha256:fe8d824220415eed5477b63addf40fb06c3b049404242b31982106ac204f6700
Status: Downloaded newer image for centos:latest
 ---> 470671670cac
Step 2/4 : VOLUME ["volume01","volume02"] 			# 卷名列表
 ---> Running in c18eefc2c233
Removing intermediate container c18eefc2c233
 ---> 623ae1d40fb8
Step 3/4 : CMD echo "-----end-----"					# 输出 脚本命令
 ---> Running in 70e403669f3c
Removing intermediate container 70e403669f3c
 ---> 0eba1989c4e6
Step 4/4 : CMD /bin/bash
 ---> Running in 4342feb3a05b
Removing intermediate container 4342feb3a05b
 ---> f4a6b0d4d948
Successfully built f4a6b0d4d948
Successfully tagged caoshipeng/centos:latest

# 查看自己构建的镜像
$ docker images
REPOSITORY          TAG          IMAGE ID            CREATED              SIZE
caoshipeng/centos   latest       f4a6b0d4d948        About a minute ago   237MB

启动自己写的容器镜像

$ docker run -it f4a6b0d4d948 /bin/bash	# 运行自己写的镜像
$ ls -l 								# 查看目录

这个卷和外部一定有一个同步的目录

查看一下卷挂载

# docker inspect 容器id
$ docker inspect ca3b45913df5

测试一下刚才的文件是否同步出去了！

这种方式使用的十分多，因为我们通常会构建自己的镜像！

假设构建镜像时候没有挂载卷，要手动镜像挂载 -v 卷名：容器内路径！

数据卷容器

多个MySQL同步数据！

命名的容器挂载数据卷！

# 测试 启动3个容器，通过刚才自己写的镜像启动
# 创建docker01：因为我本机是最新版，故这里用latest，狂神老师用的是1.0如下图
$ docker run -it --name docker01 caoshipeng/centos:latest

# 查看容器docekr01内容
$ ls
bin  home   lost+found	opt   run   sys  var
dev  lib    media	proc  sbin  tmp  volume01
etc  lib64  mnt		root  srv   usr  volume02

# 不关闭该容器退出
CTRL + Q + P  

# 创建docker02: 并且让docker02 继承 docker01
$ docker run -it --name docker02 --volumes-from docker01 caoshipeng/centos:latest

# 查看容器docker02内容
$ ls
bin  home   lost+found	opt   run   sys  var
dev  lib    media	proc  sbin  tmp  volume01
etc  lib64  mnt		root  srv   usr  volume02

# 再新建一个docker03同样继承docker01
$ docker run -it --name docker03 --volumes-from docker01 caoshipeng/centos:latest
$ cd volume01	#进入volume01 查看是否也同步docker01的数据
$ ls 
docker01.txt

# 测试：可以删除docker01，查看一下docker02和docker03是否可以访问这个文件
# 测试发现：数据依旧保留在docker02和docker03中没有被删除

多个mysql实现数据共享

$ docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

$ docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01  mysql:5.7

# 这个时候，可以实现两个容器数据同步！

结论：

容器之间的配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止。

所有容器的挂载卷都是通过Linux硬连接的方式，将同步文件都连接到宿主机的本地文件中。

但是一旦你持久化到了本地，这个时候，本地的数据是不会删除的！

DockerFile

DockerFile介绍

dockerfile是用来构建docker镜像的文件！命令参数脚本！

构建步骤：

1、编写一个dockerfile文件

2、 docker build 构建称为一个镜像

3、 docker run运行镜像

4、 docker push发布镜像（DockerHub 、阿里云仓库)

点击后跳到一个Dockerfile

很多官方镜像都是基础包，很多功能没有，我们通常会自己搭建自己的镜像！

官方既然可以制作镜像，那我们也可以！

DockerFile构建过程

基础知识：

1、每个保留关键字(指令）都是必须是大写字母

2、执行从上到下顺序

3、#表示注释

4、每一个指令都会创建提交一个新的镜像曾，并提交！

Dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件，这个文件十分简单！

Docker镜像逐渐成企业交付的标准，必须要掌握！

DockerFile：构建文件，定义了一切的步骤，源代码

DockerImages：通过DockerFile构建生成的镜像，最终发布和运行产品。

Docker容器：容器就是镜像运行起来提供服务。

DockerFile的指令

FROM				# from:基础镜像，一切从这里开始构建
MAINTAINER			# maintainer:镜像是谁写的， 姓名+邮箱
RUN					# run:镜像构建的时候需要运行的命令
ADD					# add:步骤，tomcat镜像，这个tomcat压缩包！添加内容 添加同目录
WORKDIR				# workdir:镜像的工作目录
VOLUME				# volume:挂载的目录
EXPOSE				# expose:保留端口配置
CMD					# cmd:指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT			# entrypoint:指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD				# onbuild:当构建一个被继承DockerFile这个时候就会运行onbuild的指令，触发指令
COPY				# copy:类似ADD，将我们文件拷贝到镜像中
ENV					# env:构建的时候设置环境变量！

实战测试

scratch 镜像

FROM scratch
ADD centos-7-x86_64-docker.tar.xz /

LABEL \
    org.label-schema.schema-version="1.0" \
    org.label-schema.name="CentOS Base Image" \
    org.label-schema.vendor="CentOS" \
    org.label-schema.license="GPLv2" \
    org.label-schema.build-date="20200504" \
    org.opencontainers.image.title="CentOS Base Image" \
    org.opencontainers.image.vendor="CentOS" \
    org.opencontainers.image.licenses="GPL-2.0-only" \
    org.opencontainers.image.created="2020-05-04 00:00:00+01:00"

CMD ["/bin/bash"]

Docker Hub 中 99%的镜像都是从这个基础镜像过来的 FROM scratch，然后配置需要的软件和配置来进行构建。

创建一个自己的centos

# 1./home下新建dockerfile目录
$ mkdir dockerfile

# 2. dockerfile目录下新建mydockerfile-centos文件
$ vim mydockerfile-centos

# 3.编写Dockerfile配置文件
FROM centos							# 基础镜像是官方原生的centos
MAINTAINER yangchen<1509724111@qq.com> 	# 作者

ENV MYPATH /usr/local				# 配置环境变量的目录 
WORKDIR $MYPATH						# 将工作目录设置为 MYPATH

RUN yum -y install vim				# 给官方原生的centos 增加 vim指令
RUN yum -y install net-tools		# 给官方原生的centos 增加 ifconfig命令

EXPOSE 80							# 暴露端口号为80

CMD echo $MYPATH					# 输出下 MYPATH 路径
CMD echo "-----end----"				
CMD /bin/bash						# 启动后进入 /bin/bash

# 4.通过这个文件构建镜像
# 命令： docker build -f 文件路径 -t 镜像名:[tag] .
$ docker build -f mydockerfile-centos -t mycentos:0.1 .

# 5.出现下图后则构建成功

$ docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mycentos            0.1                 cbf5110a646d        2 minutes ago       311MB

# 6.测试运行
$ docker run -it mycentos:0.1 		# 注意带上版本号，否则每次都回去找最新版latest

$ pwd	
/usr/local							# 与Dockerfile文件中 WORKDIR 设置的 MYPATH 一致
$ vim								# vim 指令可以使用
$ ifconfig     						# ifconfig 指令可以使用

# docker history 镜像id 查看镜像构建历史步骤
$ docker history 镜像id

我们可以列出本地进行的变更历史

我们平时拿到一个镜像，可以用 “docker history 镜像id” 研究一下是什么做的

CMD 和 ENTRYPOINT区别

CMD					# 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代。
ENTRYPOINT			# 指定这个容器启动的时候要运行的命令，可以追加命令

测试cmd

# 编写dockerfile文件
$ vim dockerfile-test-cmd
FROM centos
CMD ["ls","-a"]					# 启动后执行 ls -a 命令

# 构建镜像
$ docker build  -f dockerfile-test-cmd -t cmd-test:0.1 .

# 运行镜像
$ docker run cmd-test:0.1		# 由结果可得，运行后就执行了 ls -a 命令
.
..
.dockerenv
bin
dev
etc
home

# 想追加一个命令  -l 成为ls -al：展示列表详细数据
$ docker run cmd-test:0.1 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"-l\":
executable file not found in $PATH": unknown.
ERRO[0000] error waiting for container: context canceled 

# cmd的情况下 -l 替换了CMD["ls","-l"] 而 -l  不是命令所以报错

测试ENTRYPOINT

# 编写dockerfile文件
$ vim dockerfile-test-entrypoint
FROM centos
ENTRYPOINT ["ls","-a"]

# 构建镜像
$ docker build  -f dockerfile-test-entrypoint -t cmd-test:0.1 .

# 运行镜像
$ docker run entrypoint-test:0.1
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found ...

# 我们的命令，是直接拼接在我们得ENTRYPOINT命令后面的
$ docker run entrypoint-test:0.1 -l
total 56
drwxr-xr-x   1 root root 4096 May 16 06:32 .
drwxr-xr-x   1 root root 4096 May 16 06:32 ..
-rwxr-xr-x   1 root root    0 May 16 06:32 .dockerenv
lrwxrwxrwx   1 root root    7 May 11  2019 bin -> usr/bin
drwxr-xr-x   5 root root  340 May 16 06:32 dev
drwxr-xr-x   1 root root 4096 May 16 06:32 etc
drwxr-xr-x   2 root root 4096 May 11  2019 home
lrwxrwxrwx   1 root root    7 May 11  2019 lib -> usr/lib
lrwxrwxrwx   1 root root    9 May 11  2019 lib64 -> usr/lib64 ....

Dockerfile中很多命令都十分的相似，我们需要了解它们的区别，我们最好的学习就是对比他们然后测试效果！

实战：Tomcat镜像

1、准备镜像文件

准备tomcat 和 jdk 到当前目录，编写好README
1

2、编写dokerfile

$ vim dockerfile
FROM centos 										# 基础镜像centos
MAINTAINER cao<1165680007@qq.com>					# 作者
COPY README /usr/local/README 						# 复制README文件
ADD jdk-8u231-linux-x64.tar.gz /usr/local/ 			# 添加jdk，ADD 命令会自动解压
ADD apache-tomcat-9.0.35.tar.gz /usr/local/ 		# 添加tomcat，ADD 命令会自动解压
RUN yum -y install vim								# 安装 vim 命令
ENV MYPATH /usr/local 								# 环境变量设置 工作目录
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_231 				# 环境变量： JAVA_HOME环境变量
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.35 	# 环境变量： tomcat环境变量
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.35

# 设置环境变量 分隔符是：
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin 	

EXPOSE 8080 										# 设置暴露的端口

CMD /usr/local/apache-tomcat-9.0.35/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.35/logs/catalina.out 					# 设置默认命令

3、构建镜像

# 因为dockerfile命名使用默认命名 因此不用使用-f 指定文件
$ docker build -t mytomcat:0.1 .

4、run镜像

# -d:后台运行 -p:暴露端口 --name:别名 -v:绑定路径 
$ docker run -d -p 8080:8080 --name tomcat01 
-v /home/kuangshen/build/tomcat/test:/usr/local/apache-tomcat-9.0.35/webapps/test 
-v /home/kuangshen/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.35/l

5、访问测试

$ docker exec -it 自定义容器的id /bin/bash

$ cul localhost:8080

6、发布项目

(由于做了卷挂载，我们直接在本地编写项目就可以发布了！)

发现：项目部署成功，可以直接访问！

我们以后开发的步骤：需要掌握Dockerfile的编写！我们之后的一切都是使用docker镜像来发布运行！

发布自己的镜像

发布到 Docker Hub

1、地址 https://hub.docker.com/

2、确定这个账号可以登录

3、登录

$ docker login --help
Usage:  docker login [OPTIONS] [SERVER]

Log in to a Docker registry.
If no server is specified, the default is defined by the daemon.

Options:
  -p, --password string   Password
      --password-stdin    Take the password from stdin
  -u, --username string   Username

$ docker login -u 你的用户名 -p 你的密码

4、提交 push镜像

# 会发现push不上去，因为如果没有前缀的话默认是push到 官方的library
# 解决方法：
# 第一种 build的时候添加你的dockerhub用户名，然后在push就可以放到自己的仓库了
$ docker build -t kuangshen/mytomcat:0.1 .

# 第二种 使用docker tag #然后再次push
$ docker tag 容器id kuangshen/mytomcat:1.0 #然后再次push
$ docker push kuangshen/mytomcat:1.0

发布到阿里云镜像服务上,看官网很详细https://cr.console.aliyun.com/repository/

$ sudo docker login --username=zchengx registry.cn-shenzhen.aliyuncs.com
$ sudo docker tag [ImageId] registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:[镜像版本号]

# 修改id 和 版本
sudo docker tag a5ef1f32aaae registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:1.0
# 修改版本
$ sudo docker push registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:[镜像版本号]

Docker网络

三个网络

问题： docker 是如果处理容器网络访问的？

# 测试  运行一个tomcat
$ docker run -d -P --name tomcat01 tomcat

# 查看容器内部网络地址
$ docker exec -it 容器id ip addr

# 发现容器启动的时候会得到一个 eth0@if91 ip地址，docker分配！
$ ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
    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
261: eth0@if91: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:12:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.18.0.2/16 brd 172.18.255.255 scope global eth0
       valid_lft forever preferred_lft forever

       
# 思考？ linux能不能ping通容器内部！ 可以 容器内部可以ping通外界吗？ 可以！
$ ping 172.18.0.2
PING 172.18.0.2 (172.18.0.2) 56(84) bytes of data.
64 bytes from 172.18.0.2: icmp_seq=1 ttl=64 time=0.069 ms
64 bytes from 172.18.0.2: icmp_seq=2 ttl=64 time=0.074 ms

原理

1、我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要按照了docker，就会有一个docker0桥接模式，使用的技术是veth-pair技术！

https://www.cnblogs.com/bakari/p/10613710.html

再次测试 ip addr

容器数据卷

什么是容器数据卷

将应用和环境打包成一个镜像！

数据？如果数据都在容器中，那么我们容器删除，数据就会丢失！需求：数据可以持久化

MySQL，容器删除了，删库跑路！需求：MySQL数据可以存储在本地！

容器之间可以有一个数据共享的技术！Docker容器中产生的数据，同步到本地！

这就是卷技术！目录的挂载，将我们容器内的目录，挂载到Linux上面！

总结一句话：容器的持久化和同步操作！容器间也是可以数据共享的！

使用数据卷

方式一：直接使用命令挂载 -v

-v, --volume list                    Bind mount a volume

docker run -it -v 主机目录:容器内目录  -p 主机端口:容器内端口
# /home/ceshi：主机home目录下的ceshi文件夹  映射：centos容器中的/home
[root@iz2zeak7 home]# docker run -it -v /home/ceshi:/home centos /bin/bash
#这时候主机的/home/ceshi文件夹就和容器的/home文件夹关联了,二者可以实现文件或数据同步了

#通过 docker inspect 容器id 查看
[root@iz2zeak7sgj6i7hrb2g862z home]# docker inspect 6064c490c371
123456789

测试文件的同步

再来测试！

1、停止容器

2、宿主机修改文件

3、启动容器

4、容器内的数据依旧是同步的

好处：我们以后修改只需要在本地修改即可，容器内会自动同步！

实战：安装MySQL

思考：MySQL的数据持久化的问题

# 获取mysql镜像
[root@iz2zeak7sgj6i7hrb2g862z home]# docker pull mysql:5.7

# 运行容器,需要做数据挂载 #安装启动mysql，需要配置密码的，这是要注意点！
# 参考官网hub 
docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

#启动我们得
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
-- name 容器名字
$ docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql03 mysql:5.7

# 启动成功之后，我们在本地使用sqlyog来测试一下
# sqlyog-连接到服务器的3306--和容器内的3306映射 

# 在本地测试创建一个数据库，查看一下我们映射的路径是否ok！
12345678910111213141516171819

测试连接：注意3310端口要在阿里云服务器的安全组中打开，否则无法连接。

当我们在本地用SQLyog新建名称为test的数据库时候，容器容器也会创建

假设我们将包含mysql的容器删除时，

发现，我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能。

具名和匿名挂载

# 匿名挂载
-v 容器内路径!
$ docker run -d -P --name nginx01 -v /etc/nginx nginx

# 查看所有的volume(卷)的情况
$ docker volume ls    
DRIVER              VOLUME NAME # 容器内的卷名(匿名卷挂载)
local               21159a8518abd468728cdbe8594a75b204a10c26be6c36090cde1ee88965f0d0
local               b17f52d38f528893dd5720899f555caf22b31bf50b0680e7c6d5431dbda2802c
         
# 这里发现，这种就是匿名挂载，我们在 -v只写了容器内的路径，没有写容器外的路径！

# 具名挂载 -P:表示随机映射端口
$ docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
9663cfcb1e5a9a1548867481bfddab9fd7824a6dc4c778bf438a040fe891f0ee

# 查看所有的volume(卷)的情况
$ docker volume ls                  
DRIVER              VOLUME NAME
local               21159a8518abd468728cdbe8594a75b204a10c26be6c36090cde1ee88965f0d0
local               b17f52d38f528893dd5720899f555caf22b31bf50b0680e7c6d5431dbda2802c
local               juming-nginx #多了一个名字


# 通过 -v 卷名：查看容器内路径
# 查看一下这个卷
$ docker volume inspect juming-nginx
[
    {
        "CreatedAt": "2020-05-23T13:55:34+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data", #默认目录
        "Name": "juming-nginx",
        "Options": null,
        "Scope": "local"
    }
]
1234567891011121314151617181920212223242526272829303132333435363738

所有的docker容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volumes/自定义的卷名/_data下，
如果指定了目录，docker volume ls 是查看不到的。

区分三种挂载方式

# 三种挂载： 匿名挂载、具名挂载、指定路径挂载
-v 容器内路径			#匿名挂载
-v 卷名：容器内路径		  #具名挂载
-v /宿主机路径：容器内路径 #指定路径挂载 docker volume ls 是查看不到的
1234

拓展：

# 通过 -v 容器内路径： ro rw 改变读写权限
ro #readonly 只读
rw #readwrite 可读可写
$ docker run -d -P --name nginx05 -v juming:/etc/nginx:ro nginx
$ docker run -d -P --name nginx05 -v juming:/etc/nginx:rw nginx

# ro 只要看到ro就说明这个路径只能通过宿主机来操作，容器内部是无法操作！
1234567

初始Dockerfile

Dockerfile 就是用来构建docker镜像的构建文件！命令脚本！先体验一下！

通过这个脚本可以生成镜像，镜像是一层一层的，脚本是一个个的命令，每个命令都是一层！

# 创建一个dockerfile文件，名字可以随便 建议Dockerfile
# 文件中的内容： 指令(大写) + 参数
$ vim dockerfile1
    FROM centos 					# 当前这个镜像是以centos为基础的

    VOLUME ["volume01","volume02"] 	# 挂载卷的卷目录列表(多个目录)

    CMD echo "-----end-----"		# 输出一下用于测试
    CMD /bin/bash					# 默认走bash控制台

# 这里的每个命令，就是镜像的一层！
# 构建出这个镜像 
-f dockerfile1 			# f代表file，指这个当前文件的地址(这里是当前目录下的dockerfile1)
-t caoshipeng/centos 	# t就代表target，指目标目录(注意caoshipeng镜像名前不能加斜杠‘/’)
. 						# 表示生成在当前目录下
$ docker build -f dockerfile1 -t caoshipeng/centos .
Sending build context to Docker daemon   2.56kB
Step 1/4 : FROM centos
latest: Pulling from library/centos
8a29a15cefae: Already exists 
Digest: sha256:fe8d824220415eed5477b63addf40fb06c3b049404242b31982106ac204f6700
Status: Downloaded newer image for centos:latest
 ---> 470671670cac
Step 2/4 : VOLUME ["volume01","volume02"] 			# 卷名列表
 ---> Running in c18eefc2c233
Removing intermediate container c18eefc2c233
 ---> 623ae1d40fb8
Step 3/4 : CMD echo "-----end-----"					# 输出 脚本命令
 ---> Running in 70e403669f3c
Removing intermediate container 70e403669f3c
 ---> 0eba1989c4e6
Step 4/4 : CMD /bin/bash
 ---> Running in 4342feb3a05b
Removing intermediate container 4342feb3a05b
 ---> f4a6b0d4d948
Successfully built f4a6b0d4d948
Successfully tagged caoshipeng/centos:latest

# 查看自己构建的镜像
$ docker images
REPOSITORY          TAG          IMAGE ID            CREATED              SIZE
caoshipeng/centos   latest       f4a6b0d4d948        About a minute ago   237MB
123456789101112131415161718192021222324252627282930313233343536373839404142

启动自己写的容器镜像

$ docker run -it f4a6b0d4d948 /bin/bash	# 运行自己写的镜像
$ ls -l 								# 查看目录
12

这个卷和外部一定有一个同步的目录

查看一下卷挂载

# docker inspect 容器id
$ docker inspect ca3b45913df5
12

测试一下刚才的文件是否同步出去了！

这种方式使用的十分多，因为我们通常会构建自己的镜像！

假设构建镜像时候没有挂载卷，要手动镜像挂载 -v 卷名：容器内路径！

数据卷容器

多个MySQL同步数据！

命名的容器挂载数据卷！

# 测试 启动3个容器，通过刚才自己写的镜像启动
# 创建docker01：因为我本机是最新版，故这里用latest，狂神老师用的是1.0如下图
$ docker run -it --name docker01 caoshipeng/centos:latest

# 查看容器docekr01内容
$ ls
bin  home   lost+found	opt   run   sys  var
dev  lib    media	proc  sbin  tmp  volume01
etc  lib64  mnt		root  srv   usr  volume02

# 不关闭该容器退出
CTRL + Q + P  

# 创建docker02: 并且让docker02 继承 docker01
$ docker run -it --name docker02 --volumes-from docker01 caoshipeng/centos:latest

# 查看容器docker02内容
$ ls
bin  home   lost+found	opt   run   sys  var
dev  lib    media	proc  sbin  tmp  volume01
etc  lib64  mnt		root  srv   usr  volume02
123456789101112131415161718192021

# 再新建一个docker03同样继承docker01
$ docker run -it --name docker03 --volumes-from docker01 caoshipeng/centos:latest
$ cd volume01	#进入volume01 查看是否也同步docker01的数据
$ ls 
docker01.txt

# 测试：可以删除docker01，查看一下docker02和docker03是否可以访问这个文件
# 测试发现：数据依旧保留在docker02和docker03中没有被删除
12345678

多个mysql实现数据共享

$ docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

$ docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01  mysql:5.7

# 这个时候，可以实现两个容器数据同步！
12345

结论：

容器之间的配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止。

但是一旦你持久化到了本地，这个时候，本地的数据是不会删除的！

DockerFile

DockerFile介绍

dockerfile是用来构建docker镜像的文件！命令参数脚本！

构建步骤：

1、编写一个dockerfile文件

2、 docker build 构建称为一个镜像

3、 docker run运行镜像

4、 docker push发布镜像（DockerHub 、阿里云仓库)

点击后跳到一个Dockerfile

很多官方镜像都是基础包，很多功能没有，我们通常会自己搭建自己的镜像！

官方既然可以制作镜像，那我们也可以！

DockerFile构建过程

基础知识：

1、每个保留关键字(指令）都是必须是大写字母

2、执行从上到下顺序

3、#表示注释

4、每一个指令都会创建提交一个新的镜像层，并提交！

Dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件，这个文件十分简单！

Docker镜像逐渐成企业交付的标准，必须要掌握！

DockerFile：构建文件，定义了一切的步骤，源代码

DockerImages：通过DockerFile构建生成的镜像，最终发布和运行产品。

Docker容器：容器就是镜像运行起来提供服务。

DockerFile的指令

FROM				# from:基础镜像，一切从这里开始构建
MAINTAINER			# maintainer:镜像是谁写的， 姓名+邮箱
RUN					# run:镜像构建的时候需要运行的命令
ADD					# add:步骤，tomcat镜像，这个tomcat压缩包！添加内容 添加同目录
WORKDIR				# workdir:镜像的工作目录
VOLUME				# volume:挂载的目录
EXPOSE				# expose:保留端口配置
CMD					# cmd:指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT			# entrypoint:指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD				# onbuild:当构建一个被继承DockerFile这个时候就会运行onbuild的指令，触发指令
COPY				# copy:类似ADD，将我们文件拷贝到镜像中
ENV					# env:构建的时候设置环境变量！
123456789101112

实战测试

scratch 镜像

FROM scratch
ADD centos-7-x86_64-docker.tar.xz /

LABEL \
    org.label-schema.schema-version="1.0" \
    org.label-schema.name="CentOS Base Image" \
    org.label-schema.vendor="CentOS" \
    org.label-schema.license="GPLv2" \
    org.label-schema.build-date="20200504" \
    org.opencontainers.image.title="CentOS Base Image" \
    org.opencontainers.image.vendor="CentOS" \
    org.opencontainers.image.licenses="GPL-2.0-only" \
    org.opencontainers.image.created="2020-05-04 00:00:00+01:00"

CMD ["/bin/bash"]
123456789101112131415

Docker Hub 中 99%的镜像都是从这个基础镜像过来的 FROM scratch，然后配置需要的软件和配置来进行构建。

创建一个自己的centos

# 1./home下新建dockerfile目录
$ mkdir dockerfile

# 2. dockerfile目录下新建mydockerfile-centos文件
$ vim mydockerfile-centos

# 3.编写Dockerfile配置文件
FROM centos							# 基础镜像是官方原生的centos
MAINTAINER cao<1165680007@qq.com> 	# 作者

ENV MYPATH /usr/local				# 配置环境变量的目录 
WORKDIR $MYPATH						# 将工作目录设置为 MYPATH

RUN yum -y install vim				# 给官方原生的centos 增加 vim指令
RUN yum -y install net-tools		# 给官方原生的centos 增加 ifconfig命令

EXPOSE 80							# 暴露端口号为80

CMD echo $MYPATH					# 输出下 MYPATH 路径
CMD echo "-----end----"				
CMD /bin/bash						# 启动后进入 /bin/bash

# 4.通过这个文件构建镜像
# 命令： docker build -f 文件路径 -t 镜像名:[tag] .
$ docker build -f mydockerfile-centos -t mycentos:0.1 .

# 5.出现下图后则构建成功
123456789101112131415161718192021222324252627

$ docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mycentos            0.1                 cbf5110a646d        2 minutes ago       311MB

# 6.测试运行
$ docker run -it mycentos:0.1 		# 注意带上版本号，否则每次都回去找最新版latest

$ pwd	
/usr/local							# 与Dockerfile文件中 WORKDIR 设置的 MYPATH 一致
$ vim								# vim 指令可以使用
$ ifconfig     						# ifconfig 指令可以使用

# docker history 镜像id 查看镜像构建历史步骤
$ docker history 镜像id
1234567891011121314

我们可以列出本地进行的变更历史

我们平时拿到一个镜像，可以用 “docker history 镜像id” 研究一下是什么做的

CMD 和 ENTRYPOINT区别

CMD					# 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代。
ENTRYPOINT			# 指定这个容器启动的时候要运行的命令，可以追加命令
12

测试cmd

# 编写dockerfile文件
$ vim dockerfile-test-cmd
FROM centos
CMD ["ls","-a"]					# 启动后执行 ls -a 命令

# 构建镜像
$ docker build  -f dockerfile-test-cmd -t cmd-test:0.1 .

# 运行镜像
$ docker run cmd-test:0.1		# 由结果可得，运行后就执行了 ls -a 命令
.
..
.dockerenv
bin
dev
etc
home

# 想追加一个命令  -l 成为ls -al：展示列表详细数据
$ docker run cmd-test:0.1 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"-l\":
executable file not found in $PATH": unknown.
ERRO[0000] error waiting for container: context canceled 

# cmd的情况下 -l 替换了CMD["ls","-l"] 而 -l  不是命令所以报错
12345678910111213141516171819202122232425

测试ENTRYPOINT

# 编写dockerfile文件
$ vim dockerfile-test-entrypoint
FROM centos
ENTRYPOINT ["ls","-a"]

# 构建镜像
$ docker build  -f dockerfile-test-entrypoint -t cmd-test:0.1 .

# 运行镜像
$ docker run entrypoint-test:0.1
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found ...

# 我们的命令，是直接拼接在我们得ENTRYPOINT命令后面的
$ docker run entrypoint-test:0.1 -l
total 56
drwxr-xr-x   1 root root 4096 May 16 06:32 .
drwxr-xr-x   1 root root 4096 May 16 06:32 ..
-rwxr-xr-x   1 root root    0 May 16 06:32 .dockerenv
lrwxrwxrwx   1 root root    7 May 11  2019 bin -> usr/bin
drwxr-xr-x   5 root root  340 May 16 06:32 dev
drwxr-xr-x   1 root root 4096 May 16 06:32 etc
drwxr-xr-x   2 root root 4096 May 11  2019 home
lrwxrwxrwx   1 root root    7 May 11  2019 lib -> usr/lib
lrwxrwxrwx   1 root root    9 May 11  2019 lib64 -> usr/lib64 ....

12345678910111213141516171819202122232425262728293031323334

Dockerfile中很多命令都十分的相似，我们需要了解它们的区别，我们最好的学习就是对比他们然后测试效果！

实战：Tomcat镜像

1、准备镜像文件

准备tomcat 和 jdk 到当前目录，编写好README
1

2、编写dokerfile

$ vim dockerfile
FROM centos 										# 基础镜像centos
MAINTAINER cao<1165680007@qq.com>					# 作者
COPY README /usr/local/README 						# 复制README文件
ADD jdk-8u231-linux-x64.tar.gz /usr/local/ 			# 添加jdk，ADD 命令会自动解压
ADD apache-tomcat-9.0.35.tar.gz /usr/local/ 		# 添加tomcat，ADD 命令会自动解压
RUN yum -y install vim								# 安装 vim 命令
ENV MYPATH /usr/local 								# 环境变量设置 工作目录
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_231 				# 环境变量： JAVA_HOME环境变量
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.35 	# 环境变量： tomcat环境变量
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.35

# 设置环境变量 分隔符是：
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin 	

EXPOSE 8080 										# 设置暴露的端口

CMD /usr/local/apache-tomcat-9.0.35/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.35/logs/catalina.out 					# 设置默认命令

1234567891011121314151617181920212223

3、构建镜像

# 因为dockerfile命名使用默认命名 因此不用使用-f 指定文件
$ docker build -t mytomcat:0.1 .
12

4、run镜像

# -d:后台运行 -p:暴露端口 --name:别名 -v:绑定路径 
$ docker run -d -p 8080:8080 --name tomcat01 
-v /home/kuangshen/build/tomcat/test:/usr/local/apache-tomcat-9.0.35/webapps/test 
-v /home/kuangshen/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.35/logs mytomcat:0.1
1234

5、访问测试

$ docker exec -it 自定义容器的id /bin/bash

$ cul localhost:8080
123

6、发布项目

(由于做了卷挂载，我们直接在本地编写项目就可以发布了！)

发现：项目部署成功，可以直接访问！

我们以后开发的步骤：需要掌握Dockerfile的编写！我们之后的一切都是使用docker镜像来发布运行！

发布自己的镜像

发布到 Docker Hub

1、地址 https://hub.docker.com/

2、确定这个账号可以登录

3、登录

$ docker login --help
Usage:  docker login [OPTIONS] [SERVER]

Log in to a Docker registry.
If no server is specified, the default is defined by the daemon.

Options:
  -p, --password string   Password
      --password-stdin    Take the password from stdin
  -u, --username string   Username

$ docker login -u 你的用户名 -p 你的密码
123456789101112

4、提交 push镜像

# 会发现push不上去，因为如果没有前缀的话默认是push到 官方的library
# 解决方法：
# 第一种 build的时候添加你的dockerhub用户名，然后在push就可以放到自己的仓库了
$ docker build -t kuangshen/mytomcat:0.1 .

# 第二种 使用docker tag #然后再次push
$ docker tag 容器id kuangshen/mytomcat:1.0 #然后再次push
$ docker push kuangshen/mytomcat:1.0
12345678

发布到阿里云镜像服务上

看官网很详细https://cr.console.aliyun.com/repository/

$ sudo docker login --username=zchengx registry.cn-shenzhen.aliyuncs.com
$ sudo docker tag [ImageId] registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:[镜像版本号]

# 修改id 和 版本
sudo docker tag a5ef1f32aaae registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:1.0
# 修改版本
$ sudo docker push registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:[镜像版本号]
1234567

小结

Docker 网络

理解Docker 0

学习之前清空下前面的docker 镜像、容器

# 删除全部容器
$ docker rm -f $(docker ps -aq)

# 删除全部镜像
$ docker rmi -f $(docker images -aq)
12345

测试

三个网络

问题： docker 是如果处理容器网络访问的？

# 测试  运行一个tomcat
$ docker run -d -P --name tomcat01 tomcat

# 查看容器内部网络地址
$ docker exec -it 容器id ip addr

# 发现容器启动的时候会得到一个 eth0@if91 ip地址，docker分配！
$ ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
    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
261: eth0@if91: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:12:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.18.0.2/16 brd 172.18.255.255 scope global eth0
       valid_lft forever preferred_lft forever

       
# 思考？ linux能不能ping通容器内部！ 可以 容器内部可以ping通外界吗？ 可以！
$ ping 172.18.0.2
PING 172.18.0.2 (172.18.0.2) 56(84) bytes of data.
64 bytes from 172.18.0.2: icmp_seq=1 ttl=64 time=0.069 ms
64 bytes from 172.18.0.2: icmp_seq=2 ttl=64 time=0.074 ms
1234567891011121314151617181920212223

原理

1、我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要按照了docker，就会有一个docker0桥接模式，使用的技术是veth-pair技术！

https://www.cnblogs.com/bakari/p/10613710.html

再次测试 ip addr

2 、再启动一个容器测试，发现又多了一对网络

# 我们发现这个容器带来网卡，都是一对对的
# veth-pair 就是一对的虚拟设备接口，他们都是成对出现的，一端连着协议，一端彼此相连
# 正因为有这个特性 veth-pair 充当一个桥梁，连接各种虚拟网络设备的
# OpenStack,Docker容器之间的连接，OVS的连接，都是使用veth-pair技术

3、我们来测试下tomcat01和tomcat02是否可以ping通

# 获取tomcat01的ip 172.17.0.2
$ docker-tomcat docker exec -it tomcat01 ip addr  
550: eth0@if551: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
       
# 让tomcat02 ping tomcat01       
$ docker-tomcat docker exec -it tomcat02 ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.098 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.071 ms

# 结论：容器和容器之间是可以互相ping通

网络模型图

结论：tomcat01和tomcat02公用一个路由器，docker0。

所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用ip。

小结

Docker使用的是Linux的桥接，宿主机是一个Docker容器的网桥 docker0

Docker中所有网络接口都是虚拟的，虚拟的转发效率高（内网传递文件）

只要容器删除，对应的网桥一对就没了！

思考一个场景：我们编写了一个微服务，database url=ip: 项目不重启，数据ip换了，我们希望可以处理这个问题，可以通过名字来进行访问容器？

--link

$ docker exec -it tomcat02 ping tomca01   # ping不通
ping: tomca01: Name or service not known

# 运行一个tomcat03 --link tomcat02 
$ docker run -d -P --name tomcat03 --link tomcat02 tomcat
5f9331566980a9e92bc54681caaac14e9fc993f14ad13d98534026c08c0a9aef

# 3连接2
# 用tomcat03 ping tomcat02 可以ping通
$ docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.17.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.17.0.3): icmp_seq=1 ttl=64 time=0.115 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.080 ms

# 2连接3
# 用tomcat02 ping tomcat03 ping不通

探究：

docker network inspect 网络id 网段相同

docker inspect tomcat03

查看tomcat03里面的/etc/hosts发现有tomcat02的配置

–link 本质就是在hosts配置中添加映射

现在使用Docker已经不建议使用–link了！

自定义网络，不适用docker0！

docker0问题：不支持容器名连接访问！

自定义网络

docker network
connect     -- Connect a container to a network
create      -- Creates a new network with a name specified by the
disconnect  -- Disconnects a container from a network
inspect     -- Displays detailed information on a network
ls          -- Lists all the networks created by the user
prune       -- Remove all unused networks
rm          -- Deletes one or more networks

查看所有的docker网络

网络模式

bridge ：桥接 docker（默认，自己创建也是用bridge模式）

none ：不配置网络，一般不用

host ：和所主机共享网络

container ：容器网络连通（用得少！局限很大）

测试

# 我们直接启动的命令 --net bridge,而这个就是我们得docker0
# bridge就是docker0
$ docker run -d -P --name tomcat01 tomcat
等价于 => docker run -d -P --name tomcat01 --net bridge tomcat

# docker0，特点：默认，域名不能访问。 --link可以打通连接，但是很麻烦！
# 我们可以 自定义一个网络
$ docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.

$ docker network inspect mynet;

启动两个tomcat,再次查看网络情况

在自定义的网络下，服务可以互相ping通，不用使用–link

我们自定义的网络docker当我们维护好了对应的关系，推荐我们平时这样使用网络！

好处：

redis -不同的集群使用不同的网络，保证集群是安全和健康的

mysql-不同的集群使用不同的网络，保证集群是安全和健康的

网络连通

# 测试两个不同的网络连通  再启动两个tomcat 使用默认网络，即docker0
$ docker run -d -P --name tomcat01 tomcat
$ docker run -d -P --name tomcat02 tomcat
# 此时ping不通

# 要将tomcat01 连通 tomcat—net-01 ，连通就是将 tomcat01加到 mynet网络
# 一个容器两个ip（tomcat01）

# 01连通 ，加入后此时，已经可以tomcat01 和 tomcat-01-net ping通了
# 02是依旧不通的

结论：假设要跨网络操作别人，就需要使用docker network connect 连通！

实战：部署Redis集群

# 创建网卡
docker network create redis --subnet 172.38.0.0/16
# 通过脚本创建六个redis配置
for port in $(seq 1 6);\
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF >> /mydata/redis/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

    # 通过脚本运行六个redis
    for port in $(seq 1 6);\
    do
    docker run -p 637${port}:6379 -p 1667${port}:16379 --name redis-${port} \
    -v /mydata/redis/node-${port}/data:/data \
    -v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
    -d --net redis --ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
    docker exec -it redis-1 /bin/sh #redis默认没有bash
    done
docker exec -it redis-1 /bin/sh #redis默认没有bash
redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379  --cluster-replicas 1

docker搭建redis集群完成！

SpringBoot微服务打包Docker镜像

1、构建SpringBoot项目

2、打包运行

mvn package

3、编写dockerfile

FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","app.jar"]

4、构建镜像

# 1.复制jar和DockerFIle到服务器
# 2.构建镜像
$ docker build -t xxxxx:xx  .

5、发布运行

以后我们使用了Docker之后，给别人交付就是一个镜像即可！

原文地址：https://www.cnblogs.com/yangchen-geek/p/15129690.html

Docker学习笔记

Docker

docker的安装

一、如果之前安装过docker，卸载

二、更新yum源

三、如果是新安装的系统，可以更新操作系统和内核

四、添加docker-ce yum源

五、添加阿里云镜像加速器

六、安装Docker

七、启动并设置开机自启

八、检查docker是否启动成功

Docker的常用命令

docker镜像命令

一、常用镜像仓库

二、docker镜像常用命令

三、docker镜像命令使用及进阶

1、搜索镜像search

2、拉取镜像pull

3、查看当前镜像列表images

4、获取镜像详细信息inspect

5、登录镜像仓库login

6、镜像标签tag

7、镜像上传push

8、镜像删除 rmi

9、清空镜像image prune

10、查看镜像构建历史 history

11、保存容器为镜像commit

12、保存容器为镜像包（export/import）

13、保存镜像为镜像包（save/load）

docker容器命令

一、容器介绍

二、容器命令

三、容器命令的使用及进阶

1、docker ps查看容器列表

2、docker run创建容器

参数

1）-d 守护进程方式运行

2）—name指定容器名称

3）-p指定端口映射

4）-P随机端口映射

5）-it以交互式方式打开一个伪终端

6）-v 给容器挂载数据卷

7）—rm容器生命周期结束立即删除

8）-e在容器中创建一个环境变量

9）—link连上一个容器，实现网络互通

10）-h设置容器主机名

3、docker create创建容器不启动

4、start/stop启停容器

5、docker rm删除容器

6、docker inspect查看容器信息

7、docker cp复制命令

8、docker exec/attach进入容器

9、其他进入容器的方法

10、保存容器为镜像commit

11、保存容器为镜像包（export/import）

Docker镜像讲解

镜像是什么

Docker镜像加载原理

为什么 Docker 镜像要采用这种分层结构呢

如何提交自己的镜像 commit镜像

容器数据卷

使用数据卷

方式一：直接使用命令来挂载 -v

方式二：匿名挂载

方法三：具名挂载

初始Dockerfile

数据卷容器

DockerFile

DockerFile介绍

DockerFile构建过程

基础知识：

DockerFile的指令

实战测试

CMD 和 ENTRYPOINT区别

测试cmd

测试ENTRYPOINT

实战：Tomcat镜像

1、准备镜像文件

2、编写dokerfile

3、构建镜像