- 命令太多了，记不住
- 软件安装包名字复杂，不知道去哪里找
- 安装和部署步骤复杂，容易出错
什么是 Docker
Docker 是一个开源的应用容器引擎，可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。
我们知道，软件的安装是要区分系统环境的；即使是运行环境相同，依赖的版本一旦有所出入，也容易出现"我这里明明好使，你那里为啥不行"的问题。容器技术解决了环境一致性与依赖管理的问题。
因此，容器是我们的项目的运行环境，而 docker 是容器的运行环境与管理平台。
关键词
镜像 (Image)
镜像是构建容器的模板，可以简单理解为类似 Js 中的 class 类或构造函数。
镜像中详细记录了应用所需的运行环境、应用代码、如何操作系统文件等等信息；
容器 (Container)
容器是镜像的运行实例。可以简单理解为"new 镜像()"的实例，通过 docker 命令可以任意创建容器。
当前操作系统（宿主机）与容器之间的关系，可以参照浏览器页面与 iframe 之间的关系。容器可以拥有独立的 IP 地址，网络，文件系统以及指令等；容器与容器、容器与"宿主机"之间以隔离的方式运行，每个容器中通常运行着一个（或多个）应用。
仓库 (Registry)
仓库是集中管理镜像的地方。类似于 npm 平台与 npm 包之间的关系。
如果我们将搭建项目环境的详细过程以及具体的依赖记录进镜像中，每当需要部署新服务时，就可以很容易的通过镜像，创建出一个个完整的项目运行环境，完成部署。
安装 Docker
本安装教程参考 Docker 官方文档，地址如下：
https://docs.docker.com/engine/install/centos/
1.卸载旧版
首先如果系统中已经存在旧的 Docker，则先卸载：
yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine2.配置 Docker 的 yum 库
首先要安装一个 yum 工具
yum install -y yum-utils
安装成功后，执行命令，配置 Docker 的 yum 源：
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
3.安装 Docker
最后，执行命令，安装 Docker
yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
4.启动和校验
# 启动 Docker
systemctl start docker
# 停止 Docker
systemctl stop docker
# 重启
systemctl restart docker
# 设置开机自启
systemctl enable docker
# 执行 docker ps 命令，如果不报错，说明安装启动成功
docker ps5.配置镜像加速
这里以阿里云镜像加速为例。
5.1.注册阿里云账号
首先访问阿里云网站:
注册一个账号。
5.2.开通镜像服务
在首页的产品中，找到阿里云的容器镜像服务：
点击后进入控制台：
首次可能需要选择立刻开通，然后进入控制台。
5.3.配置镜像加速
找到镜像工具下的镜像加速器：
页面向下滚动，即可找到配置的文档说明：
具体命令如下：
创建目录
mkdir -p /etc/docker
# 复制内容，注意把其中的镜像加速地址改成你自己的
tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://xxxx.mirror.aliyuncs.com"]
}
EOF
# 重新加载配置
systemctl daemon-reload
# 重启 Docker
systemctl restart docker1.快速入门
1.1.部署 MySQL
利用传统方式部署 MySQL，大概的步骤有：
- 搜索并下载 MySQL 安装包
- 上传至 Linux 环境
- 编译和配置环境
- 安装
不同操作系统下其安装包、运行环境是都不相同的！如果是手动安装，必须手动解决安装包不同、环境不同的、配置不同的问题！而使用 Docker，这些完全不用考虑
使用 Docker 安装，仅仅需要一步即可，在命令行输入下面的命令：
docker run -d \
--name mysql \
-p 3306:3306 \
-e TZ=Asia/Shanghai \
-e MYSQL_ROOT_PASSWORD=123 \
mysqlMySQL 安装完毕！通过任意客户端工具即可连接到 MySQL.
当我们执行命令后，Docker 做的第一件事情，是去自动搜索并下载了 MySQL，然后会自动运行 MySQL，我们完全不用插手，非常方便。
这里下载的不是安装包，而是镜像 。镜像中不仅包含了 MySQL 本身，还包含了其运行所需要的环境、配置、系统级函数库。因此它在运行时就有自己独立的环境，就可以跨系统运行，也不需要手动再次配置环境了。
这套独立运行的隔离环境我们称为容器
Docker 本身包含一个后台服务，我们可以利用 Docker 命令告诉 Docker 服务，帮助我们快速部署指定的应用。Docker 服务部署应用时，首先要去搜索并下载应用对应的镜像，然后根据镜像创建并允许容器，应用就部署完成了。
1.2.部署 Redis
部署 Redis 的方式与 MySQL 类似，也是利用 Docker 命令，执行下面的命令：
docker run -d \
--name redis \
-p 6379:6379 \
-e TZ=Asia/Shanghai \
redis1.3.部署 Nginx
部署 Nginx 的方式与 MySQL 类似，也是利用 Docker 命令，执行下面的命令：
docker run -d \
--name nginx \
-p 80:80 \
-e TZ=Asia/Shanghai \
nginx1.4.部署 Tomcat
部署 Tomcat 的方式与 MySQL 类似，也是利用 Docker 命令，执行下面的命令：
docker run -d \
--name tomcat \
-p 8080:8080 \
-e TZ=Asia/Shanghai \
tomcat1.5.部署 Elasticsearch
部署 Elasticsearch 的方式与 MySQL 类似，也是利用 Docker 命令，执行下面的命令：
docker run -d \
--name elasticsearch \
-p 9200:9200 \
-p 9300:9300 \
-e TZ=Asia/Shanghai \
elasticsearch1.6.部署 Kibana
部署 Kibana 的方式与 MySQL 类似，也是利用 Docker 命令，执行下面的命令：
docker run -d \
--name kibana \
-p 5601:5601 \
-e TZ=Asia/Shanghai \
kibana1.7.部署 RabbitMQ
部署 RabbitMQ 的方式与 MySQL 类似，也是利用 Docker 命令，执行下面的命令：
docker run -d \
--name rabbitmq \
-p 5672:5672 \
-p 15672:15672 \
-p 25672:25672 \
-e TZ=Asia/Shanghai \
rabbitmq1.8.部署 Zookeeper
部署 Zookeeper 的方式与 MySQL 类似，也是利用 Docker 命令，执行下面的命令：
docker run -d \
--name zookeeper \
-p 2181:2181 \
-p 2888:2888 \
-e TZ=Asia/Shanghai \
zookeeper1.9.部署 ActiveMQ
部署 ActiveMQ 的方式与 MySQL 类似，也是利用 Docker 命令，执行下面的命令：
docker run -d \
--name activemq \
-p 61616:61616 \
-p 8161:8161 \
-e TZ=Asia/Shanghai \
activemq1.10.部署 RocketMQ
部署 RocketMQ 的方式与 MySQL 类似，也是利用 Docker 命令，执行下面的命令：
docker run -d \
--name rocketmq \
-p 9876:9876 \
-p 1091:1091 \
-e TZ=Asia/Shanghai \
rocketmq1.11.部署 Nacos
部署 Nacos 的方式与 MySQL 类似，也是利用 Docker 命令，执行下面的命令：
docker run -d \
--name nacos \
-p 8848:8848 \
-p 9848:9848 \
-e TZ=Asia/Shanghai \
nacos/nacos-server1.12.部署 RocketMQ
部署 RocketMQ 的方式与 MySQL 类似，也是利用 Docker 命令，执行下面的命令：
docker run -d \
--name rocketmq \
-p 9876:9876 \
-p 1091:1091 \
-e TZ=Asia/Shanghai \
rocketmq1.2.命令解读
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
2.Docker 基础
2.1.常见命令
2.1.1.命令介绍
| 命令 | 说明 | 文档地址 |
|---|---|---|
| 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 |
2.1.2.演示
我们以 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
# 也可以加格式化方式访问，格式会更加清爽
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 nginx2.1.3.命令别名
给常用 Docker 命令起别名，方便我们访问
# 修改/root/.bashrc文件
vi /root/.bashrc
内容如下：
# .bashrc
# User specific aliases and functions
alias 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
2.2.数据卷
容器是隔离环境，容器内程序的文件、配置、运行时产生的容器都在容器内部，我们要读写容器内的文件非常不方便。大家思考几个问题：
- 如果要升级 MySQL 版本，需要销毁旧容器，那么数据岂不是跟着被销毁了？
- MySQL、Nginx 容器运行后，如果我要修改其中的某些配置该怎么办？
- 我想要让 Nginx 代理我的静态资源怎么办？
因此，容器提供程序的运行环境，但是程序运行产生的数据、程序运行依赖的配置都应该与容器解耦。
2.2.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 代理了。
2.2.2.数据卷命令
数据卷的相关命令有：
| 命令 | 说明 | 文档地址 |
|---|---|---|
| docker volume create | 创建数据卷 | docs.docker.com |
| docker volume ls | 查看所有数据卷 | docs.docker.com |
| docker volume rm | 删除指定数据卷 | docs.docker.com |
| docker volume prune | 清除数据卷 | docs.docker.com |
| docker volume inspect | 查看某个数据卷的详情 | docs.docker.com |
演示一下 nginx 的 html 目录挂载
# 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,
"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 的匿名数据卷
# 1.查看MySQL容器详细信息
docker inspect mysql
# 关注其中.Config.Volumes部分和.Mounts部分可以发现，其中有几个关键属性：
- 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 对应的页面
2.2.3.挂载本地目录或文件
可以发现，数据卷的目录结构较深，如果我们去操作数据卷目录会不太方便。在很多情况下，我们会直接将容器目录与宿主机指定目录挂载。挂载语法与数据卷类似：
# 挂载本地目录
-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 配置文件目录）
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
mysql4.查看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)
2.3.镜像
2.3.1.镜像结构
自定义镜像本质：程序运行的基础环境、依赖、应用本身、运行配置等文件，并且打包而成。镜像就是一堆文件的集合
2.3.2 dockerfile
由于制作镜像的过程中，需要逐层处理和打包，比较复杂，所以 Docker 就提供了自动打包镜像的功能。我们只需要将打包的过程，每一层要做的事情用固定的语法写下来，交给 Docker 去执行即可。
而这种记录镜像结构的文件就称为 Dockerfile。
| 指令 | 说明 | 示例 |
|---|---|---|
| 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 |
我们都知道一个基于 npm 的项目，需要一个 package.json 文件，然后执行 npm run install 下载包，npm run build 打包，打包出来的文件其实是不能直接运行的，需要启动一个 node 服务运行，所以我们就写一个最基本的基于 node 和 nginx 的镜像
# 选择一个带有Node.js的轻量级基础镜像，使用 as 多阶段构建
FROM node:18-alpine as build-stage
# 设置工作目录
WORKDIR /app
# 复制package.json和package-lock.json（如果存在）
COPY package*.json ./
# 安装项目生产依赖
# 利用 Docker 缓存层，如果 package.json 没有变化，则不会重新安装node modules
RUN npm install --only=production
# 复制项目文件到工作目录
COPY . .
# 构建应用
RUN npm run build
# 阶段2：运行
# 使用 Nginx 镜像作为基础来提供前端静态文件服务
FROM nginx:stable-alpine as production-stage
# 定义环境变量，例如NODE_ENV
# ARG NODE_ENV=production
# ENV NODE_ENV=${NODE_ENV}
WORKDIR /app
# 从构建阶段拷贝构建出的文件到Nginx目录
COPY --from=build-stage /app/build /usr/share/nginx/html
# 配置nginx，如果有自定义的nginx配置可以取消注释并修改下面的行
# COPY nginx.conf /etc/nginx/conf.d/default.conf
# 暴露80端口
EXPOSE 80
# 启动Nginx服务器
CMD ["nginx", "-g", "daemon off;"]2.3.3 镜像构建
当 Dockerfile 文件写好以后，就可以利用命令来构建镜像了。
拷贝到虚拟机的/root/demo 目录
-
执行命令，构建镜像：
进入镜像目录
cd /root/demo
-
启动 docker dekstop，打包镜像：
docker build -t webapp-demo:v1 .
-
docker build : 就是构建一个 docker 镜像
-
-t webapp-demo:v1 ：-t 参数是指定镜像的名称（repository 和 tag）
-
. : 最后的点是指构建时 Dockerfile 所在路径，由于我们进入了 demo 目录，所以指定的是.代表当前目录，也可以直接指定 Dockerfile 目录：
直接指定Dockerfile目录
docker build -t webapp-demo:v1 /root/demo
-
运行镜像：
docker run -d -p 8000:80 webapp-demo:v1
Step 1: 使用带有 Node.js 的基础镜像
FROM node:18-alpine as builder设置工作目录
WORKDIR /usr/src/app
复制 package.json 和 package-lock.json（如果可用）
COPY package*.json ./
安装项目依赖
RUN npm install --only=production
安装 nest CLI 工具（确保它作为项目依赖被安装）
RUN npm install @nestjs/cli -g
复制所有文件到容器中
COPY . .
构建应用程序
RUN npm run build
Step 2: 运行时使用更精简的基础镜像
FROM node:18-alpine
创建 runc 的符号链接
RUN ln -s /sbin/runc /usr/bin/runc
WORKDIR /usr/src/app
从 builder 阶段复制构建好的 /usr/src/app/dist 和 /usr/src/app/node_modules 的文件到当工作目录
COPY --from=builder /usr/src/app/dist ./dist
COPY --from=builder /usr/src/app/node_modules ./node_modules暴露 3000 端口
EXPOSE 3000
运行 Nest.js 应用程序
CMD ["node", "dist/main"]
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