docker

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

文档地址：https://docs.docker.com/

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

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

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

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

基础

docker概述

为什么会出现docker？

一套产品：开发（开发，应用环境）和上线（运维，应用配置），两套环境。

问题：我在电脑上可以运行！版本更新，导致服务不可用，对于运维来说，考验十分大。

开发项目的时候，能不能把带上环境一起安装打包！

传统：开发jar，其他的运维来做！java – apk – 发布（应用商店）–张三使用apk – 安装可用

现在：开发打包部署上线，一套流程做完：java – jar（环境）-- 打包项目带上环境（镜像）-- （docker仓库：商店） – 下载我们发布的镜像 – 直接运行即可

docker为以上问题，提出了解决方案。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VKt2Zgwt-1638600226468)(docker.assets/1637939351697.png)]

docker的思想源于集装箱。

隔离：docker思想核心，打包装箱，每个箱子相互隔离

docker通过隔离机制，可以将服务器利用到极致。

docker历史

2010年，几个搞IT的年轻人，在美国成立了一家公司dotCloud，做一些pass的云计算服务，LXC有关的容器技术，他们将自己的技术（容器化技术）命名，就是docker！

Docker刚刚诞生的时候，没有引起行业的注意，就活不下去！

所以开源，开发源代码！

2013年，Docker开源！越多越多的人发现docker的优点。火了，Docker每个月都会更新一个版本！

2014年4月9日，Docker1.0发布！

Docker为什么这么火？

十分轻巧！在容器技术出来之前，我们都是使用虚拟化技术！

虚拟机也是虚拟化技术，Docker容器技术，也是一种虚拟化技术。

虚拟机：在window上装一个Vmware，虚拟出一个或多个电脑，十分笨重。

vm：linux centos原生镜像(一台电脑) 隔离：需要开启多个虚拟机，几分钟（大小至少几个G）
docker：隔离，镜像（最核心的环境），十分小巧，运行镜像就可以了！启动时间十分快，几秒（大小可以是几个M，甚至是kB级别的）。

所以：所有的开发人员都必须会Docker！

docker能干什么？

虚拟机技术缺点：

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

容器化技术：

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

docker和虚拟机技术的不同：

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

DevOps（开发，运维）

应用更快的交付和部署

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

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

更便捷升级和扩缩容

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

更简单系统运维

  • 用来容器化技术之后，我们的开发，测试环境都是高度一致的

更高效的计算资源利用：

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

docker 安装

docker的基本组成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ab4aDjDt-1638600226469)(docker.assets/6.jfif)]

镜像（image）：

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

容器（container）：

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

启动，停止，删除，基本命令

仓库（repository）：

仓库就是存放镜像的地方！仓库分为共有仓库和私有仓库！

Docker Hub（默认是国外的），阿里云…都有容器服务器（配置镜像加速）

安装

启动

systemctl start docker：启动

systemctl stop docker：关闭（停止）

systemctl status docker：查看状态

查看是否安装成功

docker version：查看docker的版本（docker启动之后）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-699EPY8M-1638600226469)(docker.assets/image-20211127210552054-16380183547091.png)]

测试

# hello-world
docker run Hello World /bin/bash

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LHY3xtjZ-1638600226469)(docker.assets/image-20211127210513532.png)]

安装成功！仅此而已！

# 查看一下下载的hello-world镜像
docker images

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ubwMW4FX-1638600226470)(docker.assets/image-20211127210918489.png)]

了解:卸载docker

# 卸载依赖
yum remove docker-ce docker-ce-cli containerd.io

# 删除资源
# /var/lib/docker 是docker的默认工作路径
rm -rf /var/lib/docker

阿里云镜像加速

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N664Pckp-1638600226470)(docker.assets/image-20211127235535869.png)]

2, 找到镜像加速地址

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FK7ordXV-1638600226471)(docker.assets/image-20211127235920233.png)]

3, 配置使用

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

配置完毕!

docker run的工作原理:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DH33aX7L-1638600226472)(docker.assets/image-20211129211744232-16381918660793.png)]

底层原理

Docker是怎么工作的?

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

DockerServer 接收 Docker-Client 的指令,就会执行这个命令!

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hps5NQeb-1638600226473)(docker.assets/image-20211129212029919.png)]

Docker为什么比Vm快?

1, Docker有着笔虚拟机更少的抽象层

2, docker 利用的是宿主机的内核,vm 需要 虚拟机操作系统(Guest OS), docker不需要安装虚拟机操作系统(Guest OS), 避免引导(就是加载虚拟机操作系统(Guest OS)), docker 是利用宿主机的操作系统, 省略了这个复杂的过程.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-84lPpvHu-1638600226473)(docker.assets/image-20211128002059985.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ywl0YtFp-1638600226474)(docker.assets/image-20211128002821835.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x6RyjAuH-1638600226474)(docker.assets/image-20211128002835647.png)]

docker常用命令

帮助命令

docker version	# 显示docker的版本信息
docker info		# 显示docker更加详细的信息(系统信息,包括镜像和容器的数量)
docker 命令 --help	 # 帮助命令

命令帮助文档:https://docs.docker.com/reference/

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fRaEAH76-1638600226474)(docker.assets/image-20211128003652823.png)]

镜像命令

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sVzWKKen-1638600226475)(docker.assets/image-20211128004257777.png)]

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

参数:
-a --all		# 列出所有的镜像
-q --quiet		# 只显示镜像的id
2）、docker search 搜索镜像

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OQ4G9Q3O-1638600226475)(docker.assets/image-20211128005022741.png)]

参数:通过搜藏来过滤
 --filter=STARS=3000		# 搜索出来的镜像就是STARS大于3000的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V5p89J7E-1638600226476)(docker.assets/image-20211128005535524.png)]

3）、docker pull 下载镜像

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lkxQxnhb-1638600226476)(docker.assets/image-20211128005905252.png)]

docker pull 镜像名[:tag]		# 下载指定的版本
4）、docker rmi 镜像 删除镜像
docker rmi -f 容器id		# 删除指定的容器

docker rmi -f 容器id 容器id ... 容器id		# 删除多个容器

docker rmi -f ${docker images -aq}		# 删除所有的镜像

通过id删除镜像

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-stpVci8h-1638600226477)(docker.assets/image-20211128011115836.png)]

容器命令

有了镜像才可以创建容器，下载一个centos镜像来测试学习

docker pull centos
docker run [可选参数] image ：新建容器并启动

后台启动：docker run -d 容器名

参数说明：

​ --name=“Name” # 容器名字 tomcat01 tomcat02 用于区分容器
​ -d # 后台方式运行
​ -it # 使用交互方式运行，进入容器查看内容
​ -P # 指定容器的端口：三种方式
​ -P ip 主机端口：容器端口
​ -P 主机端口：容器端口
​ -P 容器端口
​ 容器端口
​ -p # 随机指定端口

[hadoop@localhost ~]$ docker run -it centos		# 启动并进入centos容器
[root@318be26b34ea /]# ls
bin  etc   lib    lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
[root@318be26b34ea /]# exit		# 从容器退出到主机
exit
列出所有运行的容器

docker ps [可选参数] # 列出当前正在运行的容器

参数说明：

-a ：列出当前正在运行的容器 + 历史运行过的容器

-n=？：显示最近创建的容器

-q：只显示容器的编号

[hadoop@localhost ~]$ docker ps			# 列出所有运行的容器
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[hadoop@localhost ~]$ docker ps -a		# 列出所有运行过的容器
CONTAINER ID   IMAGE          COMMAND       CREATED         STATUS                       PORTS     NAMES
318be26b34ea   centos         "/bin/bash"   6 minutes ago   Exited (0) 3 minutes ago               charming_mendel
退出容器
exit		# 直接停止容器并退出
ctrl+p+Q	# 容器不停止退出
删除容器
docker rm 容器id					# 删除指定容器，不可以删除正在运行的容器，强制删除 rm -f 
docker rm -f $(docker ps -aq)	# 删除全部容器
docker ps -a | xargs docker rm  # 删除全部容器
启动和停止容器的操作
docker start 容器id		# 启动容器
docker restart 容器id		# 重启容器
docker stop 容器id		# 停止当前正在运行的容器
docker kill 容器id		# 强制停止当前正在运行的容器

常用其他命令

后台启动：docker run -d 容器名

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

# 问题：docker ps 发现 centos 停止了，为什么？
# docker容器使用后台运行，就必须要有一个前台进行，如果docker发现没有应用，就会自动停止。
# 容器后台启动后，发现自己没有提供服务，就会立刻停止
查看日志

docker logs -f -t --tail 容器id

-tf # 显示日志

–tail number # 显示日志的参数

# 编写一些shell脚本
[hadoop@localhost ~]$ docker run -d centos /bin/sh -c "while true;do echo kuangshen;sleep 1;done"

# 显示日志
[hadoop@localhost ~]$ docker logs -tf --tail 10 b8f367213e1d		# 显示10条日志

[hadoop@localhost ~]$ docker logs -tf b8f367213e1d		# 显示所有日志
查看容器中的进程信息

docker top 容器id

[hadoop@localhost ~]$ docker top 20e48848a779
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                431082              431064              0                   21:07               pts/0               00:00:00            /bin/bash
查看镜像的源数据

docker inspect 容器id

[hadoop@localhost ~]$ docker inspect 20e48848a779
[
    {
        "Id": "20e48848a77926fb8750b35945c97e5ce0f7888845477bb3d2562ec997c6b3f4",
        "Created": "2021-11-28T13:07:51.701255822Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 431082,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2021-11-28T13:07:52.057112654Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/20e48848a77926fb8750b35945c97e5ce0f7888845477bb3d2562ec997c6b3f4/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/20e48848a77926fb8750b35945c97e5ce0f7888845477bb3d2562ec997c6b3f4/hostname",
        "HostsPath": "/var/lib/docker/containers/20e48848a77926fb8750b35945c97e5ce0f7888845477bb3d2562ec997c6b3f4/hosts",
        "LogPath": "/var/lib/docker/containers/20e48848a77926fb8750b35945c97e5ce0f7888845477bb3d2562ec997c6b3f4/20e48848a77926fb8750b35945c97e5ce0f7888845477bb3d2562ec997c6b3f4-json.log",
        "Name": "/hardcore_davinci",
        "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/c500acec3af70f1e291b8d4868dfc1eb7981ef772f171a768c105c63e6ab82d4-init/diff:/var/lib/docker/overlay2/f96d7136b96fd89badf04b130361a27c676fa5bebc3315ba3e6aff331ea42e5f/diff",
                "MergedDir": "/var/lib/docker/overlay2/c500acec3af70f1e291b8d4868dfc1eb7981ef772f171a768c105c63e6ab82d4/merged",
                "UpperDir": "/var/lib/docker/overlay2/c500acec3af70f1e291b8d4868dfc1eb7981ef772f171a768c105c63e6ab82d4/diff",
                "WorkDir": "/var/lib/docker/overlay2/c500acec3af70f1e291b8d4868dfc1eb7981ef772f171a768c105c63e6ab82d4/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "20e48848a779",
            "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": "9772e7754d8f1736e7253474c390530ab576398a1b53fb6f9030ead17cd0f71a",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/9772e7754d8f",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "63a193f8e33e905604a83071cb80e40673e7149b02c4e3fbeb70b2fc700ac5a3",
            "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": "dd76ed4eeddb894f5bb8b7d183bba2fdbf00c0de182144ae415004133b2bae8f",
                    "EndpointID": "63a193f8e33e905604a83071cb80e40673e7149b02c4e3fbeb70b2fc700ac5a3",
                    "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 /bin/bash # 进入指定的容器的命令行

[hadoop@localhost ~]$ docker exec -it 20e48848a779 /bin/bash
[root@20e48848a779 /]#
  • 方式二

docker attach 容器id

[hadoop@localhost ~]$ docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS          PORTS     NAMES
20e48848a779   centos    "/bin/bash"   14 minutes ago   Up 14 minutes             hardcore_davinci
[hadoop@localhost ~]$ docker attach 20e48848a779
[root@20e48848a779 /]#

区别：

  • docker exec # 进入容器后开启一个新的终端，可以在里面操作（常用）
  • docker attach # 进入容器正在执行的终端，不会启动新的进程
从容器内拷贝文件到主机上

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

[hadoop@localhost simple]$ ls
[hadoop@localhost simple]$ docker cp 20e48848a779:/home/test.java /home/hadoop/simple		# 无论容器是否运行都可以拷贝出来
[hadoop@localhost simple]$ ls
test.java
图解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CJzU9nBJ-1638600226478)(docker.assets/image-202111292118303.png)]

实践

实践一：部署Nginx

Docker 安装 Nginx

第一步：搜索镜像（也可以去docker上搜索）；

  • docker search nginx

第二步：下载镜像；

  • docker pull nginx
# 启动nginx
# -d：后台运行
# -name：给容器命名
# -p：宿主机端口 容器内部端口
[hadoop@localhost simple]$ docker run -d --name nginx01 -p 3344:80 nginx
5cd4db78bbbe676797cf6460eac15c408e255c9c0374f20bd76750f1a95176ea
# 查看所有容器
[hadoop@localhost simple]$ docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                                   NAMES
5cd4db78bbbe   nginx     "/docker-entrypoint.…"   5 seconds ago   Up 4 seconds   0.0.0.0:3344->80/tcp, :::3344->80/tcp   nginx01
# 运行测试
[hadoop@localhost simple]$ 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>

# 进入nginx
[hadoop@localhost simple]$ docker exec -it nginx01 /bin/bash
# 查看nginx配置
root@5cd4db78bbbe:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@5cd4db78bbbe:/# cd /etc/nginx
root@5cd4db78bbbe:/etc/nginx# ls
conf.d  fastcgi_params  mime.types  modules  nginx.conf  scgi_params  uwsgi_params
root@5cd4db78bbbe:/etc/nginx#

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3n4HrnJM-1638600226478)(docker.assets/image-20211129212126583.png)]

实践二：部署tomcat

# 官方使用：
docker run -it --rm tomcat		# 用完之后直接删除，一般用来测试（docker run如果本地没有容器，会直接下载）

# 下载tomcat
docker pull tomcat
# 启动运行
docker run -d -p 3355:8080 --name tomcat01 tomcat

# 测试访问没问题
# 进入容器
docker exec -it tomcat01 /bin/bash
# 发现问题。1、linux命令少了，2、没有webapps
# 原因：默认是最小的镜像，保证最小可运行的环境！所有不必要的都剔除了
# 解决方案：webapps的不必要文件放置在webapps.dist中，将webapps.dist目录下的文件复制或移动到webapps目录下就可以了。

实践三：部署es+kibana

es 暴露的端口很多

es 十分耗内存

es 的数据一般需要放置到安全目录！挂载

# 下载启动
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2
# 启动后虚拟机会很卡（es 十分耗内存）

# 查看状态 docker stats
[hadoop@localhost ~]$ docker stats
# 测试一下es
[hadoop@localhost ~]$ curl localhost:9200
{
  "name" : "7c531115cf17",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "Oz-YByqXRSK-nP2czHhaqQ",
  "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"
}
# 关闭
[hadoop@localhost ~]$ docker stop 7c531115cf17

加上内存限制，修改配置 -e 环境配置修改

-e ES_JAVA_OPTS="-Xms64m -Xmx512m" ：占用内存最大，最小

# 加上内存限制，修改配置  -e 环境配置修改
docker run -d --name elasticsearch02 -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2
[hadoop@localhost ~]$ curl localhost:9200
{
  "name" : "d7d201104598",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "KLIuNNpfRqmeJuOIwkpwhg",
  "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"
}
[hadoop@localhost ~]$

作业4：用kibana连接es

可视化：portainer

  • portainer(先用这个)

  • Rancher(使用CI/CD的时候再用)

什么是portainer？

portainer是Docker的界面管理工具！提供一个后台面板供我们操作

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

访问测试：外网：8080

可以通过它来访问

Docker镜像讲解

镜像是什么

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

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

如何得到镜像：

  • 远程仓库下载
  • 朋友copy给你
  • 自己制作一个镜像DockerFile

Docker镜像加载原理

UnionFS(联合文件系统)

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

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

Docker镜像加载原理

docker 的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BRLjEPwG-1638600226479)(docker.assets/image-20211129211609469-16381917707022.png)]

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EMfZJCal-1638600226479)(docker.assets/20190522121705397.png)]

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

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

分层理解

分层的镜像

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iq83elWm-1638600226480)(docker.assets/image-20211129212411203-16381922541965.png)]

[hadoop@localhost ~]$ docker image inspect redis:latest
[
    {
        "Id": "sha256:40c68ed3a4d246b2dd6e59d1b05513accbd2070efb746ec16848adc1b8e07fd4",
        "RepoTags": [
            "redis:latest"
        ],
        "RepoDigests": [
            "redis@sha256:619af14d3a95c30759a1978da1b2ce375504f1af70ff9eea2a8e35febc45d747"
        ],
        "Parent": "",
        "Comment": "",
        "Created": "2021-11-17T23:55:32.992203883Z",
        "Container": "204dce7042f7d9b9ddfe3166f1fb31ab9e6796e9f85a61add0d162fa1b2af1d5",
        "ContainerConfig": {
            "Hostname": "204dce7042f7",
            "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:f68fe14ac3ec56717680e0a1e8562ba7ec42aabcc9626615012304e2f18c5a84",
            "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:f68fe14ac3ec56717680e0a1e8562ba7ec42aabcc9626615012304e2f18c5a84",
            "Volumes": {
                "/data": {}
            },
            "WorkingDir": "/data",
            "Entrypoint": [
                "docker-entrypoint.sh"
            ],
            "OnBuild": null,
            "Labels": null
        },
        "Architecture": "amd64",
        "Os": "linux",
        "Size": 112713219,
        "VirtualSize": 112713219,
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/54f75801057275ab5c8db9dfcd21c55ec357c72b3a47d0b6227a5c6a0fca52ea/diff:/var/lib/docker/overlay2/3aacbdae1ac705ba5eb19e97cfc3ba7d9028998132092367311a0e0de4a46948/diff:/var/lib/docker/overlay2/a132c57b6254d0f24361b1c7b26463a9950a9177b0acf394814ac87790086ba6/diff:/var/lib/docker/overlay2/744e9c8bb45e8e241423545768e200c7911022042987f2dc74c6d3ab7e1147ff/diff:/var/lib/docker/overlay2/fc574c7d2ca7560be148f538360bc1b22dec9b6c1848aa3ad1d5532f8db148b2/diff",
                "MergedDir": "/var/lib/docker/overlay2/46518390068acc2e5b5cb373a3a897b30e17a6ef04abd5c6427a667d8de8246a/merged",
                "UpperDir": "/var/lib/docker/overlay2/46518390068acc2e5b5cb373a3a897b30e17a6ef04abd5c6427a667d8de8246a/diff",
                "WorkDir": "/var/lib/docker/overlay2/46518390068acc2e5b5cb373a3a897b30e17a6ef04abd5c6427a667d8de8246a/work"
            },
            "Name": "overlay2"
        },
        "RootFS": {
            "Type": "layers",
# 文件记录
            "Layers": [
                "sha256:e1bbcf243d0e7387fbfe5116a485426f90d3ddeb0b1738dca4e3502b6743b325",
                "sha256:58e6a16139eebebf7f6f0cb15f9cb3c2a4553a062d2cbfd1a782925452ead433",
                "sha256:503a5c57d9786921c992b7b2216ae58f69dcf433eedb28719ddea3606b42ce26",
                "sha256:277199a0027e044f64ef3719a6d7c3842e99319d6e0261c3a5190249e55646cf",
                "sha256:d0d567a1257963b9655dfceaddc76203c8544fbf6c8672b372561a3c8a3143d4",
                "sha256:a7115aa098139866d7073846e4321bafb8d5ca0d0f907a3c9625f877311bee7c"
            ]
        },
        "Metadata": {
            "LastTagTime": "0001-01-01T00:00:00Z"
        }
    }
]

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

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

特点

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

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

所有用户的操作基于容器层

如何提交一个自己的镜像？

Commit：提交镜像

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

实战：

# 第一步：
# 启动一个默认的tomcat
[hadoop@localhost ~]$ docker run -it -p 8080:8080 tomcat

[hadoop@localhost ~]$ docker ps
CONTAINER ID   IMAGE     COMMAND             CREATED         STATUS         PORTS                                       NAMES
adf4e36458f4   tomcat    "catalina.sh run"   8 minutes ago   Up 8 minutes   0.0.0.0:8080->8080/tcp, :::8080->8080/tcp   focused_johnson

# 第二步：
# 默认的tomcat没有webapps应用，镜像的原因
# 自己拷贝进去基本的文件
# 将操作过的容器通过commit提交为一个镜像，我们以后就使用修改过的镜像即可。
···省略

# 第三步：
# 将修改的镜像提交
[hadoop@localhost ~]$  docker commit -a="test" -m="add webapps" adf4e36458f4 tomcat02:1.0
sha256:0136008ee22f3e70443ab3af15b6f90ee7d5e001059f87d7134123dd5720f135

# 第四步：
# 查看镜像;tomcat02就是我们自己修改的镜像
[hadoop@localhost ~]$ docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
tomcat02              1.0       0136008ee22f   8 seconds ago   684MB
tomcat                latest    904a98253fbf   10 days ago     680MB
redis                 latest    40c68ed3a4d2   11 days ago     113MB
nginx                 latest    ea335eea17ab   12 days ago     141MB
centos                latest    5d0da3dc9764   2 months ago    231MB
portainer/portainer   latest    580c0e4e98b0   8 months ago    79.1MB
elasticsearch         7.6.2     f29a1ee41030   20 months ago   791MB

如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像，就好比学习VM的时候的快照。

到了这里才算入门！！！

容器数据卷

什么是容器数据卷

程序要保存数据？如果数据都在容器中，容器删除，数据就会丢失。需求：数据可以持久化

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

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

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

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

挂载方式（两种）

方法一，使用数据卷

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

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

相当于 主机的目录 和 容器的目录 公用一个目录

# 挂载
[hadoop@localhost simple]$ docker run -it -v /home/hadoop/simple:/home centos /bin/bash
# 启动后，我们可以查看挂载
[hadoop@localhost simple]$ docker inspect 19a873e8ccec

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mm5FOzda-1638600226481)(docker.assets/image-20211129232542916.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cJiiFVhn-1638600226481)(docker.assets/image-20211129231749338.png)]

挂载的主机上的容器目录的文件会直接同步到主机的目录下。

  • 容器目录下的增删改数据会同步到主机的目录下
  • 同理，主机目录下增删改数据也会同步到容器目录下

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

实战：MySQL

# 获取镜像
[hadoop@localhost simple]$ docker pull mysql:5.7

# 运行mysql容器，挂载数据
# 注意：安装配置MySQL，需要配置密码 
# 官方测试：docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=密码 -d myslq:tag

# 挂载两个目录：	/home/hadoop/mysql/conf:/etc/mysql/conf.d 
#				 /home/hadoop/mysql/data:/var/lib/mysql
# 设置密码：-e MYSQL_ROOT_PASSWORD=123456
[hadoop@localhost ~]$ docker run -d -p 3310:3306 -v /home/hadoop/mysql/conf:/etc/mysql/conf.d -v /home/hadoop/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
# -d：后台运行
# -p：端口映射
# -v：数据卷挂载
# -e：环境配置
# --name：容器名字

哪怕mysql容器删了，数据依然保存在本地，没有丢失。这就实现了数据持久化功能！

具名挂载和匿名挂载

匿名挂载

-v 容器内路径

# 匿名挂载
[hadoop@localhost data]$ docker run -d -P --name nginx02 -v /ect/nginx nginx
# 查看所有的 volume 的情况
[hadoop@localhost data]$ docker volume ls
DRIVER    VOLUME NAME
local     3829378eb864173516eb635d44b7068052dc875c96c276e52c3baebcdc0c014f
local     c7715edff6073a406f1c7bd15cbac1a1e1fe33cfcef1862666221e4b3f68838b
# 这里就是匿名挂载，我们只写了容器内的路径，没有写容器外的路径

具名挂载

-v 卷名: 容器内的路径

[hadoop@localhost data]$ docker run -d -P --name nginx02 -v /ect/nginx nginx
551ba73f33179e53c4b031df31c6d6346418eb5bdb08e0ee0faa1869b8241cd8
[hadoop@localhost data]$ docker volume ls
DRIVER    VOLUME NAME
local     3829378eb864173516eb635d44b7068052dc875c96c276e52c3baebcdc0c014f
local     c7715edff6073a406f1c7bd15cbac1a1e1fe33cfcef1862666221e4b3f68838b
[hadoop@localhost data]$ docker run -d -P --name nginx03 -v juming-nginx:/ect/nginx nginx
954ce4587e18a09ad195514af317a90ded27c764d32146649dfb9bb9104b3c5c
[hadoop@localhost data]$ docker volume ls
DRIVER    VOLUME NAME
local     3829378eb864173516eb635d44b7068052dc875c96c276e52c3baebcdc0c014f
local     c7715edff6073a406f1c7bd15cbac1a1e1fe33cfcef1862666221e4b3f68838b
local     juming-nginx
[hadoop@localhost data]$

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8ftHrcEC-1638600226481)(docker.assets/image-20211130202230383.png)]

查看挂载的位置

docker volume inspect 卷名

[hadoop@localhost data]$ docker volume inspect juming-nginx
[
    {
        "CreatedAt": "2021-11-30T20:19:25+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
        "Name": "juming-nginx",
        "Options": null,
        "Scope": "local"
    }
]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vn8rGDKP-1638600226482)(docker.assets/image-20211130203125885.png)]

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

如何确定是具名挂载，匿名挂载还是指定路径挂载

  • -v 容器内路径 # 匿名挂载
  • -v 卷名:容器内路径 # 具名挂载
  • -v /宿主机路径:容器内路径 # 指定路径挂载

扩展

# -v 挂载方式:ro rw 改变读写权限
# ro:readonly 只读
# rw:readwrite 可读可写

# 一旦设置了容器权限，容器对我们挂载出来的内容就有限定了（对于容器而言）！
[hadoop@localhost lib]$ docker run -d -P --name nginx01 demo:/etc/nginx:ro nginx
# ro 只要看到ro就说明这个路径只能通过宿主机来操作，容器内部是无法操作的！

方法二，初始DockerFile

DockerFile 就是用来构建 docker镜像的构建文件！命令脚本！

写一个脚本，生成一个镜像。镜像是一层一层的，脚本是一个个的命令，每个命令就是一层

步骤：

  • 创建一个dockerfile文件，名字可以随意，建议使用dockerfile
  • 文件中的内容 指令（大写） 参数
[hadoop@localhost docke-test-volume]$ vim dockerfile
	# 每一个命令，就是镜像的一层
	FROM centos
	VOLUME ["volume01","volume02"]
	CMD echo "====end==="
	CMD /bin/bash
[hadoop@localhost docke-test-volume]$ docker build -f /home/hadoop/docke-test-volume/dockerfile01 -t kuangshen/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 4606f939d65e
Removing intermediate container 4606f939d65e
 ---> ac41ca12aae5
Step 3/4 : CMD echo "====end==="
 ---> Running in 7282c25a9eb6
Removing intermediate container 7282c25a9eb6
 ---> 027f3902fd86
Step 4/4 : CMD /bin/bash
 ---> Running in 309c0d5305fb
Removing intermediate container 309c0d5305fb
 ---> 38a01741128c
Successfully built 38a01741128c
Successfully tagged kuangshen/centos:1.0
[hadoop@localhost docke-test-volume]$

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cIW4vbpn-1638600226482)(docker.assets/image-20211130214331358.png)]

# 启动自己写的容器
[hadoop@localhost docke-test-volume]$ docker run -it 38a01741128c /bin/bash
[root@dc8dcfd9cbdd /]# ls
bin  etc   lib    lost+found  mnt  proc  run   srv  tmp  var       volume02
dev  home  lib64  media       opt  root  sbin  sys  usr  volume01
[root@dc8dcfd9cbdd /]#

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nHyaHy7D-1638600226482)(docker.assets/image-20211130215111066.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ADQhxNcI-1638600226483)(docker.assets/image-20211130215313251.png)]

# 通过docker inspect查看镜像信息（挂载路径）
[hadoop@localhost docke-test-volume]$ docker inspect 4310b9f85d32
# 查看挂载目录
[hadoop@localhost docke-test-volume]$ sudo ls /var/lib/docker/volumes/f95fab034f632a4e8a9cba11a67134d6171c6d61f473ac3f69595bdeb03cc6aa/_data
demo01
[hadoop@localhost docke-test-volume]$

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7M3tNVZE-1638600226483)(docker.assets/image-20211130215727794.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FmezWaT0-1638600226483)(docker.assets/image-20211130220053295.png)]

这个挂载方式未来用的十分多。

数据容器卷

实现多个容器之间实现数据共享。–volumes-from

多个mysql同步数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FU0FeYl4-1638600226484)(docker.assets/image-20211130225155036.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oICTlY1j-1638600226484)(docker.assets/image-20211130231741383.png)]

[hadoop@localhost ~]$ docker run -it --name docker01 kuangshen/centos:1.0
# docker01链接docker02
[hadoop@localhost ~]$ docker run -it --name docker02 --volumes-from docker01 kuangshen/centos:1.0
# 在docker01挂载目录下创建的文件可以直接同步到docker02挂载的目录下
# 同理，创建的其他容器也可以同步

[hadoop@localhost ~]$ docker run -it --name docker01 kuangshen/centos:1.0

[hadoop@localhost ~]$ docker run -it --name docker02 --volumes-from docker01 kuangshen/centos:1.0

[hadoop@localhost ~]$ docker run -it --name docker03 --volumes-from docker01 kuangshen/centos:1.0

测试：删除docker01，查看docker02和docker03是否还可以实现文件共享？

结果：可以

容器卷机制，是一种备份机制。容器之间是相互拷贝的概念！

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

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

DockerFile介绍

dockerfile的核心是用来构建docker镜像的！dockerfile是一个命令参数脚本！

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

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

1，编写一个dockerfilewenjian

2，docker build 构建成为一个镜像

3，docker run 运行镜像

4，docker pull 发布镜像（可以发布到DockerHub或阿里云镜像仓库！）

DockerFile构建过程

基础知识：

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r1Bit01F-1638600226485)(docker.assets/image-20211201164923581.png)]

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

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

步骤：开发，部署，运维：缺一不可！

  • Dockerfile：构建文件，定义了一切的步骤，源代码
  • DockerImages：通过Dockerfile构建生成的镜像，最终发布和运行的产品，原来是jar包，war包
  • Docker容器：容器就是镜像运行起来提供服务的

DockerFile的指令

以前我们都是使用别人的，现在我们知道了这些指令，就可以自己搭建镜像！

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-INo0JFyy-1638600226485)(docker.assets/image-20211201165933399.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0V0nyrw0-1638600226485)(docker.assets/image-20211201165856427.png)]

实战测试：构建centos

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

创建一个自己的centos

# 编写DockerFile文件
[hadoop@localhost dockerfile]$ vim mydockerfile-centos 
	FROM centos
	MAINTAINER xie<2012324892@qq.com>

	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
	
# 通过这个文件构建镜像
# 命令 docker build -f dockerfile文件路径 -t 镜像名:[tag] .
[hadoop@localhost dockerfile]$ docker build -f mydockerfile-centos -t mycentos:0.1 .
Sending build context to Docker daemon  2.048kB
Step 1/10 : FROM centos
 ---> 5d0da3dc9764
Step 2/10 : MAINTAINER xie<2012324892@qq.com>
 ---> Using cache
 ---> 07d4363feda1
Step 3/10 : ENV MYPATH /usr/local
···
Successfully built 5fe4588163fa
Successfully tagged mycentos:0.1

# 运行
[hadoop@localhost dockerfile]$ docker run -it mycentos:0.1
# 进行测试，发现vim 和 ifconfig都可以使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mCKbM7Ph-1638600226486)(docker.assets/image-20211201221635584.png)]

查看docker镜像的变更历史

语法：docker history 镜像id

[hadoop@localhost dockerfile]$ docker history 5fe4588163fa
IMAGE          CREATED          CREATED BY                                      SIZE      COMMENT
5fe4588163fa   6 minutes ago    /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "/bin…   0B        
79e701b24535   6 minutes ago    /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B        
66f53c82eb2c   6 minutes ago    /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B        
b5b4856917c2   6 minutes ago    /bin/sh -c #(nop)  EXPOSE 80                    0B

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mdnLaDHg-1638600226486)(docker.assets/image-20211201221935868.png)]

可以用这个命令，研究（官方）镜像是怎么做的

CMD 和 ENTRYPOINT 区别

CMD				# 指定容器启动的时候运行的命令（只有最后一个会生效，可被替代）
ENTRYPOINT		# 指定容器启动的时候运行的命令，可以追加命令
测试CMD
[hadoop@localhost dockerfile]$ vim dockerfile-cmd-test 

FROM centos
CMD ["ls","-a"]

# 构建镜像
[hadoop@localhost dockerfile]$ docker build -f 
dockerfile-cmd-test -t cmdtest .
# 执行，发现命令生效了
[hadoop@localhost dockerfile]$ docker run -it cmdtest
.   .dockerenv  dev  home  lib64       media  opt   root  sbin  sys  usr
..  bin         etc  lib   lost+found  mnt    proc  run   srv   tmp  var
# 想追加一个命令-l，即ls -al
[hadoop@localhost dockerfile]$ docker run -it cmdtest -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:380: starting container process caused: exec: "-l": executable file not found in $PATH: unknown.
# cmd的下 -l 替换了CMD ["ls","-a"] 命令，而不是 ls -al ；所以报错

[hadoop@localhost dockerfile]$ docker run -it cmdtest ls -al
total 0
drwxr-xr-x.   1 root root   6 Dec  1 14:37 .
drwxr-xr-x.   1 root root   6 Dec  1 14:37 ..
-rwxr-xr-x.   1 root root   0 Dec  1 14:37 .dockerenv
lrwxrwxrwx.   1 root root   7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x.   5 root root 360 Dec  1 14:37 dev
drwxr-xr-x.   1 root root  66 Dec  1 14:37 etc
drwxr-xr-x.   2 root root   6 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   6 Sep 15 14:17 lost+found
drwxr-xr-x.   2 root root   6 Nov  3  2020 media
drwxr-xr-x.   2 root root   6 Nov  3  2020 mnt
drwxr-xr-x.   2 root root   6 Nov  3  2020 opt
dr-xr-xr-x. 291 root root   0 Dec  1 14:37 proc
dr-xr-x---.   2 root root 162 Sep 15 14:17 root
drwxr-xr-x.  11 root root 163 Sep 15 14:17 run
lrwxrwxrwx.   1 root root   8 Nov  3  2020 sbin -> usr/sbin
drwxr-xr-x.   2 root root   6 Nov  3  2020 srv
dr-xr-xr-x.  13 root root   0 Dec  1 05:32 sys
drwxrwxrwt.   7 root root 171 Sep 15 14:17 tmp
drwxr-xr-x.  12 root root 144 Sep 15 14:17 usr
drwxr-xr-x.  20 root root 262 Sep 15 14:17 var
测试 ENTRYPOINT
[hadoop@localhost dockerfile]$ vim docker-entrypoint
FROM centos
ENTRYPOINT ["ls","-a"]

[hadoop@localhost dockerfile]$ docker build -f docker-entrypoint -t entrypoint-test .

[hadoop@localhost dockerfile]$ docker run -it entrypoint-test
.   .dockerenv  dev  home  lib64       media  opt   root  sbin  sys  usr
..  bin         etc  lib   lost+found  mnt    proc  run   srv   tmp  var

# 我们追加命令，是直接拼接在 ENTRYPOINT 后面的
[hadoop@localhost dockerfile]$ docker run -it entrypoint-test -l
total 0
drwxr-xr-x.   1 root root   6 Dec  1 14:43 .
drwxr-xr-x.   1 root root   6 Dec  1 14:43 ..
-rwxr-xr-x.   1 root root   0 Dec  1 14:43 .dockerenv
lrwxrwxrwx.   1 root root   7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x.   5 root root 360 Dec  1 14:43 dev
drwxr-xr-x.   1 root root  66 Dec  1 14:43 etc
drwxr-xr-x.   2 root root   6 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   6 Sep 15 14:17 lost+found
drwxr-xr-x.   2 root root   6 Nov  3  2020 media
drwxr-xr-x.   2 root root   6 Nov  3  2020 mnt
drwxr-xr-x.   2 root root   6 Nov  3  2020 opt
dr-xr-xr-x. 293 root root   0 Dec  1 14:43 proc
dr-xr-x---.   2 root root 162 Sep 15 14:17 root
drwxr-xr-x.  11 root root 163 Sep 15 14:17 run
lrwxrwxrwx.   1 root root   8 Nov  3  2020 sbin -> usr/sbin
drwxr-xr-x.   2 root root   6 Nov  3  2020 srv
dr-xr-xr-x.  13 root root   0 Dec  1 05:32 sys
drwxrwxrwt.   7 root root 171 Sep 15 14:17 tmp
drwxr-xr-x.  12 root root 144 Sep 15 14:17 usr
drwxr-xr-x.  20 root root 262 Sep 15 14:17 var
[hadoop@localhost dockerfile]$

Dockerfile中很多命令都是十分相似的，对比学习更有效！

实战：tomcat镜像

1，准备工作

​ 1，准备镜像文件，tomcat压缩包，jdk压缩包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BkfWRHMx-1638600226486)(docker.assets/image-20211201233353493.png)]

​ 2，编写dockerfile文件；官方命令：Dockerfile，会自动寻找这个文件，不需要 -f 指定了

2，编写镜像

[hadoop@localhost test]$  vim Dockerfile
FROM centos
MAINTAINET xie<2012324892@qq.com>

COPY readme.txt /home/hadoop/test/readme.txt

# 自动解压，解压到/usr/local目录下
ADD jdk-8u152-linux-x64.tar.gz /usr/local

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

# 设置java环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_152
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV PATH $PATH:$JAVA_HOME/bin

EXPOSE 8080

CMD /bin/bash

3，构建镜像

[hadoop@localhost test]$ docker build -t java_test .
Sending build context to Docker daemon  189.8MB
Step 1/12 : FROM centos
 ---> 5d0da3dc9764
Step 2/12 : MAINTAINER xie<2012324892@qq.com>
 ---> Using cache
 ---> 07d4363feda1
Step 3/12 : COPY readme.txt /home/hadoop/test/readme.txt
 ---> 9b04f6dc2e2a
Step 4/12 : ADD jdk-8u152-linux-x64.tar.gz /usr/local
 ---> 9ba2716f2da9
···
Successfully built 2c1ee8192565
Successfully tagged java_test:latest

未完成！

发布镜像

发布到Docker Hub

1，需要自己注册一个账号

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

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

[hadoop@localhost test]$ 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
[hadoop@localhost test]$ docker login -u 用户名
Password:

4，登录完了就可以提交镜像了：docker push

# 登录成功后,push镜像
docker push 作者名/镜像名:tag

扩展：

# 修改镜像的名字和tag
docker tag 镜像id 新的镜像名:新的tag

注：发布的镜像尽量带上版本号

​ 提交镜像的时候，也是一层一层的进行提交

发布到阿里云服务上

1，登录阿里云

2，找到容器镜像服务

3，创建命名空间

​ 一个账号最多创建3个命名空间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-idn0EfYK-1638600226487)(docker.assets/image-20211202001634794.png)]

​ 创建成功后

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2D2vfA5a-1638600226487)(docker.assets/image-20211202001730403.png)]

4，创建容器镜像

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GE2m1L9U-1638600226487)(docker.assets/image-20211202001817310.png)]

​ 创建仓库的信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YBQCxrKH-1638600226487)(docker.assets/image-20211202001951457.png)]

5，浏览阿里云

6，上传到阿里云的步骤：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KpeRpQll-1638600226488)(docker.assets/image-20211202002143115.png)]

小结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YLhU2A5l-1638600226488)(docker.assets/image-20211202002516853.png)]

docker save
docker load

Docker网络

理解Docker0

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RFRgORox-1638600226488)(docker.assets/image-20211202200609661.png)]

三个网络，代表三个不同的环境

# 问题：docker 是如何处理容器网络访问的
[hadoop@localhost ~]$ docker run -d -P --name tomcat01 tomcat

# 查看容器内部的网络地址：ip a
[hadoop@localhost ~]$ docker inspect --format='{{.NetworkSettings.IPAddress}}' tomcat01
172.17.0.2

原理

每启动启动一个容器，docker就会给docker容器分配一个ip。只要安装了一个docker，就会有一个网卡docker0。

桥接模式：使用的技术是evth-pair技术！

每启动一个容器，网卡就会多一对

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VlYVXLxl-1638600226489)(docker.assets/image-20211204005627427.png)]

报错

使用docker 出现Error response from daemon: Conflict. The container name “***” is already in use

解决方法：
（1）给容器换一个名字, 比如说 docker run -it --name=mycentos2 centos:7 /bin/bash, 可以解决问题.
（2）将原来的容器删除

查询当前容器：docker container ls -all

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b7b9HRpv-1638600226489)(docker.assets/image-20211130230242659.png)]

删除当前容器：docker container rm mycentos(提示: 这一步要确定删除容器没问题的情况下, 才可以做)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NuQkb2yC-1638600226489)(docker.assets/image-20211130230301025.png)]

docker容器内没有网络

docker容器中没有yum和apt命令

企业用的

.

Options:
-p, --password string Password
–password-stdin Take the password from stdin
-u, --username string Username
[hadoop@localhost test]$ docker login -u 用户名
Password:


4，登录完了就可以提交镜像了：**docker push**

```shell
# 登录成功后,push镜像
docker push 作者名/镜像名:tag

扩展：

# 修改镜像的名字和tag
docker tag 镜像id 新的镜像名:新的tag

注：发布的镜像尽量带上版本号

​ 提交镜像的时候，也是一层一层的进行提交

发布到阿里云服务上

1，登录阿里云

2，找到容器镜像服务

3，创建命名空间

​ 一个账号最多创建3个命名空间

[外链图片转存中…(img-idn0EfYK-1638600226487)]

​ 创建成功后

[外链图片转存中…(img-2D2vfA5a-1638600226487)]

4，创建容器镜像

[外链图片转存中…(img-GE2m1L9U-1638600226487)]

​ 创建仓库的信息

[外链图片转存中…(img-YBQCxrKH-1638600226487)]

5，浏览阿里云

6，上传到阿里云的步骤：

[外链图片转存中…(img-KpeRpQll-1638600226488)]

小结

[外链图片转存中…(img-YLhU2A5l-1638600226488)]

docker save
docker load

报错

使用docker 出现Error response from daemon: Conflict. The container name “***” is already in use

解决方法：
（1）给容器换一个名字, 比如说 docker run -it --name=mycentos2 centos:7 /bin/bash, 可以解决问题.
（2）将原来的容器删除

查询当前容器：docker container ls -all

[外链图片转存中…(img-b7b9HRpv-1638600226489)]

删除当前容器：docker container rm mycentos(提示: 这一步要确定删除容器没问题的情况下, 才可以做)

[外链图片转存中…(img-NuQkb2yC-1638600226489)]

# docker # 容器 # 运维
Logo
Linux

更多推荐

Linux虚拟文件系统之文件系统卸载（sys_umount())

Linux中卸载文件系统由umount系统调用实现，入口函数为sys_umount()。较于文件系统的安装较为简单，下面是具体的实现。1. /*sys_umont系统调用*/2. SYSCALL_DEFINE2(umount, char __user *, name, int, flags)3. {4.struct path path;

avatar Linux

网卡速率和双工模式的配置

http://linux.chinaitlab.com/system/792187.html1、mii-tool 配置网络设备协商方式的工具；    1.1 mii-tool 介绍；    mii-tool - view, manipulate media-independent interface status （mii-tool 是查看，管理介质的网络接口的状态）

avatar Linux

Linux系统下超级终端Minicom的使用方法（例如：连接交换机，路由器等）转http://baike.baidu.com/view/2911642.htm?fr=ala0_1

<br />　　Linux系统下超级终端Minicom的使用方法 <br />　　Linux下的Minicom的功能与下的超级终端功能相似，适于在通过超级终端对设备的管理以及对嵌入操作系统的升级，现写出Minicom的使用手册： <br />　　1． 启动minicom <br />　　以root权限登录系统 <br />　　使用命令 <br />　　minicom –s 则minicom启动，屏

avatar Linux