Docker学习笔记-EW帮帮网

环境全部基于 CentOS 9

文章目录

`Docker` 安装
`Docker` 拉取 `MySQL`
`Docker` 常见命令
- 设置常用命令别名
`Docker` 数据卷
`Docker` 自定义镜像
`Docker` 网络
- `Docker` 网络概述
- 自定义网络例子
`Docker` 项目部署

`Docker` 安装

第一步：卸载旧版

yum remove docker \
    docker-client \
    docker-client-latest \
    docker-common \
    docker-latest \
    docker-latest-logrotate \
    docker-logrotate \
    docker-engine \
    docker-selinux

第二步：配置 `Docker` 的 `yum` 库

首先要安装一个yum工具

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

安装成功后，执行命令，配置 Docker 的 yum 源（阿里云源）：

sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

sudo sed -i 's+download.docker.com+mirrors.aliyun.com/docker-ce+' /etc/yum.repos.d/docker-ce.repo

更新 yum，建立缓存

sudo yum makecache fast

第三步：安装 `Docker`

yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

第四步：启动和校验

# 启动Docker
systemctl start docker

# 停止Docker
systemctl stop docker

# 重启
systemctl restart docker

# 设置开机自启
systemctl enable docker

# 执行docker ps命令，如果不报错，说明安装启动成功
docker ps

第五步：配置镜像加速

2025适配有效

sudo mkdir -p /etc/docker

向配置文件写入镜像源

sudo tee /etc/docker/daemon.json <<-'EOF'
{
    "registry-mirrors": [
    	"https://docker.m.daocloud.io",
    	"https://docker.imgdb.de",
    	"https://docker-0.unsee.tech",
    	"https://docker.hlmirror.com",
    	"https://docker.1ms.run",
    	"https://func.ink",
    	"https://lispy.org",
    	"https://docker.xiaogenban1993.com"
    ]
}
EOF

重启 docker 服务

sudo systemctl daemon-reload && sudo systemctl restart docker

验证：出现图片内容说明成功

在这里插入图片描述
注意：换源后，可以成功pull，但是search会出错，因为国内政策问题。除非挂梯子，

`Docker` 拉取 `MySQL`

自动配置完 MySQL 后就可以用任意 SQL 客户端连接 Linux 的 ip 的 MySQL 了。
,
Docker原理：Docker 自动从远程仓库自动搜索并下载 MySQL。注意：这里下载的不是安装包，而是镜像。镜像中不仅包含了MySQL本身，还包含了其运行所需要的环境、配置、系统级函数库。因此它在运行时就有自己独立的环境，就可以跨系统运行，也不需要手动再次配置环境了。这套独立运行的隔离环境我们称为容器。
.
说明：

镜像：英文是image

容器：英文是container

在这里插入图片描述

docker run -d \
  --name mysql \
  -p 3306:3306 \ 
  -e TZ=Asia/Shanghai \
  -e MYSQL_ROOT_PASSWORD=Ting123321 \ #密码改成自己的
  mysql:8.0.33

在这里插入图片描述

`Docker` 常见命令

docker | Docker Docs

在这里插入图片描述

命令	说明	文档地址
docker pull	拉取镜像到本地	docker pull
docker push	推送镜像到 `DockerRegistry`	docker push
docker images	查看本地镜像	docker images
docker rmi	删除本地镜像	docker rmi
docker run	创建并运行容器（不能重复创建）	docker run
docker stop	停止指定容器	docker stop
docker start	启动指定容器	docker start
docker restart	重新启动容器	docker restart
docker rm	删除指定容器	docs.docker.com
docker ps	查看启动的容器	docker ps
docker logs	查看容器运行日志	docker logs
docker exec	进入容器	docker exec
docker save	保存镜像到本地压缩文件	docker save
docker load	加载本地压缩文件到镜像	docker load
docker inspect	查看容器详细信息	docker inspect

举例

# 第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
# 也可以加格式化方式访问，格式会更加清爽
docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"

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

# 第7步，停止容器
docker stop nginx

# 第8步，查看所有容器
docker ps -a --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"

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

# 第10步，再次查看容器
docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"

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

设置常用命令别名

配置命令别名

# 修改/root/.bashrc文件
vi /root/.bashrc

# User specific aliases and functions
alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'
# dps = docker ps 格式化查看所有运行中的容器
alias dps='docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"'
# dis = docker images 查看所有存在的镜像
alias dis='docker images'

让命令生效

source /root/.bashrc

`Docker` 数据卷

`Docker` 数据卷概述

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

数据卷命令

注意：容器与数据卷的挂载要在创建容器时配置，对于创建好的容器，是不能设置数据卷的。而且创建容器的过程中，数据卷会自动创建。也就是我们必须在 run 阶段指定数据卷

命令	说明
docker volume create	创建数据卷
docker volume ls	查看所有数据卷
docker volume rm	删除指定数据卷
docker volume inspect / docker inspect	查看某个数据卷的详情 / 查看某个容器详细信息
docker volume prune	清除数据卷

案例

# 1.首先创建容器并指定数据卷，注意通过 -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,
        //这里是宿主机目录 /var/lib/docker/volumes/html/_data 隐射到 虚拟目录 /usr/share/nginx/html 也就是这两个目录是共享的
        "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 的数据卷自动挂载了一个随意命名的文件。很乱。所以我们一般会手动挂载

/var/lib/mysql：要映射的 mysql 容器内部的数据库文件相关

/docker-entrypoint-initdb.d：初始化的SQL脚本目录

/etc/mysql/conf.d：MySQL配置文件目录

我们一般会在 root 下创建 mysql/data，mysql/init, mysql/conf 这几个目录。然后映射到这几个目录上
# 挂载本地目录
-v 本地目录:容器内目录
# 挂载本地文件
-v 本地文件:容器内文件

注意：本地目录或文件必须以 / 或 ./开头，如果直接以名字开头，会被识别为数据卷名而非本地目录名。

-v mysql:/var/lib/mysql # 会被识别为一个数据卷叫mysql，运行时会自动创建这个数据卷。然后映射到/var/lib/mysql
-v ./mysql:/var/lib/mysql # 会被识别为当前目录下的mysql目录，运行时如果不存在会创建目录

在这里插入图片描述
演示

# 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:8.0.33

# 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

# 查看data目录，会发现里面有大量数据库数据，说明数据库完成了初始化
ls -l 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)

`Docker` 自定义镜像

`Docker` 自定义镜像概述

前面我们一直在使用别人准备好的镜像，那如果我要部署一个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/

比较常用的有：

指令	说明	示例
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镜像都重复制作前两层镜像，是不是很麻烦。
.
所以，就有人提供了基础的linux系统加JDK环境基础镜像，我们在此基础上制作java镜像，就可以省去JDK的配置了：

# 基础镜像 可以直接 pull 或者 下载好基础镜像 tar 包然后 load 加载一下
FROM openjdk:11.0-jre-buster #jdk 换其他可以
# 设定时区
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 拷贝jar包
COPY docker-demo.jar /app.jar #部署其他 jar 包就换个名字
# 入口
ENTRYPOINT ["java", "-jar", "/app.jar"]

构建 `Java` 项目镜像

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

拷贝写好的 Dockerfile 和 jar 包到指定的目录比如 /root/demo

在这里插入图片描述

然后指定命令构建镜像
- docker build : 就是构建一个docker镜像
- -t docker-demo:1.0 ：-t参数是指定镜像的名称（repository和tag）
- . : 最后的点是指构建时Dockerfile所在路径，由于我们进入了demo目录，所以指定的是.代表当前目录，也可以直接指定Dockerfile目录：

# 进入镜像目录
cd /root/demo
# 开始构建
docker build -t docker-demo:1.0 .

查看镜像列表

# 查看镜像列表：
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>

`Docker` 网络

`Docker` 网络概述

Java项目往往需要访问其它各种中间件，例如MySQL、Redis，容器之间可以相互访问，但是，容器的网络IP其实是一个虚拟的IP，其值并不固定与某一个容器绑定，如果我们在开发时写死某个IP，而在部署时很可能MySQL容器的IP会发生变化，连接会失败。所以，我们必须借助于docker的网络功能来解决这个问题，

官方文档：

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

常见命令

命令	说明
docker network create	创建一个网络
docker network ls	查看所有网络
docker network rm	删除指定网络
docker network prune	清除未使用的网络
docker network connect	使指定容器连接加入某网络
docker network disconnect	使指定容器连接离开某网络
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 ms

总结：

在自定义网络中，可以给容器起多个别名，默认的别名是容器名本身

在同一个自定义网络中的容器，可以通过别名互相访问

`Docker` 项目部署

先部署 `MySQL`

拉镜像

挂载数据卷

#查看启动的 MYSQL 容器，有的话删掉
docker ps
#删除之前的 MYSQL 容器
docker docker rm -f [CONTAINER ID]

#创建目录用于挂载
#然后把自己的配置拖进去
cd ~
mkdir mysql
cd mysql
mkdir conf
mkdir data
mkdir init

#在root文件夹下面创建 mysql 文件夹 然后 mysql 文件夹下面分别创建 conf data init 文件夹
#然后拉取 mysql 镜像然后 启动容器。或者 pull 过了 直接进行这一步也行 
#注意挂载的宿主机路径可以修改, 但是关联虚拟路径是规定的路径不能更改
docker run -d \
  --name mysql \
  -p 3306:3306 \
  -e TZ=Asia/Shanghai \
  -e MYSQL_ROOT_PASSWORD=123 \
  -v /root/mysql/data:/var/lib/mysql \
  -v /root/mysql/conf:/etc/mysql/conf.d \
  -v /root/mysql/init:/docker-entrypoint-initdb.d \
  mysql:8.0.25
  
#进行 mysql 容器内部 shell
docker exec -it mysql mysql -uroot -p123

配置网路组

# 看一下有没有自定义的网络组, 没有就自己创建一下
docker network ls
docker network create heima

# 查看自己的容器有没有关联进去 比如 heima
docker network inspect mysql

# 没有就绑定一下 后期前端后端都要配置进这个网络组
# alias 是别名
docker network connect heima mysql --alias db

部署后端

编写 DockerFile

# 基础镜像 可以直接 pull 或者 下载好基础镜像 tar 包然后 load 加载一下
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 hm-service.jar /app.jar
# 入口
ENTRYPOINT ["java", "-jar", "/app.jar"]

使用 maven 的 package 打成 jar 包，然后和 DockerFile 一起复制到自己想复制到的没目录，

在这里插入图片描述

切换到这个目录开始构建项目
- 注意网络组绑定名称

# 1.构建项目镜像，不指定tag，则默认为latest
docker build -t hmall .

# 2.查看镜像
docker images
# 结果
REPOSITORY    TAG       IMAGE ID       CREATED          SIZE
hmall         latest    0bb07b2c34b9   43 seconds ago   362MB
docker-demo   1.0       49743484da68   24 hours ago     327MB
nginx         latest    605c77e624dd   16 months ago    141MB
mysql         latest    3218b38490ce   17 months ago    516MB

# 3.创建并运行容器，并通过--network将其加入heima网络，这样才能通过容器名访问mysql
docker run -d --name hmall --network heima -p 8080:8080 hmall

#测试，通过浏览器访问：http://你的虚拟机地址:8080/search/list

部署前端

把 nignx 文件夹复制到想放的目录

在这里插入图片描述

然后完成 nginx 数据卷挂载和网络组绑定
- 注意挂载路径
- 还有网络组名称

docker run -d \
  --name nginx \
  -p 18080:18080 \
  -p 18081:18081 \
  -v /root/heimashop/nginx/html:/usr/share/nginx/html \
  -v /root/heimashop/nginx/nginx.conf:/etc/nginx/nginx.conf \
  --network heima \ 
  nginx

`DockerCompose` 自动部署

模板

# 指定 Docker Compose 文件的版本，这里使用的是 3.8 版本
version: "3.8"

# 定义服务，每个服务代表一个容器
services:
  # 定义名为 mysql 的服务
  mysql:
    # 指定使用的 Docker 镜像，这里使用官方的 MySQL 镜像
    image: mysql
    # 为容器指定一个名称，方便后续管理
    container_name: mysql
    # 进行端口映射，将宿主机的 3306 端口映射到容器内部的 3306 端口
    ports:
      - "3306:3306"
    # 设置容器的环境变量
    environment:
      # 设置时区为亚洲/上海
      TZ: Asia/Shanghai
      # 设置 MySQL 的 root 用户密码为 123
      MYSQL_ROOT_PASSWORD: 123
    # 进行数据卷挂载，实现数据持久化和配置文件挂载
    volumes:
      # 将宿主机当前目录下的 mysql/conf 目录挂载到容器内的 /etc/mysql/conf.d 目录，用于自定义 MySQL 配置
      - "./mysql/conf:/etc/mysql/conf.d"
      # 将宿主机当前目录下的 mysql/data 目录挂载到容器内的 /var/lib/mysql 目录，用于存储 MySQL 数据
      - "./mysql/data:/var/lib/mysql"
      # 将宿主机当前目录下的 mysql/init 目录挂载到容器内的 /docker-entrypoint-initdb.d 目录，用于在容器启动时初始化数据库
      - "./mysql/init:/docker-entrypoint-initdb.d"
    # 指定容器要加入的网络
    networks:
      - hm-net

  # 定义名为 hmall 的服务
  hmall:
    # 构建自定义镜像的配置
    build: 
      # 指定构建上下文的路径，这里使用当前目录
      context: .
      # 指定 Dockerfile 的路径，这里使用当前目录下的 Dockerfile
      dockerfile: Dockerfile
    # 为容器指定一个名称，方便后续管理
    container_name: hmall
    # 进行端口映射，将宿主机的 8080 端口映射到容器内部的 8080 端口
    ports:
      - "8080:8080"
    # 指定容器要加入的网络
    networks:
      - hm-net
    # 定义服务之间的依赖关系，hmall 服务依赖于 mysql 服务，即 mysql 服务会先启动
    depends_on:
      - mysql

  # 定义名为 nginx 的服务
  nginx:
    # 指定使用的 Docker 镜像，这里使用官方的 Nginx 镜像
    image: nginx
    # 为容器指定一个名称，方便后续管理
    container_name: nginx
    # 进行端口映射，将宿主机的 18080 和 18081 端口分别映射到容器内部的 18080 和 18081 端口
    ports:
      - "18080:18080"
      - "18081:18081"
    # 进行数据卷挂载，实现配置文件和静态文件挂载
    volumes:
      # 将宿主机当前目录下的 nginx/nginx.conf 文件挂载到容器内的 /etc/nginx/nginx.conf 文件，用于自定义 Nginx 配置
      - "./nginx/nginx.conf:/etc/nginx/nginx.conf"
      # 将宿主机当前目录下的 nginx/html 目录挂载到容器内的 /usr/share/nginx/html 目录，用于存放 Nginx 静态文件
      - "./nginx/html:/usr/share/nginx/html"
    # 定义服务之间的依赖关系，nginx 服务依赖于 hmall 服务，即 hmall 服务会先启动
    depends_on:
      - hmall
    # 指定容器要加入的网络
    networks:
      - hm-net

# 定义网络
networks:
  # 定义名为 hm-net 的网络
  hm-net:
    # 为网络指定一个名称，这里将网络命名为 hmall
    name: hmall

在这里插入图片描述

Docker学习笔记

文章目录

`Docker` 安装

第一步：卸载旧版

第二步：配置 `Docker` 的 `yum` 库

第三步：安装 `Docker`

第四步：启动和校验

第五步：配置镜像加速

`Docker` 拉取 `MySQL`

`Docker` 常见命令

设置常用命令别名

`Docker` 数据卷

`Docker` 数据卷概述

数据卷命令

`MySQL` 的数据挂载

`Docker` 自定义镜像

`Docker` 自定义镜像概述

`DockerFile`

例如基于 `Ubuntu` 镜像构建 `Java` 应用，其 `Dockerfile` 内容如下

构建 `Java` 项目镜像

`Docker` 网络

`Docker` 网络概述

自定义网络例子

`Docker` 项目部署

先部署 `MySQL`

配置网路组

部署后端

部署前端

`DockerCompose` 自动部署

网站公告

今日签到

热门文章

最新发布

Docker学习笔记

文章目录

Docker 安装

第一步：卸载旧版

第二步：配置 Docker 的 yum 库

第三步：安装 Docker

第四步：启动和校验

第五步：配置镜像加速

Docker 拉取 MySQL

Docker 常见命令

设置常用命令别名

Docker 数据卷

Docker 数据卷概述

数据卷命令

MySQL 的数据挂载

Docker 自定义镜像

Docker 自定义镜像概述

DockerFile

例如基于 Ubuntu 镜像构建 Java 应用，其 Dockerfile 内容如下

构建 Java 项目镜像

Docker 网络

Docker 网络概述

自定义网络例子

Docker 项目部署

先部署 MySQL

配置网路组

部署后端

部署前端

DockerCompose 自动部署

网站公告

今日签到

热门文章

最新发布

`Docker` 安装

第二步：配置 `Docker` 的 `yum` 库

第三步：安装 `Docker`

`Docker` 拉取 `MySQL`

`Docker` 常见命令

`Docker` 数据卷

`Docker` 数据卷概述

`MySQL` 的数据挂载

`Docker` 自定义镜像

`Docker` 自定义镜像概述

`DockerFile`

例如基于 `Ubuntu` 镜像构建 `Java` 应用，其 `Dockerfile` 内容如下

构建 `Java` 项目镜像

`Docker` 网络

`Docker` 网络概述

`Docker` 项目部署

先部署 `MySQL`

`DockerCompose` 自动部署