第八阶段：Linux运维-03Docker入门到精通

LI JS@你猜啊

已于 2022-05-30 16:09:31 修改

阅读量286

点赞数

分类专栏：狂神文章标签：运维 linux docker

于 2022-05-30 10:31:49 首次发布

本文链接：https://blog.csdn.net/m0_45209551/article/details/125040702

版权

狂神专栏收录该内容

9 篇文章 3 订阅

订阅专栏

attach      Attach local standard input, output, and error streams to a running container
#当前shell下 attach连接指定运行的镜像
build       Build an image from a Dockerfile # 通过Dockerfile定制镜像
commit      Create a new image from a container's changes #提交当前容器为新的镜像
cp          Copy files/folders between a container and the local filesystem #拷贝文件
create      Create a new container #创建一个新的容器
diff        Inspect changes to files or directories on a container's filesystem #查看docker容器的变化
events      Get real time events from the server # 从服务获取容器实时时间
exec        Run a command in a running container # 在运行中的容器上运行命令
export      Export a container's filesystem as a tar archive #导出容器文件系统作为一个tar归档文件[对应import]
history     Show the history of an image # 展示一个镜像形成历史
images      List images #列出系统当前的镜像
import      Import the contents from a tarball to create a filesystem image #从tar包中导入内容创建一个文件系统镜像
info        Display system-wide information # 显示全系统信息
inspect     Return low-level information on Docker objects #查看容器详细信息
kill        Kill one or more running containers # kill指定docker容器
load        Load an image from a tar archive or STDIN #从一个tar包或标准输入中加载一个镜像[对应save]
login       Log in to a Docker registry #
logout      Log out from a Docker registry
logs        Fetch the logs of a container
pause       Pause all processes within one or more containers
port        List port mappings or a specific mapping for the container
ps          List containers
pull        Pull an image or a repository from a registry
push        Push an image or a repository to a registry
rename      Rename a container
restart     Restart one or more containers
rm          Remove one or more containers
rmi         Remove one or more images
run         Run a command in a new container
save        Save one or more images to a tar archive (streamed to STDOUT by default)
search      Search the Docker Hub for images
start       Start one or more stopped containers
stats       Display a live stream of container(s) resource usage statistics
stop        Stop one or more running containers
tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
top         Display the running processes of a container
unpause     Unpause all processes within one or more containers
update      Update configuration of one or more containers
version     Show the Docker version information
wait        Block until one or more containers stop, then print their exit codes

1.docker概述&历史

将开发人员开发的jar包与运行所需环境打包成镜像（Hadoop）
docker核心：隔离，镜像互不影响，
容器化技术，也是一种虚拟技术
开源
相比于VMware等虚拟机轻巧的多
基于go语言开发的

官网
官方文档Docker文档是超详细的
仓库地址

2.docker做什么

之前的虚拟机

虚拟机技术缺点：

1.资源占用多

2.冗余步骤多

3.启动慢

容器化技术

比较Docker和虚拟化技术的不同

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

应用更快速的交互和部署

传统：一堆帮助文档，安装程序
Docker：打包镜像发布测试，一键运行

DevOps：开发、运维：

应用更快速的交付和部署

传统：一堆帮助文档，安装程序
Docker：打包镜像发布测试，一键运行

更便捷的升级和扩缩容
更简单的系统运维
更高效的计算资源利用

3.docker安装

1）docker的基本组成
架构图

3. 名词解释

镜像（image）
- Docker镜像就好比是一个模板，可以通过这个模板来创建容器服务，tomcat镜像 ===> run ===> tomcat01容器，通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中的）
容器（container）
- Docker利用容器技术，独立运行一个或者一组应用，通过镜像来创建的
- 启动，停止，删除，基本命令！
- 就目前可以把这个容器理解为一个建议的linux系统
仓库（repository）
- 存放镜像的地方
- Docker Hub（默认是国外的）
- 阿里云,,,都有容器服务（配置镜像加速！）

4. 阿里云镜像加速

登录阿里云服务器，找到容器镜像服务
设置Registry登录密码
找到镜像加速器
配置使用

3.配置使用

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

4.2 安装docker

环境准备

需要会一点点的Linux的基础
CentOS 7
我们使用Xshell连接远程服务器进行操作!

环境查看

[root@jason /]# uname -r
3.10.0-1062.18.1.el7.x86_64

系统版本

[root@jason /]# uname -r
3.10.0-1062.18.1.el7.x86_64
[root@jason /]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="7"
PRETTY_NAME="CentOS Linux 7 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:7"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"

CENTOS_MANTISBT_PROJECT="CentOS-7"
CENTOS_MANTISBT_PROJECT_VERSION="7"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="7"

安装

#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、设置镜像的仓库
$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo #默认是国外的

yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo #推荐使用阿里云的

#更新软件包索引
[root@jason /]# yum makecache fast


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


#5.启动 Docker。
systemctl start docker

#6.版本信息
docker version

#7.运行第一个docker
docker run hello-world

#8.查询我刚下载的镜像
docker images

#9.卸载资源
yum remove docker-ce docker-ce-cli containerd.io

#10.删除资源
rm -rf /var/lib/docker

#/var/lib/docker docker的默认工作空间

#7.运行第一个docker

#8.查询我刚下载的镜像

5. 底层原理

HelloWorld镜像

底层原理

Docker Engine是一个客户端-服务器应用程序，具有以下主要组件:

一个服务器，它是一种长期运行的程序，称为守护进程(dockerd命令)
一个REST API，它指定程序可以用来与守护进程对话并指示它做什么的接口。

Docker是一个Client Server结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。容器，是一个运行时环境就是我们所说的集装箱。

为什么Docker比Vm快

docker有着比虚拟机更少的抽象层。由于docker不需要Hypervisor实现硬件资源虚拟化,*运行在docker容器上的程序直接使用的都是实际物理机的硬件资源*。因此在CPU、内存利用率上docker将会在效率上有明显优势。**
docker利用的是宿主机的内核,而不需要Guest OS。因此,当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。而docker由于直接利用宿主机的操作系统,则省略了返个过程,因此新建一个docker容器只需要几秒钟。

二，Docker基本命令

1. Docker的常用命令

帮助命令

docker version # docker版本信息

docker info # 系统级别的信息，包括镜像和容器的数量

docker 命令 --help

帮助文档

镜像命令

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

[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              bf756fb1ae65        7 months ago        13.3kB
 
# 解释
REPOSITORY      # 镜像的仓库
TAG             # 镜像的标签
IMAGE ID        # 镜像的ID
CREATED         # 镜像的创建时间
SIZE            # 镜像的大小
 
# 可选项
--all , -a      # 列出所有镜像
--quiet , -q    # 只显示镜像的id

docker search 查找镜像

[root@jason /]# docker search mysql

NAME                              DESCRIPTION                                     STARS               OFFICIAL         AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   9822                [OK]                
mariadb                           MariaDB is a community-developed fork of MyS…   3586                [OK]                
mysql/mysql-server                Optimized MySQL Server Docker images. Create…   719                                     [OK]
 
# 可选项
--filter=STARS=3000     # 搜素出来的镜像就是STARS大于3000的
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker search mysql --filter=STARS=3000
NAME                DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql               MySQL is a widely used, open-source relation…   9822                [OK]                
mariadb             MariaDB is a community-developed fork of MyS…   3586                [OK]

docker pull 下拉镜像

# 下载镜像，docker pull 镜像名[:tag]
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker pull mysql
Using default tag: latest           # 如果不写tag，默认就是latest
latest: Pulling from library/mysql
bf5952930446: Pull complete         # 分层下载，dockerimages的核心，联合文件系统
8254623a9871: Pull complete 
938e3e06dac4: Pull complete 
ea28ebf28884: Pull complete 
f3cef38785c2: Pull complete 
894f9792565a: Pull complete 
1d8a57523420: Pull complete 
6c676912929f: Pull complete 
ff39fdb566b4: Pull complete 
fff872988aba: Pull complete 
4d34e365ae68: Pull complete 
7886ee20621e: Pull complete 
Digest: sha256:c358e72e100ab493a0304bda35e6f239db2ec8c9bb836d8a427ac34307d074ed     # 签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest      # 真实地址
 
# 等价于
docker pull mysql
docker pull docker.io/library/mysql:latest
 
# 指定版本下载
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
bf5952930446: Already exists 
8254623a9871: Already exists 
938e3e06dac4: Already exists 
ea28ebf28884: Already exists 
f3cef38785c2: Already exists 
894f9792565a: Already exists 
1d8a57523420: Already exists 
5f09bf1d31c1: Pull complete 
1b6ff254abe7: Pull complete 
74310a0bf42d: Pull complete 
d398726627fd: Pull complete 
Digest: sha256:da58f943b94721d46e87d5de208dc07302a8b13e638cd1d24285d222376d6d84
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7
 
# 查看本地镜像
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mysql               5.7                 718a6da099d8        6 days ago          448MB
mysql               latest              0d64f46acfd1        6 days ago          544MB
hello-world         latest              bf756fb1ae65        7 months ago        13.3kB

docker rmi 删除镜像

# 删除指定镜像
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker rmi -f IMAGE ID 
# 删除多个镜像
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker rmi -f IMAGE ID1 IMAGE ID2 IMAGE ID3 
 # 删除所有镜像
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]#  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@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker run -it centos /bin/bash
[root@74e82b7980e7 /]# ls   # 查看容器内的centos，基础版本，很多命令是不完善的
bin  etc   lib    lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
 
# 从容器中退回主机
[root@77969f5dcbf9 /]# exit
exit
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# ls
bin   dev  fanfan  lib    lost+found  mnt  proc  run   srv  tmp  var
boot  etc  home    lib64  media       opt  root  sbin  sys  usr

列出所有的运行的容器

# docker ps 命令
        # 列出当前正在运行的容器
-a      # 列出正在运行的容器包括历史容器
-n=?    # 显示最近创建的容器
-q      # 只显示当前容器的编号
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS               NAMES
77969f5dcbf9        centos              "/bin/bash"         5 minutes ago       Exited (0) 5 minutes ago                       xenodochial_bose
74e82b7980e7        centos              "/bin/bash"         16 minutes ago      Exited (0) 6 minutes ago                       silly_cori
a57250395804        bf756fb1ae65        "/hello"            7 hours ago         Exited (0) 7 hours ago                         elated_nash
392d674f4f18        bf756fb1ae65        "/hello"            8 hours ago         Exited (0) 8 hours ago                         distracted_mcnulty
571d1bc0e8e8        bf756fb1ae65        "/hello"            23 hours ago        Exited (0) 23 hours ago                        magical_burnell
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker ps -qa
77969f5dcbf9
74e82b7980e7
a57250395804
392d674f4f18
571d1bc0e8e8

退出容器

exit            # 直接退出容器并关闭
Ctrl + P + Q    # 容器不关闭退出

删除容器

docker rm -f 容器id                       # 删除指定容器
docker rm -f $(docker ps -aq)       # 删除所有容器
docker ps -a -q|xargs docker rm -f  # 删除所有的容器

启动和停止容器的操作

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

常用的其他命令

后台启动容器

# 命令 docker run -d 镜像名
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker run -d centos
 
# 问题 docker ps， 发现centos停止了
 
# 常见的坑， docker 容器使用后台运行， 就必须要有一个前台进程，docker发现没有应用，就会自动停止
# nginx， 容器启动后，发现自己没有提供服务，就会立即停止，就是没有程序了

查看日志

docker logs -t -f --tail number 容器id
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker logs -tf --tail 1 8d1621e09bff
2020-08-11T10:53:15.987702897Z [root@8d1621e09bff /]# exit      # 日志输出
 
# 自己编写一段shell脚本
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker run -d centos /bin/sh -c "while true;do echo xiaofan;sleep 1;done"
a0d580a21251da97bc050763cf2d5692a455c228fa2a711c3609872008e654c2
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
a0d580a21251        centos              "/bin/sh -c 'while t…"   3 seconds ago       Up 1 second                             lucid_black
 
# 显示日志
-tf                 # 显示日志
--tail number       # 显示日志条数
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker logs -tf --tail 10 a0d580a21251

查看容器中进程信息ps

# 命令 docker top 容器id
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker top df358bc06b17
UID                 PID                 PPID                C                   STIME               TTY     
root                28498               28482               0                   19:38               ?

查看镜像的元数据

# 命令
docker inspect 容器id
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker inspect df358bc06b17
[
    {
        "Id": "df358bc06b17ef44f215d35d9f46336b28981853069a3739edfc6bd400f99bf3",
        "Created": "2020-08-11T11:38:34.935048603Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 28498,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2020-08-11T11:38:35.216616071Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:0d120b6ccaa8c5e149176798b3501d4dd1885f961922497cd0abef155c869566",
        "ResolvConfPath": "/var/lib/docker/containers/df358bc06b17ef44f215d35d9f46336b28981853069a3739edfc6bd400f99bf3/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/df358bc06b17ef44f215d35d9f46336b28981853069a3739edfc6bd400f99bf3/hostname",
        "HostsPath": "/var/lib/docker/containers/df358bc06b17ef44f215d35d9f46336b28981853069a3739edfc6bd400f99bf3/hosts",
        "LogPath": "/var/lib/docker/containers/df358bc06b17ef44f215d35d9f46336b28981853069a3739edfc6bd400f99bf3/df358bc06b17ef44f215d35d9f46336b28981853069a3739edfc6bd400f99bf3-json.log",
        "Name": "/hungry_heisenberg",
        "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,
            "Capabilities": null,
            "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/5af8a2aadbdba9e1e066331ff4bce56398617710a22ef906f9ce4d58bde2d360-init/diff:/var/lib/docker/overlay2/62926d498bd9d1a6684bb2f9920fb77a2f88896098e66ef93c4b74fcb19f29b6/diff",
                "MergedDir": "/var/lib/docker/overlay2/5af8a2aadbdba9e1e066331ff4bce56398617710a22ef906f9ce4d58bde2d360/merged",
                "UpperDir": "/var/lib/docker/overlay2/5af8a2aadbdba9e1e066331ff4bce56398617710a22ef906f9ce4d58bde2d360/diff",
                "WorkDir": "/var/lib/docker/overlay2/5af8a2aadbdba9e1e066331ff4bce56398617710a22ef906f9ce4d58bde2d360/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "df358bc06b17",
            "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": "20200809",
                "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": "4822f9ac2058e8415ebefbfa73f05424fe20cc8280a5720ad3708fa6e80cdb08",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/4822f9ac2058",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "5fd269c0a28227241e40cd30658e3ffe8ad6cc3e6514917c867d89d36a31d605",
            "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": "30d6017888627cb565618b1639fecf8fc97e1ae4df5a9fd5ddb046d8fb02b565",
                    "EndpointID": "5fd269c0a28227241e40cd30658e3ffe8ad6cc3e6514917c867d89d36a31d605",
                    "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
                }
            }
        }
    }
]
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]#

进入当前正在运行的容器

# 我们通常容器使用后台方式运行的，需要进入容器，修改一些配置

# 命令
docker exec -it 容器id /bin/bash

# 测试
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker exec -it df358bc06b17 /bin/bash
[root@df358bc06b17 /]# ls
bin etc   lib    lost+found mnt proc run   srv tmp var
dev home lib64 media       opt root sbin sys usr
[root@df358bc06b17 /]# ps -ef
UID        PID PPID C STIME TTY          TIME CMD
root         1     0 0 Aug11 pts/0    00:00:00 /bin/bash
root        29     0 0 01:06 pts/1    00:00:00 /bin/bash
root        43    29 0 01:06 pts/1    00:00:00 ps -ef

# 方式二
docker attach 容器id

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

从容器中拷贝文件到主机

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

[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker cp 7af535f807e0:/home/Test.java /home

三，Docker部署软件实战

1.Docker部署软件实战

Docker安装Nginx

# 1. 搜索镜像 search 建议去docker hub搜索，可以看到帮助文档
# 2. 下载镜像 pull
# 3. 运行测试
[root@iZ2zeg4ytp0whqtmxbsqiiZ home]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
centos              latest              0d120b6ccaa8        32 hours ago        215MB
nginx               latest              08393e824c32        7 days ago          132MB
 
# -d 后台运行
# -name 给容器命名
# -p 宿主机端口：容器内部端口
[root@iZ2zeg4ytp0whqtmxbsqiiZ home]# docker run -d --name nginx01 -p 3344:80 nginx  # 后台方式启动启动镜像
fe9dc33a83294b1b240b1ebb0db9cb16bda880737db2c8a5c0a512fc819850e0
[root@iZ2zeg4ytp0whqtmxbsqiiZ home]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
fe9dc33a8329        nginx               "/docker-entrypoint.…"   4 seconds ago       Up 4 seconds        0.0.0.0:3344->80/tcp   nginx01
[root@iZ2zeg4ytp0whqtmxbsqiiZ home]# curl localhost:3344    # 本地访问测试
 
# 进入容器
[root@iZ2zeg4ytp0whqtmxbsqiiZ home]# docker exec -it nginx01 /bin/bash
root@fe9dc33a8329:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@fe9dc33a8329:/# cd /etc/nginx/
root@fe9dc33a8329:/etc/nginx# ls
conf.d      koi-utf  mime.types  nginx.conf   uwsgi_params
fastcgi_params  koi-win  modules     scgi_params  win-utf

端口暴露概念

2. Docker安装Tomcat

# 官方的使用
docker run -it --rm tomcat:9.0
 
# 我们之前的启动都是后台的，停止了容器之后， 容器还是可以查到，docker run -it --rm 一般用来测试，用完就删
 
# 下载再启动
docker pull tomcat
 
# 启动运行
docker run -d -p 3344:8080 --name tomcat01 tomcat
 
# 测试访问没有问题
 
# 进入容器
docker exec -it tomcat01 /bin/bash
 
# 发现问题：1.linux命令少了， 2. webapps下内容为空，阿里云净吸纳过默认是最小的镜像，所有不必要的都剔除了，保证最小可运行环境即可

3. Docker部署es + kibana

# es 暴露的端口很多
# es 十分的耗内存
# es 的数据一般需要放置到安全目录！ 挂载
# --net somenetwork 网络配置
 
# 启动elasticsearch
docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ home]# docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2
a920894a940b354d3c867079efada13d96cf9138712c76c8dea58fabd9c7e96f
 
# 启动了linux就卡主了，docker stats 查看cpu状态
 
# 测试一下es成功了
[root@iZ2zeg4ytp0whqtmxbsqiiZ home]# curl localhost:9200
{
  "name" : "a920894a940b",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "bxE1TJMEThKgwmk7Aa3fHQ",
  "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"
}
 
 
# 增加内存限制，修改配置文件 -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

可视化

portainer（先用这个）

docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer
 
# 测试
[root@iZ2zeg4ytp0whqtmxbsqiiZ home]# curl localhost:8088
<!DOCTYPE html
><html lang="en" ng-app="portainer">
 
# 外网访问 http://ip:8088

四.Docker原理

5)测试是否映射成功：[root@atong ~]# curl localhost:3306
6）进入nginx容器：docker exec -it nginx01 /bin/bash
7）查看nginx位置：whereis nginx
8）可以尝试修改配置文件在/etc/目录下的nginx.conf
9)思考，如何在容器外部提供一个映射修改容器内的配置文件，涉及到数据卷的知识。

2）作业二：docker安装tomcat

tomcat：轻量级web应用服务器
1）按作业一中1-3步骤
2）查看官方文档：发现命令：

—rm 的意思是运行完即删除；我们不运行这个命令
3）查看状态发现404

[root@atong ~]# curl localhost:8888
<!doctype html><html lang="en"><head><title>HTTP Status 404 ? Not Found</title><style type="text/css">body {font-family:Tahoma,Arial,sans-serif;} h1, h2, h3, b {color:white;background-color:#525D76;} h1 {font-size:22px;} h2 {font-size:16px;} h3 {font-size:14px;} p {font-size:12px;} a {color:black;} .line {height:1px;background-color:#525D76;border:none;}</style></head><body><h1>HTTP Status 404 ? Not Found</h1><hr class="line" /><p><b>Type</b> Status Report</p><p><b>Description</b> The origin server did not find a current representation for the target resource or is not willing to disclose that one exists.</p><hr class="line" /><h3>Apache Tomcat/9.0.38</h3></body></html>

进入容器发现没有webapps服务，因为下载镜像默认最小可运行，不必要的东西都被剔除了
需要把webapp.dist文件下内容拷贝到webapps下，才能在外网访问到容器内的tomcat

3)作业三：部署elasticsearch+kibanar

ElasticSearch : Elasticsearch 是一个分布式、RESTful 风格的搜索和数据分析引擎[官网介绍]
Kibana:能够对 Elasticsearch 中的数据进行可视化并在 Elastic Stack 进行操作[官网介绍]
1）注意事项：es暴露端口多、占用内存大、数据需要放置到安全目录（挂载）
2）运行命令：docker run -d —name elasticsearch —net somenetwork -p 9200:9200 -p 9300:9300 -e “discovery.type=single-node” elasticsearch:7.6.2

—net somework 网络配置

3）启动后linux运行会很卡：docker stats #查看内存cpu
4）测试访问es是否启动成功：curl localhost：9200#出现下面则表示启动成功

5）测试完之后立马关闭es，增加内存限制
6）修改配置文件：-e 环境配置修改（限制es运行内存在64M到512M之间）

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

7）再次查看stats：

8）测试是否连接成功：curl localhost：9200

使用kibana连接es

8.可视化

portainer&Rancher（CI/CD再用）
什么是portainer？
Docker图形化界面管理工具，提供一个后台面板供我们操作
1）安装命令：#docker run -d -p 8888:9000 \
—restart=always -v /var/run/docker.sock:/var/run/docker.sock —privileged=true portainer/portainer #注意内网端口要在阿里云安全组设置开放
2）访问测试http://101.200.167.167:8888/

3）可以自己设置密码登录试试

9.Docker镜像之联合文件系统

1）Docker 镜像是什么？
镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码，运行时的库、环境变量和配置文件。#所有应用直接打包，可以直接跑起来
如何获得镜像：
从远程仓库下载
朋友拷贝给你
自己制作一个镜像DockerFile
2）Docker镜像加载原理
UnionFS（联合文件系统）Docker 联合文件系统(Union Filesystem) - 简书
3）commit 镜像
docker commit #提交容器成为一个新的镜像
用法：docker commit -m=”提交的描述信息” -a=”作者” 容器id 目标镜像名:[TAG]

1、启动一个默认的tomcat

[root@atong ~]# docker run -tid -p:8080 :8080 tomcat( :8080前面多了空格，所有这种情况都是)
5eadc8f8b7c4b30df11ac356006d4d747d7a874a62c0b2baba886067e2ad0da8

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

docker exec -it 容器id /bin/bash

[root@atong ~]# docker exec -it 5eadc8f8b7c4 /bin/bash
root@5eadc8f8b7c4:/usr/local/tomcat#
root@5eadc8f8b7c4:/usr/local/tomcat# cd webapps
root@5eadc8f8b7c4:/usr/local/tomcat/webapps# ls
root@5eadc8f8b7c4:/usr/local/tomcat/webapps#

3、从webapps.dist拷贝文件进去webapp

root@5eadc8f8b7c4:/usr/local/tomcat# cd webapps.dist
root@5eadc8f8b7c4:/usr/local/tomcat/webapps.dist# ls
ROOT docs examples host-manager manager
root@5eadc8f8b7c4:/usr/local/tomcat/webapps.dist# cd ..
root@5eadc8f8b7c4:/usr/local/tomcat# cp -r webapps.dist/* webapps
root@5eadc8f8b7c4:/usr/local/tomcat# cd webapps
root@5eadc8f8b7c4:/usr/local/tomcat/webapps# ls
ROOT docs examples host-manager manager

4、将操作过的容器通过commit提交为一个镜像！我们以后就使用我们修改过的镜像即可，而不需要每次都重新拷贝webapps.dist下的文件到webapps了，这就是我们自己的一个修改的镜像。

[root@atong ~]# docker commit -m=”add webapps app” -a=”atong” 5eadc8f8b7c4 tomcat02
sha256:1820873e4dec68dc782e034320745ec6732bc505683021a7798ab0c92e7846df

5、用自己创建的tomcat镜像重新运行一个容器出现如下界面：

[root@atong ~]# docker run -tid -p:8080 :8080 tomcat02

10.容器数据卷

1）什么是容器数据卷？
容器之间可以有一个数据共享的技术，将Docker容器中产生的数据同步到本地。
这就是卷技术：目录的挂载，将我们容器内的目录，挂载到linux上面，实现双向数据同步。
总结：容器的持久化操作。容器内也是可以数据共享的！
2）使用数据卷：
挂载的第一种方式：直接使用命令挂载 -v
docker run -it -v 主机目录:容器内目录容器名 /bin/bash
例：docker run -it -v /home/ceshi:/home centos /bin/bash
将centos容器中/home目录下文件挂载到主机下/home/ceshi目录下
挂载成功检测（在主机下输入）：docker inspect 容器id

分别在容器和主机对应目录下新建文件，发现可以同步；
将容器停止，修改主机上测试文件内容，再重新将容器启动，发现数据仍然同步。
3）实战：安装MySQL（失败后成功了，不是端口问题，因该是MySQL版本太新，客户端不支持，换成mysql:5.7就可以）

获取mysql镜像

docker pull mysql:5.7

运行容器,需要做数据挂载 #安装启动mysql，需要配置密码的，这是要注意点！

参考官网hub

docker run —name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

启动option

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

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

sqlyog-连接到服务器的3306—和容器内的3306映射

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

假设我们将包含mysql的容器删除时，
发现，我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能。
4）具名和匿名挂载
docker volume ls #列出所有挂载
匿名挂载：-v 容器内目录
具名挂载：-v 卷名:容器内目录
指定路径挂载：-v /宿主机目录:容器内目录
通过docker inspect 容器id 查看具体挂载目录
“ 所有的docker容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volumes/自定义的卷名/_data下，如果指定了目录，docker volume ls 是查看不到的。”
5）拓展

# 通过 -v 容器内路径： ro rw 改变读写权限；默认rw可读可写

ro #readonly 只读
rw #readwrite 可读可写
$ docker run -d -P —name nginx05 -v juming:/etc/nginx:ro nginx
$ docker run -d -P —name nginx05 -v juming:/etc/nginx:rw nginx
一旦设定了ro，则容器的权限随之改变为只读，所以只能从宿主机操作。

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

11.DockerFile

挂载的第二种方式：编写dockerfile脚本设置挂载目录
DockerFile 就是用来构建docker镜像的构建文件，就是命令脚本！
通过脚本可以生成镜像，镜像是一层一层的，所以脚本是一个一个的命令，每个命令就是一层！
编写dockerfile，设置挂载目录

创建一个dockerfile文件，名字可以随便建议Dockerfile

dockerfile1 文件中的内容：指令(大写) + 参数

$ vim dockerfile1
FROM centos # 当前这个镜像是以centos为基础的
VOLUME [“volume01”,”volume02”] # 挂载卷的卷目录列表(多个目录)
CMD echo “——-end——-“ # 输出一下用于测试
CMD /bin/bash # 默认走bash控制台

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

# 构建出这个镜像

[root@atong ~]# docker build -f dockerfile1 -t atong/centos .
-f dockerfile1 # f代表file，指这个当前文件的地址(这里是当前目录下的dockerfile1)
-t atong/centos # t就代表target，指目标镜像名(注意镜像名前不能加斜杠‘/’)
. # 表示生成在当前目录下 -t后一定要加个 . 要不然不成功
运行一个容器：docker run -it atong/centos /bin/bash
测试：在 atong/centos 镜像运行的容器内的 volume01 挂载目录下新建一个文件container.txt ，然后不退出在宿主机上通过命令：#docker inspect 容器id 查看 mounts 中的具体匿名挂载目录，进入该目录下查看是否 container.txt 文件已经同步，若同步则成功。

数据卷容器
两个或多个mysql同步数据：双向拷贝
实现容器间的数据共享：—volumes-from
用到的命令：
docker run -it —name docker01 atong/centos:latest #注意要加上版本号不然默认最新
docker run -it —name docekr02 —volumes-from docker01 84719eb2a4a5
docker attach 84719eb2a4a5
docker run -it —name docker03 —volumes-from docker01 atong/centos:latest
ctrl+p+q

docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 —name mysql01 mysql:5.7
docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 —name mysql02 —volumes-from mysql01 mysql:5.7 #将mysql02挂载到mysql01上
结论：容器之间的配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止。
但是一旦你持久化到了本地，这个时候，本地的数据是不会删除的
DockerFile介绍
dockerfile 是用来构建docker镜像的文件，是命令参数脚本
构建步骤：
1.编写dockerfile 文件
2.docker build 构建成为一个镜像
3.docker run 运行镜像
4.docker push 发送镜像（DockerHub、阿里云镜像）
DockerFile构建过程
基础知识：
1.每个保留关键字（指令）都必须是大写字母
2.指令从上到下顺序执行
3.#表示注释
4.每一个指令都会创建提交一个新的镜像层，并提交！
dockerfile 是面向开发的，要发布项目、做镜像需要编写dockerfile文件。
DockerFile的指令
1）
FROM #基础镜像，一切从这里开始构建
MAINTAINER #镜像作者：姓名+邮箱
RUN #镜像构建的时候需要运行的命令
ADD #步骤。（tomcat镜像的压缩包就是一种添加内容）
WORKDIR #镜像的工作目录
VOLUME #挂载的目录
EXPOSE #暴露端口配置
CMD #指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT #指定这个容器启动的时候要运行的命令，可以直接追加命令
ONBUILD #当构建一个被继承 DockerFile ，这个时候就会运行 ONBUILD 的指令，是一种触发指令
COPY #类似ADD命令，将我们的文件拷贝到镜像中
ENV #构建的时候这只环境变量

2）CMD 和 ENTRYPOINT 的区别：
CMD #指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT #指定这个容器启动的时候要运行的命令，可以直接追加命令
测试CMD：

编写dockerfile文件

vim dockerfile-test-cmd
FROM centos
CMD [“ls”,”-a”] # 启动后执行 ls -a 命令

构建镜像

docker build -f dockerfile-test-cmd -t cmd-test:0.1 .

运行镜像

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

想追加一个命令 -l 成为ls -al：展示列表详细数据

docker run cmd-test:0.1 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused “exec: \”-l\”:
executable file not found in $PATH”: unknown.
ERRO[0000] error waiting for container: context canceled

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

测试ENTRYPOINT：

编写dockerfile文件

vim dockerfile-test-entrypoint
FROM centos
ENTRYPOINT [“ls”,”-a”]

构建镜像

docker build -f dockerfile-test-entrypoint -t cmd-test:0.1 .

运行镜像

docker run entrypoint-test:0.1
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found …

我们的命令，是直接拼接在我们得ENTRYPOINT命令后面的

docker run entrypoint-test:0.1 -l #注意输出结果
total 56
drwxr-xr-x 1 root root 4096 May 16 06:32 .
drwxr-xr-x 1 root root 4096 May 16 06:32 ..
-rwxr-xr-x 1 root root 0 May 16 06:32 .dockerenv
lrwxrwxrwx 1 root root 7 May 11 2019 bin -> usr/bin
drwxr-xr-x 5 root root 340 May 16 06:32 dev
drwxr-xr-x 1 root root 4096 May 16 06:32 etc
drwxr-xr-x 2 root root 4096 May 11 2019 home
lrwxrwxrwx 1 root root 7 May 11 2019 lib -> usr/lib
lrwxrwxrwx 1 root root 9 May 11 2019 lib64 -> usr/lib64 ….
实战测试1：（构建一个自己的centos镜像，添加官方centos镜像中没有的命令）
DockerHub中大多数镜像都是从这个基础镜像过来的：FROM scratch
1）命令：
[root@atong dockerfile]# vi mydockerfile-centos
[root@atong dockerfile]# cat mydockerfile-centos
FROM centos
MAINTAINER atong2469485159@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 #因为CMD中命令会被覆盖，所以每一个命令写在一个CMD中
2）测试运行
docker run -it mycentos:0.1 # 注意带上版本号，否则每次都回去找最新版latest
pwd
/usr/local # 与Dockerfile文件中 WORKDIR 设置的 MYPATH 一致
vim # vim 指令可以使用
ifconfig # ifconfig 指令可以使用
docker history 镜像id # docker history 镜像id 查看镜像构建历史步骤
实战测试2：（构建一个tomcat镜像）
1）准备镜像文件，tomcat压缩包、jdk压缩包（因为tomcat基于java所以也需要jdk压缩包）

2）编写dockerfile文件，官方命名：Dockerfile ，build 会自动寻找这个文件不需额外指定

3）构建镜像：docker build -t diytomcat . # . 表示当前目录
4）启动镜像：docker run -d -p 8880:8080 —name atongtomcat02 -v /home/atong/build/tomcat/test:/usr/local/apache-tomcat-9.0.39/webapps/test -v /home/atong/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.39/logs diytomcat
5）访问测试：[root@atong ~]# curl localhost:8080
curl: (56) Recv failure: Connection reset by peer #失败了
6）发布项目（由于做了卷挂载，我们直接在本地编写项目就可以发布了）

12.Docker网络：

查看开放端口：[root@atong ~]# /sbin/iptables -L -n
查看ip：ip addr & ifconfig
link：docker run -d -P —name tomcat03 —link tomcat02 tomcat #局限性很大，得相互link两次

网络模式
bridge ：桥接 docker（默认，自己创建也是用bridge模式）
none ：不配置网络，一般不用
host ：和所主机共享网络
container ：容器网络连通（用得少！局限很大）

我们直接启动的命令 —net bridge,而这个就是我们得docker0

bridge就是docker0

docker run -d -P —name tomcat01 tomcat

等价于 =>>

docker run -d -P —name tomcat01 —net bridge tomcat

假设要跨网络操作别人，就需要使用docker network connect 连通
docker network connect tomcat01 mynet
docker network connect 容器名网名

LI JS@你猜啊

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
第八阶段：Linux运维-03Docker入门到精通

1.docker概述&历史将开发人员开发的jar包与运行所需环境打包成镜像（Hadoop）docker核心：隔离，镜像互不影响，容器化技术，也是一种虚拟技术开源相比于VMware等虚拟机轻巧的多基于go语言开发的官网官方文档Docker文档是超详细的仓库地址2.docker做什么之前的虚拟机虚拟机技术缺点：1.资源占用多2.冗余步骤多3.启动慢容器化技术比较Docker和虚拟化技术的不同传统虚拟机，虚拟出一条硬件，运..
复制链接

扫一扫