Docker 入门

新科日记

墨衍会员 · AI 创作全网分发码龄6年

关注

原创 2026-07-05 12:58:50 1.6k 阅读 AI 写同款· GEO 优化 ›

Docker镜像是什么原理？Dockerfile是什么? docker镜像什么？该如何制作镜像？怎么通过dockerfile来制作镜像并应用？阅读详情

01-Docker 介绍

1.1 什么是 Docker

- We have a complete container solution for you - no matter who you are and where you are on your containerization journey.

- 翻译：我们为你提供了一个完整的容器解决方案，不管你是谁，不管你在哪，你都可以开始容器的的旅程。

- 官方定义：docker 是一个容器技术。

1.2 Docker 的起源

Docker 最初是 dotCloud 公司创始人 Solomon Hykes 在法国期间发起的一个公司内部项目，它是基于 dotCloud 公司多年云服务技术的一次革新，并于 2013 年 3 月以 Apache 2.0 授权协议开源，主要项目代码在 GitHub 上进行维护。Docker 项目后来还加入了 Linux 基金会，并成立推动开放容器联盟（OCI）。特别注意 Docker 不是国产的。

Docker 自开源后受到广泛的关注和讨论，至今其 GitHub 项目已经超过 5 万 7 千个星标和一万多个 fork。甚至由于 Docker 项目的火爆，在 2013 年底，dotCloud 公司决定改名为 Docker。Docker 最初是在 Ubuntu 12.04 上开发实现的；Red Hat 则从 RHEL 6.5 开始对 Docker 进行支持；Google 也在其 PaaS 产品中广泛应用 Docker。

Docker 使用 Google 公司推出的 Go 语言进行开发实现，基于 Linux 内核的 cgroup，namespace，以及 OverlayFS 类的 Union FS 等技术，对进程进行封装隔离，属于操作系统层面的虚拟化技术。由于隔离的进程独立于宿主和其它的隔离的进程，因此也称其为容器。

1.3 为什么选择 Docker

程序在本机测试环境可以跑，生产环境跑不起来

这里我们拿 java Web 应用程序举例，我们一个 java Web 应用程序涉及很多东西，比如 jdk、tomcat、mysql 等软件环境。当这些其中某一项版本不一致的时候，可能就会导致应用程序跑不起来这种情况。Docker 则将程序以及使用软件环境直接打包在一起，无论在哪个机器上都能保证环境一致。

优势：一致的运行环境，更轻松的迁移。

自己的程序挂了，排查发现竟然是别人的程序出了问题把内存吃完了，自己的程序因为内存不够就挂了

这种也是一种比较常见的情况，如果你的程序重要性不是特别高的话，公司基本上不可能让你的程序独享一台服务器的，这时候你的程序就会跟公司其他人的程序共享一台服务器，所以不可避免地就会受到其他程序的干扰，导致自己的程序出现问题。Docker 就很好解决了环境隔离的问题，别人程序不会影响到自己的程序。

优势：对进程进行封装隔离，容器与容器之间互不影响，更高效的利用系统资源。

公司要弄一个活动，可能会有大量的流量进来，公司需要再多部署几十台服务器

在没有 Docker 的情况下，要在几天内部署几十台服务器，这对运维来说是一件非常折磨人的事，而且每台服务器的环境还不一定一样，就会出现各种问题，最后部署地头皮发麻。用 Docker 的话，我只需要将程序打包到镜像，然后在每台服务器上安装 Docker 启动镜像即可，极大地提高了部署效率。

优势：通过镜像复制 N 多个环境一致的容器。

1.4 Docker 与虚拟机区别

比较上面两张图，我们发现虚拟机是携带操作系统，本身很小的应用程序却因为携带了操作系统而变得非常大，很笨重。Docker 是不携带操作系统的，所以 Docker 的应用就非常的轻巧。另外在调用宿主机的 CPU、磁盘等等这些资源的时候，拿内存举例，虚拟机是利用 Hypervisor 去虚拟化内存，整个调用过程是虚拟内存 -> 虚拟物理内存 -> 真正物理内存，但是 Docker 是利用 Docker Engine 去调用宿主的的资源，这时候过程是虚拟内存 -> 真正物理内存。

比较项	传统虚拟机	Docker 容器
磁盘占用	几个 GB 到几十个 GB 左右	几十 MB 到几百 MB 左右
CPU 内存占用	虚拟操作系统非常占用CPU和内存	Docker 引擎占用极低
启动速度	（从开机到运行项目）几分钟	（从开启容器到运行项目）几秒
安装管理	需要专门的运维技术	安装、管理方便
应用部署	每次部署都费时费力	从第二次部署开始轻松简捷
耦合性	多个应用程序安装到一起，容易互相影响	每个应用程序都对应一个容器，达成隔离
系统依赖	无	需求相同或相似的内核，目前推荐是 Linux

1.5 Docker 安装

1）有线安装（centos7.x）

1. 更新系统包索引

sudo yum update -y



2. 安装所需的软件包

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



3. 添加阿里云 docker 仓库

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



4. 安装 docker CE

sudo yum install -y docker-ce docker-ce-cli containerd.io



5. 启动 docker

sudo systemctl start docker

# 设置开机自启

sudo systemctl enable docker



6. 验证 docker 安装

sudo docker run hello-world

2）离线安装 (centos7.x)

[1] 下载 docker 安装包

wget https://download.docker.com/linux/static/stable/x86_64/

[2] 上传安装包并解压

tar -zxvf docker-18.06.3-ce.tgz

[3] 将解压后 docker 里的所有文件移至 /usr/bin/ 目录下

cp docker/* /usr/bin/

[4] 切换到 /etc/systemd/system 目录并创建 docker.service 文件（将 docker 注册为系统服务）

touch docker.service

[5] 插入如下配置

[Unit]

Description=Docker Application Container Engine

Documentation=https://docs.docker.com

After=network-online.target firewalld.service

Wants=network-online.target

[Service]

Type=notify

ExecStart=/usr/bin/dockerd

ExecReload=/bin/kill -s HUP $MAINPID

LimitNOFILE=infinity

LimitNPROC=infinity

TimeoutStartSec=0

Delegate=yes

KillMode=process

Restart=on-failure

StartLimitBurst=3

StartLimitInterval=60s

[Install]

WantedBy=multi-user.target

[6] 给配置文件添加执行权限

chmod +x /etc/systemd/system/docker.service

[7] 重新加载配置文件

systemctl daemon-reload

[8] 启动 docker

systemctl start docker

# 设置开机自启

systemctl enable docker

02-Docker 核心架构

2.1 运行流程

2.2 镜像工作流程

1）流程图

2）解读

镜像: 一个镜像代表一个应用环境，他是一个只读的文件，如 mysql 镜像，tomcat 镜像，nginx 镜像等；
容器: 镜像每次运行之后就是产生一个容器，就是正在运行的镜像，特点就是可读可写；
仓库: 用来存放镜像的位置，类似于 maven 仓库，也是镜像下载和上传的位置；
dockerFile: docker 生成镜像配置文件，用来书写自定义镜像的一些配置；
tar: 一个对镜像打包的文件，日后可以还原成镜像。

3）官网仓库

# 远程仓库地址

https://hub.docker.com/

注意：下载镜像之前先去远程仓库检索查看版本，判断是否存在。

2.3 镜像源配置

1）添加镜像源地址

1. 创建 docker 文件夹

sudo mkdir -p /etc/docker

2. 执行如下命令

sudo tee /etc/docker/daemon.json <<-'EOF'

{

"registry-mirrors": ["https://dockerhub.icu"]

}

EOF

3. 重新启动

sudo systemctl daemon-reload

sudo systemctl restart docker

2）验证 docker 的镜像是否生效

[root@localhost ~]# docker info

..........

127.0.0.0/8

Registry Mirrors:

'https://dockerhub.icu'

Live Restore Enabled: false

Product License: Community Engine

03-Docker 入门程序

3.1 运行流程

1. 拉取镜像

docker pull hello-world

2. 运行镜像

docker run hello-world

3.2 特别注意

在启动 docker 之后，不要去修改防火墙（firewalld），在 docker 启动期间去修改防火墙，这样会清除 docker 的相关配置，导致在查询防火墙规则的时候显示不到 docker 的链，如果必须需要修改防火墙，需要重启 docker；
拉取镜像的时不指定版本默认拉取最新版。

04-Docker 常用命令

4.1 辅助命令

1. 查看版本信息

docker version

2. 查看详细信息

docker info

3. 帮助命令

docker --help

4.2 Images 镜像命令

1. 列出本地所有镜像

语法：

docker images

附加选项：

-a ：列出所有镜像（包含中间映像层）

-q ：只显示镜像 ID



2. 搜索镜像

语法：

docker search 镜像名

附加选项：

-s ：指定值，列出收藏数不少于指定值的镜像

--no-trunc ：显示完整的镜像信息

示例：

docker search tomcat



3. 下载镜像

语法：

docker pull 镜像名:镜像版本号

示例：

docker pull tomcat:8.0



4. 删除镜像

语法：

# 指定镜像名和版本号删除

docker rmi 镜像名:镜像版本号

# 指定镜像ID删除

docker rmi 镜像ID

附加选项：

-f ：强制删除

示例：

docker rmi -f hello-world:1.0



5. 查看镜像详细信息

语法：

docker inspect 镜像名:镜像版本号

示例：

docker inspect tomcat:8.0



6. 打包镜像

语法：

docker save 镜像名:镜像版本号 -o 名称.tar

示例：

docker save tomcat-love:8.0 -o /root/love.tar



7. 载入镜像

语法：

docker load -i 名称.tar

示例：

docker load -i /root/love.tar

4.3 Contrainer 容器命令

1. 运行容器

语法：

docker run 镜像名:镜像版本号

附加选项：

-d ：启动守护式容器（在后台启动容器）

-p ：映射端口号，指定端口号启动

--name ：别名为容器起一个名字

示例：

# 当前窗口运行

docker run -p 8080:8080 --name tomcat01 tomcat:8.0

# 后台运行

docker run -d -p 8080:8080 --name tomcat01 tomcat:8.0



2. 列出运行容器

语法：

docker ps

附加选项：

-a ：运行的和历史运行的容器

-q ：静默模式，只显示容器编号



3. 启动容器

语法：

docker start 容器名或者容器ID



4. 重启容器

语法：

docker restart 容器名或者容器ID



5. 正常停止容器

语法：

docker stop 容器名或者容器ID



6. 立即停止容器

语法：

docker kill 容器名或者容器ID



7. 删除容器

语法：

docker rm -f 容器名或者容器ID

示例：

docker rm -f tomcat01



8. 删除所有容器

语法：

docker rm -f $(docker ps -aq)



9. 查看容器内进程

语法：

docker top 容器名或者容器ID

示例：

docker top tomcat01



10. 查看容器详细信息

语法：

docker inspect 容器名或者容器ID

示例：

docker inspect tomcat01



11. 查看容器运行日志

语法：

docker logs 容器名或者容器ID

附加选项：

-t 加入时间戳

-f 跟随最新的日志打印

--tail 数字显示最后多少条

--since='时间' 导出日志的开始时间

--until='时间' 导出日志的结束时间

示例：

# 查看全部

docker logs -f tomcat01

# 显示最后10行

docker logs --tail 10 tomcat01

# 导出全部日志

docker logs tomcat01 > tomcat01.log

docker logs tomcat01 >> tomcat01.log

# 导出2025-08-01日至今的日志

docker logs --since='2025-08-01T00:00:00' tomcat01 > /root/tomcat01.log

# 导出2025-08-01日至2025-08-30日的日志

docker logs --since='2025-08-01T00:00:00' --until='2025-08-30T00:00:00' tomcat01 > /root/tomcat01.log

注意：一个 '>' 为覆盖模式，两个 '>>' 为追加模式

[1] 覆盖模式：tomcat01.log不存在，创建新文件并写入，tomcat01.log已存在，清空文件内容，然后写入新日志。

[2] 追加模式：tomcat01.log不存在，创建新文件并写入日志，tomcat01.log已存在，在文件末尾添加新日志。



12. 进入容器内部

语法：

docker exec -it 容器名或者容器ID

示例：

# 进入容器

docker exec -it tomcat01 bash

# 退出（容器内部执行）

exit



13. 容器与宿主机之间拷贝文件

语法：

# 将宿主机复制到容器内部

docker cp 文件或者目录容器名或者容器ID:容器路径

# 将容器内资源拷贝到主机上

docker cp 容器名或者容器ID:容器内资源路径宿主机目录路径

示例：

docker cp aa.txt tomcat01:/usr/local/tomcat/webapps

docker cp tomcat01:/usr/local/tomcat/webapps/docs /root/



14. 容器挂载宿主机资源

语法：

docker run -v 数据卷名或者宿主机的资源 :容器内的资源镜像名:镜像版本号

示例：

docker run -d -p 8081:8080 --name tomcat02 -v /root/apps/:/usr/local/tomcat/webapps tomcat:8.0

docker run -d -p 8081:8080 --name tomcat02 -v /root/service.xml:/usr/local/tomcat/conf/service.xml tomcat:8.0

注意：宿主机路径必须是绝对路径，宿主机目录会覆盖容器内目录内容。



15. 容器打包成新的镜像

语法：

docker commit -m "描述信息" -a "作者信息" 容器名或者容器ID 新镜像名:版本号

示例：

docker commit -m 'test' -a 'wuxinke' tomcat01 tomcat-test:8.0

05-Docker 镜像原理

5.1 镜像是什么

Docker 镜像是一种只读的、包含应用程序运行所需所有文件和环境的模板。镜像 = 应用程序 + 依赖 + 运行环境 + 配置的打包文件。创建容器时，就是根据镜像“复制”一个运行实例。

5.2 一个镜像为什么那么大

核心概念：

Docker 镜像的基石是联合文件系统。它是一种“叠罗汉”式的文件系统，可以将多个目录（称为层）挂载到同一个虚拟目录下；好比一个“花卷”。

UnionFS（联合文件系统）:

Union 文件系统是一种分层，轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下。Union 文件系统是 Docker 镜像的基础，这种文件系统特性：就是一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录。

5.3 镜像原理

解读：

bootfs（boot file system）：主要包含 bootloader 和 kernel，bootloader 主要是引导加载 kernel，Linux 刚启动时会加载 bootfs 文件系统。在 docker 镜像的最底层就是 rootfs。这一层与 Linux/Unix 系统是一样的，包含 boot 加载器（bootloader）和内核（kernel）。当 boot 加载完,后整个内核就都在内存中了，此时内存的使用权已由 bootfs 转交给内核，此时会卸载 bootfs。
rootfs（root file system）：在 bootfs 之上，包含的就是典型的 linux 系统中的 /dev，/proc，/bin，/etc 等标准的目录和文件。rootfs 就是各种不同的操作系统发行版，比如 Ubuntu/CentOS 等等。

注意：

镜像要比虚拟机要小得多，一个虚拟镜像一般在几个GB，镜像只有几百MB；因为镜像不包含内核，它是共享宿主机内核，只是一个用户空间的文件系统；
虚拟机设计目标是通用操作系统；镜像设计目标是作为应用运行的基础环境，通常只运行一个特定应用。

5.4 问题

问：镜像采用分层结构好处？

答：节约存储，资源共享，多个相同的 base 镜像构建，宿主机只需要保存一份 base 镜像到磁盘中；镜像层都是共享的，当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称为容器层，容器层之下都叫镜像层。

06-Docker 网络

6.1 简介

当 Docker 启动时，会自动在主机上创建一个 docker0 虚拟网桥，给 docker0 分配一个默认网段，以后所有使用默认 bridge 网络的容器都会连接到 docker0。

1）docker0 的作用

功能	描述
提供子网	容器获取类似 172.17.x.x 的 IP
实现容器间通信	同一网桥上的容器可直接互通
负责 NAT 转换	通过 iptables 将容器访问外网的流量进行 SNAT
端口映射 DNAT	-p 8080:80 的 DNAT 转换也是通过 docker0 处理

2）Docker 中网络类型

[1] bridge（默认桥接网络）

概念：创建容器时默认使用的网络，属于单机网络。Docker 会创建一个虚拟网桥 docker0，容器通过 veth 虚拟网卡连接到这个网桥。

特点：

默认网络类型
支持容器之间互相通信
可以通过端口映射（-p）供外部访问
单机使用，不支持跨主机

使用场景：

单机多容器开发环境
小型项目
本地测试

示例：

docker network ls

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

[2] host（主机网络）

概念：容器与宿主机共享网络空间，不使用 docker0。容器没有独立 IP。

特点：

无网络隔离（容器直接使用宿主机的网络栈）
性能最好（无 NAT 转换）
无需端口映射，容器端口即宿主机端口

使用场景：

对网络性能要求高
写 Prometheus Node Exporter、ELK Agent 这类需要访问宿主机资源的服务
不需要网络隔离

示例：

docker run --network host nginx

[3] none（无网络）

概念：容器完全没有网络，只能使用 loopback 本地回环。

特点：

全网络隔离
最安全

使用场景：

安全性极高的运行环境
需要完全离线的任务

示例：

docker run --network none busybox

[4] container（共享容器网络）

概念：多个容器共享同一个容器的网络栈，拥有相同的 IP。

特点：

多个容器共享网络、端口
常用于容器间紧密协作（如 Sidecar 模式）

使用场景：

日志容器 + 应用容器（Sidecar）
监控代理与应用网络共享

示例：

docker run --network container:nginx busybox

[5] overlay（跨主机网络）

概念：Docker Swarm 或 Kubernetes 使用的分布式网络，让不同主机上的容器相互通信。

特点：

支持跨物理机、跨节点
常用于 Swarm/K8S 集群
自动加密、自动路由

使用场景：

分布式微服务
Docker Swarm
K8S（CNI）

示例：

docker network create -d overlay my-overlay

6.2 基础命令

1. 列出所有网络

docker network ls



2. 创建网络

docker network create -d 网络类型网桥名称



3. 删除网络

docker network rm 网络名称或者网络ID



4. 查看网络信息

docker inspect 网络名称或者网络ID

07-Docker 数据卷

7.1 简介

Docker 数据卷（Volume）是 Docker 提供的持久化存储机制，用来保存容器产生的数据，即使容器删除，数据仍然存在。

通俗理解：

容器的数据是临时的，容器删了数据就没了；
数据卷就是一个“外置硬盘”，让数据持久保存。

1）为什么需要数据卷？

容器删除，数据随之丢失，临时存储；
多容器共享数据困难，每个容器有独立文件系统；
性能不如宿主机文件系统，容器文件系统是分层的；
容器迁移不方便，数据跟着容器走。

2）数据卷的作用

数据持久化：容器删除后，数据不丢失；
容器间共享数据：多个容器可挂载同一个数据卷（Volume）；
数据与容器解耦：容器可以随时删除，数据独立存在；
提升 I/O 性能：数据卷（Volume）直接使用宿主机文件系统；
方便备份、迁移：数据卷（Volume）是独立目录，可任意复制。

3）数据卷的类型（3 种挂载方式）

[1] 匿名卷

概念：Docker 自动创建，没有名字；产生一个随机名称的卷。

示例：

docker run -v /var/lib/mysql mysql

[2] 具名卷

概念：有明确名字，常用于生产；适合长期管理。

示例：

docker run -v mysql-data:/var/lib/mysql mysql

[3] 目录挂载 / 绑定挂载

概念：直接把宿主机真实目录挂到容器内部。

示例：

docker run -v /opt/mysql:/var/lib/mysql mysql

4）卷与目录挂载区别

特性	创建卷	目录挂载
数据存放位置	/var/lib/docker/volumes	自定义目录
管理方式	Docker 管理	用户管理
常用场景	生产环境	开发调试
安全性	高	需注意权限
备份迁移	容易	手动操作

7.2 基础命令

1. 列出所有数据卷

docker volume ls



2. 创建数据卷

docker volume create 数据卷名称



3. 查看数据卷信息

docker volume inspect 数据卷名称



4. 删除数据卷

docker volume rm 数据卷名称

08-常用镜像

8.1 MySQL

1）启动步骤

1. 拉取 mysql 镜像到本地

docker pull mysql:tag

# 注意：tag 不加默认最新版本

2. 查看是否拉取成功

docker images

3. 运行 mysql 服务（基础版）

docker run --name mysql -e MYSQL_ROOT_PASSWORD=root -p 3306:3306 --restart=always -d mysql:tag

# 注意：暴露外部端口外部能连接（前提是防火墙开放暴露的端口并且端口不能冲突）。

2）启动配置

# mysql 容器启动配置（完整版）

docker run --name mysql --network networkname -v /mydata:/var/lib/mysql -v /my.cnf:/etc/my.cnf -e MYSQL_ROOT_PASSWORD=root -p 3306:3306 --restart=always -d mysql:tag

配置项说明：

- 自定义容器名称：--name mysql

- 定义网络：--network networkname

- 挂载数据（宿主机:容器）：-v /mydata:/var/lib/mysql

- 挂载 mysql 配置文件（宿主机:容器）：-v /my.cnf:/etc/my.cnf

- 设置 root 账号的密码：-e MYSQL_ROOT_PASSWORD=root

- 暴露端口（宿主机:容器）：-p 3306:3306

- 设置 mysql 容器随 docker 启动而启动：--restart=always

- 后台运行：-d

3）挂载文件

[1] my.cnf

[mysqld]

skip-host-cache

skip-name-resolve

datadir=/var/lib/mysql

socket=/var/run/mysqld/mysqld.sock

secure-file-priv=/var/lib/mysql-files

user=mysql

lower_case_table_names=1



character-set-server=utf8mb4

collation-server=utf8mb4_unicode_ci



symbolic-links=0



pid-file=/var/run/mysqld/mysqld.pid

[client]

socket=/var/run/mysqld/mysqld.sock



!includedir /etc/mysql/conf.d/

!includedir /etc/mysql/mysql.conf.d/

4）扩展

# 执行 sql 文件到 mysql 中

docker exec -i 容器名或者容器ID sh -c 'exec mysql -u账号 -p"密码"' < /sql文件

示例：

docker exec -i mysql sh -c 'exec mysql -uroot -p"$MYSQL_ROOT_PASSWORD"' < /root/user.sql

8.2 Redis

1）启动步骤

1. 拉取 redis 镜像到本地

docker pull redis:tag



2. 查看是否拉取成功

docker images



3. 运行 redis 服务（基础版）

docker  run  --name  redis -p  6379:6379 --restart=always -d mysql:tag

2）启动配置

# redis 容器启动配置（完整版）

docker run --name redis --network networkname -p 6379:6379 -v /redis.conf:/usr/local/etc/redis/redis.conf -v /mydata:/data --restart=always -d redis:tag redis-server /usr/local/etc/redis/redis.conf

配置项说明：

- 挂载配置文件：-v /redis.conf:/usr/local/etc/redis/redis.conf

- 挂载数据实现持久化：-v /mydata:/data

- 指定 redis 在 docker 中的配置文件路径：redis-server /usr/local/etc/redis/redis.conf

3）挂载文件

[1] redis.conf

1. 创建 redis.conf 配置文件

touch redis.conf

2. 编辑配置文件

vim redis.conf

3. 配置如下内容

#开启远程访问

bind 0.0.0.0

#开启持久化

appendonly yes

#持久化文件名称

appendfilename "appendonly.aof"

#设置密码

requirepass 123456

8.3 Nginx

1）启动步骤

1. 拉取 nginx 镜像到本地

docker pull nginx:tag

2. 查看是否拉取成功

docker images

3. 运行 nginx 容器（基础版）

docker run --name nginx -p 80:80 --restart=always -d nginx:tag

2）启动配置

# nginx 容器启动配置（完整版）

docker run --name nginx --network networkname -v /nginx.conf:/etc/nginx/nginx.conf -v /myhtml:/usr/share/nginx/html -p 80:80 --restart=always -d nginx:tag

配置项说明：

- 挂载配置文件：-v /nginx.conf:/etc/nginx/nginx.conf

- 挂载部署包：-v /myhtml:/usr/share/nginx/html

3）挂载文件

[1] nginx.conf

1. 创建 nginx.conf 配置文件

touch nginx.conf



2. 编辑配置文件

vim nginx.conf



3. 配置如下内容

events {

    worker_connections 1024;  # 允许的最大连接数

}

http {

    include       mime.types;   # 引入 MIME 类型配置

    default_type application/octet-stream;

    client_max_body_size 500m;

    server {

        listen 80; # 监听端口

        location / {

            root   /usr/share/nginx/html;  # 指向前端资源的目录

            index  index.html index.htm;    # 默认首页文件

            try_files $uri $uri/ /index.html;  # 处理前端路由

        }

    }

}

8.4 Tomcat

1）启动步骤

1. 拉取 tomcat 镜像到本地

docker pull tomcat:tag

2. 查看是否拉取成功

docker images

3. 运行 tomcat 容器（基础版）

docker run --name mytomcat -p 8080:8080 --restart=always -d tomcat:tag

2）启动配置

# tomcat 容器启动配置（完整版）

docker run --name mytomcat --network networkname -v /myserver.xml:/usr/local/tomcat/conf/server.xml -v /mywebapps:/usr/local/tomcat/webapps -p 8080:8080 --restart=always -d tomcat:tag

配置项说明：

- 挂载配置文件：-v /myserver.xml:/usr/local/tomcat/conf/server.xml

- 挂载部署包：-v /mywebapps:/usr/local/tomcat/webapps

# 注意：选用 tomcat 的版本尽量选用包含 jdk，因为 tomcat 需要 jdk 配合启动 java 项目，如果你拉取的 tomcat 镜像版本不包含 jdk，需要使用 dockerfile 打包方式，创建包含 jdk 的 tomcat 镜像（不建议）。

3）挂载文件

[1] server.xml

1. 创建 server.xml 配置文件

touch server.xml



2. 编辑配置文件

vim server.xml



3. 配置如下内容

<?xml version="1.0" encoding="UTF-8"?>

<Server port="8005" shutdown="SHUTDOWN">

  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />

  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />

  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />

  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />

  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />



  <GlobalNamingResources>

    <Resource name="UserDatabase" auth="Container"

              type="org.apache.catalina.UserDatabase"

              description="User database that can be updated and saved"

              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"

              pathname="conf/tomcat-users.xml" />

  </GlobalNamingResources>



  <Service name="Catalina">

    <Connector port="8080" protocol="HTTP/1.1"

               connectionTimeout="20000"

               redirectPort="8443"

               maxParameterCount="1000"

               />

    <Engine name="Catalina" defaultHost="localhost">

      <Realm className="org.apache.catalina.realm.LockOutRealm">

        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"

               resourceName="UserDatabase"/>

      </Realm>

      <Host name="localhost"  appBase="webapps"

            unpackWARs="true" autoDeploy="true">

        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"

               prefix="localhost_access_log" suffix=".txt"

               pattern="%h %l %u %t "%r" %s %b" />

      </Host>

    </Engine>

  </Service>

</Server>

8.5 ElasticSearch

1）介绍

ElasticSearch 是搜索引擎。

官网地址： https://www.elastic.co/cn/

2）启动步骤

1. 拉取 elasticsearch 镜像到本地

docker pull elasticsearch:tag

2. 查看是否拉取成功

docker images

3. 运行 elasticsearch 容器（基础版）

docker run --name es -p 9200:9200 -p 9300:9300 -e discovery.type=single-node -e ES_JAVA_OPTS="-Xms128m -Xmx128m" --restart=always -d elasticsearch:tag

3）启动配置

# elesticsearch 容器启动配置（完整版）

docker run --name es --network networkname -p 9200:9200 -p 9300:9300 -e discovery.type=single-node -e ES_JAVA_OPTS="-Xms128m -Xmx128m" -e xpack.security.enabled=true -e ELASTIC_PASSWORD=your_password -v /myplugins:/usr/share/elasticsearch/plugins -v /mydata:/usr/share/elasticsearch/data --restart=always -d elasticsearch:tag

配置项说明：

- 端口映射：9200端口：Elasticsearch 的 HTTP 端口，用于处理 RESTful API 请求；9300端口：用于 Elasticsearch 节点之间的通信。

- 单节点模式（适合开发和测试环境）：-e discovery.type=single-node

- jvm 堆内存调整（128m：128MB，4g：4GB）：-e ES_JAVA_OPTS="-Xms128m -Xmx128m"

- 开启 X-Pack 安全功能：-e xpack.security.enabled=true

- 默认超级用户（elastic 用户）的密码：-e ELASTIC_PASSWORD=your_password

- 插件挂载：-v /myplugins:/usr/share/elasticsearch/plugins

- 数据挂载：-v /mydata:/usr/share/elasticsearch/data

# 注意：调高 JVM 线程数限制数量，挂载的目录需要 elasticsearch 默认用户需要读写权限。

4）插件

[1] IK 分词器

1. 下载对应版本的 IK 分词器

wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.4.2/elasticsearch-analysis-ik-6.4.2.zip

2. 解压到挂载的 plugins 文件夹中

unzip elasticsearch-analysis-ik-6.4.2.zip -d /myplugins/ik

5）扩展

# 为 elasticsearch 默认用户设置挂载目录的读写权限，elasticsearch 在启动时默认创建一个名为 elasticsearch 的用户，并为该用户分配默认的 UID 和 GID 为1000

chown -R 1000:1000 /myplugins /mydata

8.6 Kibana

1）介绍

Kibana 是搜索引擎可视化工具，配合 elasticsearch 使用。

官网地址： https://www.elastic.co/cn/

2）启动步骤

1. 拉取 kibana 镜像到本地

docker pull kibana:tag

# 注意：kibana 版本要与 elasticsearch 严格一致

2. 查看是否拉取成功

docker images

3. kibana 容器启动配置（基础版）

docker run --name kibana --network networkname -e ELASTICSEARCH_URL=http://10.15.x.x:9200 -e ELASTICSEARCH_PASSWORD=your_password -p 5601:5601 --restart=always -d kibana:tag

3）启动配置

# kibana 容器启动配置（完整版）

docker run --name kibana --network networkname -p 5601:5601 -v /kibana.yml:/usr/share/kibana/config/kibana.yml --restart=always -d kibana:tag

4）挂载文件

[1] kibana.yml

1. 创建 kibana.yml 配置文件

touch kibana.yml

2. 编辑配置文件

vim kibana.yml

3. 配置如下内容

#连接到 Elasticsearch（可以使用服务名代替IP）

elasticsearch.hosts: ["http://elasticsearch:9200"]

#设置 Kibana 服务器

server.host: "0.0.0.0"

#端口

server.port: 5601

#设置关闭时的超时时间

server.shutdownTimeout: "5s"

#启用安全功能

xpack.security.enabled: true

elasticsearch.username: "elastic"

elasticsearch.password: "your_password"

#启用监控，Kibana 会显示有关 Elasticsearch 集群健康状态、节点信息、索引统计等的监控数据

monitoring.ui.container.elasticsearch.enabled: true

8.7 FastDFS

1）启动步骤

1. 拉取 fastdfs 镜像到本地

docker pull delron/fastdfs:tag



2. 查看是否拉取成功

docker images



3. tracker 容器启动配置（完整版）

docker run --name tracker -p 8080:8080 -p 22122:22122 -p 23000:23000 --network=networkname -v /mytracker:/var/fdfs --restart=always -d delron/fastdfs:tag tracker

配置项说明：

- 端口映射：8080端口：tracker的http访问端口；22122端口：tracker默认监听端口；23000端口：storage端口。

- 数据挂载：-v /mytracker:/var/fdfs



4. storage 容器启动配置（完整版）

docker run --name storage -p 8888:8888 --network=networkname -v /mystorage:/var/fdfs -e TRACKER_SERVER=10.15.x.x:22122 -e GROUP_NAME=groupname --restart=always -d delron/fastdfs:tag storage

配置项说明：

- 端口映射：8888端口需要跟nginx监听端口保持一致。

- 挂载数据：-v /mystorage:/var/fdfs

- 关联tracker：-e TRACKER_SERVER=10.15.x.x:22122

- 分组：-e GROUP_NAME=groupname

8.8 Portainer

1）介绍

Portainer 是 docker可视化 web 服务。

官网地址： https://www.portainer.io/installation/

2）启动步骤

1. 拉取 portainer 镜像到本地

docker pull portainer/portainer:tag

2. 查看是否拉取成功

docker images

3. portainer 容器启动配置（基础版）

docker run --name portainer -p 8000:8000 -p 9000:9000 --restart=always -d portainer/portainer:tag

3）启动配置

# portainer 容器启动配置（完整版）

docker run --name portainer -p 8000:8000 -p 9000:9000 --network=networkname -v /var/run/docker.sock:/var/run/docker.sock -v /mydata:/data --restart=always -d portainer/portainer:tag

配置项说明：

- 端口映射：8000端口：是 Portainer Agent 的端口，用于管理多个 Docker 环境；9000：是 Portainer Web UI 的默认端口，访问 http://localhost:9000。

- 将 docker 的管理接口（docker.sock 文件）挂载到中（固定宿主机地址）：-v /var/run/docker.sock:/var/run/docker.sock

- 数据挂载：-v /mydata:/data

4）扩展

[1] 重置密码

1. 查看容器详细信息

docker inspect portainer



2. 复制 Source 目录路径地址（Mounts 下）

"Mounts":[

{

      "Type":"volume"

        "Name":"..."

        "Source":"/var/lib/docker/volumes/436d93252d9a382768eab7e9b7a29b8a10cbbf990257e37c9171eedc8df21c2e/_data"

      ...

   }，

...

]



3. 执行命令

docker run --rm -v 挂载目录地址:/data portainer/helper-reset-password

示例：

docker run --rm -v /var/lib/docker/volumes/436d93252d9a382768eab7e9b7a29b8a10cbbf990257e37c9171eedc8df21c2e/_data:/data portainer/helper-reset-password



4. 重新启动 portainer

docker start portainer

8.9 Minio

1）介绍

Minio 是对象存储工具，提供 web 页面管理系统。

官网地址： https://www.minio.org.cn/

2）启动步骤

1. 拉取 minio 镜像到本地

docker pull minio/minio:tag

2. 查看是否拉取成功

docker images

3. minio 容器启动配置（基础版）

docker run --name minio --restart=always -p 9000:9000 -p 9001:9001 -e MINIO_ROOT_USER=username -e MINIO_ROOT_PASSWORD=password -d minio/minio:tag server /data --console-address ":9001"

3）启动配置

# minio 容器启动配置（完整版）

docker run --name minio --restart=always -p 9000:9000 -p 9001:9001 -e MINIO_ROOT_USER=username -e MINIO_ROOT_PASSWORD=password -v /minio:/data -d minio/minio:tag server /data --console-address ":9001"

配置项说明：

- 端口映射：9000：对象存储 API 端口，9001：web 控制台管理页面访问端口。

- 账号/密码：-e MINIO_ROOT_USER=username -e MINIO_ROOT_PASSWORD=password

- 数据挂载：-v /minio:/data

- 启动时指定对象存储路径：server /data

- 管理控制台监听端口：--console-address ":9001"

09-Dockerfile 简介

9.1 什么是 Dockerfile

Dockerfile 可以认为是 Docker 镜像的描述文件，是由一系列命令和参数构成的脚本。主要作用是用来构建 Docker 镜像的构建文件。

9.2 解析过程

9.3 构建镜像步骤

1）创建命令：“touch Dockerfile”创建 Dockerfile 文件然后在文件里编写命令

Dockerfile 内容要求：

每条保留字指令都必须为大写，且后面都要跟至少一个参数
指令按照从上到下，顺序执行
# ：表示注释
每条指令都会创建一个新的镜像层，并对镜像进行提交

2）构建命令：“docker build -t 镜像名:版本 Dockerfile 所在目录 ”

#“.”表示当前目录，会把 Dockerfile 所在目录里的所有文件打包

docker build -t mycentos:1.0 .

3）dockerignore 文件过滤

如果不想将 Dockerfile 所在目录的所有文件打包，可以创建 . dockerignore 文件过滤

1. 在 Dockerfile 所在的目录创建 .dockerignore 文件

touch .dockerignore



2. 然后在里面编写需要过滤的文件“#”为注释，参考如下：

# 忽略所有隐藏文件和目录

.*

# 但保留 .dockerignore 本身

!.dockerignore



# 忽略常见的版本控制目录

.git/

.svn/

.hg/



# 忽略日志文件

*.log

logs/



# 忽略依赖目录（如果需要重新安装）

node_modules/

vendor/



# 忽略配置文件（如果需要使用容器内的配置）

config/development.yml

config/test.yml



# 忽略文档文件

README.md

docs/



# 忽略构建产物

dist/

build/

*.tar.gz

*.zip



# 忽略特定文件

Dockerfile.old

docker-compose.yml

.env

9.4 问题

问：在 dockerhub 官网中提供很多镜像已经能满足我们的需求，为什么还需要自定义镜像？

答：官网中的镜像并不能完全满足我们的所有需求，这时我们需要对官网中的镜像做自定义。

10-Dockerfile 内置指令

10.1 指令的作用

保留字	作用
FROM	当前镜像是基于哪个镜像为基础，第一个指令必须是 FROM
MAINTAINER	镜像维护者的姓名和邮箱地址
RUN	构建镜像时需要运行的指令
EXPOSE	当前容器对外暴露出的端口号，仅仅是声明
WORKDIR	指定在创建容器后，终端默认登录进来的工作目录，一个落脚点
ENV	用来在构建镜像过程中设置环境变量
ADD	将宿主机目录下的文件拷贝进镜像且 ADD 命令会自动处理 URL 和解压 tar 包
COPY	类似于 ADD，拷贝文件和目录到镜像中将从构建上下文目录中<原路径>的文件/目录复制到新的一层的镜像内的<目标路径>位置
VOLUME	容器数据卷，用于数据保存和持久化工作，仅仅是声明
CMD	指定一个容器启动时要运行的命令 Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换
ENTRYPOINT	指定一个容器启动时要运行的命令 ENTRYPOINT 的目的和 CMD 一样，都是在指定容器启动程序及其参数
ARG	用来定义构建阶段的参数，只在 docker build 的时候生效，容器运行时不可用（除非再用 ENV 传递）

10.2 指令分类

1）基础镜像指令

[1] FROM：指定基础镜像。

FROM openjdk:8-jdk-alpine

# 注意：必须作为 Dockerfile 第一个指令出现。

[2] MAINTAINER（已弃用）：作者信息，现在推荐用 LABEL 。

LABEL maintainer="yourname@example.com"

2）构建环境指令

[1] WORKDIR：指定工作目录（后续命令都在这里执行）。

WORKDIR /app

[2] ENV：设置环境变量。

ENV SPRING_PROFILES_ACTIVE=prod

环境变量用法：$变量名称

# 方式一（空格分隔）

ENV APP_HOME /app

# 方式二（等号分隔）

ENV APP_HOME=/app

# 使用环境变量

WORKDIR $APP_HOME

COPY . $APP_HOME

[3] ARG：定义参数。

ARG APP_VERSION=1.0.0

# 配合 ENV 使用

ARG APP_ENV=dev

ENV APP_ENV=$APP_ENV

[4] COPY：复制文件到镜像中。

COPY target/app.jar /app/app.jar

[5] ADD：类似 COPY，但多了自动解压和支持 URL 下载功能。

ADD https://example.com/app.tar.gz /app/

[6] RUN：构建时执行命令（生成新的镜像层）。

RUN apk add --no-cache curl

3）容器运行指令

[1] CMD：容器启动时默认执行的命令（可被覆盖）。

CMD ["java", "-jar", "/app/app.jar"]

# 注意：一个 Dockerfile 中只能出现一次CMD ，如果出现多次只有最后一次的CMD会生效。

[2] ENTRYPOINT：容器启动时执行的主命令（不容易被覆盖）。

ENTRYPOINT ["java", "-jar", "/app/app.jar"]

[3] VOLUME：声明数据挂载点。

# 宿主机的 /data 目录

VOLUME /data

[4] EXPOSE：声明容器暴露的端口（只是声明，不会真的映射到宿主机）。

EXPOSE 8080

11-Dockerfile 构建常用镜像

11.1 Java 程序

1. 创建 Dockerfile 文件

touch Dockerfile



2. 编辑 Dockerfile 文件

vim Dockerfile



3. 配置如下内容

# 使用官方 JDK 作为基础镜像

FROM openjdk:11-jre-slim

# 指定工作目录

WORKDIR /app

# 拷贝打好的 jar 包到容器

COPY target/myapp-1.0.0.jar app.jar

# 暴露端口

EXPOSE 8080

# 容器启动时执行的命令

CMD ["java", "-jar", "app.jar"]



4. 构建镜像

docker build -t myapp:1.0 .



5. 启动容器

docker run -d -p 8080:8080 myapp:1.0