# 快速入门

# 部署 MySQL

首先，利用 Docker 来安装一个 MySQL 软件。使用 Docker 安装，仅仅需要一步即可，在命令行输入下面的命令（建议采用 CV 大法）：

docker run -d \

  --name mysql \

  -p 3306:3306 \

  -e TZ=Asia/Shanghai \

  -e MYSQL_ROOT_PASSWORD=123 \

  mysql

MySQL 安装完毕！通过任意客户端工具即可连接到 MySQL

Docker 会根据命令中的镜像名称自动搜索并下载镜像，Docker 官方提供了一个专门管理、存储镜像的网站，并对外开放了镜像上传、下载的权利。Docker 官方提供了一些基础镜像，然后各大软件公司又在基础镜像基础上，制作了自家软件的镜像，全部都存放在这个网站。这个网站就成了 Docker 镜像交流的社区：

基本上我们常用的各种软件都能在这个网站上找到，我们甚至可以自己制作镜像上传上去。

像这种提供存储、管理 Docker 镜像的服务器，被称为 DockerRegistry，可以翻译为镜像仓库。DockerHub 网站是官方仓库，阿里云、华为云会提供一些第三方仓库，我们也可以自己搭建私有的镜像仓库。

官方仓库在国外，下载速度较慢，一般我们都会使用第三方仓库提供的镜像加速功能，提高下载速度。而企业内部的机密项目，往往会采用私有镜像仓库。

总之，镜像的来源有两种：

• 基于官方基础镜像自己制作
• 直接去 DockerRegistry 下载

# 命令解读

利用 Docker 快速的安装了 MySQL，非常的方便，不过我们执行的命令到底是什么意思呢？

docker run -d \

  --name mysql \

  -p 3306:3306 \

  -e TZ=Asia/Shanghai \

  -e MYSQL_ROOT_PASSWORD=123 \

  mysql

解读：

• docker run -d ：创建并运行一个容器， -d 则是让容器以后台进程运行
• --name mysql : 给容器起个名字叫 mysql ，你可以叫别的
• -p 3306:3306 : 设置端口映射。
  • 容器是隔离环境，外界不可访问。但是可以将宿主机端口映射容器内到端口，当访问宿主机指定端口时，就是在访问容器内的端口了。
  • 容器内端口往往是由容器内的进程决定，例如 MySQL 进程默认端口是 3306，因此容器内端口一定是 3306；而宿主机端口则可以任意指定，一般与容器内保持一致。
  • 格式： -p 宿主机端口:容器内端口 ，示例中就是将宿主机的 3306 映射到容器内的 3306 端口
• -e TZ=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

镜像的名称不是随意的，而是要到 DockerRegistry 中寻找，镜像运行时的配置也不是随意的，要参考镜像的帮助文档，这些在 DockerHub 网站或者软件的官方网站中都能找到。

# Docker 基础

# 常见命令

可以参考官方文档：

# 命令介绍

其中，比较常见的命令有：

用一副图来表示这些命令的关系：

补充：

默认情况下，每次重启虚拟机我们都需要手动启动 Docker 和 Docker 中的容器。通过命令可以实现开机自启：

# Docker 开机自启

systemctl enable docker

# Docker 容器开机自启

docker update --restart=always [容器名/容器id]

# 演示

以 Nginx 为例演示上述命令。

# 第 1 步，去 DockerHub 查看 nginx 镜像仓库及相关信息

# 第 2 步，拉取 Nginx 镜像

docker pull nginx

# 第 3 步，查看镜像

docker images

# 结果如下：

REPOSITORY   TAG       IMAGE ID       CREATED         SIZE

nginx        latest    605c77e624dd   16 months ago   141MB

mysql        latest    3218b38490ce   17 months ago   516MB

# 第 4 步，创建并允许 Nginx 容器

docker run -d --name nginx -p 80:80 nginx

# 第 5 步，查看运行中容器

docker ps

# 也可以加格式化方式访问，格式会更加清爽

<!--swig2-->

# 第 6 步，访问网页，地址：http:// 虚拟机地址

# 第 7 步，停止容器

docker stop nginx

# 第 8 步，查看所有容器

<!--swig3-->

# 第 9 步，再次启动 nginx 容器

docker start nginx

# 第 10 步，再次查看容器

<!--swig4-->

# 第 11 步，查看容器详细信息

docker inspect nginx

# 第 12 步，进入容器，查看容器内目录

docker exec -it nginx bash

# 或者，可以进入 MySQL

docker exec -it mysql mysql -uroot -p

# 第 13 步，删除容器

docker rm nginx

# 发现无法删除，因为容器运行中，强制删除容器

docker rm -f nginx

# 命令别名

下面是一些常用的 vim 命令：

#进入编辑模式： i （在当前位置插入，开始编辑）；

#保存编辑文本： :w (英文冒号，保存当前编辑的文件）；

#退出编辑文件： :q（英文冒号，退出当前编辑的文件）；

#保存并退出： :wq （英文冒号，保存并退出当前编辑的文件）；

#强制退出：    :q! （英文冒号，强制退出不保存）。

给常用 Docker 命令起别名，方便我们访问：

# 修改 /root/.bashrc 文件

vi /root/.bashrc

内容如下：

# .bashrc

# User specific aliases and functions

alias rm='rm -i'

alias cp='cp -i'

alias mv='mv -i'

<!--swig5-->

alias dis='docker images'

# Source global definitions

if [ -f /etc/bashrc ]; then

        . /etc/bashrc

fi

然后，执行命令使别名生效

source /root/.bashrc

#或者 source ~/.bashrc

# 数据卷

容器是隔离环境；容器内程序的文件、配置、运行时产生的容器都在容器内部，我们要读写容器内的文件非常不方便。那么就产生了几个问题：

• 如果要升级 MySQL 版本，需要销毁旧容器，那么数据岂不是跟着被销毁了？
• MySQL、Nginx 容器运行后，如果我要修改其中的某些配置该怎么办？
• 我想要让 Nginx 代理我的静态资源怎么办？

因此，容器提供程序的运行环境，但是程序运行产生的数据、程序运行依赖的配置都应该与容器解耦。

# 什么是数据卷

数据卷（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 代理了。

# 数据卷命令

数据卷的相关命令有：

注意：容器与数据卷的挂载要在创建容器时配置，对于创建好的容器，是不能设置数据卷的。而且创建容器的过程中，数据卷会自动创建。

演示一下 nginx 的 html 目录挂载

#（可选）删除容器内若有 nginx 则要先删除，否则会冲突

docker rm -f nginx

# 1. 首先创建容器并指定数据卷，注意通过 -v 参数来指定数据卷

#在执行 docker run 命令时，使用 - v 数据卷：容器内目录可完成数据卷挂载

docker run -d --name nginx -p 80:80 -v html:/usr/share/nginx/html nginx

# 2. 然后查看数据卷

docker volume ls

# 结果

DRIVER    VOLUME NAME

local     29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f

local     html

# 3. 查看数据卷详情

docker volume inspect html

# 结果

[

    {

        "CreatedAt": "2024-05-17T19:57:08+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

# 6. 打开页面，查看效果

# 7. 进入容器内部，查看 /usr/share/nginx/html 目录内的文件是否变化

docker exec -it nginx bash

MySQL 会自动挂载数据卷：演示一下 MySQL 的匿名数据卷

# 1. 查看 MySQL 容器详细信息

docker inspect mysql

# 关注其中.Config.Volumes 部分和.Mounts 部分

我们关注两部分内容，第一是 .Config.Volumes 部分：

{

  "Config": {

    //... 略

    "Volumes": {

      "/var/lib/mysql": {}

    }

    //... 略

  }

}

可以发现这个容器声明了一个本地目录，需要挂载数据卷，但是数据卷未定义。这就是匿名卷。

然后，我们再看结果中的 .Mounts 部分：

{

  "Mounts": [

    {

      "Type": "volume",

      "Name": "29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f",

      "Source": "/var/lib/docker/volumes/29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f/_data",

      "Destination": "/var/lib/mysql",

      "Driver": "local",

    }

  ]

}

可以发现，其中有几个关键属性：

• Name：数据卷名称。由于定义容器未设置容器名，这里的就是匿名卷自动生成的名字，一串 hash 值。
• Source：宿主机目录
• Destination : 容器内的目录

上述配置是将容器内的 /var/lib/mysql 这个目录，与数据卷 29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f 挂载。于是在宿主机中就有了 /var/lib/docker/volumes/29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f/_data 这个目录。这就是匿名数据卷对应的目录，其使用方式与普通数据卷没有差别。

接下来，可以查看该目录下的 MySQL 的 data 文件：

ls -l /var/lib/docker/volumes/29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f/_data

注意：每一个不同的镜像，将来创建容器后内部有哪些目录可以挂载，可以参考 DockerHub 对应的页面

# 挂载本地目录或文件

可以发现，数据卷的目录结构较深，如果我们去操作数据卷目录会不太方便。在很多情况下，我们会直接将容器目录与宿主机指定目录挂载。挂载语法与数据卷类似：

# 挂载本地目录

-v 本地目录:容器内目录

# 挂载本地文件

-v 本地文件:容器内文件

例如：

-v mysql:/var/lib/mysql # 会被识别为一个数据卷叫 mysql，运行时会自动创建这个数据卷

-v ./mysql:/var/lib/mysql # 会被识别为当前目录下的 mysql 目录，运行时如果不存在会创建目录

删除并重新创建 mysql 容器，并完成本地目录挂载：

• 挂载 /root/mysql/data 到容器内的 /var/lib/mysql 目录
• 挂载 /root/mysql/init 到容器内的 /docker-entrypoint-initdb.d 目录（初始化的 SQL 脚本目录）
• 挂载 /root/mysql/conf 到容器内的 /etc/mysql/conf.d 目录（这个是 MySQL 配置文件目录）

#删除 mysql

docker rm -f mysql

#切换到 /root 目录下

cd ~

#在 /root 目录下创建 mysql 目录

mkdir mysql

#切换到 /root/mysql 目录下

cd mysql/

#创建相应的 data、conf、init 目录

mkdir data

mkdir conf

mkdir init

接下来，本地目录挂载：

# 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. 查看 root 目录，可以发现～/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

这样即使删除 mysql 或者做升级，也不会丢失数据。

# 镜像

前面我们一直在使用别人准备好的镜像，那如果我要部署一个 Java 项目，把它打包为一个镜像该怎么做呢？

# 镜像结构

要想自己构建镜像，必须先了解镜像的结构。

镜像之所以能让我们快速跨操作系统部署应用而忽略其运行环境、配置，就是因为镜像中包含了程序运行需要的系统函数库、环境、配置、依赖。

因此，自定义镜像本质就是依次准备好程序运行的基础环境、依赖、应用本身、运行配置等文件，并且打包而成。

举个栗子，我们要从 0 部署一个 Java 应用，大概流程是这样：

• 准备一个 linux 服务（CentOS 或者 Ubuntu 均可）
• 安装并配置 JDK
• 上传 Jar 包
• 运行 jar 包

那因此，我们打包镜像也是分成这么几步：

• 准备 Linux 运行环境（java 项目并不需要完整的操作系统，仅仅是基础运行环境即可）
• 安装并配置 JDK
• 拷贝 jar 包
• 配置启动脚本

上述步骤中的每一次操作其实都是在生产一些文件（系统运行环境、函数库、配置最终都是磁盘文件），所以镜像就是一堆文件的集合。

但需要注意的是，镜像文件不是随意堆放的，而是按照操作的步骤分层叠加而成，每一层形成的文件都会单独打包并标记一个唯一 id，称为 Layer（层）。这样，如果我们构建时用到的某些层其他人已经制作过，就可以直接拷贝使用这些层，而不用重复制作。

例如，第一步中需要的 Linux 运行环境，通用性就很强，所以 Docker 官方就制作了这样的只包含 Linux 运行环境的镜像。我们在制作 java 镜像时，就无需重复制作，直接使用 Docker 官方提供的 CentOS 或 Ubuntu 镜像作为基础镜像。然后再搭建其它层即可，这样逐层搭建，最终整个 Java 项目的镜像结构如图所示：

# Dockerfile

由于制作镜像的过程中，需要逐层处理和打包，比较复杂，所以 Docker 就提供了自动打包镜像的功能。我们只需要将打包的过程，每一层要做的事情用固定的语法写下来，交给 Docker 去执行即可。

而这种记录镜像结构的文件就称为 Dockerfile，其对应的语法可以参考官方文档：

https://docs.docker.com/engine/reference/builder/

其中的语法比较多，比较常用的有：

例如，要基于 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"]

所以，就有人提供了基础的系统加 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"]

是不是简单多了。

# 构建镜像

当 Dockerfile 文件写好以后，就可以利用命令来构建镜像了。

我们准备好一个 demo 项目及对应的 Dockerfile：

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 images

# 结果

REPOSITORY    TAG       IMAGE ID       CREATED          SIZE

docker-demo   1.0       d6ab0b9e64b9   27 minutes ago   327MB

nginx         latest    605c77e624dd   16 months ago    141MB

mysql         latest    3218b38490ce   17 months ago    516MB

然后尝试运行该镜像：

# 1. 创建并运行容器

docker run -d --name dd -p 8080:8080 docker-demo:1.0

# 2. 查看容器

dps

# 结果

CONTAINER ID   IMAGE             PORTS                                                  STATUS         NAMES

78a000447b49   docker-demo:1.0   0.0.0.0:8080->8080/tcp, :::8090->8090/tcp              Up 2 seconds   dd

f63cfead8502   mysql             0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp   Up 2 hours     mysql

# 3. 访问

curl localhost:8080/hello/count

# 结果：

<h5>欢迎访问黑马商城, 这是您第1次访问<h5>

# 网络

我们创建了一个 Java 项目的容器，而 Java 项目往往需要访问其它各种中间件，例如 MySQL、Redis 等。现在，我们的容器之间能否互相访问呢？我们来测试一下

首先，我们查看下 MySQL 容器的详细信息，重点关注其中的网络 IP 地址：

# 1. 用基本命令，寻找 Networks.bridge.IPAddress 属性

docker inspect mysql

# 也可以使用 format 过滤结果

<!--swig6-->

# 得到 IP 地址如下：

172.17.0.2

# 2. 然后通过命令进入 dd 容器

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 的网络功能来解决这个问题，官方文档：

https://docs.docker.com/engine/reference/commandline/network/

常见命令有：

学习使用 “自定义网络 “

# 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 ms

OK，现在无需记住 IP 地址也可以实现容器互联了。

总结：

• 在自定义网络中，可以给容器起多个别名，默认的别名是容器名本身
• 加入自定义网络的容器才可以通过容器名互相访问