深入浅出Docker应用（阿里云实验）

（Docker安装和配置）

一、docker安装

yum install -y yum-utils device-mapper-persistent-data lvm2
yum install -y jq

yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo 

yum install docker-ce.x86_64
yum install -y docker-ce.x86_64 3:20.10.16-3.el7 
yum install -y docker-ce.x86_64 3:24.0.6-1.el7

systemctl start docker.service

二、Docker的配置

镜像源的配置

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

sudo systemctl daemon-reload
sudo systemctl restart docker

[root@iZuf682ha96fpea6827qjzZ ~]# systemctl restart docker.service 
[root@iZuf682ha96fpea6827qjzZ ~]# 
[root@iZuf682ha96fpea6827qjzZ ~]# 
[root@iZuf682ha96fpea6827qjzZ ~]# systemctl daemon-reload
[root@iZuf682ha96fpea6827qjzZ ~]# 
[root@iZuf682ha96fpea6827qjzZ ~]# systemctl enable docker.service
[root@iZuf682ha96fpea6827qjzZ ~]# docker version
Client: Docker Engine - Community
 Version:           24.0.6
 API version:       1.43
 Go version:        go1.20.7
 Git commit:        ed223bc
 Built:             Mon Sep  4 12:35:25 2023
 OS/Arch:           linux/amd64
 Context:           default

Server: Docker Engine - Community
 Engine:
  Version:          24.0.6
  API version:      1.43 (minimum version 1.12)
  Go version:       go1.20.7
  Git commit:       1a79695
  Built:            Mon Sep  4 12:34:28 2023
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.24
  GitCommit:        61f9fd88f79f081d64d6fa3bb1a0dc71ec870523
 runc:
  Version:          1.1.9
  GitCommit:        v1.1.9-0-gccaecfc
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0
[root@iZuf682ha96fpea6827qjzZ ~]#

三、Docker的快速上手

1.启动hello-world

docker run hello-world

2.启动长期运行的bash容器

docker run -it bash

四、容器的查找和下载

1.远程查找容器

docker search ubuntu

2.查找容器的版本信息

docker pull ubuntu
docker pull ubuntu:jammy

（容器的启动和操作）

一、容器的分步骤启动流程

1.创建ubuntu容器

docker create -it ubuntu
docker ps -a

2.创建指定名称的容器

docker create -it --name ubuntu-1 ubuntu
docker ps -a

3.启动ubuntu容器

docker start ubuntu-1
docker ps -a

二、容器的快速启动方式

1.创建容器指定名称的容器

docker run -itd --name ubuntu-2 ubuntu
docker ps -a

2.操作已经创建的容器

docker exec -it ubuntu-2 bin/bash

3.创建一次性容器

docker run -it --name temp ubuntu
exit
docker ps -a

三、为容器安装命令行工具

1.启动容器并测试常用命令

docker run -it --name ubuntu-3 ubuntu
lsb_release

2.在容器中安装命令

apt-get update
apt-get install -y lsb-core net-tools vim --fix-missing

3.busybox镜像的使用

docker run -itd --name busybox-1 busybox
docker exec -it busybox-1 sh

四、查看容器系统信息

1.查看宿主机信息

lsb_release -a
ifconfig

（容器管理命令）

docker run -itd --name ubuntu-3 ubuntu
docker exec -it ubuntu-3 /bin/bash

docker images
docker ps -a 

容器的停止
docker top ubuntu-3
docker stop ubuntu-3
docker ps -a 
容器的重启
docker restart ubuntu-3
docker top ubuntu-3
容器的删除
docker ps -a
docker rm --force [CONTAINER ID]
或
docker rm --force ubuntu-3
docker ps -a

（容器镜像管理命令）

一、镜像的下载，显示和删除

1.镜像的下载

docker pull debian
docker images

2.镜像的查看

docker inspect debian

3.镜像的删除

当镜像下载之后，我们可以通过docker rmi命令进行删除。

docker run -itd --name debian-3 debian
docker rm -f debian-3
docker images

要注意的是docker rmi无法删除已经创建了容器的镜像，如果需要删除需要先停止相关的容器，并添加--force参数。

docker rmi --force debian
docker images

二、镜像的保存和加载

1.镜像的本地保存

首先我们可以通过docker save命令可以将docker内部的一个或多个镜像导出成文件。

下面的命令中我们先下载nginx，hello-world两个镜像，然后再将镜像导出到images.tar文件中。

docker save的格式为：docker save -o [导出文件名] [需要导出的镜像列表]...

docker pull hello-world
docker pull nginx
docker save -o images.tar nginx hello-world  
ll images.tar

2.删除已有镜像

上一步已经将nginx，hello-world两个镜像保存到文件images.tar。

接下面我们将现有的两个镜像从docker内部删除。为后面的镜像读取做准备。

docker rmi hello-world
docker rmi nginx
docker images

3.从本地加载镜像文件

接下来我们通过docker load命令将images.tar中的两个镜像导入回docker内部。

即可实现在没有网络访问的情况更新镜像。

docker load的格式为：docker load -i [导入文件名]。

在镜像导入完毕之后，我们可以通过docker image进行验证。

docker load -i images.tar
docker images

三、容器快照的导出和导入

通过docker save和 docker load的方法实现docker内部的镜像保存和加载。

1.创建实验容器

首先我们创建一个容器ubuntu-3，然后在ubuntu-3创建一个文本文件。

此处我们可以使用docker exec bash -c "命令行"方式直接在宿主机执行命令。

我们通过echo命令在容器中创建名为snapshot.txt的文件。

在创建之后再使用cat命令验证容器中的文件。

docker run -itd --name python-1 python
docker exec python-1 bash -c "echo snapshot > snapshot.txt"
docker exec python-1 bash -c "cat snapshot.txt"

2.容器快照的导出

当容器文件修改之后，我们可以通过docker export命令将容器以快照的形式导出到文件。

其命令的格式为docker export 容器名 > 快照文件名。

和镜像导出不同，快照的导出，会将容器的镜像，和容器在镜像之上的修改部分同时导出。

docker export python-1 > python-snapshot.tar
ll python-snapshot.tar

3.容器快照的导入

对于通过docker export导出的容器快照文件。

我们可以通过docker import命令将其导入到docker中，

在这里需要特别注意的是：docker import是以镜像而不是容器的形式导入快照。

也就是说导入的快照并不能直接运行，而是需要根据此快照镜像再次创建容器才可以使用。

docker import命令的格式为docker import 快照文件 导入镜像名称:版本号

docker import python-snapshot.tar python-snapshot:latest

快照导入后，我们可以利用导入的快照镜像创造一个新的容器。并验证通过快照创建的容器中包含着之前容器中创建的文件。

docker run -itd --name snapshot python-snapshot /bin/bash
docker exec snapshot cat snapshot.txt

四、镜像的内部层次关系

1.inspect过滤器的使用

docker inspect -f "模板字符串" 镜像名

docker pull python
docker inspect -f "{\"Id\":{{json .Id}},\"RepoTags\":{{json .RepoTags}}}" python | jq

2.镜像的层次关系

docker inspect -f "{{json .RootFS.Layers}}" python | jq

3.普通镜像和快照镜像的区别

docker inspect -f "{{json .RootFS.Layers}}"  python-snapshot | jq
docker images | grep python-snapshot
ls -ll | grep python-snapshot.tar

（容器镜像的制作1）

一、通过容器生成镜像

1.环境准备

docker run -itd --name ubuntu-commit ubuntu
docker inspect -f "{{json .RootFS.Layers}}"  ubuntu | jq

2.查看容器修改内容

docker diff 容器名

docker exec ubuntu-commit apt-get update
docker diff ubuntu-commit

3.生成新的镜像

docker commit ubuntu-commit ub/commit
docker images

4.查看新镜像的层

docker inspect -f "{{json .RootFS.Layers}}"  ub/commit | jq

二、部署私人镜像仓库

1.部署私人镜像仓库

我们使用--network=host参数，指定容器在启动时使用Host网络模型。

docker run -d  --network=host --name registry-1 registry

2.验证网络服务

netstat -tunple | grep 5000
curl 127.0.0.1:5000/v2/_catalog

三、向私有仓库中推送镜像

如何将本地docker中的镜像推送到私有仓库中。

1.为镜像设置仓库信息

默认的docker push命令会将容器推送到docker公共仓库，为了能将镜像推送到私人仓库，

我们要使用docker tag命令为镜像设置需要推送的仓库信息。

其命令的参数为docker tag [本地镜像名] [私有仓库的URL][私有仓库的镜像名称]。

标记镜像之后，我们使用docker images命令查看会发现，

为本地镜像设置tag之后，会在本地镜像列表中生成一个新的镜像。

docker tag ub/commit 127.0.0.1:5000/ub/commit
docker images

2.向仓库推送镜像

docker push 127.0.0.1:5000/ub/commit:latest

3.通过私有仓库API验证推送

curl 127.0.0.1:5000/v2/_catalog
curl 127.0.0.1:5000/v2/ub/commit/tags/list

四、从私有仓库中拉取镜像

1.删除本地镜像

docker rmi ub/commit  
docker rmi 127.0.0.1:5000/ub/commit

2.从私有仓库中拉取镜像

docker pull 127.0.0.1:5000/ub/commit
docker images

3.查看本地镜像信息

docker inspect -f \
"{\"RepoTags\":{{json .RepoTags}}, \"RepoDigests\":{{json .RepoDigests}}}" 127.0.0.1:5000/ub/commit | jq

（容器镜像的制作2）

一、docker build快速上手

1.制作Dockerfile文件

vi Dockerfile
FROM ubuntu:latest
RUN apt-get update

2.制作容器镜像

Dockerfile文件编写完毕后，我们就就可以根据该文件，使用docker build命令来制作容器镜像，

该命令的格式为docker build -t 容器镜像名 Dockerfile所在路径。

命令的第三个参数用于指定Dockerfile文明的位置，如果Dockerfile文件就在控制台的当前目录下，一般使用.来设置。

docker build -t ub/build .
docker images

3.Dockerfile命令列表

Dockerfile文件的格式于脚本文件，每一行是一条命令，每行的格式为命令 参数。

Dockerfile主要支持的命令如下表，因篇幅的原因，

本实验中我们无法具体演示每一条指令的用法，只会讲解一些重要的命令，。

FROM

指定基础镜像，必须为第一个命令

LABEL

为镜像添加标签

RUN

构建时执行的命令行指令

ADD

将本地文件添加到容器中，如果为tar类型文件，则会自动解压，可以访问网络资源，类似wget（网络资源不会被解压）

COPY

将本地文件添加到容器中，不会解压，也不可以访问网络资源

CMD

容器启动时执行的命令，只有最后一条可以生效，可以被docker run的启动命令覆盖。

ENTRYPOINT

容器启动时执行的入口，只有最后一条可以生效，一定会被执行，不可以被覆盖。

EXPOSE

设置默认开放的网络端口（后面的实验会涉及到）

VOLUME

设置默认加载的VOLUME卷（后面的实验会涉及到）

ENV

设置环境变量。

WORKDIR

设置默认的工作目录。

USER

设置容器运行时的用户。

ONBUILD

构建触发器，当此镜像被其他镜像用作基础镜像时，触发器会被执行。

ARG

设置构建参数，可以通过docker build --build-arg将参数从外部传到到Dockerfile构建过程中。

二、Dockerfile命令详解1

Dockerfile文件中的常用的FROM，RUN，WORKDIR，ADD四个命令命令。

1.命令讲解和环境准备

mkdir dir6-1
cd dir6-1
echo 本地文件 > info.txt
echo 压缩文件 > tar.txt
tar zcvf info.tar.gz tar.txt

2.构建容器镜像

vi Dockerfile

FROM ubuntu:latest
WORKDIR data
RUN echo 容器中生成的文件 > img.txt
ADD info.txt info.txt
ADD info.tar.gz .
WORKDIR dir-robots
ADD https://www.aliyun.com/robots.txt robots.txt

然后使用docker build编译容器镜像

docker build -t img6-1 .

3.验证容器镜像

docker run -itd --name container6-1 img6-1
docker exec container6-1 pwd
docker exec container6-1 cat robots.txt

我们继续验证其他目录的文件。

这里我们使用了docker exec container6-1 ls和docker exec container6-1 cat命令。

docker exec container6-1 ls ..
docker exec container6-1 cat ../img.txt
docker exec container6-1 cat ../info.txt
docker exec container6-1 cat ../tar.txt

三、Dockerfile命令详解2

我们再来看另外的三个Dockerfile命令，分别是ENV，CMD，ENTRYPOINT。

1.ENV和CMD命令讲解

Dockfile中的ENV命令的功能相对比较简单。通过该命令我们可以为容器镜像设置环境变量。通过环境变量我们可以将一些配置信息固化在镜像中。

接下来再来看CMD命令，这个命令用来设置容器的初始化命令。

通过此命令我们可以让容器在启动时候执行一条命令，通过这条命令我们可以实现容器启动后，运行一个服务，或者在控制台输出一段文字等功能。

此命令的格式为CMD [”参数1“, ”参数2“...]。

在使用CMD命令是我们需要注意的几点是：

a. 这条命令虽然可以设置很多次，但是之后最后一次会生效。

b. 当我们使用docker run命令启动容器时，我们可以docker run 容器镜像名后面加入参数1 参数2..的形式 代替容器镜像中原有的CMD命令。

我们创建子目录，并使用vi修改Dockerfile为如下内容。并编辑为如下内容。

cd  
mkdir dir6-2

vi dir6-2/Dockerfile

FROM ubuntu:latest
ENV IMG_STRING img6-2的环境变量
CMD ["echo", "$IMG_STRING"]

Dockerfile编写完毕后，使用docker build进行编译。

docker build -t img6-2 dir6-2

2.CMD和ENTRYPOINT命令讲解

除了CMD命令之外我们还可以使用ENTRYPOINT命令来实现类似的功能。

该命令和CMD命令的格式和功能基本一致，其区别在于docker run命令只能使用--entrypoint参数替换镜像中的ENTRYPOINT设置。

在编写Dockerfile时，如果ENTRYPOINT和CMD命令同时出现的时候，容器启动时会将两个指令的参数串联起来，以ENTRYPOINT参数1, ENTRYPOINT参数2..., CMD参数1, CMD参数2...的形式执行启动命令。

因此在具体使用时，我们一般在ENTRYPOINT中设置初始化命令，在CMD中设置初始化命令的参数。需要注意的是，ENTRYPOINT和CMD命令联合使用的时候，只能使用[”参数1“, ”参数2“...]格式的参数。

我们创建子目录，并使用vi修改Dockerfile为如下内容。并编辑为如下内容。

cd  
mkdir dir6-3

vi dir6-3/Dockerfile

FROM ubuntu:latest
CMD ["-c", "echo CMD作为ENTRYPOINT的参数"]
ENTRYPOINT ["bash"]

Dockerfile编写完毕后，然后使用docker build编译容器镜像

docker build -t img6-3 dir6-3

3.验证容器镜像

docker run img6-2
docker run img6-2 ls -ll
docker run img6-3
docker run --entrypoint echo img6-3 "手动设置ENTRYPOINT和CMD"
docker run img6-3 -c "echo 手动设置CMD参数"

四、容器镜像的层次关系

1.查看镜像层次

docker inspect -f "{{json .RootFS.Layers}}" img6-1 | jq

2.查看镜像历史

docker history img6-1

3.镜像层次和镜像历史之间的关系

docker history img6-2
docker inspect -f "{{json .RootFS.Layers}}" img6-2 | jq
docker history img6-3
docker inspect -f "{{json .RootFS.Layers}}" img6-3 | jq
docker inspect -f "{{json .RootFS.Layers}}" ubuntu | jq

（容器的配置和存储）

一、配置和存储的快速上手

1.容器环境变量

docker run -it --name env1 -e ECHO=环境变量 -e NUM=123456 busybox
echo $ECHO $NUM
exit

2.容器文件复制

容器中的另一个存储方式是使用docker cp命令，在宿主机和容器之间进行文件的复制。

在文件复制时容器中文件的描述方式为，容器名:容器文件路径。

echo 本机生成的文件 > local.txt
docker run -itd --name file1 busybox
docker cp local.txt file1:/local.txt
docker exec file1 cat local.txt

3.文件的挂载

可以在创建容器的时候使用-v参数将宿主机中的文件直接挂在到容器中。

该参数的用法为-v 宿主机文件的绝对路径:容器文件的绝对路径。

二、MYSQL镜像的基本用法

1.MySQL容器的启动配置

docker pull mysql:8.0
docker run -itd --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=[MYSQL密码] mysql:8.0
docker exec -it mysql bin/bash
docker stop mysql
docker rm b1749fe24b7d
docker run -itd --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root__ mysql:8.0
docker exec -it mysql bin/bash
echo $MYSQL_ROOT_PASSWORD
exit
docker exec -it mysql mysql -uroot -p
[输入MYSQL密码]

可执行mysql命令查找状态

status
show Databases;
help
exit

三、复制修改MYSQL配置文件

docker cp将配置文件复制到宿主机中的/root/mysql/config/目录中作为副本

mkdir -p /root/mysql/config/
docker cp mysql:/etc/my.cnf /root/mysql/config/my.cnf
cat /root/mysql/config/my.cnf

四、挂载MYSQL配置文件

1.应用配置文件

我们将配置文件复制回容器中，为了让配置文件生效，我们需要使用docker restart命令重新启动容器。

docker cp /root/mysql/config/my.cnf mysql:/etc/my.cnf
docker restart mysql

2.查看配置结果

docker exec -it mysql mysql -uroot -p
[MYSQL密码]
show variables like 'general_log';
exit

3.挂载方式应用配置文件

docker run -itd --name mysql-mount -e MYSQL_ROOT_PASSWORD=[MYSQL密码] -v /root/mysql/config/my.cnf:/etc/my.cnf mysql:8.0
docker exec -it mysql-mount mysql -uroot -p
[MYSQL密码]
show variables like 'general_log';
exit

docker run -itd --name mysql-mount -e MYSQL_ROOT_PASSWORD=root__ -v /root/mysql/config/my.cnf:/etc/my.cnf mysql:8.0
docker exec -it mysql-mount mysql -uroot -p  
show variables like 'general_log';
exit

（容器的文件系统挂载）

一、容器的共享挂载

1.我们先创建一个本地文件share.txt，然后让容器挂载这个文件。

echo '宿主机初始化文件' > share.txt

docker run -itd --name share1 -v $(pwd)/share.txt:/share.txt busybox

docker exec share1 cat /share.txt

2.修改本地文件然后查看

echo '从宿主机中修改文件' >> share.txt

docker exec share1 cat /share.txt

3.容器中修改文件

docker exec share1 sh -c "echo '从容器中修改文件' >> /share.txt"

cat share.txt

二、挂载的权限配置

1.容器挂载的权限

如果用户希望控制文件在容器中是否可以被修改，那么可以用rw或者readwrite参数将挂载文件设置为读写权限，或者使用ro或者readonly参数设置为只读权限。

如果文件被设置为的文件，那么只有在宿主机侧才可以进行修改。

docker rm -f $(docker ps -aq)

echo '宿主机初始化文件' > share.txt

docker run -itd --name share-readonly -v $(pwd)/share.txt:/share.txt:ro busybox

docker exec share-readonly cat /share.txt

2.验证只读权限

echo '从宿主机中修改文件' >> share.txt

docker exec share-readonly cat /share.txt

docker exec share-readonly sh -c "echo '从只读容器中修改文件' >> /share.txt"

cat share.txt

3.多个容器同时挂载一个文件

echo '宿主机初始化文件' > share.txt

docker run -itd --name share-readwrite -v $(pwd)/share.txt:/share.txt:rw busybox

docker exec share-readonly sh -c "echo '从只读容器中修改文件' >> /share.txt"

docker exec share-readwrite sh -c "echo '从读写容器中修改文件' >> /share.txt"

cat share.txt

三、文件夹的挂载

1.准备

mkdir mount

echo '宿主机中的文件' > mount/host

vi Dockerfile  
FROM busybox:latest

RUN mkdir mount

RUN echo '容器中的文件' > /mount/image

2.挂载文件夹

docker build -t folder .

docker run -itd --name folder1 -v $(pwd)/mount:/mount folder

3.验证挂载文件夹

docker exec folder1 ls /mount

docker exec folder1 cat /mount/host

四、Apache挂载案例

1.准备

首先我们在宿主机中创建一个文件夹webfile，然后通过echo >命令在文件夹中生成一个简单的纯文本网页index.html。

mkdir webfile

echo '默认网页' > ./webfile/index.html

2.挂载网页文件夹

然后我们在启动服务时，通过-v参数将宿主机中的文件夹，覆盖挂载到Apache容器的/usr/local/apache2/htdocs目录上；并且通过端口映射将容器中的服务发布到宿主机的8000端口上。

容器启动成功之后，我们通过curl命令访问127.0.0.1:8000验证容器服务。

docker run -itd --name file_server1 -p 8000:80 -v /root/webfile:/usr/local/apache2/htdocs httpd

curl 127.0.0.1:8000

3.动态修改网页

当容器启动后，我们在宿主机中修改/webfile/index.html文件，同时创建一个新文件/webfile/host.html，然后通过curl命令验证，发现宿主机中的修改，对容器中的Apache服务已经生效。

echo '修改默认网页' >> ./webfile/index.html

echo '添加Host页面' > ./webfile/host.html

curl 127.0.0.1:8000

curl 127.0.0.1:8000/host.html

（容器中的volume卷）

一、Volume挂载简介

如何在容器中挂载文件和文件夹，这种采用绝对路径，直接挂载宿主机中的文件或者文件夹的方法又叫bind mount。这种方式比较适合将宿主机中的文件共享到容器中的场景。

除此之外docker还提供了另一种volume的方式进行挂载。这种方式通常会先在宿主机中通过docker volume命令创建一个具有名称的volume，然后再将这个volume挂载到容器中。

1.创建volume

在使用volume之间，通常需要先通过docker volume create命令创建volume。

该命令的格式为docker volume create [volume名]，和bind mount方式不同的是，volume创建之后默认并没有内容。这里我们创建名为file-vol的volume

docker volume create file-vol

2.挂载volume

在volume创建好之后，我们就可以通过docker run 的-v参数进行挂载。在使用-v参数挂载volume时，用volume名称代替宿主机路径即可。

这里我们创建并启动一个busyboxy容器，并将file-vol挂载到/file目录。

在容器创建之后，我们向volume挂载的文件夹中写入一个文件/file/text。验证挂载成功。

docker run -itd --name vol1 -v file-vol:/file busybox

docker exec vol1 sh -c "echo '向volume中写入文件' > /file/text"

docker exec vol1 ls /file

docker exec vol1 cat /file/text

3.查看volume信息

当我们在容器的挂载点中保存数据之后，数据文件会被写入到volume中，这时我们可以通过docker volume inspect或者docker inspect来查看volume的信息。

docker volume inspect file-vol

二、Volume的持久化

1.删除容器

docker stop vol1

docker rm -f vol1

docker volume inspect file-vol

2.重用volume

然后我们再创建一个新的容器vol2，并将file-vol挂载到另一个目录/file-other上。

由于之前的容器把数据存储在了volume中，因此新容器中的/file-other目录中保存vol1容器中的数据

docker run -itd --name vol2 -v file-vol:/file-other busybox

docker exec vol2 ls /file-other

docker exec vol2 cat /file-other/text

3.volume的多重绑定

如同容器可以使用多个端口绑定，容器在启动时也可以使用多个-v参数绑定多个volume，同时一个volume也可以同时绑定到多个容器中。

在容器绑定volume之后，我们还可以通过docker inspect命令通过容器筛选Mounts字段查看volume的信息

docker volume create ext-vol

docker run -itd --name vol3 -v ext-vol:/ext -v file-vol:/file busybox  
docker inspect -f "{{json .Mounts}}" vol3 | jq

三、Volume的常用命令

1.查看整体磁盘占用

在docker中，占用磁盘的对象包括容器镜像，容器，volume等，我们还可以通过docker system df -v命令可以查看所有对象的的磁盘占用。

如果docker的镜像，容器，或者volume对象较多，则可以使用-f参数添加过滤器来筛选具体某一个volume的信息。

下面的命令可以筛选出名为file-vol的volume的过滤器的信息。

docker system df -v

docker system df -v --format=\
'{{range .Volumes}}{{if eq .Name "file-vol"}}\
{{.Name}} - {{.Size}}\n{{end}}{{end}}'

2.自动创建volume

我们使用docker run 创建容器并使用-v挂载volume的时候，如果需要加载的volume还没有被创建，则docker run会自动创建volume。

docker run -itd --name vol4 -v auto-vol:/auto busybox  
docker inspect auto-vol

3.volume的自动删除

ocker也提供了删除所有当前没有被挂载的volume的指令docker volume prune，需要注意的是使用此指令时需要小心，防止数据被误删除！

docker rm -f $(docker ps -aq)  
docker volume prune -a

docker volume ls

四、在MySQL中使用Volume

1.volume的自动创建

docker run -itd --name mysql1 -v db-vol:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=[MYSQL密码] mysql

docker exec -it mysql1 mysql -uroot -p
[MYSQL密码]

docker run -itd --name mysql1 -v db-vol:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root__ mysql
docker exec -it mysql1 mysql -uroot -p

2.操作数据库

CREATE DATABASE ali_db;
USE ali_db;
CREATE TABLE ali_tab (`name` VARCHAR(100));
INSERT INTO ali_tab VALUES('aliyun');
SELECT * FROM ali_tab;
exit

3.重用MySQL数据库

接下来我们删除mysql1容器，删除之后在创建另一个名为mysql2的mysql容器。

mysql2容器创建成功后进入mysql控制台，在控制台中通过USE命令选择数据库，然后用SELECT命令查看数据记录。会发现数据库中记录仍存存在。

docker rm -f mysql1

docker run -itd --name mysql2 -v db-vol:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root__ mysql

docker exec -it mysql2 mysql -uroot -p
[MYSQL密码]

查看数据

USE ali_db;
SELECT * FROM ali_tab;
exit

（Docker Compose入门）

一、Docker Compose的安装

1.插件安装（推荐）

yum install -y docker-compose-plugin

docker compose version

2.单独应用安装

curl -SL https://github.com/docker/compose/releases/download/v2.5.0/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose

docker-compose version

二、YML到JSON的转化工具

YML文件是一种适合人类阅读的配置文件格式，这种文件格式能够表示的数据结构和JSON格式配置文件类似。

为了便于我们学习，我们先来制作一个YML和JSON的互相转换工具，以便于理解YML的格式。

1.创建转换镜像

vi Dockerfile

FROM python:latest

RUN pip install pyyaml

RUN echo "import yaml, json, sys\n\

print(json.dumps(yaml.safe_load(sys.stdin.read()), indent=4))" > 2json.py

RUN echo "import yaml, json, sys\n\

print(yaml.safe_dump(json.load(sys.stdin), sort_keys=False))" > 2yml.py

docker build -t yml/py .  
docker images

2.YML转化为JSON

echo id: '10' > demo.yml

docker run -i --rm yml/py python 2json.py < demo.yml

3.JSON转化为YML

echo \{\"name\":\"aliyun\",\"age\":100} > demo.json

docker run -i --rm yml/py python 2yml.py < demo.json

三、YML格式配置文件

vi demo1.yml

name: "aliyun"

attr:  
    age: 10

    addr: "HANGZHOU"

cat demo1.yml

docker run -i --rm yml/py python 2json.py < demo1.yml

vi demo2.yml

string: "aliyun"
number1: 10
number2: 10.01
boolean: true
# datatime: 2000-01-01 23:59:59

cat demo2.yml

docker run -i --rm yml/py python 2json.py < demo2.yml

vi demo3.yml

scores:  
    - 100
    - 90.5
    - 78

cat demo3.yml

docker run -i --rm yml/py python 2json.py < demo3.yml

四、Docker Compose快速上手

vi docker-compose.yml

version: "3.9"
services:
    busy:
        container_name: busy1
        image: "busybox:latest"
        stdin_open: true
        tty: true

docker compose up -d

docker ps

（Docker Compose部署案例）

version: "3.9"
services:
    web:
       container_name: web
       image: "httpd:latest"
       ports:
          - "5000:80"
          - "6000:8000"
    db:
       container_name: db
       image: "mysql"
       volumes:
          - "mysql-vol:/var/lib/mysql"
       environment:
          MYSQL_ROOT_PASSWORD: "[MYSQL密码]"
volumes:
    mysql-vol: {}

配置文件编写完毕后，我们通过docker compose来启动容器。

docker compose up -d

2.类Docker命令

docker compose exec db ls

docker compose cp docker-compose.yml db:/root/

docker compose exec db bin/bash -c "cat /root/docker-compose.yml"

3.容器的启停删除

docker compose pause

docker compose unpause

docker compose stop

docker compose restart

docker compose down

二、部署WordPress论坛

1.定义MySQL配置

vi db.yml

version: "3"
services:
  db:
    image: mysql:8.0
    command:
      - "--character-set-server=utf8mb4"
      - "--collation-server=utf8mb4_unicode_ci"
    volumes:
      - db_data:/var/lib/mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: [MySQL root账号密码]
      MYSQL_DATABASE: wordpress
volumes:
  db_data:

2.定义Redis配置

vi cache.yml

version: "3"
services:
  cache:
     depends_on:
       - db
     image: redis
     network_mode: "service:db"
     restart: always

3.定义WordPress配置

vi app.yml

version: "3"
services:
  db:
    ports:
      - "8000:80"
    environment:
      MYSQL_ROOT_PASSWORD: &wp_passwd [MySQL wordpress账号密码]
  app:
    depends_on:
      - db
      - cache
    image: wordpress:6.0
    network_mode: "service:db"
    restart: always
    environment:
      WORDPRESS_DB_HOST: 127.0.0.1
      WORDPRESS_DB_USER: root
      WORDPRESS_DB_PASSWORD: *wp_passwd

4.启动容器

docker compose -f db.yml -f cache.yml -f app.yml -p wp up -d

（YML配置文件的常用属性）

一、YML配置文件简介

1.环境准备

yum install -y docker-compose-plugin

vi docker-compose.yml

version: "3.9"
services:
    web:
       container_name: web
       image: "httpd:latest"
       ports:
          - "5000:80"
          - "6000:8000"
    db:
       container_name: db
       image: "mysql"
       volumes:
          - "mysql-vol:/var/lib/mysql"
       environment:
          MYSQL_ROOT_PASSWORD: "[MYSQL密码]"
volumes:
    mysql-vol: {}

docker compose up -d

2.配置文件基本讲解

在通过docker compose up启动容器之后，我们来看一下docker_comose.yml的配置文件结构。

在docker_compose中，一个project可以包含多个配置文件中的内容，

如果没有设置所有的资源都会创建在root这个project中，

在project中serviecs字段中的每一个key表示一个serviec，

每个service下又可以由一个或多个container，在service中的基本配置选项如下表。

container_name

等同于--name

image

容器镜像

volumes

等价于-v，类型为数组

ports

等价于-p，类型为数组

environment

等价于ie，类型为对象

需要注意的是，默认情况下docker compose会为每个project自动创建一个network，接下来创建的所有的容器都会连接到这个network，我们来验证容器的配置。

docker network ls

docker port web

docker inspect -f "{{json .Mounts}}"  db | jq

3.容器状态查询

我们演示docker compose ps，docker compose top，docker compose images三个命令

docker compose ps

docker compose top

docker compose images

docker compose down

二、YML的常用配置项目

在上一个小节中我们演示了docker compose的主要配置和常用命令，

接下来我们再来看一下docker compose配置文件中的其他配置项目。

yml中的一部分配置选项可以和docker run中的命令行对应，这些属性主要包括在下表中，在本小节中我们来实验这些属性。

stdin_open

设置为true等价于-i参数

tty

设置为true等价于-t参数

networ_mode

网络模式

networks

容器连接的网络，类型为数组

1.编写配置文件

在docker compose中默认使用docker-compose.yml配置文件，  

如果我们想使用不同名称的配置文件，可以在docker compose后面添加-f参数指定yml文件。

我们使用vi创建一个web.yml文件以演示配置选项。

创建之后，我们启动project，在启动时我们可以通过-p参数指定资源所在的Project，以避免资源橙色图，这里我们指定project为web。

vi web.yml

version: "3.9"
services:
    busybox:
        container_name: sh
        image: "busybox:latest"
        tty: true
        stdin_open: true
        networks:
            - "custom"
    python:
        container_name: web
        image: "python"
        network_mode: "host"
        command: "python -m http.server 8000"
networks:
    custom:
        name: "custom"

docker compose -f web.yml -p web up -d

2.创建Project并验证

docker inspect -f '{"Tty":{{.Config.Tty}},"OpenStdin":{{.Config.OpenStdin}}}' sh | jq

docker inspect -f "{{json .NetworkSettings.Networks}}" sh | jq

3.查看配置信息

docker compose -f web.yml -p web convert busybox

docker compose -f web.yml -p web convert python

三、YML的其他配置项目

在本小节中我们再来看三个并不是和docker run 命令参数有对应关系的docker compose属性值的用法。

deploy.replicas

可以选择Service中容器的部署个数。

depends_on

可以选择Service启动的先后顺序

restart

设置Service的重启策略

1.容器个数

deploy:
            replicas: 3

2.启动顺序

depends_on:
            - "busybox-before"
            - "busybox"

3.重启策略

restart: "always"

因此在生产环境中，我们一般会配置使用restart属性。该属性可以根据值得不同设定容器得自动重启策略。

常用得属性值包括：no不自动重启，always总是自动重启，on-failure错误退出时重启。

四、Flask的build联动案例

1.环境准备

mkdir app

vi app/main.py

# 导入Flask类
from flask import Flask  
# 创建app对象
app = Flask(__name__)

# 将对路径"/"得访问路由到函数index上
@app.route('/')
def index():
    return '网页首页\n'

# 将对路径"/Host"得访问路由到函数index上
@app.route('/host')

def host():
    return '访问Host路径\n'

# 启动app对象中得服务，并指导服务端口为8000
if __name__ == '__main__':
    app.run(host="0.0.0.0", port=8000)

vi app/Dockerfile

FROM python
RUN pip install Flask
ADD main.py /app/main.py
WORKDIR /app/
CMD python main.py

vi build.yml

version: "3.9"
services:
    app:
        build: app/
#       build:  
#           context: app/
#           dockerfile: Dockerfile
        ports:  
            - "8080:8000"
        restart: "always"

docker compose -f build.yml -p build up -d

docker compose -f build.yml -p build ps

curl 127.0.0.1:8080

curl 127.0.0.1:8080/host