Docker学习记录

1、Docker是什么

Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从 Apache2.0 协议开源。

Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。

2、Docker 的优点

来自菜鸟教程：

Docker 是一个用于开发，交付和运行应用程序的开放平台。Docker 使您能够将应用程序与基础架构分开，从而可以快速交付软件。借助 Docker，您可以与管理应用程序相同的方式来管理基础架构。通过利用 Docker 的方法来快速交付，测试和部署代码，您可以大大减少编写代码和在生产环境中运行代码之间的延迟。

快速，一致地交付您的应用程序

Docker 允许开发人员使用您提供的应用程序或服务的本地容器在标准化环境中工作，从而简化了开发的生命周期。

容器非常适合持续集成和持续交付（CI / CD）工作流程，请考虑以下示例方案：

• 您的开发人员在本地编写代码，并使用 Docker 容器与同事共享他们的工作。
• 他们使用 Docker 将其应用程序推送到测试环境中，并执行自动或手动测试。
• 当开发人员发现错误时，他们可以在开发环境中对其进行修复，然后将其重新部署到测试环境中，以进行测试和验证。
• 测试完成后，将修补程序推送给生产环境，就像将更新的镜像推送到生产环境一样简单。

响应式部署和扩展

Docker 是基于容器的平台，允许高度可移植的工作负载。Docker 容器可以在开发人员的本机上，数据中心的物理或虚拟机上，云服务上或混合环境中运行。

Docker 的可移植性和轻量级的特性，还可以使您轻松地完成动态管理的工作负担，并根据业务需求指示，实时扩展或拆除应用程序和服务。

在同一硬件上运行更多工作负载

Docker 轻巧快速。它为基于虚拟机管理程序的虚拟机提供了可行、经济、高效的替代方案，因此您可以利用更多的计算能力来实现业务目标。Docker 非常适合于高密度环境以及中小型部署，而您可以用更少的资源做更多的事情。

3、docker能干嘛

• Web 应用的自动化打包和发布。
• 自动化测试和持续集成、发布。
• 在服务型环境中部署和调整数据库或其他的后台应用。
• 从头编译或者扩展现有的 OpenShift 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。

之前的虚拟机技术

虚拟机技术缺点：

1. 资源占用十分多
2. 冗余步骤多
3. 启动很慢

容器化技术

容器化技术不是模拟的一个完整的操作系统

比较Docker和虚拟机技术不同：

• 传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统，然后再这个系统上安装和运行软件
• 容器内的应用直接运行在宿主机的内核，容器是没有自己的内核的，也没有虚拟我们的硬件，所以就轻便了。
• 每个容器间都是相互隔离，每个容器内都有一个属于自己的文件系统，互不影响

这样也就是如果之前在一个大的lib集成里面，只能够安装下3个软件，那么，容器化后，就可能安装下30个软件。

DevOps(开发、运维)

应用更快速的交付和部署

传统：一堆帮助文档，安装程序

Docker：运行打包镜像发布测试，一键运行

更便捷的升级和扩缩容

使用了Docker之后，我们部署应用就和搭积木一样！

项目打包为一个镜像，扩展 服务器A 服务器B

更简单的系统运维

在容器化之后，我们的开发，测试环境都是高度一致的。

更高效的计算资源利用：

Docker 是 内核级别的虚拟化，可以在一个物理机上可以运行很多的容器实例！服务器的性能可以被压榨到极致！

4、Docker基本组成

镜像（image）:

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

容器（container）：

Docker利用容器技术，独立运行一个或者一组应用，通过镜像来创建的。

启动、停止、删除、基本命令！

目前可以把这个容器理解为一个简易的linux系统

仓库（repository）：

仓库就是存放镜像的地方！

仓库分为公有仓库和私有仓库！

Docker Hub（默认是国外的！）

国内阿里云…都有容器服务器（配置镜像加速）

5、Docker安装及删除

环境准备

1. 需要会一点点的Linux的基础
2. CentOS 7以上
3. 我们使用Xshell连接远程服务器进行操作

环境查看

# 系统内核是 5.10
[root@heze /]# uname -r
5.10.134-12.2.al8.x86_64

# 系统版本
[root@heze /]# cat /etc/os-release
NAME="Alibaba Cloud Linux"
VERSION="3 (Soaring Falcon)"
ID="alinux"
ID_LIKE="rhel fedora centos anolis"
VERSION_ID="3"
PLATFORM_ID="platform:al8"
PRETTY_NAME="Alibaba Cloud Linux 3 (Soaring Falcon)"
ANSI_COLOR="0;31"
HOME_URL="https://www.aliyun.com/"

安装

帮助文档：https://docs.docker.com/engine/install/centos/

# 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 \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 

# 更新软件包索引
yum makecache

# 4.安装docker docker-ce 社区   ee 企业版
yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# 5.启动docker
systemctl start docker

# 6.判断docker是否安装成功（出现如下图所示即表示安装成功）
docker version

# 7.测试运行 hello-world
docker run hello-world

# 8.查看一下下载的这个 hello-world 镜像
[root@heze /]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    feb5d9fea6a5   17 months ago   13.3kB

了解：卸载docker

# 1.卸载依赖
yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras

# 2.删除资源
sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd

# /var/lib/docker	docker的默认工作路径

6、配置阿里云镜像加速

1、登录阿里云找到容器服务

2、找到镜像加速地址

3、配置使用

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://8wito3c6.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

7、Run的流程和Docker原理

1、Run的流程

2、底层原理

Docker是怎么工作的？

Docker是一个 Client-Server 结构的系统，Docker的守护进程运行在主机上，通过Socket从客户端访问！

DockerSever接收到Docker-Client的指令，就会执行这个命令！

Docker为什么比VM快

1、Docker有着比虚拟机更少的抽象层

2、docker利用的是宿主机的内核，vm需要是Guest OS

所以说，新建一个容器的时候，docker不需要像虚拟机一样重新加载一个操作系统内核，避免引导。虚拟机是加载Guest OS，分钟级别的，而docker是利用宿主机的操作系统，省略了这个复杂过程，秒级。

8、Docker的常用命令

命令不记得，有两种方式：1、通过帮助命令查询；2、通过帮助文档地址查询。

帮助命令

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

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

镜像命令

docker images 查看所有本地主机上的镜像

[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    feb5d9fea6a5   17 months ago   13.3kB

# 解释
REPOSITORY	镜像的仓库源
TAG			镜像的标签
TMAGE ID	镜像的id
CREATED		镜像的创建时间
SIZE		镜像的大小

# 可选项
	  -a, --all             Show all images (default hides intermediate images)
      -q, --quiet           Only show image IDs

docker search 搜索镜像

[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker search mysql
NAME                            DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                           MySQL is a widely used, open-source relation…   13936     [OK]       

# 可选项，通过搜藏来过滤
--filter=STARS=3000	搜索出来的镜像就是STARS大于3000的
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker search mysql --filter=STARS=5000
NAME      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql     MySQL is a widely used, open-source relation…   13936     [OK]       
mariadb   MariaDB Server is a high performing open sou…   5315      [OK]  

docker pull 下载镜像

# 下载镜像 docker pull 镜像名[:tag]
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker pull mysql
Using default tag: latest	# 如果不写 tag，默认就是 latest
latest: Pulling from library/mysql	
72a69066d2fe: Pull complete 	# 分层下载，docker images的核心 联合文件系统
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:latest

# 指定版本下载(注意这里的版本号要在dockerhub里面存在才行)
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker pull mysql:8.0

# 查看我们的镜像，看mysql的信息
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
mysql         latest    3218b38490ce   14 months ago   516MB
hello-world   latest    feb5d9fea6a5   17 months ago   13.3kB

**docker rmi ** 删除镜像

[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker rmi -f 镜像id	# 删除指定的容器
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker rmi -f 镜像id 镜像id	# 删除多个容器
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker rmi -f $(docker images -aq) # 删除全部的容器

容器命令

说明：我们有了镜像才可以创建容器，linux，下载一个centos镜像来测试学习

docker pull centos

新建容器并启动

docker run [可选参数] image

# 参数说明
--name="Name"	容器名字 tomcat01，tomcat02，用来区分容器
-d				后台方式运行
-it				使用交互方式运行，进入容器查看内容
-P				指定容器的端口 -p 8080:8080
	-p  ip:主机端口:容器端口
	-p	主机端口:容器端口（常用）
	-p  容器端口
	容器端口
-p				随机指定端口


# 测试，新建容器启动并进入容器
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker run -it centos /bin/bash
[root@eb117be99768 /]# ls	# 查看容器内的centos，基础版本，很多命令都是不完善的！
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

# 从容器中退回主机
[root@eb117be99768 /]# exit
exit
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# cd ..
[root@iZf8z6tlihyt1tfjeoklzqZ /]# ls
bin   dev  home        lib    lost+found  mnt       opt    proc  run   srv  tmp  var
boot  etc  install.sh  lib64  media       myconfig  patch  root  sbin  sys  usr  www

列出所有运行的容器

# docker ps 命令
-a   # 列出当前正在运行的容器+带出历史运行过得程序
-n=? # 显示最近创建的容器
-q	 # 显示编号

[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker ps -a
CONTAINER ID   IMAGE         COMMAND       CREATED         STATUS                     PORTS     NAMES
eb117be99768   centos        "/bin/bash"   7 minutes ago   Exited (0) 6 minutes ago             naughty_ellis
c7440d2a4001   hello-world   "/hello"      47 hours ago    Exited (0) 47 hours ago              peaceful_pike

退出容器

exit	# 直接容器停止并退出
Ctrl + P + Q # 容器不停止退出

删除容器

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

启动和停止容器的操作3

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

# 下面这个是创建容器并启动，是我们上面提到过的，拿出来与上面这几个命令进行比较，避免搞混
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker run -it centos /bin/bash
[root@1ad1821b97f3 /]# exit
exit
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker ps -a
CONTAINER ID   IMAGE         COMMAND       CREATED          STATUS                      PORTS     NAMES
1ad1821b97f3   centos        "/bin/bash"   20 seconds ago   Exited (0) 9 seconds ago              crazy_shtern
eb117be99768   centos        "/bin/bash"   48 minutes ago   Exited (0) 46 minutes ago             naughty_ellis
c7440d2a4001   hello-world   "/hello"      2 days ago       Exited (0) 2 days ago                 peaceful_pike

# 可以看出，子系统又创建了一个，id不同，可以看出区分

镜像与容器的进一步理解

# 查看所有的镜像
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
mysql         latest    3218b38490ce   14 months ago   516MB
hello-world   latest    feb5d9fea6a5   17 months ago   13.3kB
centos        latest    5d0da3dc9764   18 months ago   231MB

# 查看所有的容器
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker ps -a
CONTAINER ID   IMAGE         COMMAND       CREATED          STATUS                      PORTS     NAMES
eb117be99768   centos        "/bin/bash"   18 minutes ago   Exited (0) 17 minutes ago             naughty_ellis
c7440d2a4001   hello-world   "/hello"      47 hours ago     Exited (0) 47 hours ago               peaceful_pike

# 可以看出上面一个是查看所有镜像和容器的，镜像可以理解为一个大的系统，根据这个大的系统可以创建出很多简单的小系统，这些小系统就是容器。

常用其他命令（主要）

后台启动容器

# 命令 docker run -d 镜像名！
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker run -d centos

# 问题docker ps，发现centos 停止了

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

查看日志

docker logs -f -t --tail 10 容器id # 没有日志

# 自己编写一段shell脚本
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker run -d centos /bin/sh -c "while true;do echo kuangshen;sleep 1;done"

[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS     NAMES
48f2e5f1d73d   centos    "/bin/sh -c 'while t…"   9 seconds ago   Up 9 seconds             vigilant_bartik

# 查看日志
-tf				# 显示日志
--tail number   # 要显示日志条数
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker logs -tf --tail 10 48f2e5f1d73d
2023-03-15T13:25:55.792927717Z kuangshen
2023-03-15T13:25:56.794481053Z kuangshen
2023-03-15T13:25:57.796205359Z kuangshen

查看容器中进程信息ps

# 命令 docker top 容器id
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker ps
CONTAINER ID   IMAGE         COMMAND                  CREATED             STATUS                         PORTS     NAMES
48f2e5f1d73d   centos        "/bin/sh -c 'while t…"   7 minutes ago       Up 7 minutes                             vigilant_bartik
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker top 48f2e5f1d73d
UID                 PID                 PPID                C                   STIME       
root                1381167             1381147             0                   21:25       
root                1381903             1381167             0                   21:33      

查看镜像的元数据

# 命令
docker inspect 容器id

# 测试
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker inspect 48f2e5f1d73d
[
    {
        "Id": "48f2e5f1d73dec25cc340999e3e52169e95cb6c0887449c2d5523dcef8280240",
        "Created": "2023-03-15T13:25:18.495767502Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true;do echo kuangshen;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 1381167,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2023-03-15T13:25:18.724021607Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/48f2e5f1d73dec25cc340999e3e52169e95cb6c0887449c2d5523dcef8280240/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/48f2e5f1d73dec25cc340999e3e52169e95cb6c0887449c2d5523dcef8280240/hostname",
        "HostsPath": "/var/lib/docker/containers/48f2e5f1d73dec25cc340999e3e52169e95cb6c0887449c2d5523dcef8280240/hosts",
        "LogPath": "/var/lib/docker/containers/48f2e5f1d73dec25cc340999e3e52169e95cb6c0887449c2d5523dcef8280240/48f2e5f1d73dec25cc340999e3e52169e95cb6c0887449c2d5523dcef8280240-json.log",
        "Name": "/vigilant_bartik",
        "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,
            "ConsoleSize": [
                33,
                115
            ],
            "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",
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": [],
            "BlkioDeviceWriteBps": [],
            "BlkioDeviceReadIOps": [],
            "BlkioDeviceWriteIOps": [],
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "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/2490e1cd5ddba9470439742a7c6ceba6e40153e324d2045dd1f9d304f6be54ff-init/diff:/var/lib/docker/overlay2/22a578509fbfc18a3bc6d89919091487849082dbd6563e45c31087438282b97b/diff",
                "MergedDir": "/var/lib/docker/overlay2/2490e1cd5ddba9470439742a7c6ceba6e40153e324d2045dd1f9d304f6be54ff/merged",
                "UpperDir": "/var/lib/docker/overlay2/2490e1cd5ddba9470439742a7c6ceba6e40153e324d2045dd1f9d304f6be54ff/diff",
                "WorkDir": "/var/lib/docker/overlay2/2490e1cd5ddba9470439742a7c6ceba6e40153e324d2045dd1f9d304f6be54ff/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "48f2e5f1d73d",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "while true;do echo kuangshen;sleep 1;done"
            ],
            "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": "a6bd7c8a17b5e28d64c5cdd8675676e6bcb07e16f55c8c156b8d8fb2c352279f",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/a6bd7c8a17b5",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "3a6944e03790f8c34971e1072afe2dc429c5a9dfef569b96eb3719da364fae4a",
            "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": "1e5a6102ef6305964694edb8a05ef47fdafdf71404b29b003fb6ce290bb14e4c",
                    "EndpointID": "3a6944e03790f8c34971e1072afe2dc429c5a9dfef569b96eb3719da364fae4a",
                    "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 bashShell

# 测试
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED        STATUS         PORTS     NAMES
48f2e5f1d73d   centos    "/bin/sh -c 'while t…"   22 hours ago   Up 4 seconds             vigilant_bartik
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker exec -it 48f2e5f1d73d /bin/bash
[root@48f2e5f1d73d /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@48f2e5f1d73d /]# ps -ef
UID          PID    PPID  C STIME TTY          TIME CMD
root           1       0  0 11:17 ?        00:00:00 /bin/sh -c while true;do echo kuangshen;sleep 1;done
root          50       0  0 11:18 pts/0    00:00:00 /bin/bash
root          81       1  0 11:18 ?        00:00:00 /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/slee
root          82      50  0 11:18 pts/0    00:00:00 ps -ef

# 方式二（进入正在执行的代码）
docker attach 容器id


# docker exec 	# 进入容器后开启一个新的终端，可以在里面操作（常用）
# docker attach	# 进入容器正在执行的终端，不会启动写的进程！

从容器内拷贝文件到主机上

docker cp 容器id:容器内路径 目的的主机路径

# 查看当前主机目录下
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED         STATUS         PORTS     NAMES
9ae6f3e033d8   centos    "/bin/bash"   2 minutes ago   Up 4 seconds             eager_kepler

# 进入docker容器内部
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker attach 9ae6f3e033d8
[root@9ae6f3e033d8 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@9ae6f3e033d8 /]# cd home
[root@9ae6f3e033d8 home]# ls

# 在容器内新建一个文件夹
[root@9ae6f3e033d8 home]# touch test.java
[root@9ae6f3e033d8 home]# ls
test.java
[root@9ae6f3e033d8 home]# cd
[root@9ae6f3e033d8 ~]# exit
exit
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# cd ../home
[root@iZf8z6tlihyt1tfjeoklzqZ home]# ls
heze  redis  www

# 将文件拷贝出来到外面主机上
[root@iZf8z6tlihyt1tfjeoklzqZ home]# docker cp 9ae6f3e033d8:/home/test.java /home
Preparing to copy...
Successfully copied 1.536kB to /home
[root@iZf8z6tlihyt1tfjeoklzqZ home]# ls
heze  redis  test.java  www

# 拷贝是一个手动过程，未来我们使用 -v 卷的技术，可以实现，自动同步 /home /home

常用命令总结

#info|version
docker info       #显示docker的系统信息，包括镜像和容器的数量
docker version    #显示docker的版本信息。
#帮助命令
docker 命令 --help #帮助命令
#镜像命令
docker images #查看所有本地主机上的镜像 可以使用docker image ls代替
docker search #搜索镜像
docker pull #下载镜像 docker image pull
docker rmi #删除镜像 docker image rm
#容器命令
docker run 镜像id #新建容器并启动
docker ps 列出所有运行的容器 docker container list
docker rm 容器id #删除指定容器
	#删除所有容器
	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	#强制停止当前容器
#退出容器
exit 		#容器直接退出
ctrl +P +Q  #容器不停止退出 	---注意：这个很有用的操作
#其他常用命令
docker run -d 镜像名  #后台启动命令
docker logs 		#查看日志
docker top 容器id 	#查看容器中进程信息ps
docker inspect 容器id  #查看镜像的元数据
docker exec 		#进入当前容器后开启一个新的终端，可以在里面操作。（常用）
docker attach 		# 进入容器正在执行的终端
docker cp 容器id:容器内路径  主机目的路径	#从容器内拷贝到主机上

docker命令大全

docker attach	#连接到正在运行中的容器
docker build	#使用 Dockerfile 创建镜像
docker builder	#管理builds
    docker builder prune	#清除build缓存
docker checkpoint	#管理checkpoints
    docker checkpoint create	#从正在运行的容器创建检查点
    docker checkpoint ls	#列出容器的检查点
    docker checkpoint rm	#删除指定的检查点
docker commit	#从容器创建一个新的镜像
docker config	#管理Docker配置
    docker config create	#创建配置文件
    docker config inspect	#查看配置文件信息
    docker config ls		#显示docker里已经保存得配置文件
    docker config rm		#删除配置文件
docker container	#管理容器
    docker container prune	#删除所有已停止的容器
docker context	#管理contexts
    docker context create	#创建一个上下文
    docker context export	#将上下文导出到tar或kubecconfig文件中
    docker context import	#从tar或zip文件导入上下文
    docker context inspect	#在一个或多个上下文上显示详细信息
    docker context ls		#列出上下文
    docker context rm		#删除一个或多个上下文
    docker context update	#更新
    docker context use		#设置当前docker的上下文
docker cp		#用于容器与主机之间的数据拷贝
docker create	#创建一个新的容器但不启动它
docker diff		#检查容器里文件结构的更改
docker events	#从服务器获取实时事件
docker exec		#在运行的容器中执行命令
docker export	#将文件系统作为一个tar归档文件导出到STDOUT
docker history	#查看指定镜像的创建历史
docker image	#管理镜像
    docker image inspect	#显示一个或多个镜像的元数据
    docker image ls			#列出本地镜像
    docker image prune		#删除没有使用的镜像
    docker image rm			#删除一个或多个镜像
docker images	#列出本地镜像
docker import	#从归档文件中创建镜像
docker info		#显示 Docker 系统信息，包括镜像和容器数
docker inspect	#获取容器/镜像的元数据
docker kill		#杀掉一个运行中的容器
docker load		#导入使用 docker save 命令导出的镜像
docker login	#登陆到一个Docker镜像仓库，如果未指定镜像仓库地址，默认为官方仓库 Docker Hub
docker logout	#登出一个Docker镜像仓库，如果未指定镜像仓库地址，默认为官方仓库 Docker Hub
docker logs		#获取容器的日志
docker manifest	#管理manifest(实验，不应用于生产环境)
    docker manifest annotate	#向本地镜像清单添加附加信息
    docker manifest create		#创建用于注释和推入注册表的本地清单列表
    docker manifest inspect		#显示镜像清单或清单列表
    docker manifest push		#将清单列表推入仓库
    docker manifest rm			#从本地存储中删除一个或多个清单列表
docker network	#管理网络
    docker network connect		#将容器连接到网络
    docker network create		#创建一个网络
    docker network disconnect	#断开容器的网络
    docker network inspect		#显示一个或多个网络的元数据
    docker network ls			#列出网络
    docker network prune		#删除所有没有使用的网络
    docker network rm			#删除一个或多个网络
docker node		#管理集群(swarm)节点
    docker node demote			#从群集(swarm)管理器中降级一个或多个节点
    docker node inspect			#显示一个或多个节点的元数据
    docker node ls				#列出群集(swarm)中的节点
    docker node promote			#将一个或多个节点推入到群集管理器中
    docker node ps				#列出在一个或多个节点上运行的任务，默认为当前节点
    docker node rm				#从群集(swarm)删除一个或多个节点
    docker node update			#更新一个节点
docker pause	#暂停容器中所有的进程
docker plugin	#管理插件
    docker plugin create		#从rootfs和配置创建一个插件。插件数据目录必须包含config.json和rootfs目录。
    docker plugin disable		#禁用插件
    docker plugin enable		#启用插件
    docker plugin inspect		#显示一个或多个插件的元数据
    docker plugin install		#安装一个插件
    docker plugin ls			#列出所有插件
    docker plugin push			#将插件推送到注册表
    docker plugin rm			#删除一个或多个插件
    docker plugin set			#更改插件的设置
    docker plugin upgrade		#升级现有插件
docker port		#列出指定的容器的端口映射，或者查找将PRIVATE_PORT NAT到面向公众的端口
docker ps		#列出容器
docker pull		#从镜像仓库中拉取或者更新指定镜像
docker push		#将本地的镜像上传到镜像仓库,要先登陆到镜像仓库
docker rename	#重命名容器
docker restart	#重启容器
docker rm		#删除一个或多个容器
docker rmi		#删除一个或多个镜像
docker run		#创建一个新的容器并运行一个命令
docker save		#将指定镜像保存成 tar 归档文件
docker search	#从Docker Hub查找镜像
docker secret	#管理Docker secrets
    docker secret create	#从文件或STDIN创建一个秘密作为内容
    docker secret inspect	#显示有关一个或多个秘密的详细信息
    docker secret ls		#列出秘密
    docker secret rm		#删除一个或多个秘密
docker service	#管理服务
    docker service create	#创建一个服务
    docker service inspect	#查看服务的元数据
    docker service logs		#获取服务的日志
    docker service ls		#列出服务
    docker service ps		#列出一个或多个服务的任务
    docker service rm		#删除一个或多个服务
    docker service rollback	#将更改恢复到服务的配置
    docker service scale	#缩放一个或多个复制服务
    docker service update	#更新服务
docker stack	#管理堆栈
    docker stack deploy		#部署新的堆栈或更新现有堆栈
    docker stack ls			#列出现有堆栈
    docker stack ps			#列出堆栈中的任务
    docker stack rm			#删除堆栈	
    docker stack services	#列出堆栈中的服务
docker start	#启动一个或多个已经被停止的容器
docker stats	#显示容器的实时流资源使用统计信息
docker stop		#停止一个运行中的容器
docker swarm	#管理集群(Swarm)
    docker swarm ca			#查看或旋转当前群集CA证书。此命令必须针对管理器节点
    docker swarm init		#初始化一个群集(Swarm)
    docker swarm join		#加入群集作为节点和/或管理器
    docker swarm join-token	#管理加入令牌
    docker swarm leave		#离开群集(Swarm)
    docker swarm unlock		#解锁群集(Swarm)
    docker swarm unlock-key	#管理解锁钥匙
    docker swarm update		#更新群集(Swarm)
docker system	#管理Docker
    docker system df		#显示docker磁盘使用情况
    docker system events	#从服务器获取实时事件
    docker system info		#显示系统范围的信息
    docker system prune		#删除未使用的数据
docker tag		#标记本地镜像，将其归入某一仓库
docker top		#查看容器中运行的进程信息，支持 ps 命令参数
docker trust	#管理Docker镜像的信任
    docker trust inspect	#返回有关key和签名的低级信息
    docker trust key		#管理登入Docker镜像的keys
    	docker trust key generate	#生成并加载签名密钥对
		docker trust key load		#加载私钥文件以进行签名
    docker trust revoke		#删除对镜像的认证
    docker trust sign		#镜像签名
    docker trust signer		#管理可以登录Docker镜像的实体
    	docker trust signer add		#新增一个签名者
		docker trust signer remove	#删除一个签名者
docker unpause	#恢复容器中所有的进程
docker update	#更新一个或多个容器的配置
docker version	#显示 Docker 版本信息
docker volume	#管理volumes
    docker volume create	#创建一个卷
    docker volume inspect	#显示一个或多个卷的元数据
    docker volume ls		#列出卷
    docker volume prune		#删除所有未使用的卷
    docker volume rm		#删除一个或多个卷
docker wait		#阻塞运行直到容器停止，然后打印出它的退出代码

作业练习

作业（一）：安装nginx

# 1、搜索镜像 search nginx 去看看docker搜索帮助文档
# 2、下载镜像 pull
# 3、运行测试
[root@iZf8z6tlihyt1tfjeoklzqZ home]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
nginx         latest    605c77e624dd   14 months ago   141MB
mysql         latest    3218b38490ce   15 months ago   516MB
hello-world   latest    feb5d9fea6a5   17 months ago   13.3kB
centos        latest    5d0da3dc9764   18 months ago   231MB

# -d 后台运行
# --name 给容器命名
# -p 宿主机端口:容器内部端口 端口暴露，相当于外面的端口映射到容器内部的端口
[root@iZf8z6tlihyt1tfjeoklzqZ home]# docker run -d --name nginx01 -p 3344:80 nginx
ce4c1f919255665740d4399db77fb99af44873747809e9cd1899d66e38e517e7
[root@iZf8z6tlihyt1tfjeoklzqZ home]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                                   NAMES
ce4c1f919255   nginx     "/docker-entrypoint.…"   6 seconds ago   Up 4 seconds   0.0.0.0:3344->80/tcp, :::3344->80/tcp   nginx01
[root@iZf8z6tlihyt1tfjeoklzqZ home]# curl localhost:3344
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

端口暴露的概念：

[root@iZf8z6tlihyt1tfjeoklzqZ home]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS         PORTS                                   NAMES
ce4c1f919255   nginx     "/docker-entrypoint.…"   12 minutes ago   Up 4 seconds   0.0.0.0:3344->80/tcp, :::3344->80/tcp   nginx0
[root@iZf8z6tlihyt1tfjeoklzqZ home]# docker exec -it nginx01 /bin/bash
root@ce4c1f919255:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@ce4c1f919255:/# cd /etc/nginx
root@ce4c1f919255:/etc/nginx# ls
conf.d	fastcgi_params	mime.types  modules  nginx.conf  scgi_params  uwsgi_params

外网访问3344如下：

作业（二）：安装tomcat

# 官方的使用
docker run -it --rm tomcat:9.0

# 我们之前的启动都是后台，停止了容器之后，容器还是可以查到 docker run -it -rm一般用于测试，测试完自动删除

# 启动运行
docker run -it -p 3355:8080 --name tomcat01 tomcat:9.0

# 测试访问没有问题

# 进入容器
[root@iZf8z6tlihyt1tfjeoklzqZ home]# docker exec -it tomcat01 /bin/bash
root@cd7b63307297:/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@cd7b63307297:/usr/local/tomcat# ll
bash: ll: command not found
root@cd7b63307297:/usr/local/tomcat/webapps# ls
root@cd7b63307297:/usr/local/tomcat/webapps# 

# 发现问题，1、linux命令变少了；2、没有webapps。阿里云镜像的原因，默认是最小的镜像，所有不必要的都剔除掉。
# 保证最小可运行的命令

最小的镜像tomcat打开：

将webapps.dist文件夹里面的东西复制一份到webapps里面，即可出现我们熟悉的页面。

root@cd7b63307297:/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@cd7b63307297:/usr/local/tomcat# cp -r webapps.dist/* webapps
root@cd7b63307297:/usr/local/tomcat# cd webapps
root@cd7b63307297:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager

作业（三）：部署es+kibana

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

# 启动ElasticSearch
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

# 启动了 linux就卡住了 docker stats 查看 cpu状态

# es 是十分耗内存的，1.xG   2核2G跑的够呛

# 关闭，增加内存限制

# 修改配置文件 -e 环境配置修改
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

# 查看 docker stats
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# curl localhost:9200
{
  "name" : "ea84f554a3ae",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "6R4NXBbgRwiWJdGom67QVg",
  "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？思考网络如何才能连接过去？

可视化

• portainer

docker run -d -p 8088:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

• Rancher（CI/CD再用）

什么是portainer？

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

访问测试：http://ip:8088/

选择本地的

可视化面板我们平时不会使用，一般玩玩即可。

9、Docker镜像讲解

镜像是什么

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

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

如何得到镜像：

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

Docker镜像加载原理

UnionFS（联合文件系统）

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

UnionFS（联合文件系统）：Union文件系统（Union）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下（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。

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

分层理解

分层的镜像

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

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

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

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

理解：

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

举一个简单的例子，加入基于Ubuntu Lunux16.04 创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加Python包，该镜像当前已经包含3个镜像层，如下图所示（这只是一个用于演示的很简单的例子）。

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

上图中的镜像层跟之前图中的略有区别，主要目的是便于展示文件。

下图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有6个文件，这是因为最上层中的文件7是文件5的一个更新版本。

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

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

Linux上可用的存储引擎有AUFS、Overlay2、Device Mapper、Btrfs以及ZFS。顾明思义，每种存储引擎都基于Linux中对应的Docker在Windows上仅支持windowsfilter一种存储引擎都有其独有的性能特点。

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

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

特点

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

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

如何提交一个自己的镜像

commit镜像

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

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

实战测试

# 1、启动一个默认的tomcat

# 2、发现这个默认的tomcat 是没有webapps应用，镜像的原因，官方的镜像默认webapps下面是没有文件的！

# 3、我自己拷贝进去了基本的文件

# 4、将我们操作过的容器通过commit提交为一个镜像！我们以后就使用我们修改过的镜像即可，这就是我们自己的一个修改镜像

学习方式说明：理解概念，但是一定要实践，最后实践与理论相结合搞定这个知识点

如果想要保存当前容器的状态，就可以通过commit来提交，并获得一个镜像。下载的镜像下的容器是个最基本的容器，我们在里面添加一些我们的设置及功能后，可以打包成为一个新的镜像供我们新环境的使用。

简单来说，镜像是一个主要基础模块，根据这个模块可以建立很多子模块即容器，容器更改后可以打包成为一个新的镜像。

到了这里我们才算是入门docker！

10、容器数据卷

什么是容器数据卷

docker的理念回顾

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

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

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

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

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

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

docker run -it -v 主机目录:容器内目录 

# 测试
[root@iZf8z6tlihyt1tfjeoklzqZ home]# docker run -it -v /home/ceshi:/home centos /bin/bash

# 启动起来的时候我们可以通过 docker inspect 容器id 来看挂载卷

测试文件的同步：双向绑定

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

实战：安装MySQL

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

# 获取镜像

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

# 启动我们的
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
--name 容器名字
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/home/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql

# 启动成功之后，我们在本地使用sqlyog来测试一下

# sqlyog-连接到服务器的3306 连接成功

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

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

具名和匿名挂载

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

# 查看所有的 volume 的情况
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker volume ls
DRIVER    VOLUME NAME
local     685c656dd72330279b700977019804b26e3e66db4399f663eabaf1dec2e37f81

# 这里发现，这种就是匿名挂载，我们在 -v 只写了容器内路径，没有写容器外的路径！

# 具名挂载
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker run -d -P --name nginx03 -v juming-nginx:/etc/nginx nginx
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker volume ls
DRIVER    VOLUME NAME
local     685c656dd72330279b700977019804b26e3e66db4399f663eabaf1dec2e37f81
local     juming-nginx

# 通过 -v 卷名：容器内路径
# 查看一下这个卷

所有的docker容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volumes/xxxx/_data

我们通过具名下载可以方便的找到我们的一个卷，大多数情况下就是使用具名挂载。

# 如何确定是具名挂载还是匿名挂载，还是指定路径挂载！
-v 容器内路径 			# 匿名挂载
-v 卷名：容器内路径		  # 具名挂载
-v /宿主机路径：容器内路径	# 指定路径挂载

拓展：

# 通过 -v 容器内路径:ro rw 改变读写权限
ro readonly 	# 只读
ow readwrite	# 可读可写

# 一旦这个设置了容器权限，容器对我们挂载出来的内容就有限定了！
docker run -d -P --name nginx03 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx03 -v juming-nginx:/etc/nginx:rw nginx

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

初识Dockerfile

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

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

# 创建一个dockerfile文件，名字可以随机 建议dockerfile
[root@iZf8z6tlihyt1tfjeoklzqZ docker-test-volume]# pwd
/home/docker-test-volume
[root@iZf8z6tlihyt1tfjeoklzqZ docker-test-volume]# vim dockerfile1
# 文件中的内容 指令（大写） 参数
FORM centos

VOLUME ["volume01", "volume02"]

CMD echo "-----and----“
CMD /bin/bash

# 这里的每个命令，就是镜像的一层！

# 启动镜像

查看一下卷挂载的路径

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

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

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

数据卷容器

多个mysql同步数据！

# 启动3个容器，通过我们刚才自己写的镜像启动！

--volumes-from 数据同步

# 测试，删除docker01后，docker02的数据还在，备份机制，双向拷贝的概念

多个mysql实现数据共享

[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker run -d -p 3306:3306 -v /etc/home/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql

[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker run -d -p 3306:3306 -v /etc/home/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql

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

结论：

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

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

11、DockerFile

DockerFile介绍

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

构建步骤：

1. 编写一个dockerfile文件
2. docker build 构建成为一个镜像
3. docker run 运行镜像
4. docker push 发布镜像 （DockerHub、阿里云镜像仓库！）

FROM scratch
ADD centos-8-x86_64.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="20210915"
CMD ["/bin/bash"]

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

DockerFile构建过程

基础知识：

1. 每个保留关键字（指令）都必须是大写字母
2. 执行从上到下顺序执行
3. #表示注释
4. 每一个指令都会创建提交一个新的镜像层，并提交！

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

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

步骤：开发，部署，运维。。。

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

DockerImages：通过DockerFile构建生成的镜像，最终发布和运行的产品，原来是jar war

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

DockerFile指令

我们可以自己构建一个镜像，来满足自己的某些需求！

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

实战测试

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

创建一个自己的centos

# 1、编写Dockerfile的文件
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# cd /home
[root@iZf8z6tlihyt1tfjeoklzqZ home]# ls
ceshi  docker-test-volume  heze  mysql  redis  test.java  www
[root@iZf8z6tlihyt1tfjeoklzqZ home]# mkdir dockerfile
[root@iZf8z6tlihyt1tfjeoklzqZ home]# ls
ceshi  dockerfile  docker-test-volume  heze  mysql  redis  test.java  www
[root@iZf8z6tlihyt1tfjeoklzqZ home]# cd dockerfile/
[root@iZf8z6tlihyt1tfjeoklzqZ dockerfile]# ls
[root@iZf8z6tlihyt1tfjeoklzqZ dockerfile]# vim mydockerfile-centos

FROM centos:centos7
MAINTAINER heze

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "----end----"
CMD /bin/bash

# 由于下载的是压缩版，没有vim命令和ifconfig命令，故在上面yum安装两个命令，成为我们的镜像

# 2、通过这个文件构建镜像
# 命令 docker build -f dockerfile文件路径 -t 镜像名:[tag] .

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

我们平时拿到一个镜像，可以研究一下它是怎么做的？

CMD 和 ENTRYPOINT 区别

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

测试cmd

# 编写dockerfile文件
[root@iZf8z6tlihyt1tfjeoklzqZ dockerfile]# vim dockerfile-cmd-test
[root@iZf8z6tlihyt1tfjeoklzqZ dockerfile]# cat dockerfile-cmd-test 
FROM centos
CMD ["ls", "-a"]
# 构建镜像
[root@iZf8z6tlihyt1tfjeoklzqZ dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .
[+] Building 0.0s (5/5) FINISHED                                                                                                             
 => [internal] load build definition from dockerfile-cmd-test                                                                           0.0s
 => => transferring dockerfile: 75B                                                                                                     0.0s
 => [internal] load .dockerignore                                                                                                       0.0s
 => => transferring context: 2B                                                                                                         0.0s
 => [internal] load metadata for docker.io/library/centos:latest                                                                        0.0s
 => CACHED [1/1] FROM docker.io/library/centos                                                                                          0.0s
 => exporting to image                                                                                                                  0.0s
 => => exporting layers                                                                                                                 0.0s
 => => writing image sha256:0334f47f3de288661f5ac9c168d34ec12010ea6667b372223ca83e719a768589                                            0.0s
 => => naming to docker.io/library/cmdtest                                                                                              0.0s
 
 # run 运行，发现我们ls -a命令生效
[root@iZf8z6tlihyt1tfjeoklzqZ dockerfile]# docker run cmdtest
.
..
.dockerenv
bin
dev
etc
home
lib

# 想追加一个命令 -l  => ls -al
[root@iZf8z6tlihyt1tfjeoklzqZ 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:    

# cmd的清理下，-l 替换了 CMD["ls","-a"]命令，-l不是命令，所以报错！

# 将CMD命令替换成ENTRYPOINT命令，我们会发现，-l是直接拼接在命令后面的，可以获得ls -al命令的操作
.
..
.dockerenv
bin
dev
etc
home
lib

Dockerfile中有很多命令都是十分相似的，我们需要了解他们之间的区别，对比学习测试效果！

实战：Tomcat镜像

1、准备镜像文件 Tomcat压缩包，jdk的压缩包！

2、编写dockerfile文件，官方命名Dockerfile,build会自动寻找这个文件，就不需要-f指定了！

# 这个centos:centos7是为了后面的vim指令能够下载成功
FROM centos:centos7
MAINTAINER heze

COPY readme.txt /usr/local/readme.txt

ADD jdk-17_linux-x64_bin.tar.gz /usr/local/
ADD apache-tomcat-9.0.73.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

# 这里的jdk-17.0.6和apache-tomcat-9.0.73是压缩包解压后的文件名
ENV JAVA_HOME /usr/local/jdk-17.0.6
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.73
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.73
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

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

3、构建镜像

# docker build -t diytomcat .

4、启动镜像

[root@iZf8z6tlihyt1tfjeoklzqZ test]# docker run -d -p 8090:8080 --name hezetomcat -v /home/heze/build/tomcat/test:/usr/local/apache-tomcat-9.0.73/webapps/test -v /home/heze/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.73/logs diytomcat

5、访问测试

6、发布项目（由于做了卷挂载，我们直接在本地编写项目就可以发布了）

在本机里面建立WEB-INF和index.jsp，web.xml文件：

进入容器里面检查卷挂载是否一致：

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

 </web-app>

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>问卷调查</title>
<style type="text/css">
body {
    padding: 0px 10% 0px 10%;
}
#ft {
	text-align:center;
	font-size:29px;<!--2号中文字体 -->
	font-family:SimSun;<!--宋体-->
	
}
 
.fp {
	font-family:KaiTi;<!--楷体-->
	font-size:14px;<!--5号中文字体 -->
}
 
.st {
	font-size:21px;<!--3号中文字体 2-->
	font-family:SimHei;<!--黑体-->
}
 
.sp {
	font-size:16px;<!--5号中文字体 -->
	font-family:SimSun;<!--宋体-->
	
}
</style>
</head>
<body>
<div>
    <p id="ft"><b>企业电子商务调查问卷</b></p>
    <div class="fp">
        <p>尊敬的先生/女士：</p>
        <p style="text-indent:2em;">您好！为了了解目前企业开展电子商务的状况和问题，我们课题组希望您能协助填写这份调查表。在此，我们郑重承诺，调查结果仅供研究使用。如果您有兴趣和需要，我们可以将最终的统计和分析结果通过电子邮件的方式反馈给您。
		</p>
        <p style="text-indent:2em;">本次调查对于电子商务的界定是：通过计算机网络完成的购买和销售货物以及服务的行为，这些货物或服务的订单是通过相关网络下达的，但是支付和物流可以是网下进行的。通过传真、电话和电子邮件达成的交易不算在内。
		</p>
        <p style="text-indent:2em;">非常感谢您的大力支持！</p>
        <p style="text-align:right;">广东省电子商务发展规划前期研究课题组
		</p>
    </div>
    <hr/>
</div>
 
<div>
	<b class="st">一、企业基本简况</b>
	<br/>
	<div class="sp">
		<p>
		1.企业名称：
		<input name="qyname" size=30 type="text">
		注册地：
		<input name="zcaddress" size=10 type="text">
		<br/>
		<br/>
		2.您所在的企业的职务（职业）：
		<input name="zyname" size=20 type="text">
		<br/>
		<br/>
		3.企业成立时间：
		<input name="cltime" size=20 type="text">
		<br/>
		<br/>
		4企业所在行业：
		<input name="szhy" size=20 type="text">
		<br/>
		<br/>
		<u style="font-size=20px">
		<b>
		以下选择题，若无特别声明，皆为多项选择题
		</b>
		</u>
		<br/>
		<br/>
		<p>
		5.您所在企业的所有制形式为：（单选）<br/>
		<input  name="r1" type="radio"/>国有 
		<input  name="r1" type="radio"/>集体 
		<input  name="r1" type="radio"/>民营 
		<input  name="r1" type="radio"/>外资 
		<input  name="r1" type="radio"/>合资
		<input  name="r1" type="radio"/>股份制 
		<input  name="r1" type="radio"/>其他 
		<input  name="qt1" size=5 type="text" />
		</p>
		<p>
		6.您所在企业的类型为： （多选）<br/>
		<input  name="r2" type="checkbox"/>流程型制造业
		<input  name="r2" type="checkbox"/>离散型制造业
		<input  name="r2" type="checkbox"/>混合型企业
		<input  name="r2" type="checkbox"/>旅游服务业
		<input  name="r2" type="checkbox"/>餐饮服务业
		<input  name="r2" type="checkbox"/>信息服务业
		<input  name="r2" type="checkbox"/>金融服务业
		<input  name="r2" type="checkbox"/>物流服务业
		<input  name="r2" type="checkbox"/>其他
		<input  name="qt2" size=10 type="text" />
		</p>
		<p>
		7.您所在企业是否是上市公司：（单选）
		<select>
		<option value="00">请选择</option>
		<option value="01">是</option>
		<option value="02">不是</option>
		</select>
		<br>
		</p>
		</p>
		<br/>
		</div>
</div>
<div>
		<b class="st">二、企业信息化总体状况</b>
		<p>
		8.您所在企业最需要的信息包括（选择其中最重要的4项信息）：
		</p>
		<table>
                <tr>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">产品开发</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">生产技术</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">技术引进</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">市场行情</td>
                    </tr>
                    <tr>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">竞争对手</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">政策法规</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">薪酬水平</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">人才信息</td>
                    </tr>
                    <tr>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">财务状况</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">投资融资</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">市场预测</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">员工关系</td>
                    </tr>
                    <tr>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">客户信息</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">供应商信息</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">产品价格</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">质量管理</td>
                    </tr>
                    <tr>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">社交活动</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">合作伙伴信息</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">企业绩效</td>
                    <td><input type="checkbox" name="dxcbox" οnclick="checkCount(this);">行业动态</td>
                    </tr>
                    <tr>
                     <td><input type="checkbox" name="cbox" />其他 
					 <input name="qt3" size="5" type="text" >
                        </td>
                    </tr>
                </table>
		<p>
		9.您所在企业从何时开始采用ERP（或MIS）系统？
		<select id="sel">
		</select>
		年
		</p>
		<p>
		10.您所在企业网站的更新周期是多长时间？（单选）
		<select>
		<option value="0">单选，请下拉</option>
		<option value="1">每天</option>
		<option value="2">每周</option>
		<option value="3">每月</option>
		<option value="4">每季度</option>
		<option value="5">每半年</option>
		<option value="6">半年以上</option>
		</select>
		</p>
		<p>
		11.您认为目前您所在企业存在的主要问题：
		</p>
		<table border="0">
		<tr>
		<td>  </td> <td>非常重要</td> <td>重要</td> <td>一般 </td> <td>不重要</td> <td>不存在</td>
		</tr>
		<tr>
		<td> <input  name="r3" type="checkbox" value="110"/>利润增长 </td>
		<td align="center" align="center"><input  name="r4" type="radio"/>5</td>
		<td align="center" align="center"><input  name="r4" type="radio"/>4</td> 
		<td align="center" align="center"><input  name="r4" type="radio"/>3</td> 
		<td align="center" align="center"><input  name="r4" type="radio"/>2</td> 
		<td align="center" align="center"><input  name="r4" type="radio"/>1</td>
		</tr>
		<tr>
		<td> <input  name="r3" type="checkbox" value="111"/>市场份额</td>
		<td align="center" align="center"><input  name="c5" type="radio"/>5</td>
		<td align="center" align="center"><input  name="c5" type="radio"/>4</td> 
		<td align="center" align="center"><input  name="c5" type="radio"/>3</td> 
		<td align="center" align="center"><input  name="c5" type="radio"/>2</td> 
		<td align="center" align="center"><input  name="c5" type="radio"/>1</td>
		</tr>
		<tr>
		<td> <input  name="r3" type="checkbox" value="112"/>战略管理</td>
		<td align="center" align="center"><input  name="c6" type="radio"/>5</td>
		<td align="center" align="center"><input  name="c6" type="radio"/>4</td> 
		<td align="center" align="center"><input  name="c6" type="radio"/>3</td> 
		<td align="center" align="center"><input  name="c6" type="radio"/>2</td> 
		<td align="center" align="center"><input  name="c6" type="radio"/>1</td>
		</tr>
		<tr>
		<td> <input  name="r3" type="checkbox" value="113"/>部门协调</td>
		<td align="center" align="center"><input  name="c7" type="radio"/>5</td>
		<td align="center" align="center"><input  name="c7" type="radio"/>4</td> 
		<td align="center" align="center"><input  name="c7" type="radio"/>3</td> 
		<td align="center" align="center"><input  name="c7" type="radio"/>2</td> 
		<td align="center" align="center"><input  name="c7" type="radio"/>1</td>
		</tr>
		<tr>
		<td> <input  name="r3" type="checkbox" value="114"/>员工流失</td>
		<td align="center" align="center"><input  name="c8" type="radio"/>5</td>
		<td align="center" align="center"><input  name="c8" type="radio"/>4</td> 
		<td align="center" align="center"><input  name="c8" type="radio"/>3</td> 
		<td align="center" align="center"><input  name="c8" type="radio"/>2</td> 
		<td align="center" align="center"><input  name="c8" type="radio"/>1</td>
		</tr>
		<tr>
		<td> <input  name="r3" type="checkbox" value="115"/>激励机制</td>
		<td align="center" align="center"><input  name="c9" type="radio"/>5</td>
		<td align="center" align="center"><input  name="c9" type="radio"/>4</td> 
		<td align="center" align="center"><input  name="c9" type="radio"/>3</td> 
		<td align="center" align="center"><input  name="c9" type="radio"/>2</td> 
		<td align="center" align="center"><input  name="c9" type="radio"/>1</td>
		</tr>
		<tr>
		<td> <input  name="r3" type="checkbox" value="116"/>人才培养和引进</td>
		<td align="center" align="center"><input  name="c10" type="radio"/>5</td>
		<td align="center" align="center"><input  name="c10" type="radio"/>4</td> 
		<td align="center" align="center"><input  name="c10" type="radio"/>3</td> 
		<td align="center" align="center"><input  name="c10" type="radio"/>2</td> 
		<td align="center" align="center"><input  name="c10" type="radio"/>1</td>
		</tr>
		<tr>
		<td> <input  name="r3" type="checkbox" value="117"/>领导班子</td>
		<td align="center" align="center"><input  name="c11" type="radio"/>5</td>
		<td align="center" align="center"><input  name="c11" type="radio"/>4</td> 
		<td align="center" align="center"><input  name="c11" type="radio"/>3</td> 
		<td align="center" align="center"><input  name="c11" type="radio"/>2</td> 
		<td align="center" align="center"><input  name="c11" type="radio"/>1</td>
		</tr>
		<tr>
		<td> <input  name="r3" type="checkbox" value="118"/>企业信息化建设</td>
		<td align="center" align="center"><input  name="c12" type="radio"/>5</td>
		<td align="center" align="center"><input  name="c12" type="radio"/>4</td> 
		<td align="center" align="center"><input  name="c12" type="radio"/>3</td> 
		<td align="center" align="center"><input  name="c12" type="radio"/>2</td> 
		<td align="center" align="center"><input  name="c12" type="radio"/>1</td>
		</tr>
		<tr>
		<td> <input  name="r3" type="checkbox" value="119"/>品牌经营</td>
		<td align="center" align="center"><input  name="c13" type="radio"/>5</td>
		<td align="center" align="center"><input  name="c13" type="radio"/>4</td> 
		<td align="center" align="center"><input  name="c13" type="radio"/>3</td> 
		<td align="center" align="center"><input  name="c13" type="radio"/>2</td> 
		<td align="center" align="center"><input  name="c13" type="radio"/>1</td>
		</tr>
		<tr>
		<td> <input  name="r3" type="checkbox" value="120"/>其他<input  name="qt4" size=5 	type="text" /></td>
		</tr>
		</table>
</div>
</div>
</body>
</html>
<script type="text/javascript">
    onload = function ()
    {
         var year=new Date().getFullYear(); //获取当前年份
         
       var sel = document.getElementById ('sel');//获取select下拉列表
       for ( var i = 1990; i <= year; i++)//循环添加2006到当前年份的每个年份依次添加到下拉列表
       {
           var option = document.createElement ('option');
           option.value = i;
           var txt = document.createTextNode (i);
           option.appendChild (txt);
           sel.appendChild (option);
       }
	  /********************************************************/
	   
    }
    function checkCount(cbox) {
        var dx4 = document.getElementsByName("dxcbox");
        var num = 0;
        for (i = 0; i < dx4.length; i++){
            if (dx4[i].checked)
                num += 1;
		}
			if (num > 4) {
            alert("最多可以选择四个！");
			//num-=1;
            cbox.checked = false;
        }
	   
    }
	 
	
</script>

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

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

发布自己的镜像

DockerHub

1、地址 https://hub.docker.com/ 注册自己账号

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

3、在我们服务器上提交自己的镜像

[root@iZf8z6tlihyt1tfjeoklzqZ test]# docker login --help

Usage:  docker login [OPTIONS] [SERVER]

Log in to a 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

4、登录完毕后就可以提交镜像了

[root@iZf8z6tlihyt1tfjeoklzqZ test]# docker login -u heze
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

5、上传镜像到dockerhub docker push

# 若出现如下错误，解决办法：增加一个 tag 进行规范命名
[root@iZf8z6tlihyt1tfjeoklzqZ test]# docker push heze128/diytomcat:1.0
The push refers to repository [docker.io/heze128/diytomcat]
An image does not exist locally with the tag: heze128/diytomcat

# tag的作用：规范命名=>镜像名称:版本号（是创建一个新的）
[root@iZf8z6tlihyt1tfjeoklzqZ heze]# docker tag --help
Usage:  docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]
Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
Aliases:
  docker image tag, docker tag


# docker tag 镜像id dockerHub注册名/镜像名称:1.0
[root@iZf8z6tlihyt1tfjeoklzqZ test]# docker tag af785cf7e74b heze128/diytomcat:1.0
[root@iZf8z6tlihyt1tfjeoklzqZ test]# docker images
heze128/diytomcat     1.0       af785cf7e74b   6 hours ago     796MB
diytomcat             latest    af785cf7e74b   6 hours ago     796MB

# docker push dockerHub注册名/镜像名称:1.0
[root@iZf8z6tlihyt1tfjeoklzqZ test]# docker push heze128/diytomcat:1.0

提交的时候也是按照镜像的层级来进行提交的！

阿里云镜像服务上

1、登录阿里云

2、找到容器镜像服务

3、创建命名空间

4、创建容器镜像

创建本地仓库：

5、浏览阿里云，参考官方文档

docker login --username=aliyun** registry.cn-heyuan.aliyuncs.com
docker tag [ImageId] registry.cn-heyuan.aliyuncs.com/heze-test/heze-test01:[镜像版本号]
docker push registry.cn-heyuan.aliyuncs.com/heze-test/heze-test01:[镜像版本号]

两种方式：Docker Hub / 阿里云

小结

12、Docker网络

理解Docker0

清空所有环境！

测试

三个网络

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

# [root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker run -d -P --name tomcat01 tomcat

# 打开容器ip信息，出现如下错误，这是最新版tomcat里面缺少东西导致的，所以需要安装东西，或者降低版本到tomcat7
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# docker inspect tomcat01
"Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "1e5a6102ef6305964694edb8a05ef47fdafdf71404b29b003fb6ce290bb14e4c",
                    "EndpointID": "3de70906b788764c076074be9d5f0634592e944f2f37c8eaf301ac2d48d436ab",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.3",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:03",
                    "DriverOpts": null
                }

# 思考，linux 能不能ping通容器内部！
[root@iZf8z6tlihyt1tfjeoklzqZ ~]# ping 172.17.0.3
PING 172.17.0.3 (172.17.0.3) 56(84) bytes of data.
64 bytes from 172.17.0.3: icmp_seq=1 ttl=64 time=0.079 ms
64 bytes from 172.17.0.3: icmp_seq=2 ttl=64 time=0.055 ms
64 bytes from 172.17.0.3: icmp_seq=3 ttl=64 time=0.049 ms

# linux 可以ping通docker容器内部

原理

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

1、再次测试 ip addr

2、再启动一个容器测试，发现又多了一堆网卡！

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

3、测试可得tomcat02和tomcat03能ping通

结论：tomcat01和tomcat02是公用的一个路由器，docker0.

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

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

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

–link

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

# 通过--link可以解决网络连通的问题
docker run -d -P --name tomcat03 --link tomcat02 tomcat

# 可以ping通
docker exec -it tomcat03 ping tomcat02

# 反向可以ping通么（不可以）
docker exec -it tomcat02 ping tomcat03

探究：inspect

其实这个tomcat03就是在本地配置了tomcat02的配置？

本质探究：–link就是我们在hosts配置中增加一个172.18.0.3 tomcat02 312857784cd4

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

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

自定义网络（容器互联）

查看所有的docker网络

网络模式

bridge：桥接 docker 搭桥 相当于中介（默认）

none：不配置网络

host：和宿主机共享网络

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

测试

# 我们直接启动的命令 默认省略--net 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.168.0.1 mynet

我们自己的网络就创建好了！

# docker run -d -P --name tomcat-net-01 --net mynet tomcat

再次测试ping连接

现在不使用–link也可以ping名字了！

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

好处：

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

网络连通

# 测试打通，tomcat01 - mynet （不同网络与网络不能打通，但是容器和网络能够打通）
docker network connect mynet tomcat02
docker network connect mynet tomcat03

# 连通后就是将tomcat01 放到了 mynet网络下

# 一个容器两个ip地址，公网ip，私网ip

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

Redis集群部署实战

shell脚本！

# 创建网卡
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

# 启动6个redis服务
docker run -p 6371:6379 -p 16371:16379 --name redis-1 \
-v /mydata/redis/node-1/data:/data \
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6372:6379 -p 16372:16379 --name redis-2 \
-v /mydata/redis/node-2/data:/data \
-v /mydata/redis/node-2/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6373:6379 -p 16373:16379 --name redis-3 \
-v /mydata/redis/node-3/data:/data \
-v /mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6374:6379 -p 16374:16379 --name redis-4 \
-v /mydata/redis/node-4/data:/data \
-v /mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6375:6379 -p 16375:16379 --name redis-5 \
-v /mydata/redis/node-5/data:/data \
-v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6376:6379 -p 16376:16379 --name redis-6 \
-v /mydata/redis/node-6/data:/data \
-v /mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

# 创建集群配置
/data # 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 --cl
uster-replicas 1
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 172.38.0.15:6379 to 172.38.0.11:6379
Adding replica 172.38.0.16:6379 to 172.38.0.12:6379
Adding replica 172.38.0.14:6379 to 172.38.0.13:6379
M: 6422e43f4a95f9e749405719f06e5616717dcb80 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
M: ab4a4dea4531a4ad94420147f78239f3e4c051a3 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: 60086435810205414218fb7364412e9e03da6780 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: aac7911e88b12f64bdb9200dd56bc587bc250ff4 172.38.0.14:6379
   replicates 60086435810205414218fb7364412e9e03da6780
S: ebda218f98faa05ab6f873ec0a03c931d25a472a 172.38.0.15:6379
   replicates 6422e43f4a95f9e749405719f06e5616717dcb80
S: e75cbfb3cf4bccd38b195a7e7170a9d9c8a365c6 172.38.0.16:6379
   replicates ab4a4dea4531a4ad94420147f78239f3e4c051a3
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
..
>>> Performing Cluster Check (using node 172.38.0.11:6379)
M: 6422e43f4a95f9e749405719f06e5616717dcb80 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: e75cbfb3cf4bccd38b195a7e7170a9d9c8a365c6 172.38.0.16:6379
   slots: (0 slots) slave
   replicates ab4a4dea4531a4ad94420147f78239f3e4c051a3
S: aac7911e88b12f64bdb9200dd56bc587bc250ff4 172.38.0.14:6379
   slots: (0 slots) slave
   replicates 60086435810205414218fb7364412e9e03da6780
M: ab4a4dea4531a4ad94420147f78239f3e4c051a3 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
M: 60086435810205414218fb7364412e9e03da6780 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: ebda218f98faa05ab6f873ec0a03c931d25a472a 172.38.0.15:6379
   slots: (0 slots) slave
   replicates 6422e43f4a95f9e749405719f06e5616717dcb80
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

# 集群配置完毕

现在删除第三个redis服务，看看从机能不能变成主机，实现从机替代主机成为master

看到redis-3由master变成fail宕机，redis-4由之前的slave变成master。docker搭建redis集群完成！

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

13、SpringBoot微服务打包Docker镜像

1、构架SpringBoot项目

2、打包应用

3、编写dockerfile

4、构建镜像

5、发布运行！

jar包生成在target下面！

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

到了这里，我们已经完全够用了！

如果有很多镜像，100个镜像？就需要以下扩展学习了！

• Docker Compose
• Docker Swarm
• CI/CD之Jenkins

14、总结

我们从docker是什么，能干嘛，组成，运行原理，和常用命令学习了基本使用docker的方法，再从镜像容器，数据卷以及dockerfile和网络进行延伸，并结合我们在学习过程中进行实质性的测试，亲手感受这个过程，打包上传镜像等。这一系列的操作内容还是很多，但是同样也扩展了很多的思维和认知，了解使用及简单原理，记录笔记以供复习和分享。