1.什么是docker
Docker 是一个开源的应用容器引擎,由于docker影响巨大,今天也用"Docker" 指代容器化技术。
2.docker的优势 一键部署,开箱即用 容器使用基于image镜像的部署模式,image中包含了运行应用程序所需的一切:代码、运行时、系统工具、系统库和配置文件。无论是单个程序还是多个程序组成的复杂服务,或者分布式系统,都可以使用 docker run 或 docker compose up命令一键部署,省去了大量搭建、配置环境、调试和排查错误的时间。
一次打包,到处运行
Docker 为容器创建了行业标准,使容器成为了软件交付过程中的一种标准化格式,将软打包成容器镜(image),能够使软件在不同环境下运行一致,应用程序可以快速可靠地从一个环境移植到另外一个环境,并确保在所有的部署目标(例如开发、测试、生产环境)上都按预期运行,从而避免了“在我电脑上是好的,怎么到你那却不能用了?”的问题。
3.容器与虚拟机
容器包括应用程序及其所有依赖项。容器运行时,与宿主机共享操作系统内核,容器在linux内核层面(使用 Cgroups 和 namespaces)来实现进程间的隔离,容器在主机操作系统上的用户空间中作为独立进程运行。因此,容器相比于虚拟机更加轻量化,它体积小,启动快,占用资源少,性能好。
虚拟机使用虚拟化技术,应用程序运行在完整的操作系统(OS)之上,因此占用的资源更多,安装更复杂。
但是由于容器与宿主机共享内核,所以在隔离性和安全性方面不如虚拟机。
![](/i/l/?n=22&i=blog/1410855/202211/1410855-20221122100901136-1184681054.png)
二、安装docker
1.Windows下安装Docker
注意事项:容器主要使用linux内核技术,因此Windows下安装docker可能会有遇到各种问题,建议刚入门的同学先在linux虚拟机里安装docker,学完之后在windows下安装,免得遇到问题后,还没入门就放弃了。
2.linux下安装Docker
安装环境:CentOS 7.3+
如果之前安装了旧版docker,请先删除。
sudo yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine
安装仓库
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
安装docker engine
sudo yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin
启动docker,运行hello world查看是否成功sudo systemctl start docker
sudo docker run hello-world
配置国内镜像仓库地址:新建/etc/docker/daemon.json文件,输入如下内容:
{
"registry-mirrors": [
"https://registry.docker-cn.com",
"http://hub-mirror.c.163.com",
"https://fsp2sfpr.mirror.aliyuncs.com/"
]
}
然后重启,配置开机启动
sudo systemctl restart docker
sudo systemctl enable docker
sudo systemctl enable containerd
三、docker run 开箱即用
1.docker架构
![](/i/l/?n=22&i=blog/1410855/202211/1410855-20221122101458092-76721946.png)
registry可以理解为镜像仓库,用于保存docker image。
Docker Hub 是docker官方的镜像仓库,docker命令默认从docker hub中拉取镜像。我们也可以搭建自己的镜像仓库。
image 镜像
image可以理解为一个只读的应用模板。image包含了应用程序及其所需要的依赖环境,例如可执行文件、环境变量、初始化脚本、启动命令等。
container 容器
容器是image的一个运行实例。当我们运行一个image,就创建了一个容器。
2.docker pull 拉取镜像
从镜像仓库拉取镜像到本地docker pull nginx 不写默认是latest
docker pull nginx:latest
docker pull nginx:1.22
docker pull nginx:1.22.0-alpine
一般不建议使用latest,因为最新的镜像是滚动更新的,过一段时间,可能跟你本地的不是同一个。使用docker images命令查看本地镜像
3.docker run 命令
docker run [可选参数] 镜像名:版本 []
docker run --name some-nginx -d -p 8080:80 nginx:1.22
默认情况下,容器无法通过外部网络访问。需要使用-p参数将容器的端口映射到宿主机端口,才可以通过宿主机IP进行访问。浏览器打开 http://192.168.56.106:8080
![](/i/l/?n=22&i=blog/1410855/202211/1410855-20221122101646619-1607894954.png)
-p 8080-8090:8080-8090 公开端口范围,前后必须对应
-p 192.168.56.106:8080:80 如果宿主机有多个ip,可以指定绑定到哪个ip
后台运行
docker run --name db-mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7
使用run命令,部署mysql,docker先去本地查找镜像,如果找不到,就去docker hub中拉取镜像
●--name 定义容器的名称●-e 声明环境变量
●-d容器在后台运行
●查看容器ip
docker inspect \
--format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' db-mysql
可以使用以下命令操作容器:
docker start db-mysql 启动容器
docker stop 关闭容器
docker restart 重启容器
docker rm 删除容器
前台交互运行
创建一个新的容器,使用mysql客户端docker run -it --rm mysql:5.7 mysql -h172.17.0.2 -uroot -p
-it 使用交互模式,可以在控制台里输入、输出
--rm在容器退出时自动删除容器。一般在使用客户端程序时使用此参数。
如果每次使用客户端都创建一个新的容器,这样将占用大量的系统空间。其中mysql -h172.17.0.2 -uroot -p
表示启动容器时执行的命令。
docker exec
在运行的容器中执行命令,一般配合-it参数使用交互模式,docker exec -it db-mysql /bin/bash
●docker ps -a 查看所有容器,包括正在运行和停止的
●docker inspect 查看容器的信息
●docker logs查看日志
●docker cp 在容器和宿主机间复制文件
docker cp ./some_file 容器名:/work
docker cp 容器名:/var/logs/ /tmp/app_logs
四、docker 网络
默认网络
docker会自动创建三个网络,bridge,host,none
bridge桥接网络
如果不指定,新创建的容器默认将连接到bridge网络。
默认情况下,使用bridge网络,宿主机可以ping通容器ip,容器中也能ping通宿主机。
容器之间只能通过 IP 地址相互访问,由于容器的ip会随着启动顺序发生变化,因此不推荐使用ip访问。
host
慎用,可能会有安全问题。
容器与宿主机共享网络,不需要映射端口即可通过宿主机IP访问。(-p选项会被忽略)
主机模式网络可用于优化性能,在容器需要处理大量端口的情况下,它不需要网络地址转换 (NAT),并且不会为每个端口创建“用户空间代理”。
none
禁用容器中所用网络,在启动容器时使用。
用户自定义网络
创建用户自定义网络
docker network create my-net
将已有容器连接到此网络docker network connect my-net db-mysql
创建容器时指定网络。docker run -it --rm --network my-net mysql:5.7 mysql -hdb-mysql -uroot -p
在用户自定义网络上,容器之间可以通过容器名进行访问。用户自定义网络使用 Docker 的嵌入式 DNS 服务器将容器名解析成 IP。
主机名解析
hostname
容器的hostname默认为容器的 ID。
docker run -it -d --hostname my-alpine --name my-alpine alpine:3.15
docker inspect \
--format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' my-alpine
/etc/hosts
在容器内手动修改/etc/hosts文件,容器重启后会恢复默认配置。要是/etc/hosts修改生效,使用--add-host
docker run --add-host=my-alpine:172.17.0.3 -it --rm alpine:3.15
五、docker存储
将数据存储到容器之外,这样删除容器也不会丢失数据。一旦容器故障,我们可以重新创建一个容器,将数据挂载到容器里,就可以快速的恢复。
存储方式
docker 提供了以下存储选项![](/i/l/?n=22&i=blog/1410855/202211/1410855-20221122103753752-1118922514.png)
volume 卷
卷存储在主机文件系统分配一块专有存储区域,由 Docker(在 Linux 上)管理,并且与主机的核心功能隔离。非 Docker 进程不能修改文件系统的这一部分。卷是在 Docker 中持久保存数据的最佳方式bind mount 绑定挂载
绑定挂载可以将主机文件系统上目录或文件装载到容器中,但是主机上的非 Docker 进程可以修改它们,同时在容器中也可以更改主机文件系统,包括创建、修改或删除文件或目录,使用不当,可能会带来安全隐患tmpfs 临时挂载
tmpfs挂载仅存储在主机系统的内存中,从不写入主机系统的文件系统。当容器停止时,数据将被删除。绑定挂载(bind mount)
绑定挂载适用以下场景:●将配置文件从主机共享到容器。
●在 Docker 主机上的开发环境和容器之间共享源代码或编译目录。
○例如,可以将 Maven 的target/目录挂载到容器中,每次在主机上用 Maven打包项目时,容器内都可以使用新编译的程序包。 -v
绑定挂载将主机上的目录或者文件装载到容器中。绑定挂载会覆盖容器中的目录或文件。如果宿主机目录不存在,docker会自动创建这个目录。但是docker只自动创建文件夹,不会创建文件。
例如,mysql的配置文件和数据存储目录使用主机的目录。可以将配置文件设置为只读(read-only)防止容器更改主机中的文件。
docker run -e MYSQL_ROOT_PASSWORD=123456 \
-v /home/mysql/mysql.cnf:/etc/mysql/conf.d/mysql.cnf:ro \
-v /home/mysql/data:/var/lib/mysql \
-d mysql:5.7
tmpfs 临时挂载
临时挂载将数据保留在主机内存中,当容器停止时,文件将被删除。docker run -d -it --tmpfs /tmp nginx:1.22-alpine
volume卷
卷 是docker 容器存储数据的首选方式,卷有以下优势: ●卷可以在多个正在运行的容器之间共享数据。仅当显式删除卷时,才会删除卷。●当你想要将容器数据存储在外部网络存储上或云提供商上,而不是本地时。
●卷更容易备份或迁移,当您需要备份、还原数据或将数据从一个 Docker 主机迁移到另一个 Docker 主机时,卷是更好的选择。 创建和挂载卷:
docker volume create my-data
docker run -e MYSQL_ROOT_PASSWORD=123456 \
-v /home/mysql/conf.d/my.cnf:/etc/mysql/conf.d/my.cnf:ro \
-v my-data:/var/lib/mysql \
-d mysql:5.7
创建nfs卷
docker volume create --driver local \
--opt type=nfs \
--opt o=addr=192.168.1.1,rw \
--opt device=:/path/to/dir \
vol-nfs
六、部署自己的应用
ruoyi官方文档:http://doc.ruoyi.vip/ruoyi/
源码下载:https://gitee.com/y_project/RuoYi/tree/v4.7.4/
配置文件中修改了端口、数据库连接信息。
#application.yml文件
server:
# 服务器的HTTP端口,默认为80
port: 8080
#application-druid.yml文件
url: jdbc:mysql://ruoyi-db:3306/ry?useUnicode=true&characterEncoding=utf8
username: root
password: 123456
将源码编译打包成ruoyi-admin.jar文件,放到宿主机/home/app目录下,/home/app/sql目录下放的是数据库初始化脚本。
●准备工作:创建网络和存储卷
docker volume create ruoyi-data
docker network create ruoyi-net
部署mysql并初始化数据库,我们在创建数据库容器的时候,需要做三件事:●创建数据库ry
●设置字符集为utf-8
●执行数据库初始化脚本
使用
MYSQL_DATABASE
环境变量创建数据库,设置字符集--character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
,容器使用/docker-entrypoint-initdb.d
目录下的脚本初始化数据库,脚本可以是.sh
.sql
和.sql.gz
这三种格式。
docker run -e MYSQL_ROOT_PASSWORD=123456 \
-e MYSQL_DATABASE=ry \
-v /home/app/sql:/docker-entrypoint-initdb.d \
-v ruoyi-data:/var/lib/mysql \
--network ruoyi-net \
--name ruoyi-db \
-d mysql:5.7 \
--character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
部署应用docker run -p 8080:8080 \
-v /home/app/ruoyi-admin.jar:/usr/local/src/ruoyi-admin.jar \
--network ruoyi-net \
--name ruoyi-java \
-d openjdk:8u342-jre \
java -jar /usr/local/src/ruoyi-admin.jar
端口被some-nginx 占用,停掉nginx:docker stop some-nginx
容器名字重复,删掉该容器:docker rm ruoyi-java
乱码问题是容器中mysql默认字符集引起的,我们需要将默认字符集改为utf8mb4。参考:https://github.com/docker-library/mysql/issues/131
可以进入容器,使用以下命令查看数据库字符集:
docker exec -it ruoyi-db mysql -uroot -p
>show variables like '%character%';
+--------------------------+----------------------------+
| Variable_name | Value |
+--------------------------+----------------------------+
| character_set_client | latin1 |
| character_set_connection | latin1 |
| character_set_database | utf8mb4 |
| character_set_filesystem | binary |
| character_set_results | latin1 |
| character_set_server | utf8mb4 |
| character_set_system | utf8 |
| character_sets_dir | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+
8 rows in set (0.03 sec)
注意:由于删除容器不会删除存储卷,修改字符集需要删除存储卷,不然已经导入的数据字符集不会发生改变
删除容器和卷docker stop ruoyi-db
docker rm ruoyi-db
docker volume rm ruoyi-data
可以通过以下两种解决方法:1.修改运行参数
使用环境变量LANG=C.UTF-8设置客户端字符集
docker run -e MYSQL_ROOT_PASSWORD=123456 \
-e MYSQL_DATABASE=ry \
-e LANG=C.UTF-8 \
-v /home/app/sql:/docker-entrypoint-initdb.d \
-v ruoyi-data:/var/lib/mysql \
--network ruoyi-net \
--name ruoyi-db \
-d mysql:5.7 \
--character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
或者使用
--skip-character-set-client-handshake
忽略客户端字符集,使用客户端和服务端字符集一致
docker run -e MYSQL_ROOT_PASSWORD=123456 \
-e MYSQL_DATABASE=ry \
-v /home/app/sql:/docker-entrypoint-initdb.d \
-v ruoyi-data:/var/lib/mysql \
--network ruoyi-net \
--name ruoyi-db \
-d mysql:5.7 \
--skip-character-set-client-handshake --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
2.修改配置文件修改
/home/mysql/mysql.cnf
[mysqld]
character-set-server=utf8mb4
collation-server=utf8mb4_general_ci
init-connect='SET NAMES utf8mb4'
[client]
default-character-set=utf8mb4
[mysql]
default-character-set=utf8mb4
将配置文件挂载到容器中
docker run -e MYSQL_ROOT_PASSWORD=123456 \
-e MYSQL_DATABASE=ry \
-v /home/mysql/mysql.cnf:/etc/mysql/conf.d/mysql.cnf:ro \
-v /home/app/sql:/docker-entrypoint-initdb.d \
-v ruoyi-data:/var/lib/mysql \
--network ruoyi-net \
--name ruoyi-db \
-d mysql:5.7
七、docker compose容器编排
github和docker hub很多项目都提供了docker-compose.yaml文件,我们可以一键部署项目,非常方便。
一键部署wordpress
wordpress是一个著名的开源博客系统。将以下内容保存到本地的docker-compose.yml文件中。
docker compose
命令启动时,默认在当前目录下寻找compose.yaml
或compose.yml
,为了兼容之前的版本,也会查找
docker-compose.yaml
或docker-compose.yml
。也可以使用
-f
参数手动指定文件docker compose -f docker-compose-dev.yml up -d
version: '3.1'
services:
wordpress:
image: wordpress
restart: always
ports:
- 8080:80
environment:
WORDPRESS_DB_HOST: db
WORDPRESS_DB_USER: exampleuser
WORDPRESS_DB_PASSWORD: examplepass
WORDPRESS_DB_NAME: exampledb
volumes:
- wordpress:/var/www/html
db:
image: mysql:5.7
restart: always
environment:
MYSQL_DATABASE: exampledb
MYSQL_USER: exampleuser
MYSQL_PASSWORD: examplepass
MYSQL_RANDOM_ROOT_PASSWORD: '1'
volumes:
- db:/var/lib/mysql
volumes:
wordpress:
db:
docker compose up -d
一键部署启动docker compose start/stop
启动/停止服务docker compose down
停止并删除容器,不会删除存储卷volume
compose文件结构
docker-compose.yml
通常需要包含以下几个顶级元素:
version
已弃用,早期版本需要此元素。services
必要元素,定义一个或多个容器的运行参数在
services
中可以通过以下元素定义容器的运行参数image
容器 镜像ports
端口映射environment
环境变量networks
容器使用的网络volumes
容器挂载的存储卷command
容器启动时执行的命令depends_on
定义启动顺序复数形式(例如ports,networks,volumes,depends_on)参数需要传入列表
networks
创建自定义网络volumes
创建存储卷yaml文件语法 缩进代表上下级关系
缩进时不允许使用Tab键,只允许使用空格
:
键值对,后面必须有空格-
列表,后面必须有空格[ ]
数组#
注释{key:value,k1:v1}
map|
多行文本块如果一个文件中包含多个文档
---
表示一个文档的开始
还有一种常见的用法:
把公共的配置提取出来,用
&
来建立锚点,<<
合并到当前数据,用*
引用锚点,例如version: '3.7'
# Settings and configurations that are common for all containers
x-minio-common: &minio-common
image: quay.io/minio/minio:RELEASE.2022-08-13T21-54-44Z
command: server --console-address ":9001" http://minio{1...2}/data{1...2}
expose:
- "9000"
- "9001"
services:
minio1:
<<: *minio-common
volumes:
- data1-1:/data1
- data1-2:/data2
minio2:
<<: *minio-common
volumes:
- data2-1:/data1
- data2-2:/data2
volumes:
data1-1:
data1-2:
data2-1:
data2-2:
编排自己的项目
以ruoyi项目为例子,先采用挂载目录的方式部署应用,等我们学完dockfile打包,就可以完整的部署应用了。version: '3.1'
services:
ruoyi-app:
# docker run --name ruoyi-app \
# -p 8080:8080 \
# --network ruoyi-net \
# -v /home/app/ruoyi-admin.jar:/usr/local/src/ruoyi-admin.jar \
# -d openjdk:8u342-jre \
# java -jar /usr/local/src/ruoyi-admin.jar
image: openjdk:8u342-jre
ports:
- 8080:8080
volumes:
- /home/app/ruoyi-admin.jar:/usr/local/src/ruoyi-admin.jar
command: java -jar /usr/local/src/ruoyi-admin.jar
networks:
- ruoyi-net
depends_on:
- ruoyi-db
ruoyi-db:
# docker run --name ruoyi-db -p 3303:3306 \
# --network ruoyi-net \
# -v ruoyi-data:/var/lib/mysql \
# -v /home/app/sql:/docker-entrypoint-initdb.d \
# -e MYSQL_DATABASE=ry \
# -e MYSQL_ROOT_PASSWORD=123456 \
# -d mysql:5.7 \
# --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci --skip-character-set-client-handshake
image: mysql:5.7
environment:
- MYSQL_ROOT_PASSWORD=123456
- MYSQL_DATABASE=ry
command: [
"--character-set-server=utf8mb4",
"--collation-server=utf8mb4_general_ci",
"--skip-character-set-client-handshake"
]
volumes:
- /home/app/sql:/docker-entrypoint-initdb.d
- ruoyi-data:/var/lib/mysql
networks:
- ruoyi-net
volumes:
ruoyi-data:
networks:
ruoyi-net:
command支持以下写法:
#推荐使用数组或列表的方式
#数组
command:
["java",
"-jar",
"/usr/local/src/ruoyi-admin.jar"
]
#列表
command:
- java
- -jar
- /usr/local/src/ruoyi-admin.jar
# shell命令模式
command: java -jar /usr/local/src/ruoyi-admin.jar
执行复杂的脚本
command:
- bash
- "-c"
- |
set -ex
# Generate mysql server-id from pod ordinal index.
[[ `hostname` =~ -([0-9]+)$ ]] || exit 1
ordinal=${BASH_REMATCH[1]}
echo [mysqld] > /mnt/conf.d/server-id.cnf
# Add an offset to avoid reserved server-id=0 value.
echo server-id=$((100 + $ordinal)) >> /mnt/conf.d/server-id.cnf
# Copy appropriate conf.d files from config-map to emptyDir.
if [[ $ordinal -eq 0 ]]; then
cp /mnt/config-map/primary.cnf /mnt/conf.d/
else
cp /mnt/config-map/replica.cnf /mnt/conf.d/
fi
environment支持如下两种写法:
# 使用map
environment:
MYSQL_DATABASE: exampledb
MYSQL_USER: exampleuser
MYSQL_PASSWORD: examplepass
MYSQL_RANDOM_ROOT_PASSWORD: '1'
#使用列表
environment:
- MYSQL_ROOT_PASSWORD=123456
- MYSQL_DATABASE=ry
- LANG=C.UTF-8
容器启动顺序depends_on
数据库初始化完成之前,不会建立connections。![](/i/l/?n=22&i=blog/1410855/202211/1410855-20221122105952567-104677219.png)
depends_on只能保证容器的启动和销毁顺序,不能确保依赖的容器是否ready。
version: "3.9"
services:
web:
build: .
depends_on:
- db
- redis
redis:
image: redis
db:
image: postgres
在这个例子中,depends_on只能保证web容器在db,redis之后启动,不会关注他们的状态是否启动完成或准备就绪。要确保应用服务在数据库初始化完成后再启动,需要配合condition和healthcheck使用。
services:
web:
build: .
depends_on:
db:
condition: service_healthy
redis:
condition: service_started
redis:
image: redis
db:
image: postgres
condition有三种状态:service_started容器已启动
service_healthy容器处于健康状态
service_completed_successfully容器执行完成且成功退出(退出状态码为0)
我们来改造一下我们自己的docker-compose.yaml文件,完整例子如下:
services:
ruoyi-app:
# docker run --name ruoyi-app \
# -p 8080:8080 \
# --network ruoyi-net \
# -v /home/app/ruoyi-admin.jar:/usr/local/src/ruoyi-admin.jar \
# -d openjdk:8u342-jre \
# java -jar /usr/local/src/ruoyi-admin.jar
image: openjdk:8u342-jre
restart: always
ports:
- 8080:8080
networks:
- ruoyi-net
volumes:
- /home/app/ruoyi-admin.jar:/usr/local/src/ruoyi-admin.jar
command: [ "java", "-jar", "/usr/local/src/ruoyi-admin.jar" ]
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8080"]
interval: 5m30
timeout: 5s
retries: 5
start_period: 20s
depends_on:
ruoyi-db:
condition: service_healthy
ruoyi-db:
# docker run --name ruoyi-db -p 3303:3306 \
# --network ruoyi-net \
# -v ruoyi-data:/var/lib/mysql \
# -v /home/app/sql:/docker-entrypoint-initdb.d \
# -e MYSQL_DATABASE=ry \
# -e MYSQL_ROOT_PASSWORD=123456 \
# -d mysql:5.7 \
# --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci --skip-character-set-client-handshake
image: mysql:5.7
environment:
- MYSQL_DATABASE=ry
- MYSQL_ROOT_PASSWORD=123456
volumes:
- ruoyi-data:/var/lib/mysql
- /home/app/sql:/docker-entrypoint-initdb.d
networks:
- ruoyi-net
command:
[
"--character-set-server=utf8mb4",
"--collation-server=utf8mb4_unicode_ci",
"--skip-character-set-client-handshake"
]
healthcheck:
test: ["CMD", 'mysqladmin', 'ping', '-h', 'localhost', '-u', 'root', '-p$$MYSQL_ROOT_PASSWORD']
interval: 5m
timeout: 5s
retries: 5
start_period: 20s
volumes:
ruoyi-data:
networks:
ruoyi-net:
八、dockerfile制作镜像
dockerfile通常包含以下几个常用命令:
FROM ubuntu:18.04
WORKDIR /app
COPY . .
RUN make .
CMD python app.py
EXPOSE 80
FROM 打包使用的基础镜像
WORKDIR相当于cd命令,进入工作目录
COPY 将宿主机的文件复制到容器内
RUN打包时执行的命令,相当于打包过程中在容器中执行shell脚本,通常用来安装应用程序所需要的依赖、设置权限、初始化配置文件等
CMD运行镜像时执行的命令
EXPOSE指定容器在运行时监听的网络端口,它并不会公开端口,仅起到声明的作用,公开端口需要容器运行时使用-p参数指定。
制作自己的镜像
参考我们之前的配置,制作dockerfile文件 ruoyi-java:
image: openjdk:8u342-jre
ports:
- 8080:8080
volumes:
- /home/app/ruoyi-admin.jar:/usr/local/src/ruoyi-admin.jar
command: [ "java", "-jar", "/usr/local/src/ruoyi-admin.jar" ]
networks:
- ruoyi-net
depends_on:
- ruoyi-db
编写dockerfile文件
FROM openjdk:8u342-jre
WORKDIR /app
COPY ./ruoyi-admin.jar .
CMD [ "java", "-jar", "ruoyi-admin.jar" ]
EXPOSE 8080
docker build . 打包
![](/i/l/?n=22&i=blog/1410855/202211/1410855-20221122112053613-694984149.png)
![](/i/l/?n=22&i=blog/1410855/202211/1410855-20221122112107666-1515337902.png)
docker tag 79d007b05ff6 ruoyi-app:4.7.4-jar 设置镜像的标签
![](/i/l/?n=22&i=blog/1410855/202211/1410855-20221122112116638-1145101365.png)
image镜像与layer层
image文件由一系列层构建而成,dockerfile每一个命令都会生成一个层。每一层都是只读的。例如前面我们制作镜像,就产生了4个层。![](/i/l/?n=22&i=blog/1410855/202211/1410855-20221122112130011-598877520.png)
也可以使用docker image history ruoyi-java:4.7.4命令查看
![](/i/l/?n=22&i=blog/1410855/202211/1410855-20221122112200774-650563387.png)
![](/i/l/?n=22&i=blog/1410855/202211/1410855-20221122112219678-1268295417.png)
多阶段构建
在构建基于 Java 的应用程序时,需要一个 JDK 将源代码编译为 Java 字节码。但是,在生产中不需要该 JDK。多阶段构建可以将生成时依赖与运行时依赖分开,减小整个image文件大小。
Maven/Tomcat 示例
使用 Maven来构建应用,在最终的image中不需要包含maven。我们可以使用多阶段构建,每一个阶段从FROM开始,最终的image只会从最后一个阶段构建,不会包含前面阶段产生的层,因此可以减少镜像体积。FROM maven AS build
WORKDIR /source
COPY . .
RUN mvn package
FROM openjdk:8u342-jre
WORKDIR /app
COPY --from=build /source/ruoyi-admin/target/ruoyi-admin.jar .
EXPOSE 80
ENTRYPOINT ["java","-jar","ruoyi-admin.jar"]
docker build -t ruoyi-jar:4.7.4 .
version: '3.1'
services:
ruoyi-java:
image: ruoyi-jar:4.7.4
command: [
"--ruoyi.profile=/home/ruoyi/uploadPath",
"--spring.datasource.druid.master.url=jdbc:mysql://ruoyi-db:3306/ry?useUnicode=true&characterEncoding=utf8",
"--spring.datasource.druid.master.username=root",
"--spring.datasource.druid.master.password=123456"
]
ports:
- 8080:8080
networks:
- ruoyi-net
depends_on:
- ruoyi-db
ruoyi-db:
image: mysql:5.7
environment:
- MYSQL_ROOT_PASSWORD=123456
- MYSQL_DATABASE=ry
command: [
"--character-set-server=utf8mb4",
"--collation-server=utf8mb4_general_ci",
"--skip-character-set-client-handshake"
]
volumes:
- /home/app/sql:/docker-entrypoint-initdb.d
- ruoyi-data:/var/lib/mysql
networks:
- ruoyi-net
volumes:
ruoyi-data:
networks:
ruoyi-net:
ENTRYPOINT和CMD的区别
dockerfile
应该至少包含一个ENTRYPOINT
或CMD
ENTRYPOINT
指定容器启动时执行的默认程序,一般运行容器时不会被替换或覆盖。除非使用
--entrypoint
进行指定。docker run -it --entrypoint /bin/bash redis
CMD可以在启动容器时被替换和覆盖。例如
docker run -it --rm mysql:5.7 /bin/bash
如果镜像中
ENTRYPOINT
和CMD
都存在,则CMD
将作为ENTRYPOINT
的参数使用。参考: 视频教程 文档教程