前言：本人练习使用的是阿里云服务器，配置为：
一：配置docker镜像加速
由于docker自带的镜像仓库地址速度很慢，甚至国内访问不了，所以需要做下镜像加速设置：
# 创建目录
mkdir -p /etc/docker# 复制内容
tee /etc/docker/daemon.json <<-'EOF'
{"registry-mirrors": ["http://hub-mirror.c.163.com","https://mirrors.tuna.tsinghua.edu.cn","http://mirrors.sohu.com","https://ustc-edu-cn.mirror.aliyuncs.com","https://ccr.ccs.tencentyun.com","https://docker.m.daocloud.io","https://docker.awsl9527.cn"]
}
EOF# 重新加载配置
systemctl daemon-reload# 重启Docker
systemctl restart docker# Docker开机自启
systemctl enable docker# Docker容器开机自启
docker update --restart=always [容器名/容器id] #容器名跟容器id要替换成具体机器上的容器名称或者容器ID
二：docker练习-安装mysql
docker安装mysql只需要一行命令：
docker run -d \--name mysql \-p 3306:3306 \-e TZ=Asia/Shanghai \-e MYSQL_ROOT_PASSWORD=mysql123 \mysql运行后，服务器就已经用docker安装并启动好mysql了，由于我是在阿里云服务器部署的mysql，所以需要做下端口开发安全组设置，设置只允许我本机地址访问。
设置后就可以远程访问mysql了。
安装mysql的命令解读
-
docker run -d：创建并运行一个容器，-d则是让容器以后台进程运行 -
--namemysql: 给容器起个名字叫mysql，也可以叫别的 -
-p 3306:3306: 设置端口映射。-
容器是隔离环境，外界不可访问。但是可以将宿主机端口映射容器内到端口，当访问宿主机指定端口时，就是在访问容器内的端口了。
-
容器内端口往往是由容器内的进程决定，例如MySQL进程默认端口是3306，因此容器内端口一定是3306；而宿主机端口则可以任意指定，一般与容器内保持一致。
-
格式：
-p 宿主机端口:容器内端口，示例中就是将宿主机的3306映射到容器内的3306端口
-
-
-eTZ=Asia/Shanghai: 配置容器内进程运行时的一些参数-
格式：
-e KEY=VALUE，KEY和VALUE都由容器内进程决定 -
案例中，
TZ=Asia/Shanghai是设置时区；MYSQL_ROOT_PASSWORD=123是设置MySQL默认密码
-
-
mysql: 设置镜像名称，Docker会根据这个名字搜索并下载镜像-
格式：
REPOSITORY:TAG，例如mysql:8.0，其中REPOSITORY可以理解为镜像名，TAG是版本号 -
在未指定
TAG的情况下，默认是最新版本，也就是mysql:latest
-
三：docker常见命令
|
命令
|
说明
|
|---|---|
|
docker pull
|
拉取镜像
|
|
docker push
|
推送镜像到DockerRegistry
|
|
docker images
|
查看本地镜像
|
|
docker rmi
|
删除本地镜像
|
|
docker run
|
创建并运行容器（不能重复创建）
|
|
docker stop
|
停止指定容器
|
|
docker start
|
启动指定容器
|
|
docker restart
|
重新启动容器
|
|
docker rm
|
删除指定容器
|
|
docker ps
|
查看容器
|
|
docker logs
|
查看容器运行日志
|
|
docker exec
|
进入容器
|
|
docker save
|
保存镜像到本地压缩文件
|
|
docker load
|
加载本地压缩文件到镜像
|
|
docker inspect
|
查看容器详细信息
|
用一副图来表示这些命令的关系：
四：docker练习-用docker安装nginx
# 第1步，拉取Nginx镜像
docker pull nginx# 第2步，查看镜像
docker images# 第3步，创建并允许Nginx容器
docker run -d --name nginx -p 80:80 nginx# 第4步，查看运行中容器
docker ps
# 使用加格式化方式查看容器，格式会更加清爽
docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"# 第5步，执行docker run 后服务器就已经启动完成nginx了，访问网页，地址：http://服务器地址# 第6步，停止容器
docker stop nginx# 第7步，查看所有容器
docker ps -a --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"# 第8步，再次启动nginx容器
docker start nginx# 第9步，再次查看容器
docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"# 第10步，查看容器详细信息
docker inspect nginx# 第11步，进入容器,查看容器内目录
docker exec -it nginx bash
# 或者，可以进入MySQL
docker exec -it mysql mysql -uroot -p
#退出容器内部
exit# 第12步，删除容器
docker rm nginx
# 发现无法删除，因为容器运行中，强制删除容器
docker rm -f nginx
五：命令别名
平时我们比较常用的命令而命令又比较长的时候，可以给常用命令起别名，方便我们使用命令，给命令起别名操作如下：
# 修改/root/.bashrc文件
vi /root/.bashrc
内容如下：
# .bashrc# User specific aliases and functionsalias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'
alias dps='docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"'
alias dis='docker images'# Source global definitions
if [ -f /etc/bashrc ]; then. /etc/bashrc
fi然后，执行命令使别名生效
source /root/.bashrc下面我们就可以用别名快速使用命令了
六：数据卷（volume）
容器是隔离环境，容器内程序的文件、配置、运行时产生的容器都在容器内部，我们作为宿主机要读写容器内的文件非常不方便。举个例子：
我们进入到nginx容器内部，修改index.html文件，会发现容器内部根本没提供vi,vim等命令，这是因为docker容器只包含应用运行必备的一些命令，像vi,vim这些非运行必须命令，docker不会自动为容器创建，然而我们又时常需要读写容器内的文件，那么就需要用到数据卷。进入nginx容器内部并且编辑index.html命令如下：
docker exec -it nginx bash
cd /usr/share/nignx/html/
ls
vi index.html
通过这些命令测试，会发现Nignx容器内部并没有帮我们准备vi命令
6.1.什么是数据卷
数据卷（volume）是一个虚拟目录，是容器内目录与宿主机目录之间映射的桥梁。
以Nginx为例，我们知道Nginx中有两个关键的目录：
- html：放置一些静态资源
- conf：放置配置文件
如果我们要让Nginx代理我们的静态资源，最好是放到html目录；如果我们要修改Nginx的配置，最好是找到conf下的nginx.conf文件。
但遗憾的是，容器运行的Nginx所有的文件都在容器内部，而往往容器内部只是提供基本的运行应用的命令，对于许多读写的命令都缺失，所以我们必须利用数据卷将两个目录与宿主机目录关联，方便我们操作。如图：
在上图中：
- 我们在宿主机创建了两个数据卷：conf、html
- Nginx容器内部的conf目录和html目录分别与宿主机的两个数据卷关联。
- 而数据卷conf和html分别指向了宿主机的/var/lib/docker/volumes/conf/_data目录和/var/lib/docker/volumes/html/_data目录
这样一来，容器内的conf和html目录就 与宿主机的conf和html目录关联起来，我们称为挂载。此时，我们操作宿主机的/var/lib/docker/volumes/html/_data就是在操作容器内的/usr/share/nginx/html/_data目录。只要我们将静态资源放入宿主机对应目录，就可以被Nginx代理了。
注意：/var/lib/docker/volumes这个目录就是默认的存放所有容器数据卷的目录，其下再根据数据卷名称创建新目录，格式为/数据卷名/_data。6.2.数据卷命令
数据卷的相关命令有：
|
命令
|
说明
|
|---|---|
|
docker volume create
|
创建数据卷
|
|
docker volume ls
|
查看所有数据卷
|
|
docker volume rm
|
删除指定数据卷
|
|
docker volume inspect
|
查看某个数据卷的详情
|
|
docker volume prune
|
清除数据卷
|
注意：容器与数据卷的挂载要在创建容器时配置，对于创建好的容器，是不能设置数据卷的。而且创建容器的过程中，数据卷会自动创建。
下面通过使用启动nginx容器并且指定数据卷示范：
# 1.首先创建容器并指定数据卷，注意通过 -v 参数来指定数据卷
#-v的命令格式为： -v [宿主机目录]:[容器目录],表示将宿主机目录挂载到容器对应目录下
docker run -d --name nginx -p 80:80 -v html:/usr/share/nginx/html nginx #此条命令表示将宿主机下的名称为“html”的数据卷挂载到nginx容器内的html目录# 2.然后查看数据卷
docker volume ls
# 结果
DRIVER VOLUME NAME
local 910db54d1b4258f008996234ba454421207884cd9f7939f2352202e5e9fba9e1
local html# 3.查看数据卷详情
docker volume inspect html
# 结果
[{"CreatedAt": "2025-03-04T21:33:15+08:00","Driver": "local","Labels": null,"Mountpoint": "/var/lib/docker/volumes/html/_data","Name": "html","Options": null,"Scope": "local"}
]# 4.查看宿主机/var/lib/docker/volumes/html/_data目录
ll /var/lib/docker/volumes/html/_data
# 可以看到宿主机的目录与容器内的nginx的html目录内容一样，结果如下：
总用量 8
-rw-r--r-- 1 root root 497 12月 28 2021 50x.html
-rw-r--r-- 1 root root 615 12月 28 2021 index.html# 5.进入该目录，并随意修改index.html内容
cd /var/lib/docker/volumes/html/_data
vi index.html #此处我将nignx的H1标题改成"Hello my friend"接下来，我们访问nginx查看效果：
这里可以观察到我们只是在宿主机修改了挂载到nignx容器的html文件，修改后，nignx容器的更新生效了，为了证明nignx容器内部的html文件是否真的被修改了，我们可以进入容器内部，查看容器内的/usr/share/nginx/html目录内的文件是否变化
docker exec -it nginx bashcat /usr/share/nginx/html/index.html
证明了一点：宿主机的数据卷与容器是双向映射的，修改宿主机的数据卷，就等同于在修改容器内的数据。
6.3：匿名数据卷
# 1.查看MySQL容器详细信息
docker inspect mysql
# 关注其中.Config.Volumes部分和.Mounts部分我们关注两部分内容，第一是
.Config.Volumes部分：{"Config": {// ... 略"Volumes": {"/var/lib/mysql": {}}// ... 略}
} 
然后，我们再看结果中的
.Mounts部分： "Mounts": [{"Type": "volume","Name": "910db54d1b4258f008996234ba454421207884cd9f7939f2352202e5e9fba9e1","Source": "/var/lib/docker/volumes/910db54d1b4258f008996234ba454421207884cd9f7939f2352202e5e9fba9e1/_data","Destination": "/var/lib/mysql","Driver": "local","Mode": "","RW": true,"Propagation": ""}],可以发现，其中有几个关键属性：
-
Name：数据卷名称。由于定义容器未设置容器名，这里的就是匿名卷自动生成的名字，一串hash值。
-
Source：宿主机目录
-
Destination : 容器内的目录
上述配置是将容器内的
/var/lib/mysql这个目录，与数据卷29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f挂载。于是在宿主机中就有了/var/lib/docker/volumes/29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f/_data这个目录。这就是匿名数据卷对应的目录，其使用方式与普通数据卷没有差别。接下来，可以查看该目录下的MySQL的data文件：
ls -l /var/lib/docker/volumes/910db54d1b4258f008996234ba454421207884cd9f7939f2352202e5e9fba9e1/_data6.4：挂载本地目录或文件
上面我们使用数据卷挂载时可以发现，数据卷的目录结构往往都比较深，如果我们去操作数据卷目录会不太方便。为了方便操作，我们会直接将容器目录与宿主机指定目录挂载。挂载语法与数据卷类似。
# 挂载本地目录
-v 本地目录:容器内目录
# 挂载本地文件
-v 本地文件:容器内文件注意：本地目录或文件必须以
/ 或 ./开头，如果直接以名字开头，会被识别为数据卷名而非本地目录名。例如：
-v mysql:/var/lib/mysql # 会被识别为一个数据卷叫mysql，运行时会自动创建这个数据卷
-v ./mysql:/var/lib/mysql # 会被识别为当前目录下的mysql目录，运行时如果不存在会创建目录下面我们做个挂载本地目录练习：
-
挂载
/root/mysql/data到容器内的/var/lib/mysql目录 -
挂载
/root/mysql/init到容器内的/docker-entrypoint-initdb.d目录（初始化的SQL脚本目录） -
挂载
/root/mysql/conf到容器内的/etc/mysql/conf.d目录（这个是MySQL配置文件目录）
第一步：先上传init文件和conf文件上传到服务器，然后执行以下命令：
# 1.删除原来的MySQL容器
docker rm -f mysql# 2.进入root目录
cd ~# 3.创建并运行新mysql容器，挂载本地目录
docker run -d \--name mysql \-p 3306:3306 \-e TZ=Asia/Shanghai \-e MYSQL_ROOT_PASSWORD=123 \-v ./mysql/data:/var/lib/mysql \-v ./mysql/conf:/etc/mysql/conf.d \-v ./mysql/init:/docker-entrypoint-initdb.d \mysql# 4.查看mysql目录，可以发现~/mysql/data目录已经自动创建好了
ls -l mysql
# 结果：
总用量 4
drwxr-xr-x. 2 root root 20 5月 19 15:11 conf
drwxr-xr-x. 7 polkitd root 4096 5月 19 15:11 data
drwxr-xr-x. 2 root root 23 5月 19 15:11 init# 查看data目录，会发现里面有大量数据库数据，说明数据库完成了初始化
ls mysql/data# 5.查看MySQL容器内数据
# 5.1.进入MySQL
docker exec -it mysql mysql -uroot -p123
# 5.2.查看编码表
show variables like "%char%";
# 5.3.结果，发现编码是utf8mb4没有问题
+--------------------------+--------------------------------+
| Variable_name | Value |
+--------------------------+--------------------------------+
| character_set_client | utf8mb4 |
| character_set_connection | utf8mb4 |
| character_set_database | utf8mb4 |
| character_set_filesystem | binary |
| character_set_results | utf8mb4 |
| character_set_server | utf8mb4 |
| character_set_system | utf8mb3 |
| character_sets_dir | /usr/share/mysql-8.0/charsets/ |
+--------------------------+--------------------------------+# 6.查看数据
# 6.1.查看数据库
show databases;
# 结果，hmall是黑马商城数据库
+--------------------+
| Database |
+--------------------+
| hmall |
| information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+
5 rows in set (0.00 sec)
# 6.2.切换到hmall数据库
use hmall;
# 6.3.查看表
show tables;
# 结果：
+-----------------+
| Tables_in_hmall |
+-----------------+
| address |
| cart |
| item |
| order |
| order_detail |
| order_logistics |
| pay_order |
| user |
+-----------------+
# 6.4.查看address表数据
+----+---------+----------+--------+----------+-------------+---------------+-----------+------------+-------+
| id | user_id | province | city | town | mobile | street | contact | is_default | notes |
+----+---------+----------+--------+----------+-------------+---------------+-----------+------------+-------+
| 59 | 1 | 北京 | 北京 | 朝阳区 | 13900112222 | 金燕龙办公楼 | 李佳诚 | 0 | NULL |
| 60 | 1 | 北京 | 北京 | 朝阳区 | 13700221122 | 修正大厦 | 李佳红 | 0 | NULL |
| 61 | 1 | 上海 | 上海 | 浦东新区 | 13301212233 | 航头镇航头路 | 李佳星 | 1 | NULL |
| 63 | 1 | 广东 | 佛山 | 永春 | 13301212233 | 永春武馆 | 李晓龙 | 0 | NULL |
+----+---------+----------+--------+----------+-------------+---------------+-----------+------------+-------+
4 rows in set (0.00 sec)
七：镜像（Images）
7.1镜像结构
前面我们演示mysql,nginx都是在使用别人准备好的镜像，那如果我要部署一个Java项目，把它打包为一个镜像该怎么做呢？
要想自己构建镜像，必须先了解镜像的结构。镜像之所以能让我们快速跨操作系统部署应用而忽略其运行环境、配置，就是因为镜像中包含了程序运行需要的系统函数库、环境、配置、依赖。
因此，自定义镜像本质就是依次准备好程序运行的基础环境、依赖、应用本身、运行配置等文件，并且打包而成。
举个例子，我们要从0部署一个Java应用，大概流程是这样：
-
准备一个linux服务器（CentOS或者Ubuntu均可）
-
安装并配置JDK
-
上传Jar包
-
运行jar包
那么我们打包镜像也是分成这么几步：
-
准备Linux运行环境（java项目并不需要完整的操作系统，仅仅是基础运行环境即可）
-
安装并配置JDK
-
准备Java项目打包好的jar包
-
配置启动脚本
上述步骤中的每一次操作其实都是在生产一些文件（系统运行环境、函数库、配置最终都是磁盘文件），所以镜像就是一堆文件的集合。
但需要注意的是，镜像文件不是随意堆放的，而是按照操作的步骤分层叠加而成，每一层形成的文件都会单独打包并标记一个唯一id，称为Layer（层）。这样，如果我们构建时用到的某些层其他人已经制作过，就可以直接拷贝使用这些层，而不用重复制作。
例如，第一步中需要的Linux运行环境，通用性就很强，所以Docker官方就制作了这样的只包含Linux运行环境的镜像。我们在制作java镜像时，就无需重复制作，直接使用Docker官方提供的CentOS或Ubuntu镜像作为基础镜像。然后再搭建其它层即可，这样逐层搭建，最终整个Java项目的镜像结构如图所示：
由于制作镜像的过程中，需要逐层处理和打包，比较复杂，所以Docker就提供了自动打包镜像的功能。我们只需要将打包的过程，每一层要做的事情用固定的语法写下来，交给Docker去执行即可。这种记录镜像结构的文件就称为Dockerfile，其对应的语法可以参考官方文档：https://docs.docker.com/engine/reference/builder/
7.2 Docker File
docker file的语法比较多，比较常用的有：
|
指令
|
说明
|
示例
|
|---|---|---|
|
FROM
|
指定基础镜像
|
FROM centos:6 |
|
ENV
|
设置环境变量，可在后面指令使用
|
ENV key value |
|
COPY
|
拷贝本地文件到镜像的指定目录
|
COPY ./xx.jar /tmp/app.jar |
|
RUN
|
执行Linux的shell命令，一般是安装过程的命令
|
RUN yum install gcc |
|
EXPOSE
|
指定容器运行时监听的端口，是给镜像使用者看的
|
EXPOSE 8080
|
|
ENTRYPOINT
|
镜像中应用的启动命令，容器运行时调用
|
ENTRYPOINT java -jar xx.jar
|
例如，要基于Ubuntu镜像来构建一个Java应用，其Dockerfile内容如下：
# 指定基础镜像
FROM ubuntu:16.04
# 配置环境变量，JDK的安装目录、容器内时区
ENV JAVA_DIR=/usr/local
ENV TZ=Asia/Shanghai
# 拷贝jdk和java项目的包
COPY ./jdk8.tar.gz $JAVA_DIR/
COPY ./docker-demo.jar /tmp/app.jar
# 设定时区
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 安装JDK
RUN cd $JAVA_DIR \&& tar -xf ./jdk8.tar.gz \&& mv ./jdk1.8.0_144 ./java8
# 配置环境变量
ENV JAVA_HOME=$JAVA_DIR/java8
ENV PATH=$PATH:$JAVA_HOME/bin
# 指定项目监听的端口
EXPOSE 8080
# 入口，java项目的启动命令
ENTRYPOINT ["java", "-jar", "/app.jar"]这里存在一个问题：以后我们会有很多很多java项目需要打包为镜像，他们都需要Linux系统环境、JDK环境这两层，只有上面的3层不同（因为jar包不同）。如果每次制作java镜像都重复制作前两层镜像，是不是很麻烦，因此就有人提供了基础的系统加JDK环境，我们在此基础上制作java镜像，就可以省去JDK的配置了：
# 基础镜像
FROM openjdk:11.0-jre-buster
# 设定时区
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 拷贝jar包
COPY docker-demo.jar /app.jar
# 入口
ENTRYPOINT ["java", "-jar", "/app.jar"]这样一来是不是简单多了。
7.3 构建镜像
当Dockerfile文件写好以后，就可以利用命令来构建镜像了。
这里准备好了一个demo项目及对应的Dockerfile：首先，我们将资料提供的
docker-demo.jar包以及Dockerfile拷贝到虚拟机的/root/demo目录，然后执行命令构建镜像：# 进入镜像目录
cd /root/demo
# 开始构建
docker build -t docker-demo:1.0 .命令说明：
-
docker build: 就是构建一个docker镜像 -
-t docker-demo:1.0：-t参数是指定镜像的名称（repository和tag） -
.: 最后的点是指构建时Dockerfile所在路径，由于我们进入了demo目录，所以指定的是.代表当前目录，也可以直接指定Dockerfile目录：
# 直接指定Dockerfile目录
docker build -t docker-demo:1.0 /root/demo结果：
查看镜像列表，发现成功构建出一个docker-demo的镜像：
# 查看镜像列表：
docker images
# 结果
REPOSITORY TAG IMAGE ID CREATED SIZE
docker-demo 1.0 62bd304a1d76 About a minute ago 319MB
minio/minio latest 1ef859c0288a 11 months ago 158MB
aerokube/selenoid latest 3c2e705d6a11 11 months ago 16.6MB
aerokube/selenoid-ui latest c175ed498566 12 months ago 18.2MB
aerokube/selenoid latest-release b0be3a476a08 13 months ago 18.4MB
selenoid/vnc chrome_117.0 6546b96d2eb3 17 months ago 1.22GB
selenoid/vnc chrome_104.0 fbfc55ec3a1d 2 years ago 1.14GB
selenoid/vnc firefox_103.0 4d894e5a1cd8 2 years ago 1.13GB
nginx latest 605c77e624dd 3 years ago 141MB
mysql latest 3218b38490ce 3 years ago 516MB
selenoid/video-recorder latest-release 654b710209f9 4 years ago 37.6MB
selenoid/video-recorder latest c8018c23fcb7 6 years ago 30.4MB然后尝试运行该镜像：
# 1.创建并运行容器
docker run -d --name dd -p 8080:8080 docker-demo:1.0
# 2.查看容器
dps
# 结果
CONTAINER ID IMAGE PORTS STATUS NAMES
016e5bd094d1 docker-demo:1.0 0.0.0.0:8080->8080/tcp, :::8080->8080/tcp Up 4 seconds dd
39e07a03e80f mysql 0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp Up 28 minutes mysql
d24f9e8c586a nginx 0.0.0.0:80->80/tcp, :::80->80/tcp Up 2 hours nginx
45b07845d3f7 minio/minio Up 4 hours minio
# 3.访问
curl 服务器地址:8080/hello/count
# 结果：
<h5>欢迎访问黑马商城, 这是您第1次访问<h5>八：网络
前面我们创建了一个Java项目的容器，而Java项目往往需要访问其它各种中间件，例如MySQL、Redis等。那么容器之间能否互相访问呢？我们来测试一下
首先，我们查看下MySQL容器的详细信息，重点关注其中的网络IP地址：
# 1.用基本命令，寻找Networks.bridge.IPAddress属性
docker inspect mysql
# 也可以使用format过滤结果
docker inspect --format='{{range .NetworkSettings.Networks}}{{println .IPAddress}}{{end}}' mysql
# 得到IP地址如下：
172.17.0.2# 2.然后通过命令进入dd容器，dd容器是我们前面docker-demo项目
docker exec -it dd bash# 3.在容器内，通过ping命令测试网络
ping 172.17.0.2
# 结果
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.053 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.059 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.058 ms实验结果发现可以互联，这里貌似没有问题。但是，容器的网络IP其实是一个虚拟的IP，其值并不固定与某一个容器绑定，如果我们在开发时写死某个IP，而在部署时很可能MySQL容器的IP会发生变化，连接容易失败。所以，我们必须借助于docker的网络功能来解决这个问题，docker网络的官方文档：https://docs.docker.com/engine/reference/commandline/network/
8.1 docker网络常见命令
|
命令
|
说明
|
文档地址
|
|---|---|---|
|
docker network create
|
创建一个网络
|
docker network create
|
|
docker network ls
|
查看所有网络
|
docs.docker.com
|
|
docker network rm
|
删除指定网络
|
docs.docker.com
|
|
docker network prune
|
清除未使用的网络
|
docs.docker.com
|
|
docker network connect
|
使指定容器连接加入某网络
|
docs.docker.com
|
|
docker network disconnect
|
使指定容器连接离开某网络
|
docker network disconnect
|
|
docker network inspect
|
查看网络详细信息
|
docker network inspect
|
演示自定义网络
# 1.首先通过命令创建一个网络
docker network create hmall# 2.然后查看网络
docker network ls
# 结果：
NETWORK ID NAME DRIVER SCOPE
639bc44d0a87 bridge bridge local
403f16ec62a2 hmall bridge local
0dc0f72a0fbb host host local
cd8d3e8df47b none null local
# 其中，除了hmall以外，其它都是默认的网络# 3.让dd和mysql都加入该网络，注意，在加入网络时可以通过--alias给容器起别名
# 这样该网络内的其它容器可以用别名互相访问！
# 3.1.mysql容器，指定别名为db，另外每一个容器都有一个别名是容器名
docker network connect hmall mysql --alias db
# 3.2.db容器，也就是我们的java项目
docker network connect hmall dd# 4.进入dd容器，尝试利用别名访问db
# 4.1.进入容器
docker exec -it dd bash
# 4.2.用db别名访问
ping db
# 结果
PING db (172.18.0.2) 56(84) bytes of data.
64 bytes from mysql.hmall (172.18.0.2): icmp_seq=1 ttl=64 time=0.070 ms
64 bytes from mysql.hmall (172.18.0.2): icmp_seq=2 ttl=64 time=0.056 ms
# 4.3.用容器名访问
ping mysql
# 结果：
PING mysql (172.18.0.2) 56(84) bytes of data.
64 bytes from mysql.hmall (172.18.0.2): icmp_seq=1 ttl=64 time=0.044 ms
64 bytes from mysql.hmall (172.18.0.2): icmp_seq=2 ttl=64 time=0.054 msOK，现在无需记住IP地址也可以实现容器互联了。
总结：
-
在自定义网络中，可以给容器起多个别名，默认的别名是容器名本身
-
在同一个自定义网络中的容器，可以通过别名互相访问
九：黑马商城项目部署
前面一大通的阐述是为了熟悉了Docker的基本用法，接下来可以尝试部署项目了。
项目说明：
-
hmall：商城的后端代码
-
hmall-portal：商城用户端的前端代码
-
hmall-admin：商城管理端的前端代码
部署的容器及端口说明：
|
项目
|
容器名
|
端口
|
备注
|
|---|---|---|---|
|
hmall
|
hmall
|
8080
|
黑马商城后端API入口
|
|
hmall-portal
|
nginx
|
18080
|
黑马商城用户端入口
|
|
hmall-admin
|
18081
|
黑马商城管理端入口
|
|
|
mysql
|
mysql
|
3306
|
数据库
|
在正式部署前，我们先删除之前的nginx、dd两个容器：
docker rm -f nginx dd9.1 部署Java项目
hmall项目是一个maven聚合项目，使用IDEA打开hmall项目，查看项目结构如图：
我们要部署的就是其中的
hm-service，其中的配置文件采用了多环境的方式：
其中的
application-dev.yaml是部署到开发环境的配置，application-local.yaml是本地运行时的配置。查看application.yaml，会发现其中的JDBC地址并未写死，而是读取变量：
这两个变量在
application-dev.yaml和application-local.yaml中并不相同：
接下来将项目打包：
结果
将
hm-service目录下的Dockerfile和hm-service/target目录下的hm-service.jar一起上传到服务器的root/hmall目录部署项目：
cd /root/hmall# 1.构建项目镜像，不指定tag，则默认为latest
docker build -t hmall .# 2.查看镜像
docker images
# 结果
REPOSITORY TAG IMAGE ID CREATED SIZE
hmall latest d7eac12ec1e1 5 seconds ago 370MB
docker-demo 1.0 62bd304a1d76 47 minutes ago 319MB
minio/minio latest 1ef859c0288a 11 months ago 158MB
aerokube/selenoid latest 3c2e705d6a11 11 months ago 16.6MB
aerokube/selenoid-ui latest c175ed498566 12 months ago 18.2MB
aerokube/selenoid latest-release b0be3a476a08 13 months ago 18.4MB
selenoid/vnc chrome_117.0 6546b96d2eb3 17 months ago 1.22GB
selenoid/vnc chrome_104.0 fbfc55ec3a1d 2 years ago 1.14GB
selenoid/vnc firefox_103.0 4d894e5a1cd8 2 years ago 1.13GB
nginx latest 605c77e624dd 3 years ago 141MB
mysql latest 3218b38490ce 3 years ago 516MB
selenoid/video-recorder latest-release 654b710209f9 4 years ago 37.6MB
selenoid/video-recorder latest c8018c23fcb7 6 years ago 30.4MB
# 3.创建并运行容器，并通过--network将其加入hmall网络，这样才能通过容器名访问mysql
docker run -d --name hmall --network hmall -p 8080:8080 hmall测试访问接口：http://自己的服务器地址:8080/search/list
9.2 部署前端
hmall-portal和hmall-admin是前端代码，需要基于nginx部署，在资料中给大家提供了nginx的部署目录：其中：
-
html是静态资源目录，我们需要把hmall-portal以及hmall-admin都复制进去 -
nginx.conf是nginx的配置文件，主要是完成对html下的两个静态资源目录做代理
我们现在要做的就是把整个nginx目录上传到虚拟机的
/root/hmall目录下,然后创建nginx容器并完成两个挂载：
-
把
/root/nginx/nginx.conf挂载到/etc/nginx/nginx.conf -
把
/root/nginx/html挂载到/usr/share/nginx/html
由于需要让nginx同时代理hmall-portal和hmall-admin两套前端资源，因此我们需要暴露两个端口：
-
18080：对应hmall-portal
-
18081：对应hmall-admin
命令如下：
docker run -d \--name nginx \-p 18080:18080 \-p 18081:18081 \-v /root/nginx/html:/usr/share/nginx/html \-v /root/nginx/nginx.conf:/etc/nginx/nginx.conf \--network hmall \nginx测试，通过浏览器访问：http://你的虚拟机ip:18080
十： DockerCompose
前面我们通过DockerFile方式部署项目可以看到，我们部署一个简单的java项目，其中包含3个容器：
-
MySQL
-
Nginx
-
Java项目
而稍微复杂的项目，其中还会有各种各样的其它中间件，需要部署的东西远不止3个。如果还像之前那样手动的逐一部署，就太麻烦了。Docker Compose就可以帮助我们实现多个相互关联的Docker容器的快速部署。它允许用户通过一个单独的 docker-compose.yml 模板文件（YAML 格式）来定义一组相关联的应用容器。
10.1 dockerCompose基本语法
docker-compose.yml文件的基本语法可以参考官方文档：https://docs.docker.com/reference/compose-file/legacy-versions
docker-compose文件中可以定义多个相互关联的应用容器，每一个应用容器被称为一个服务（service）。由于service就是在定义某个应用的运行时参数，因此与
docker run参数非常相似。举例来说，用docker run部署MySQL的命令如下：
docker run -d \--name mysql \-p 3306:3306 \-e TZ=Asia/Shanghai \-e MYSQL_ROOT_PASSWORD=123 \-v ./mysql/data:/var/lib/mysql \-v ./mysql/conf:/etc/mysql/conf.d \-v ./mysql/init:/docker-entrypoint-initdb.d \--network hmallmysql如果用
docker-compose.yml文件来定义，就是这样：version: "3.8"services:mysql:image: mysqlcontainer_name: mysqlports:- "3306:3306"environment:TZ: Asia/ShanghaiMYSQL_ROOT_PASSWORD: 123volumes:- "./mysql/conf:/etc/mysql/conf.d"- "./mysql/data:/var/lib/mysql"networks:- new
networks:new:name: hmall对比如下：
|
docker run 参数
|
docker compose 指令
|
说明
|
|---|---|---|
|
--name
|
container_name
|
容器名称
|
|
-p
|
ports
|
端口映射
|
|
-e
|
environment
|
环境变量
|
|
-v
|
volumes
|
数据卷配置
|
|
--network
|
networks
|
网络
|
基本语法如下：
docker compose [OPTIONS] [COMMAND]其中，OPTIONS和COMMAND都是可选参数，比较常见的有：
|
类型
|
参数或指令
|
说明
|
|---|---|---|
|
Options
|
-f
|
指定compose文件的路径和名称
|
|
-p
|
指定project名称。project就是当前compose文件中设置的多个service的集合，是逻辑概念
|
|
|
Commands
|
up
|
创建并启动所有service容器
|
|
down
|
停止并移除所有容器、网络
|
|
|
ps
|
列出所有启动的容器
|
|
|
logs
|
查看指定容器的日志
|
|
|
stop
|
停止容器
|
|
|
start
|
启动容器
|
|
|
restart
|
重启容器
|
|
|
top
|
查看运行的进程
|
|
|
exec
|
在指定的运行中容器中执行命令
|
下面使用docker-compose方式部署项目。
# 1.进入hmall目录
cd /root/hmall# 2.新建docker-compose文件
touch docker-compose.yml
vi docker-compose.yml
# docker-compose.yml的内容如下：
version: "3.8"services:mysql:image: mysqlcontainer_name: mysqlports:- "3306:3306"environment:TZ: Asia/ShanghaiMYSQL_ROOT_PASSWORD: 123volumes:- "./mysql/conf:/etc/mysql/conf.d"- "./mysql/data:/var/lib/mysql"- "./mysql/init:/docker-entrypoint-initdb.d"networks:- hm-nethmall:build: context: .dockerfile: Dockerfilecontainer_name: hmallports:- "8080:8080"networks:- hm-netdepends_on:- mysqlnginx:image: nginxcontainer_name: nginxports:- "18080:18080"- "18081:18081"volumes:- "./nginx/nginx.conf:/etc/nginx/nginx.conf"- "./nginx/html:/usr/share/nginx/html"depends_on:- hmallnetworks:- hm-net
networks:hm-net:name: hmall# 3.删除旧容器
docker rm -f $(docker ps -qa)# 4.删除hmall镜像
docker rmi hmall# 5.清空MySQL数据
rm -rf mysql/data# 6.启动所有, -d 参数是后台启动
docker compose up -d
# 结果：
[+] Building 15.5s (8/8) FINISHED=> [internal] load build definition from Dockerfile 0.0s=> => transferring dockerfile: 358B 0.0s=> [internal] load .dockerignore 0.0s=> => transferring context: 2B 0.0s=> [internal] load metadata for docker.io/library/openjdk:11.0-jre-buster 15.4s=> [1/3] FROM docker.io/library/openjdk:11.0-jre-buster@sha256:3546a17e6fb4ff4fa681c3 0.0s=> [internal] load build context 0.0s=> => transferring context: 98B 0.0s=> CACHED [2/3] RUN ln -snf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 0.0s=> CACHED [3/3] COPY hm-service.jar /app.jar 0.0s=> exporting to image 0.0s=> => exporting layers 0.0s=> => writing image sha256:32eebee16acde22550232f2eb80c69d2ce813ed099640e4cfed2193f71 0.0s=> => naming to docker.io/library/root-hmall 0.0s
[+] Running 4/4✔ Network hmall Created 0.2s✔ Container mysql Started 0.5s✔ Container hmall Started 0.9s✔ Container nginx Started 1.5s# 7.查看镜像
docker compose images
# 结果
CCONTAINER REPOSITORY TAG IMAGE ID SIZE
hmall hmall-hmall latest 4617c0538d39 370MB
mysql mysql latest 3218b38490ce 516MB
nginx nginx latest 605c77e624dd 141MB# 8.查看容器
docker compose ps
# 结果
AME IMAGE COMMAND SERVICE CREATED STATUS PORTS
hmall hmall-hmall "java -jar /app.jar" hmall 6 minutes ago Up 6 minutes 0.0.0.0:8080->8080/tcp, :::8080->8080/tcp
mysql mysql "docker-entrypoint.s…" mysql 6 minutes ago Up 6 minutes 0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp
nginx nginx "/docker-entrypoint.…" nginx 6 minutes ago Up 6 minutes 80/tcp, 0.0.0.0:18080-18081->18080-18081/tcp, :::18080-18081->18080-18081/tcp
