Docker学习

Docker

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux或Windows操作系统的机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。

docker官网：https://www.docker.com/

文档：https://docs.docker.com/ Docker的文档是超级详细的！

仓库：https://hub.docker.com/

简介

docker的基本组成：

镜像（image)：

docker镜像就好比是一个目标，可以通过这个目标来创建容器服务，tomcat镜像== > run== >容器（提供服务器），通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中的）。

容器(container)：

Docker利用容器技术，独立运行一个或者一组应用，通过镜像来创建的.
启动，停止，删除，基本命令
目前就可以把这个容器理解为就是一个简易的 Linux系统。

仓库(repository)：

仓库就是存放镜像的地方！
仓库分为公有仓库和私有仓库。(很类似git)
Docker Hub是国外的。
阿里云…都有容器服务器(配置镜像加速!)

安装docker

#1.卸载旧版本
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
#2.需要的安装包
yum install -y yum-utils

#3.设置镜像的仓库
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
#上述方法默认是从国外的，不推荐

#推荐使用国内的
yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    
#更新yum软件包索引
yum makecache fast

#4.安装docker相关的 docker-ce 社区版 而ee是企业版
yum install docker-ce docker-ce-cli containerd.io # 这里我们使用社区版即可

#5.启动docker
systemctl start docker

#6. 使用docker version查看是否按照成功
docker version

#7. 测试
docker run hello-world

#8.查看已经下载的镜像(从这里可以查看已有镜像的id)
[root@iz2zeak7sgj6i7hrb2g862z ~]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
hello-world           latest              bf756fb1ae65        4 months ago      13.

卸载docker

#1. 卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
#2. 删除资源
rm -rf /var/lib/docker
# /var/lib/docker 是docker的默认工作路径！

配置阿里云镜像加速器

centos:

sudo mkdir -p /etc/docker

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://dy01iz2r.mirror.aliyuncs.com"]
}
EOF

sudo systemctl daemon-reload

sudo systemctl restart docker

常用命令

1.帮助命令

docker version    #显示docker的版本信息。
docker info       #显示docker的系统信息，包括镜像和容器的数量
docker 命令 --help #帮助命令

帮助文档的地址：https://docs.docker.com/engine/reference/commandline/build/

2.镜像命令

docker images #查看所有本地主机上的镜像 可以使用docker image ls代替

docker search #搜索镜像(mysql。。。)

docker pull #下载镜像 docker image pull

docker rmi #删除镜像 docker image rm

docker images详解

[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    feb5d9fea6a5   13 months ago   13.3kB
# 解释
#REPOSITORY			# 镜像的仓库源
#TAG				# 镜像的标签(版本)		---lastest 表示最新版本
#IMAGE ID			# 镜像的id
#CREATED			# 镜像的创建时间
#SIZE				# 镜像的大小

# 可选项
Options:
  -a, --all         Show all images (default hides intermediate images) #列出所有镜像
  -q, --quiet       Only show numeric IDs # 只显示镜像的id

docker search 搜索镜像

[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker search mysql

# --filter=STARS=3000 #过滤，搜索出来的镜像收藏STARS数量大于3000的
Options:
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print search using a Go template
      --limit int       Max number of search results (default 25)
      --no-trunc        Don't truncate output
      
[root@iz2zeak7sgj6i7hrb2g862z ~]# docker search mysql --filter=STARS=3000
NAME        DESCRIPTION         STARS            OFFICIAL        AUTOMATED
mysql       MySQL IS ...        9520             [OK]                
mariadb     MariaDB IS ...      3456             [OK]   

docker pull 下载镜像

# 下载镜像 docker pull 镜像名[:tag]
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker pull mysql
Using default tag: latest   #如果不写tag，默认就是latest
latest: Pulling from library/mysql
72a69066d2fe: Pull complete  #分层下载： docker image 的核心 联合文件系统
93619dbc5b36: Pull complete 
99da31dd6142: Pull complete 
626033c43d70: Pull complete 
37d5d7efb64e: Pull complete 
ac563158d721: Pull complete 
d2ba16033dad: Pull complete 
688ba7d5c01a: Pull complete 
00e060b6d11d: Pull complete 
1c04857f594f: Pull complete 
4d7cfa90e6ea: Pull complete 
e0431212d27d: Pull complete 
Digest: sha256:e9027fe4d91c0153429607251656806cc784e914937271037f7738bd5b8e7709
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest

#两个等价
docker pull mysql
docker pull docker.io/library/mysql

#指定版本
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
72a69066d2fe: Already exists 
93619dbc5b36: Already exists 
99da31dd6142: Already exists 
626033c43d70: Already exists 
37d5d7efb64e: Already exists 
ac563158d721: Already exists 
d2ba16033dad: Already exists 
0ceb82207cd7: Pull complete #之前的不用下载，与前面的共用！！
37f2405cae96: Pull complete 
e2482e017e53: Pull complete 
70deed891d42: Pull complete 
Digest: sha256:f2ad209efe9c67104167fc609cca6973c8422939491c9345270175a300419f94
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7

docker rmi 删除镜像

docker rmi -f id #删除指定id的镜像
docker rmi -f id1 id2 id3 id4 #删除多个id的镜像
docker rmi -f $(docker images -aq) #删除全部的镜像

[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
mysql         5.7       c20987f18b13   10 months ago   448MB
mysql         latest    3218b38490ce   10 months ago   516MB
hello-world   latest    feb5d9fea6a5   13 months ago   13.3kB
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker rmi -f c20987f18b13  #根据id删除
Untagged: mysql:5.7
Untagged: mysql@sha256:f2ad209efe9c67104167fc609cca6973c8422939491c9345270175a300419f94
Deleted: sha256:c20987f18b130f9d144c9828df630417e2a9523148930dc3963e9d0dab302a76
Deleted: sha256:6567396b065ee734fb2dbb80c8923324a778426dfd01969f091f1ab2d52c7989
Deleted: sha256:0910f12649d514b471f1583a16f672ab67e3d29d9833a15dc2df50dd5536e40f
Deleted: sha256:6682af2fb40555c448b84711c7302d0f86fc716bbe9c7dc7dbd739ef9d757150
Deleted: sha256:5c062c3ac20f576d24454e74781511a5f96739f289edaadf2de934d06e910b92

3.容器命令

说明：我们有了镜像才可以创建容器，Linux，下载centos镜像来学习

镜像下载

#docker中下载centos
docker pull centos

docker run 镜像id #新建容器并启动

docker ps #列出所有运行的容器 
docker container list #列出所有运行的容器 

docker rm 容器id #删除指定容器

docker start 容器id	#启动容器
docker restart 容器id	#重启容器
docker stop 容器id	#停止当前正在运行的容器
docker kill 容器id	#强制停止当前容器

docker run新建容器并启动

docker run [可选参数] image | docker container run [可选参数] image 
#参书说明
--name="Name"		#容器名字 tomcat01 tomcat02 用来区分容器
-d					#后台方式运行
-it 				#使用交互方式运行，进入容器查看内容
-p					#指定容器的端口 -p 8080(宿主机):8080(容器)
		-p ip:主机端口:容器端口
		-p 主机端口:容器端口(常用)
		-p 容器端口
		容器端口
-P(大写) 				随机指定端口

# 测试、启动并进入容器
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker run -it centos
[root@2743c25518f3 /]# 
# 可以看到容器内的ls文件
[root@2743c25518f3 /]# ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
# 退出容器回到主机
[root@2743c25518f3 /]# exit
exit
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# 

docker ps 列出所有运行的容器

docker ps 命令  		#列出当前正在运行的容器
  -a, --all     	 #列出当前正在运行的容器 + 带出历史运行过的容器
  -n=?, --last int   #列出最近创建的?个容器 ?为1则只列出最近创建的一个容器,为2则列出2个
  -q, --quiet        #只列出容器的编号

退出容器

exit 		#容器直接退出
ctrl +P +Q  #容器不停止退出 	---注意：这个很有用的操作

删除容器

docker rm 容器id   				#删除指定的容器，不能删除正在运行的容器，如果要强制删除 rm -rf
docker rm -f $(docker ps -aq)  	 #删除所有的容器
docker ps -a -q|xargs docker rm  #删除所有的容器

启动和停止容器的操作

docker start 容器id	#启动容器
docker restart 容器id	#重启容器
docker stop 容器id	#停止当前正在运行的容器
docker kill 容器id	#强制停止当前容器

4.常用其他命令

后台启动命令

# 命令 docker run -d 镜像名
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker run -d centos
c9fc95d777cc229a6fbda1e23632eb4b76db77f9833f31bba72945c5f342cbaa
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

# 问题docker ps. 发现centos 停止了 ????
# 常见的坑，docker容器使用后台运行，就必须要有要一个前台进程，docker发现没有应用，就会自动停止
# nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了

查看日志

docker logs --help
Options:
      --details        Show extra details provided to logs 
*  -f, --follow         Follow log output
      --since string   Show logs since timestamp (e.g. 2013-01-02T13:23:37) or relative (e.g. 42m for 42 minutes)
*      --tail string    Number of lines to show from the end of the logs (default "all")
*  -t, --timestamps     Show timestamps
      --until string   Show logs before a timestamp (e.g. 2013-01-02T13:23:37) or relative (e.g. 42m for 42 minutes)
➜  ~ docker run -d centos /bin/sh -c "while true;do echo 6666;sleep 1;done" #模拟日志      
#显示日志
-tf		#显示日志信息（一直更新）
--tail number    #需要显示日志条数
#docker命令
docker logs -t --tail n 容器id    #查看n行日志
docker logs -ft 容器id    #跟着日志

查看容器中进程信息ps

docker top 容器id

[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS          PORTS     NAMES
1d5ced030257   centos    "/bin/bash"   23 seconds ago   Up 22 seconds             modest_darwin
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker top 1d5ced030257
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                21495               21476               0                   22:11               ?                   00:00:00            /bin/bash

# UID是用户ID，PID是进程ID，PPID是父进程ID。

查看镜像的元数据

# 命令
docker inspect 容器id

#测试
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker inspect 1d5ced030257
[
    {
        "Id": "1d5ced030257ecf60083d634c25a1b0be1b64d09aec5085d88ae33b54bc18a85",
        "Created": "2022-11-13T14:11:49.824204007Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 21495,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2022-11-13T14:11:50.114279289Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/1d5ced030257ecf60083d634c25a1b0be1b64d09aec5085d88ae33b54bc18a85/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/1d5ced030257ecf60083d634c25a1b0be1b64d09aec5085d88ae33b54bc18a85/hostname",
        "HostsPath": "/var/lib/docker/containers/1d5ced030257ecf60083d634c25a1b0be1b64d09aec5085d88ae33b54bc18a85/hosts",
        "LogPath": "/var/lib/docker/containers/1d5ced030257ecf60083d634c25a1b0be1b64d09aec5085d88ae33b54bc18a85/1d5ced030257ecf60083d634c25a1b0be1b64d09aec5085d88ae33b54bc18a85-json.log",
        "Name": "/modest_darwin",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "CgroupnsMode": "host",
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "ConsoleSize": [
                0,
                0
            ],
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": null,
            "BlkioDeviceWriteBps": null,
            "BlkioDeviceReadIOps": null,
            "BlkioDeviceWriteIOps": null,
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "KernelMemory": 0,
            "KernelMemoryTCP": 0,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/a2be47f894edb16d33543c61c2a6da648eb5dcb582c55bc42ef19c4aacd74694-init/diff:/var/lib/docker/overlay2/6b49113b041b7f9b76b868cc77212f5dde989c106eebebe667ce0eb9fd146bb9/diff",
                "MergedDir": "/var/lib/docker/overlay2/a2be47f894edb16d33543c61c2a6da648eb5dcb582c55bc42ef19c4aacd74694/merged",
                "UpperDir": "/var/lib/docker/overlay2/a2be47f894edb16d33543c61c2a6da648eb5dcb582c55bc42ef19c4aacd74694/diff",
                "WorkDir": "/var/lib/docker/overlay2/a2be47f894edb16d33543c61c2a6da648eb5dcb582c55bc42ef19c4aacd74694/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "1d5ced030257",
            "Domainname": "",
            "User": "",
            "AttachStdin": true,
            "AttachStdout": true,
            "AttachStderr": true,
            "Tty": true,
            "OpenStdin": true,
            "StdinOnce": true,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/bash"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20210915",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "a9be7363590677ebe7c51b56656885c66754c8da015cae3d9c46e322775f732a",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/a9be73635906",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "6a2de02d03dedbf393ca64654b1b4654cbe28545957bcf5d0efbc389d7768812",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.2",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:02",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "b063f6d8ed38b7d93f75a20dd4e1181c60dc25de023213c898360343f0e66369",
                    "EndpointID": "6a2de02d03dedbf393ca64654b1b4654cbe28545957bcf5d0efbc389d7768812",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:02",
                    "DriverOpts": null
                }
            }
        }
    }
]

进入当前正在进行的容器

# 我们通常容器都是使用后台方式运行的，需要进入容器，修改一些配置
docker exec -it 容器id

# 测试
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker exec -it 1d5ced030257 /bin/bash
[root@1d5ced030257 /]# 


# 方式二
docker attach 容器id
#测试
docker attach 1d5ced030257 
正在执行当前的代码...

区别
#docker exec #进入当前容器后开启一个新的终端，可以在里面操作。（常用）
#docker attach # 进入容器正在执行的终端

从容器内拷贝到主机上

# 命令
docker cp 容器id:容器内路径  主机目的路径
# 拷贝是一个手动过程，未来我们可以使用 -v 卷的技术，实现与主机同步


[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker exec -it 1d5ced030257 /bin/bash
[root@1d5ced030257 /]# ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
[root@1d5ced030257 /]# cd /home
[root@1d5ced030257 home]# touch test.java
[root@1d5ced030257 home]# exit  #退出之后，数据依然保存
exit
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker ps -a
CONTAINER ID   IMAGE         COMMAND       CREATED          STATUS                        PORTS     NAMES
1d5ced030257   centos        "/bin/bash"   15 minutes ago   Up 15 minutes                           modest_darwin
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker cp 1d5ced030257:/home/test.java /home
[root@iZ2ze8tiyk741cs5ur9si3Z /]# cd /home
[root@iZ2ze8tiyk741cs5ur9si3Z home]# ls
admin  springboot  test.java  www  yechen

5.小结

  attach      Attach local standard input, output, and error streams to a running container
  #当前shell下 attach连接指定运行的镜像
  build       Build an image from a Dockerfile # 通过Dockerfile定制镜像
  commit      Create a new image from a container's changes #提交当前容器为新的镜像
  cp          Copy files/folders between a container and the local filesystem #拷贝文件
  create      Create a new container #创建一个新的容器
  diff        Inspect changes to files or directories on a container's filesystem #查看docker容器的变化
  events      Get real time events from the server # 从服务获取容器实时时间
  exec        Run a command in a running container # 在运行中的容器上运行命令
  export      Export a container's filesystem as a tar archive #导出容器文件系统作为一个tar归档文件[对应import]
  history     Show the history of an image # 展示一个镜像形成历史
  images      List images #列出系统当前的镜像
  import      Import the contents from a tarball to create a filesystem image #从tar包中导入内容创建一个文件系统镜像
  info        Display system-wide information # 显示全系统信息
  inspect     Return low-level information on Docker objects #查看容器详细信息
  kill        Kill one or more running containers # kill指定docker容器
  load        Load an image from a tar archive or STDIN #从一个tar包或标准输入中加载一个镜像[对应save]
  login       Log in to a Docker registry #登录到Docker注册表
  logout      Log out from a Docker registry #从Docker注册表注销
  logs        Fetch the logs of a container #获取容器的日志
  pause       Pause all processes within one or more containers #暂停一个或多个容器中的所有进程
  port        List port mappings or a specific mapping for the container #列出容器的端口映射或特定映射
  ps          List containers #列表容器
  pull        Pull an image or a repository from a registry #从注册表中提取映像或存储库
  push        Push an image or a repository to a registry #将映像或存储库推送到注册中心
  rename      Rename a container #重命名容器
  restart     Restart one or more containers #重新启动一个或多个容器
  rm          Remove one or more containers #移除一个或多个容器
  rmi         Remove one or more images #删除一个或多个镜像
  run         Run a command in a new container #在新容器中运行命令
  save        Save one or more images to a tar archive (streamed to STDOUT by default) #将一个或多个图像保存到tar存档(默认情况下流到STDOUT)
  search      Search the Docker Hub for images #在Docker Hub中搜索图像
  start       Start one or more stopped containers #启动一个或多个已停止的容器
  stats       Display a live stream of container(s) resource usage statistics #显示容器资源使用统计数据的实时流
  stop        Stop one or more running containers #停止一个或多个正在运行的容器
  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE #创建一个指向SOURCE_IMAGE的标记TARGET_IMAGE
  top         Display the running processes of a container #显示一个容器正在运行的进程
  unpause     Unpause all processes within one or more containers #取消暂停一个或多个容器中的所有进程
  update      Update configuration of one or more containers #更新一个或多个容器的配置
  version     Show the Docker version information #显示Docker版本信息
  wait        Block until one or more containers stop, then print their exit codes #阻塞直到一个或多个容器停止，然后打印它们的退出代码

关于作业

1.部署Nginx

#1. 搜索镜像 search 建议大家去docker搜索，可以看到帮助文档
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker search nginx
#2. 拉取下载镜像 pull
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker pull nginx
#3. 查看是否下载成功镜像
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker images

#3. 运行测试  （主机访问服务器nginx需要开启3344端口）
# -d 后台运行
# --name 给容器命名
# -p 宿主机端口：容器内部端口     
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker run -d --name nginx01 -p 3344:80 nginx
ccac7516773f7af7693cf317e161f69155e10fec00f54903c5e4232145e2dd84

#4. 查看正在启动的镜像
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                                   NAMES
ccac7516773f   nginx     "/docker-entrypoint.…"   5 minutes ago   Up 5 minutes   0.0.0.0:3344->80/tcp, :::3344->80/tcp   nginx01

#5. 进入容器
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker exec -it nginx01 /bin/bash
root@ccac7516773f:/# whereis nginx #找到nginx位置
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@ccac7516773f:/# cd etc/nginx/
root@ccac7516773f:/etc/nginx# ls
conf.d	fastcgi_params	mime.types  modules  nginx.conf  scgi_params  uwsgi_params

#6. 退出容器
root@ccac7516773f:/etc/nginx# exit
exit
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                                   NAMES
ccac7516773f   nginx     "/docker-entrypoint.…"   7 minutes ago   Up 7 minutes   0.0.0.0:3344->80/tcp, :::3344->80/tcp   nginx01
#7. 停止容器
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker stop ccac7516773f

阿里云服务器添加防火墙规则，开放3344端口

宿主机端口 和 容器内部端口 以及端口暴露：

**问题：**我们每次改动nginx配置文件，都需要进入容器内部？十分麻烦，我要是可以在容器外部提供一个映射路径，达到在容器外部修改文件名，容器内部就可以自动修改？-v 数据卷 技术！

2.部署Tomcat

# 下载 tomcat9.0
# 之前的启动都是后台，停止了容器，容器还是可以查到， docker run -it --rm 镜像名 一般是用来测试，用完就删除
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker run -it --rm tomcat:9.0

--rm       Automatically remove the container when it exits 用完即删

# 下载tomcat9.0
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker pull tomcat:9.0


# 注意：下载版本下载的是tomcat9.0，需要指定版本号
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker run -d -p 3355:8080 --name tomcat01 tomcat
Unable to find image 'tomcat:latest' locally
^C
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker run -d -p 3355:8080 --name tomcat01 tomcat:9.0
24176581aabbc27facda98c43b1e300315db5cad6c2ac7b8d2f88f2e634f6e58

#测试访问，404错误，是因为下载的tomcat中的webapps中没有项目
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker exec -it tomcat01 /bin/bash
root@24176581aabb:/usr/local/tomcat# ls -al
total 172
drwxr-xr-x 1 root root  4096 Dec 22  2021 .
drwxr-xr-x 1 root root  4096 Dec 22  2021 ..
-rw-r--r-- 1 root root 18970 Dec  2  2021 BUILDING.txt
-rw-r--r-- 1 root root  6210 Dec  2  2021 CONTRIBUTING.md
-rw-r--r-- 1 root root 57092 Dec  2  2021 LICENSE
-rw-r--r-- 1 root root  2333 Dec  2  2021 NOTICE
-rw-r--r-- 1 root root  3378 Dec  2  2021 README.md
-rw-r--r-- 1 root root  6898 Dec  2  2021 RELEASE-NOTES
-rw-r--r-- 1 root root 16507 Dec  2  2021 RUNNING.txt
drwxr-xr-x 2 root root  4096 Dec 22  2021 bin
drwxr-xr-x 1 root root  4096 Nov 14 06:16 conf
drwxr-xr-x 2 root root  4096 Dec 22  2021 lib
drwxrwxrwx 1 root root  4096 Nov 14 06:16 logs
drwxr-xr-x 2 root root  4096 Dec 22  2021 native-jni-lib
drwxrwxrwx 2 root root  4096 Dec 22  2021 temp
drwxr-xr-x 2 root root  4096 Dec 22  2021 webapps
drwxr-xr-x 7 root root  4096 Dec  2  2021 webapps.dist
drwxrwxrwx 2 root root  4096 Dec  2  2021 work
root@24176581aabb:/usr/local/tomcat# cd webapps
root@24176581aabb:/usr/local/tomcat/webapps# ls
root@24176581aabb:/usr/local/tomcat/webapps# 

# 发现问题：1、linux命令少了（没有ll等）。 2.webapps目录为空 
# 原因：阿里云镜像的原因，阿里云默认是最小的镜像，所以不必要的都剔除掉
# 保证最小可运行的环境！
# 解决方案：
# 将webapps.dist下的文件都拷贝到webapps下即可
root@24176581aabb:/usr/local/tomcat# cd webapps
root@24176581aabb:/usr/local/tomcat/webapps# ls
root@24176581aabb:/usr/local/tomcat/webapps# cd ..
root@24176581aabb:/usr/local/tomcat# ls
BUILDING.txt	 LICENSE  README.md	 RUNNING.txt  conf  logs	    temp     webapps.dist
CONTRIBUTING.md  NOTICE   RELEASE-NOTES  bin	      lib   native-jni-lib  webapps  work
root@24176581aabb:/usr/local/tomcat# cd webapps.dist
root@24176581aabb:/usr/local/tomcat/webapps.dist# ls
ROOT  docs  examples  host-manager  manager
root@24176581aabb:/usr/local/tomcat/webapps.dist# cd ..

# 拷贝webapps.dist 内容给webapps
root@24176581aabb:/usr/local/tomcat# cp -r webapps.dist/* webapps
root@24176581aabb:/usr/local/tomcat# 


#再次访问服务器的3355端口，可以看到项目部署成功！

问题:我们以后要部署项目，如果每次都要进入容器是不是十分麻烦？要是可以在容器外部提供一个映射路径，比如webapps，我们在外部放置项目，就自动同步内部就好了！

3.部署ES+kibana

由于es十分耗内存 这里就不下载了，直接粘贴别人的博客了o.o

# es 暴露的端口很多！
# es 十分耗内存
# es 的数据一般需要放置到安全目录！挂载
# --net somenetwork ? 网络配置

# 启动elasticsearch
[root@iz2zeak7sgj6i7hrb2g862z ~]# docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

# 测试一下es是否成功启动
➜  ~ curl localhost:9200
{
  "name" : "d73ad2f22dd3",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "atFKgANxS8CzgIyCB8PGxA",
  "version" : {
    "number" : "7.6.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.4.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

#测试成功就关掉elasticSearch，防止耗内存
[root@iz2zeak7sgj6i7hrb2g862z ~]# docker stop d834ce2bd306
d834ce2bd306

[root@iz2zeak7sgj6i7hrb2g862z ~]# docker stats  # 查看docker容器使用内存情况


#测试成功就关掉elasticSearch，可以添加内存的限制，修改配置文件 -e 环境配置修改
➜  ~ docker rm -f d73ad2f22dd3            # stop命令也行                               
➜  ~ docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

➜  ~ curl localhost:9200
{
  "name" : "b72c9847ec48",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "yNAK0EORSvq3Wtaqe2QqAg",
  "version" : {
    "number" : "7.6.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.4.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

问题：使用kibana连接es (elasticSearch)？思考网络如何才能连接

4.可视化窗口Portainer

Docker图形化界面管理工具！提供一个后台面板供我们操作！

# 安装命令
docker run -d -p 8080:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

# docker下载
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker run -d -p 8080:9000 \
> --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer
Unable to find image 'portainer/portainer:latest' locally
latest: Pulling from portainer/portainer
94cfa856b2b1: Pull complete 
49d59ee0881a: Pull complete 
a2300fd28637: Pull complete 
Digest: sha256:fb45b43738646048a0a0cc74fcee2865b69efde857e710126084ee5de9be0f3f
Status: Downloaded newer image for portainer/portainer:latest
df5a228e1151b86790a0f049a6365c7dfbe706763ef1e6c2ea43220d62e8f2c1

访问服务器外网ip:8080

输入设置的密码就可以登陆看看了，一半选择本地的

镜像讲解

镜像的概念

镜像是一种轻量级、可执行的独立软件保，用来打包软件运行环境和基于运行环境开发的软件，他包含运行某个软件所需的所有内容，包括代码、运行时库、环境变量和配置文件。

所有应用，直接打包docker镜像，就可以直接跑起来！

如何得到镜像

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

UnionFs （联合文件系统）

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

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

Docker镜像加载原理

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。
boots(boot file system）主要包含 bootloader和 Kernel, bootloader主要是引导加 kernel, Linux刚启动时会加bootfs文件系统，在 Docker镜像的最底层是 boots。这一层与我们典型的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发行版， boots基本是一致的， rootfs会有差別，因此不同的发行版可以公用bootfs.

虚拟机是分钟级别，容器是秒级！

分层理解

分层的镜像

我们可以去下载一个镜像，注意观察下载的日志输出，可以看到是一层层的在下载

[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker pull redis
Using default tag: latest
latest: Pulling from library/redis
a2abf6c4d29d: Already exists 
c7a4e4382001: Pull complete 
4044b9ba67c9: Pull complete 
c8388a79482f: Pull complete 
413c8bb60be2: Pull complete 
1abfd3011519: Pull complete 
Digest: sha256:db485f2e245b5b3329fdc7eff4eb00f913e09d8feb9ca720788059fdc2ed8339
Status: Downloaded newer image for redis:latest
docker.io/library/redis:latest

思考：为什么Docker镜像要采用这种分层的结构呢？

最大的好处，我觉得莫过于资源共享了！比如有多个镜像都从相同的Base镜像构建而来，那么宿主机只需在磁盘上保留一份base镜像，同时内存中也只需要加载一份base镜像，这样就可以为所有的容器服务了，而且镜像的每一层都可以被共享。

查看镜像分层的方式可以通过docker image inspect 命令

[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker image inspect redis
[
    {
        "Id": "sha256:7614ae9453d1d87e740a2056257a6de7135c84037c367e1fffa92ae922784631",
        "RepoTags": [
            "redis:latest"
        ],
        "RepoDigests": [
            "redis@sha256:db485f2e245b5b3329fdc7eff4eb00f913e09d8feb9ca720788059fdc2ed8339"
        ],
        "Parent": "",
        "Comment": "",
        "Created": "2021-12-21T12:42:49.755107412Z",
        "Container": "13d25f53410417c5220c8dfe8bd49f06abdbcd69faa62a9b877de02464bb04a3",
        "ContainerConfig": {
            "Hostname": "13d25f534104",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "ExposedPorts": {
                "6379/tcp": {}
            },
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
                "GOSU_VERSION=1.12",
                "REDIS_VERSION=6.2.6",
                "REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.2.6.tar.gz",
                "REDIS_DOWNLOAD_SHA=5b2b8b7a50111ef395bf1c1d5be11e6e167ac018125055daa8b5c2317ae131ab"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "#(nop) ",
                "CMD [\"redis-server\"]"
            ],
            "Image": "sha256:e093f59d716c95cfce82c676f099b960cc700432ab531388fcedf79932fc81ec",
            "Volumes": {
                "/data": {}
            },
            "WorkingDir": "/data",
            "Entrypoint": [
                "docker-entrypoint.sh"
            ],
            "OnBuild": null,
            "Labels": {}
        },
        "DockerVersion": "20.10.7",
        "Author": "",
        "Config": {
            "Hostname": "",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "ExposedPorts": {
                "6379/tcp": {}
            },
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
                "GOSU_VERSION=1.12",
                "REDIS_VERSION=6.2.6",
                "REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.2.6.tar.gz",
                "REDIS_DOWNLOAD_SHA=5b2b8b7a50111ef395bf1c1d5be11e6e167ac018125055daa8b5c2317ae131ab"
            ],
            "Cmd": [
                "redis-server"
            ],
            "Image": "sha256:e093f59d716c95cfce82c676f099b960cc700432ab531388fcedf79932fc81ec",
            "Volumes": {
                "/data": {}
            },
            "WorkingDir": "/data",
            "Entrypoint": [
                "docker-entrypoint.sh"
            ],
            "OnBuild": null,
            "Labels": null
        },
        "Architecture": "amd64",
        "Os": "linux",
        "Size": 112691373,
        "VirtualSize": 112691373,
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/1f1f6c0345d96f2b8ff7a60180aa83dac1e0f5f7731682deb95604b4d3c73ee9/diff:/var/lib/docker/overlay2/61162c2798baf53791c607cf0ce094d54c9354e3434b7b06b25dca56d21a013b/diff:/var/lib/docker/overlay2/d1daa1e2bab85407110312b69096eeb4d273cfbc03ad5ed997a7877c6c5e1433/diff:/var/lib/docker/overlay2/522a143ec855611c75641a78799e6e75feb6810114c19d3c0bb0fea09ed903f5/diff:/var/lib/docker/overlay2/7ce50e163cac3be1362edd52588e332ec67ad7797ffe962150a5a183de5fefbf/diff",
                "MergedDir": "/var/lib/docker/overlay2/ef313aa6a5c8e4ac63d9cb7e4a94acac0d4a8b56a143c9de2b89381e8d58d97d/merged",
                "UpperDir": "/var/lib/docker/overlay2/ef313aa6a5c8e4ac63d9cb7e4a94acac0d4a8b56a143c9de2b89381e8d58d97d/diff",
                "WorkDir": "/var/lib/docker/overlay2/ef313aa6a5c8e4ac63d9cb7e4a94acac0d4a8b56a143c9de2b89381e8d58d97d/work"
            },
            "Name": "overlay2"
        },
        "RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:2edcec3590a4ec7f40cf0743c15d78fb39d8326bc029073b41ef9727da6c851f",
                "sha256:9b24afeb7c2f21e50a686ead025823cd2c6e9730c013ca77ad5f115c079b57cb",
                "sha256:4b8e2801e0f956a4220c32e2c8b0a590e6f9bd2420ec65453685246b82766ea1",
                "sha256:529cdb636f61e95ab91a62a51526a84fd7314d6aab0d414040796150b4522372",
                "sha256:9975392591f2777d6bf4d9919ad1b2c9afa12f9a9b4d260f45025ec3cc9b18ed",
                "sha256:8e5669d8329116b8444b9bbb1663dda568ede12d3dbcce950199b582f6e94952"
            ]
        },
        "Metadata": {
            "LastTagTime": "0001-01-01T00:00:00Z"
        }
    }
]

理解：

所有的 Docker镜像都起始于一个基础镜像层，当进行修改或培加新的内容时，就会在当前镜像层之上，创建新的镜像层。

举一个简单的例子，假如基于 Ubuntu Linux16.04创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加 Python包，
就会在基础镜像层之上创建第二个镜像层；如果继续添加一个安全补丁，就会创健第三个镜像层该像当前已经包含3个镜像层，如下图所示（这只是一个用于演示的很简单的例子）。

在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合，理解这一点.

在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合，理解这一点非常重要。下图中举了一个简单的例子，每个镜像层包含3个文件，而镜像包含了来自两个镜像层的6个文件。

上图中的镜像层跟之前图中的略有区別，主要目的是便于展示文件
下图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有6个文件，这是因为最上层中的文件7是文件5的一个更新版。

文种情況下，上层镜像层中的文件覆盖了底层镜像层中的文件。这样就使得文件的更新版本作为一个新镜像层添加到镜像当中

Docker通过存储引擎（新版本采用快照机制）的方式来实现镜像层堆栈，并保证多镜像层对外展示为统一的文件系统

Linux上可用的存储引撃有AUFS、 Overlay2、 Device Mapper、Btrfs以及ZFS。顾名思义，每种存储引擎都基于 Linux中对应的
件系统或者块设备技术，井且每种存储引擎都有其独有的性能特点。

Docker在 Windows上仅支持 windowsfilter 一种存储引擎，该引擎基于NTFS文件系统之上实现了分层和CoW [1]。

下图展示了与系统显示相同的三层镜像。所有镜像层堆并合井，对外提供统一的视图。

特点：

Docker 镜像都是只读的，当容器启动时，一个新的可写层加载到镜像的顶部！

这一层就是我们通常说的容器层，容器之下的都叫镜像层！

例如：

commit镜像

docker commit 提交容器成为一个新的副本

# 命令和git原理类似
docker commit -m="描述信息" -a="作者" 容器id 目标镜像名:[版本TAG]

# 1、启动一个默认的tomcat
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker run -it -p 8080:8080 tomcat:9.0

# 2、开启一个新的终端
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker ps
CONTAINER ID   IMAGE        COMMAND             CREATED         STATUS         PORTS                                       NAMES
472c8b320916   tomcat:9.0   "catalina.sh run"   3 minutes ago   Up 3 minutes   0.0.0.0:8080->8080/tcp, :::8080->8080/tcp   modest_gould
# 3、由于我们之前就将webapps.dist文件赋值到webapps了

# 4、将操作过的容器通过commit调教为一个镜像！我们以后就使用我们修改过的镜像即可，而不需要每次都重新拷贝webapps.dist下的文件到webapps了，这就是我们自己的一个修改的镜像。
docker commit -m="描述信息" -a="作者" 容器id 目标镜像名:[TAG]
docker commit -a="kuangshen" -m="add webapps app" 容器id tomcat02:1.0

[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker commit -a="yechen" -m="add webapps app" 472c8b320916 tomcat02:1.0
sha256:319a670a5c2060cd9369083ac4ee38f3fb08ef2fe451cb5294ce4203b9ac6c02
[root@iZ2ze8tiyk741cs5ur9si3Z /]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED          SIZE
tomcat02              1.0       319a670a5c20   41 seconds ago   680MB
tomcat                9.0       088daa6ccabd   3 minutes ago    680MB
nginx                 latest    605c77e624dd   10 months ago    141MB
tomcat                <none>    b8e65a4d736d   10 months ago    680MB
redis                 latest    7614ae9453d1   10 months ago    113MB
mysql                 latest    3218b38490ce   10 months ago    516MB
hello-world           latest    feb5d9fea6a5   13 months ago    13.3kB
centos                latest    5d0da3dc9764   14 months ago    231MB
portainer/portainer   latest    580c0e4e98b0   20 months ago    79.1MB

如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像，就好比我们我们使用虚拟机的快照。

容器数据卷

概念

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

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

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

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

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

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

容器数据卷使用

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

-v, --volume list                    Bind mount a volume

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

#通过 docker inspect 容器id 查看
[root@iZ2ze8tiyk741cs5ur9si3Z ceshi]# docker inspect a5ed134b8e0d

查看挂载的信息

这时候就可以测试文件的同步了

挂载: 既不是双向绑定, 也不是同步, 而是就是宿主机的物理路径共享

指针，容器指向宿主机地址，容器删除代表指针断了，对宿主机没有影响

再进行测试：测试停止容器，再次启动容器，会发现容器内的数据是同步的

实战：安装mysql

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

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

# 运行容器,需要做数据挂载 #安装启动mysql，需要配置密码的，这是要注意点！
# 参考官网dockerhub 
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 mysql01 mysql:5.7


[root@iZ2ze8tiyk741cs5ur9si3Z etc]# 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 mysql01 mysql:5.7
7cf2b89a47895d4d7987e23159e91cf8a3d58fc83e8a3a6100a145c7432ede8f
# 启动成功之后，我们在本地使用navicat来测试一下
# navicat-连接到服务器的3306--和容器内的3306映射 

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

# 尝试删除mysql01，
[root@iZ2ze8tiyk741cs5ur9si3Z data]# docker rm -f mysql01
mysql01
[root@iZ2ze8tiyk741cs5ur9si3Z data]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@iZ2ze8tiyk741cs5ur9si3Z data]# 

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

具名和匿名挂载

# 匿名挂载
# -v 容器内路径!
$ docker run -d -P --name nginx01 -v /etc/nginx nginx
[root@iZ2ze8tiyk741cs5ur9si3Z data]# docker run -d -P --name nginx01 -v /etc/nginx nginx
258db2caeab08f0769a91d74a9b150aaa02b0ac640c4ef392d5c62055f0b30b1

# 查看所有的volume(卷)的情况
$ docker volume ls 
[root@iZ2ze8tiyk741cs5ur9si3Z data]# docker volume ls    
DRIVER    VOLUME NAME
local     2576baab64206762d9aa7336d5781cf90643af5fe18d8de79e3ea1f4c98d276c
local     4678c5f4290b9aaa4ffd3f1ca179ad75942ccd99ef353b652f48b1017c870838
      
# 这里发现，这种就是匿名挂载，我们在 -v只写了容器内的路径，没有写容器外的路径！

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

[root@iZ2ze8tiyk741cs5ur9si3Z data]# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
31e35c06745caafb5e5f9135540c452ab6ef887c509b2a2ea8fe577eb000c919
[root@iZ2ze8tiyk741cs5ur9si3Z data]# docker volume ls    
DRIVER    VOLUME NAME
local     2576baab64206762d9aa7336d5781cf90643af5fe18d8de79e3ea1f4c98d276c
local     4678c5f4290b9aaa4ffd3f1ca179ad75942ccd99ef353b652f48b1017c870838
local     juming-nginx #可以看出具名挂载成功

# 通过 -v 卷名：查看容器内路径
# 查看一下这个卷
$ docker volume inspect juming-nginx
[root@iZ2ze8tiyk741cs5ur9si3Z data]# docker volume inspect juming-nginx
[
    {
        "CreatedAt": "2022-11-14T20:52:16+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
        "Name": "juming-nginx",
        "Options": null,
        "Scope": "local"
    }
]

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

[root@iZ2ze8tiyk741cs5ur9si3Z data]# cd /var/lib/docker
[root@iZ2ze8tiyk741cs5ur9si3Z docker]# ls
buildkit  containers  image  network  overlay2  plugins  runtimes  swarm  tmp  trust  volumes
[root@iZ2ze8tiyk741cs5ur9si3Z docker]# cd vlumes
-bash: cd: vlumes: No such file or directory
[root@iZ2ze8tiyk741cs5ur9si3Z docker]# cd volumes/
[root@iZ2ze8tiyk741cs5ur9si3Z volumes]# ls
2576baab64206762d9aa7336d5781cf90643af5fe18d8de79e3ea1f4c98d276c  backingFsBlockDev  metadata.db
4678c5f4290b9aaa4ffd3f1ca179ad75942ccd99ef353b652f48b1017c870838  juming-nginx
[root@iZ2ze8tiyk741cs5ur9si3Z volumes]# cd juming-nginx
[root@iZ2ze8tiyk741cs5ur9si3Z juming-nginx]# cd _data/
[root@iZ2ze8tiyk741cs5ur9si3Z _data]# ls
conf.d  fastcgi_params  mime.types  modules  nginx.conf  scgi_params  uwsgi_params
[root@iZ2ze8tiyk741cs5ur9si3Z _data]# cat nginx.conf

user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log notice;
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;
}

区分三种挂载方式

# 三种挂载： 匿名挂载、具名挂载、指定路径挂载
-v 容器内路径			#匿名挂载
-v 卷名:容器内路径		  #具名挂载
-v /宿主机路径：容器内路径 #指定路径挂载 docker volume ls 是查看不到的(指定路径也会生成匿名卷，本质上是匿名挂载)

拓展：

# 通过 -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就说明这个路径只能通过宿主机来操作，容器内部是无法操作！

初识DockerFile

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

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

[root@iZ2ze8tiyk741cs5ur9si3Z _data]# cd /home
[root@iZ2ze8tiyk741cs5ur9si3Z home]# ls
admin  ceshi  mysql  springboot  test.java  www  yechen
[root@iZ2ze8tiyk741cs5ur9si3Z home]# mkdir docker-test-volume
[root@iZ2ze8tiyk741cs5ur9si3Z home]# cd docker-test-volume/
[root@iZ2ze8tiyk741cs5ur9si3Z docker-test-volume]# 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镜像名前不能加斜杠‘/’)
. 						# 表示生成在当前目录下

[root@iZ2ze8tiyk741cs5ur9si3Z docker-test-volume]# docker build -f /home/docker-test-volume/dockerfile1 -t yechen/centos:1.0 .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos
 ---> 5d0da3dc9764
Step 2/4 : VOLUME ["volume01","volume02"]
 ---> Running in bfc533c7ebd3
Removing intermediate container bfc533c7ebd3
 ---> af3c0c711f46
Step 3/4 : CMD echo "-----end-----"
 ---> Running in 7c58bd28aba2
Removing intermediate container 7c58bd28aba2
 ---> 27a904713adb
Step 4/4 : CMD /bin/bash
 ---> Running in 813b2abc0895
Removing intermediate container 813b2abc0895
 ---> 5a3d36f34523
Successfully built 5a3d36f34523
Successfully tagged yechen/centos:1.0

# 查看
[root@iZ2ze8tiyk741cs5ur9si3Z docker-test-volume]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED          SIZE
yechen/centos         1.0       5a3d36f34523   38 seconds ago   231MB

运行,可以看到

[root@iZ2ze8tiyk741cs5ur9si3Z docker-test-volume]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
yechen/centos         1.0       5a3d36f34523   7 minutes ago   231MB
[root@iZ2ze8tiyk741cs5ur9si3Z docker-test-volume]# docker run -it 5a3d36f34523 /bin/bash
[root@df7a97a75d9f /]# ls -l
total 56
lrwxrwxrwx   1 root root    7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x   5 root root  360 Nov 14 13:25 dev
drwxr-xr-x   1 root root 4096 Nov 14 13:25 etc
drwxr-xr-x   2 root root 4096 Nov  3  2020 home
lrwxrwxrwx   1 root root    7 Nov  3  2020 lib -> usr/lib
lrwxrwxrwx   1 root root    9 Nov  3  2020 lib64 -> usr/lib64
drwx------   2 root root 4096 Sep 15  2021 lost+found
drwxr-xr-x   2 root root 4096 Nov  3  2020 media
drwxr-xr-x   2 root root 4096 Nov  3  2020 mnt
drwxr-xr-x   2 root root 4096 Nov  3  2020 opt
dr-xr-xr-x 137 root root    0 Nov 14 13:25 proc
dr-xr-x---   2 root root 4096 Sep 15  2021 root
drwxr-xr-x  11 root root 4096 Sep 15  2021 run
lrwxrwxrwx   1 root root    8 Nov  3  2020 sbin -> usr/sbin
drwxr-xr-x   2 root root 4096 Nov  3  2020 srv
dr-xr-xr-x  13 root root    0 Nov 14 13:25 sys
drwxrwxrwt   7 root root 4096 Sep 15  2021 tmp
drwxr-xr-x  12 root root 4096 Sep 15  2021 usr
drwxr-xr-x  20 root root 4096 Sep 15  2021 var
drwxr-xr-x   2 root root 4096 Nov 14 13:25 volume01
drwxr-xr-x   2 root root 4096 Nov 14 13:25 volume02
# volume01，volume02就是我们生成镜像的时候自动挂载的，数据卷目录

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

查看一下卷挂载

# docker inspect df7a97a75d9f

通过下面操作，在容器中创建文件，可以看出同步成功

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

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

数据卷容器

多个mysql同步数据

启动多个docker

# 启动docker01
docker run -it --name docker01 yechen/centos:1.0

# 按下ctrl+Q+P，启动docker02
docker run -it --name docker02 --volumes-from docker01 yechen/centos:1.0

#启动新的终端，并进入docker01
docker attach b283b24ba0ec
#在docker01中的volume01下创建docker01，观察dockers02下的volume01下是否有一样的文件docker01？ 有！

# 启动docker03
docker run -it --name docker03 --volumes-from docker01 yechen/centos:1.0
#在docker03中的volume01下创建docker03，观察dockers01，docker02下的volume01下是否有一样的文件docker01？ 有！

# 测试：可以删除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

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

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

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

DockerFile

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

构建步骤：

1、 编写一个dockerfile文件

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

3、 docker run运行镜像

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

点击后跳到一个Dockerfile

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

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

构建过程

基础知识

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

2、执行从上到下顺序

3、#表示注释

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

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

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

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

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

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

指令

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:构建的时候设置环境变量！

实战:创建自己的centos

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.编写dockerfile文件（/home下新建dockerfile目录，dockerfile目录下新建mydockerfile-centos文件）
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




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

Error: Failed to download metadata for repo 'appstream': Cannot prepare internal mirrorlist: No URLs in mirrorlist
The command '/bin/sh -c yum -y install vim' returned a non-zero code: 1

构建镜像遇到Error，更新yum源：

Error: Failed to download metadata for repo ‘appstream‘: Cannot prepare internal mirrorlist_华仔仔coding的博客-CSDN博客

可是没有解决问题!

因此我选择了第二中方式：FROM centos:7，指定下载的centos版本为7

可以看到构建成功了

[root@iZ2ze8tiyk741cs5ur9si3Z dockerfile]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED          SIZE

#启动测试
$ docker run -it mycentos:0.1

#输入指令，vim，ifconfig测试，可以看到测试成功
$ pwd	
/usr/local							# 与Dockerfile文件中 WORKDIR 设置的 MYPATH 一致
$ vim								# vim 指令可以使用
$ ifconfig     						# ifconfig 指令可以使用

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

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

CMD 和 ENTRYPOINT区别

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

测试cmd命令

#1.编写dockerfile文件dockerfile-cmd-test
[root@iZ2ze8tiyk741cs5ur9si3Z dockerfile]# cat dockerfile-cmd-test
FROM centos
CMD ["ls","-a"]					# 启动后执行 ls -a 命令

#2.构建镜像
[root@iZ2ze8tiyk741cs5ur9si3Z dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .
Sending build context to Docker daemon  3.072kB
Step 1/2 : FROM centos:7
 ---> eeb6ee3f44bd
Step 2/2 : CMD ["ls" ,"-a"]
 ---> Running in 617b7ee9749d
Removing intermediate container 617b7ee9749d
 ---> 8374dec1f0e4
Successfully built 8374dec1f0e4
Successfully tagged cmdtest:latest

#3.运行镜像：（由结果可得，运行后就执行了 ls -a 命令）
[root@iZ2ze8tiyk741cs5ur9si3Z dockerfile]# docker run cmdtest
.
..
.dockerenv
anaconda-post.log
bin
dev
etc
home
lib
lib64
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var

# 想追加一个命令  -l 成为ls -al：展示列表详细数据
[root@iZ2ze8tiyk741cs5ur9si3Z dockerfile]# docker run cmdtest -l
docker: Error response from daemon: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: exec: "-l": executable file not found in $PATH: unknown.
ERRO[0000] error waiting for container: context canceled 
# cmd的情况下 -l 替换了CMD["ls","-l"] 而 -l  不是命令所以报错


[root@iZ2ze8tiyk741cs5ur9si3Z dockerfile]# docker run cmdtest ls -al
total 64
drwxr-xr-x   1 root root  4096 Nov 17 06:12 .
drwxr-xr-x   1 root root  4096 Nov 17 06:12 ..
-rwxr-xr-x   1 root root     0 Nov 17 06:12 .dockerenv
-rw-r--r--   1 root root 12114 Nov 13  2020 anaconda-post.log
lrwxrwxrwx   1 root root     7 Nov 13  2020 bin -> usr/bin
drwxr-xr-x   5 root root   340 Nov 17 06:12 dev
drwxr-xr-x   1 root root  4096 Nov 17 06:12 etc
drwxr-xr-x   2 root root  4096 Apr 11  2018 home
lrwxrwxrwx   1 root root     7 Nov 13  2020 lib -> usr/lib
lrwxrwxrwx   1 root root     9 Nov 13  2020 lib64 -> usr/lib64
drwxr-xr-x   2 root root  4096 Apr 11  2018 media
drwxr-xr-x   2 root root  4096 Apr 11  2018 mnt
drwxr-xr-x   2 root root  4096 Apr 11  2018 opt
dr-xr-xr-x 127 root root     0 Nov 17 06:12 proc
dr-xr-x---   2 root root  4096 Nov 13  2020 root
drwxr-xr-x  11 root root  4096 Nov 13  2020 run
lrwxrwxrwx   1 root root     8 Nov 13  2020 sbin -> usr/sbin
drwxr-xr-x   2 root root  4096 Apr 11  2018 srv
dr-xr-xr-x  13 root root     0 Nov 14 13:25 sys
drwxrwxrwt   7 root root  4096 Nov 13  2020 tmp
drwxr-xr-x  13 root root  4096 Nov 13  2020 usr
drwxr-xr-x  18 root root  4096 Nov 13  2020 var

测试ENTRYPOINT

# 编写dockerfile文件
[root@iZ2ze8tiyk741cs5ur9si3Z dockerfile]# vim dockerfile-cmd-entrypoint
FROM centos
ENTRYPOINT ["ls","-a"]


# 构建镜像
[root@iZ2ze8tiyk741cs5ur9si3Z dockerfile]# docker build  -f dockerfile-cmd-entrypoint -t entrypoint-test .

# 运行镜像
[root@iZ2ze8tiyk741cs5ur9si3Z dockerfile]# docker run entrypoint-test
.
..
.dockerenv
anaconda-post.log
bin
dev
etc
home
lib
lib64
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var


# 我们的命令，是直接拼接在我们得ENTRYPOINT命令后面的
[root@iZ2ze8tiyk741cs5ur9si3Z dockerfile]# docker run entrypoint-test -l
total 64
drwxr-xr-x   1 root root  4096 Nov 17 06:18 .
drwxr-xr-x   1 root root  4096 Nov 17 06:18 ..
-rwxr-xr-x   1 root root     0 Nov 17 06:18 .dockerenv
-rw-r--r--   1 root root 12114 Nov 13  2020 anaconda-post.log
lrwxrwxrwx   1 root root     7 Nov 13  2020 bin -> usr/bin
drwxr-xr-x   5 root root   340 Nov 17 06:18 dev
drwxr-xr-x   1 root root  4096 Nov 17 06:18 etc
drwxr-xr-x   2 root root  4096 Apr 11  2018 home
lrwxrwxrwx   1 root root     7 Nov 13  2020 lib -> usr/lib
lrwxrwxrwx   1 root root     9 Nov 13  2020 lib64 -> usr/lib64
drwxr-xr-x   2 root root  4096 Apr 11  2018 media
drwxr-xr-x   2 root root  4096 Apr 11  2018 mnt
drwxr-xr-x   2 root root  4096 Apr 11  2018 opt
dr-xr-xr-x 131 root root     0 Nov 17 06:18 proc
dr-xr-x---   2 root root  4096 Nov 13  2020 root
drwxr-xr-x  11 root root  4096 Nov 13  2020 run
lrwxrwxrwx   1 root root     8 Nov 13  2020 sbin -> usr/sbin
drwxr-xr-x   2 root root  4096 Apr 11  2018 srv
dr-xr-xr-x  13 root root     0 Nov 14 13:25 sys
drwxrwxrwt   7 root root  4096 Nov 13  2020 tmp
drwxr-xr-x  13 root root  4096 Nov 13  2020 usr
drwxr-xr-x  18 root root  4096 Nov 13  2020 var

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

实战:Tomcat镜像

先准备好linux中的tomcat和jdk的压缩包

创建Dockerfile，注意修改自己的tomcat和jdk的版本号

FROM centos:7
MAINTAINER yechen<206875469@qq.com>
COPY readme.txt /usr/local/readme.txt
ADD jdk-8u351-linux-x64.tar.gz /usr/local/ 
ADD apache-tomcat-9.0.69.tar.gz /usr/local/
RUN yum -y install vim
ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_351
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.69
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.69

ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-9.0.69/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.69/logs/catalina.out

构建镜像

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

运行镜像

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

访问测试

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

$ curl localhost:8080

# 访问服务器ip地址:8080

发布项目

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

# 进入我们的本地项目编辑文件
$ cd /home/yechen/build/tomcat/test


# 创建一个web.xml和index.jsp
$ mkdir WEB-INF
$ cd WEB-INF/
$ vim web.xml

$ cd ..
$ vim index.jsp

# 访问服务器ip地址:8080/test/，访问成功，项目发布成功

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

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

发布自己的镜像

发布到 Docker Hub

地址 https://hub.docker.com/，申请账号并登入

$ 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 你的密码

[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker push mytomcat:0.1
The push refers to repository [docker.io/library/mytomcat]
4292ae0f0853: Preparing 
08dee0e5c25a: Preparing 
1a46a65da9b2: Preparing 
b581515fd484: Preparing 
174f56854903: Preparing 
denied: requested access to the resource is denied

会发现push不上去，因为如果没有前缀的话默认是push到 官方的library

# 第一种 build的时候添加你的dockerhub用户名，然后在push就可以放到自己的仓库了(试的没有成功)
$ docker build -t 17630393450/mytomcat:0.1 .

# 第二种 使用docker tag #然后再次push
$ docker tag 7199e68dbaa5 17630393450/mytomcat:0.1 
$ docker push 17630393450/tomcat:0.1

[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker tag 7199e68dbaa5 17630393450/mytomcat:0.1
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker push 17630393450/tomcat:0.1
The push refers to repository [docker.io/17630393450/tomcat]
An image does not exist locally with the tag: 17630393450/tomcat
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker push 17630393450/mytomcat:0.1
The push refers to repository [docker.io/17630393450/mytomcat]
4292ae0f0853: Pushed 
08dee0e5c25a: Pushed 
1a46a65da9b2: Pushing  3.308MB/375.5MB
b581515fd484: Pushed 
174f56854903: Pushed 
^C

发布到 阿里云镜像服务上

#登录阿里云Docker Registry，登录的用户名为阿里云账号全名，密码为开通服务时设置的密码。您可以在访问凭证页面修改凭证密码。
$ docker login --username=我向往的是蓝天啊 registry.cn-hangzhou.aliyuncs.com

#从Registry中拉取镜像
$ docker pull registry.cn-hangzhou.aliyuncs.com/yehcen_docker/yechen-test:[镜像版本号]


#将镜像推送到Registry
$ docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/yehcen_docker/yechen-test:[镜像版本号]
$ docker push registry.cn-hangzhou.aliyuncs.com/yehcen_docker/yechen-test:[镜像版本号]

跟着官网做就好，容器镜像服务 (aliyun.com)

小结

现在我们再看这张图片就十分熟悉了

Docker网络

Docker0网络详解

先清空所有环境

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

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

$ ip addr

三个网络

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

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

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

# 发现容器启动的时候会得到一个 eth0@if77 ip地址，docker分配！
$ ip addr
# 下载的tomcat启动看ip addr报错：OCI runtime exec failed: exec failed: unable to start container process: exec: "ip": executable file not found in $PATH: unknown
# 将tomcat版本改为7.0
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker exec -it 32e5a5eec028 ip addr
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
76: eth0@if77: <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


# 由上可知 容器内部ip地址为 172.17.0.2      
# 思考？ linux能不能ping通容器内部！ 可以 容器内部可以ping通外界吗？ 可以！
$ 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.077 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.066 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.055 ms

原理

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

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

再次测试 ip addr

在启动一个测试

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

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

$ docker exec -it tomcat01容器id ip addr
$ docker exec -it tomcat02容器id ping tomcat01容器内部ip地址

# 测试
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker exec -it 32e5a5eec028 ip addr
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
76: eth0@if77: <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
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker exec -it 50bc5cafe0c4 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.112 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.100 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:7.0
329f0214616eb61680ffab04c9d3944bed8cd7fb9ca0cdc37c0737b505627714

# 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.109 ms

# 2连接3
# 用tomcat02 ping tomcat03 发现ping不通
$ docker exec -it tomcat02 ping tomcat03

探究：

docker network inspect 网络id 网段相同

# 查看所有的docker网络
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
b063f6d8ed38   bridge    bridge    local
5954ccefa526   host      host      local
09086016b38c   none      null      local
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker network inspect b063f6d8ed38

$ docker inspect tomcat03

$ docker exec tomcat03 cat /etc/hosts

[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker exec tomcat03 cat /etc/hosts
127.0.0.1	localhost
::1	localhost ip6-localhost ip6-loopback
fe00::0	ip6-localnet
ff00::0	ip6-mcastprefix
ff02::1	ip6-allnodes
ff02::2	ip6-allrouters
172.17.0.3	tomcat02 99574030a155
172.17.0.4	329f0214616e

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

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

自定义网络，不适用docker0！

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

自定义网络

# docker network --help
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网络
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
b063f6d8ed38   bridge    bridge    local
5954ccefa526   host      host      local
09086016b38c   none      null      local

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:7.0

# docker0，特点：默认，域名不能访问。 --link可以打通连接，但是很麻烦！

# 我们可以 自定义一个网络
$ docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
1920dc37c91cffca5b16f082b2979e614e7b38e6a9a556e27d6dfeddcfa2c474
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
b063f6d8ed38   bridge    bridge    local
5954ccefa526   host      host      local
1920dc37c91c   mynet     bridge    local
09086016b38c   none      null      local

# 查看网络信息
$ docker network inspect mynet

# 创建两个容器并连接自定义网络
$ docker run -d -P --name tomcat-net-01 --net mynet tomcat:7.0
$ docker run -d -P --name tomcat-net-02 --net mynet tomcat:7.0

# 再次查看网络信息
$ docker network inspect mynet

# 测试两个容器之间相互ping，成功！
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker exec -it tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.089 ms

[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker exec -it tomcat-net-02 ping tomcat-net-01
PING tomcat-net-01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.087 ms

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

好处：

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

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

网络连通

测试tomcat01和tomcat-net-01之间能不能ping通

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

# 此时ping不通
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker exec -it tomcat01 ping tomcat-net-01
ping: tomcat-net-01: Name or service not known

需要：两容器之间打通

# 使用connect命令将tomcat01与mynet连通，连通就是将 tomcat01加到 mynet网络
# 一个容器两个ip（tomcat01） 阿里云服务：内网ip，外网ip
$ docker network connect mynet tomcat01

# 再次查看mynet
$ docker network inspect mynet

# 01连通 ，加入后此时，已经可以tomcat01 和 tomcat-01-net ping通了。 02是依旧不通的。
$ docker exec -it tomcat01 ping tomcat-net-01
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker exec -it tomcat01 ping tomcat-net-01
PING tomcat-net-01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.096 ms

Redis集群部署实战

# 创建网卡
$ docker network create redis --subnet 172.38.0.0/16
[root@iZ2ze8tiyk741cs5ur9si3Z ~]# docker network create redis --subnet 172.38.0.0/16
65c0bedef1e2b393534b4d6ca3db289da3410791dcd99f4eeea9e0026fc6efe8


# 通过shell脚本创建六个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 1637${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; \
done

#redis默认没有bash
$ docker exec -it redis-1 /bin/sh

# 创建集群
$ 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

$ redis-cli -c
$ cluster 
$ cluster nodes

然后将172.38.0.13:6379对应的redis-3容器给停止了，再次尝试获取a的值

测试成功，a的值从172.138.0.14:6379获取到了

docker搭建redis集群完成！

我们使用docker之后，所有的技术都会慢慢变得简单起来！

Springboot微服务打包Docker镜像

1、做测试：构建SpringBoot项目，只编写HelloController

package com.rui.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String hello(){
        return "hello,yechen";
    }
}

2、打包运行

mvn package

在本地测试打开运行jar包

java -jar docker-test-0.0.1-SNAPSHOT.jar

测试

可以选择插件docker进行上传，这里就不演示了

3、编写dockerfile

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

4、构建镜像，运行测试

复制jar和DockerFIle到服务器

# 2.构建镜像
$ docker build -t xxxxx:xx  .

$ docker run -d -P --name yechen-springboot-web yechen

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

企业

Docker Compose

pass

Docker Swarm

pass

CI/CD Jenkins 流水线

pass

学习视频来源于狂神，
笔记文字描述来源于兴趣使然的草帽路飞