Docker

Docker

Docker业务

容器 配置文件查看

是的,通过路径挂载是一种常见的方法来修改Docker容器中的配置文件。通过路径挂载,您可以将宿主机上的配置文件映射到容器内部,从而实现对配置文件的修改。

下面以Redis为例,介绍如何通过路径挂载修改Redis容器的配置文件:

  1. 首先,准备好您要修改的Redis配置文件。可以在宿主机上创建一个新的配置文件,或者修改已有的配置文件。

  2. 在运行Redis容器时,使用-v参数指定路径挂载的方式将宿主机上的配置文件映射到容器内部。例如:

    1
    docker run -d -p 6379:6379 -v /path/to/redis.conf:/usr/local/etc/redis/redis.conf --name my-redis redis

    其中,/path/to/redis.conf是宿主机上的配置文件路径,/usr/local/etc/redis/redis.conf是容器内部的配置文件路径。

  3. 启动Redis容器后,您可以在宿主机上修改配置文件。任何对宿主机上的配置文件的修改都会反映到容器内部。

  4. 如果Redis容器已经在运行,您可以使用docker exec命令进入容器内部,并使用编辑器或命令行工具修改容器内部的配置文件。例如:

    1
    2
    docker exec -it my-redis bash
    vi /usr/local/etc/redis/redis.conf

    修改完配置文件后,重新启动Redis服务使配置生效。

同样的方法也适用于其他容器,如MySQL和Kafka。您可以将宿主机上的配置文件路径映射到容器内部的相应路径,然后在宿主机上修改配置文件。

请注意,修改容器的配置文件可能需要重启容器或重新加载配置才能生效。具体的操作步骤可能因容器和配置文件而异,建议查阅相关容器的文档或官方指南以获取更详细的信息。

如果您需要更多帮助或有其他问题,请告诉我。

docker-compose

DockerComposeFile — 构建容器

docker run

构建容器需要指定如下参数:

  1. 镜像名称:指定需要使用的镜像名称,例如 nginx、mysql 等。

  2. 容器名称:指定容器运行时的名称,实际上是该容器的一个别名,用于在系统中唯一标识该容器。

  3. 挂载目录:将主机文件系统挂载到容器中,用于持久化数据。

  4. 端口映射:将容器内部的端口映射到外部主机的端口。

  5. 启动参数:例如执行命令、环境变量等。

下面是一个完整的例子:

1
docker run --name my_container -p 8080:80 -v /app_data:/data -e MYSQL_ROOT_PASSWORD=password -d nginx

解释如下:

  • –name:容器名称为 my_container
  • -p:将容器内部的80端口映射到主机的8080端口。
  • -v:将主机中路径为 /app_data 的目录挂载到容器内部的 /data 目录。
  • -e:设置 MYSQL_ROOT_PASSWORD 环境变量的值为 password。
  • -d:在后台运行容器。
  • nginx:指定使用 nginx 镜像。

以上是构建容器时需要指定的一些重要参数,还可以根据具体应用场景和需求,指定更多相关的参数和配置信息。

compose-file

将所有构建容器时可以使用的常用参数总结如下:

  • image: 指定需要使用的镜像名称,例如 nginxmysql 等。
  • container_name: 指定容器运行时的名称,实际上是该容器别名,用于在系统中唯一标识该容器。
  • volumes: 将主机文件系统挂载到容器中,用于持久化数据。
  • ports: 将容器内部的端口映射到外部主机的端口。
  • environment: 属性 setter,用于设置容器内部的环境变量。
  • restart: 指定容器异常终止时的自动重启策略。
  • command: 在容器中启动时执行的命令。
  • user/group: 指定运行容器的用户或用户组。

除此之外,还有一些高级选项,例如:

  • privileged: 将容器变为 Docker 主机的特权容器,拥有所有的系统权限。
  • cap_add: 添加 Linux 内核的特权。
  • cap_drop: 删除 Linux 内核的特权。
  • network_mode: 指定容器应该连接到的网络。
  • dns: 自定义 DNS 记录。
  • hostname: 设置容器主机名。

下面是一个使用 Docker Compose 文件构建容器的示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
version: '3'

services:
backend:
image: myapp-backend:latest
container_name: myapp-backend
restart: always
ports:
- "8000:8000"
environment:
- DATABASE_HOST=db
- DATABASE_PORT=3306
- DATABASE_USER=myapp
- DATABASE_PASSWORD=mysecretpassword
command: python manage.py runserver 0.0.0.0:8000

db:
image: mysql:5.7
container_name: myapp-db
restart: always
environment:
- MYSQL_ROOT_PASSWORD=mysecretpassword
- MYSQL_DATABASE=myapp
- MYSQL_USER=myapp
- MYSQL_PASSWORD=mysecretpassword
volumes:
- /data/mysql:/var/lib/mysql

在上面的示例中:

  • backend 服务运行一个使用 myapp-backend 镜像的容器,容器名称为 myapp-backend,容器将在异常终止时自动重启,并监听 8000 端口、四个环境变量用于数据库配置,并在启动时执行 python manage.py runserver 命令。
  • db 服务运行一个使用 MySQL 5.7 镜像的容器,容器名称为 myapp-db,容器将在异常终止时自动重启,并将数据库数据挂载到本地

参数列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
    build                 # 指定包含构建上下文的路径, 或作为一个对象,该对象具有 context 和指定的 dockerfile 文件以及 args 参数值
context # context: 指定 Dockerfile 文件所在的路径
dockerfile # dockerfile: 指定 context 指定的目录下面的 Dockerfile 的名称(默认为 Dockerfile)
args # args: Dockerfile 在 build 过程中需要的参数 (等同于 docker container build --build-arg 的作用)
cache_from # v3.2中新增的参数, 指定缓存的镜像列表 (等同于 docker container build --cache_from 的作用)
labels # v3.3中新增的参数, 设置镜像的元数据 (等同于 docker container build --labels 的作用)
shm_size # v3.5中新增的参数, 设置容器 /dev/shm 分区的大小 (等同于 docker container build --shm-size 的作用)

command # 覆盖容器启动后默认执行的命令, 支持 shell 格式和 [] 格式

configs # 不知道怎么用

cgroup_parent # 不知道怎么用

container_name # 指定容器的名称 (等同于 docker run --name 的作用)

credential_spec # 不知道怎么用

deploy # v3 版本以上, 指定与部署和运行服务相关的配置, deploy 部分是 docker stack 使用的, docker stack 依赖 docker swarm
endpoint_mode # v3.3 版本中新增的功能, 指定服务暴露的方式
vip # Docker 为该服务分配了一个虚拟 IP(VIP), 作为客户端的访问服务的地址
dnsrr # DNS轮询, Docker 为该服务设置 DNS 条目, 使得服务名称的 DNS 查询返回一个 IP 地址列表, 客户端直接访问其中的一个地址
labels # 指定服务的标签,这些标签仅在服务上设置
mode # 指定 deploy 的模式
global # 每个集群节点都只有一个容器
replicated # 用户可以指定集群中容器的数量(默认)
placement # 不知道怎么用
replicas # deploy 的 mode 为 replicated 时, 指定容器副本的数量
resources # 资源限制
limits # 设置容器的资源限制
cpus: "0.5" # 设置该容器最多只能使用 50% 的 CPU
memory: 50M # 设置该容器最多只能使用 50M 的内存空间
reservations # 设置为容器预留的系统资源(随时可用)
cpus: "0.2" # 为该容器保留 20% 的 CPU
memory: 20M # 为该容器保留 20M 的内存空间
restart_policy # 定义容器重启策略, 用于代替 restart 参数
condition # 定义容器重启策略(接受三个参数)
none # 不尝试重启
on-failure # 只有当容器内部应用程序出现问题才会重启
any # 无论如何都会尝试重启(默认)
delay # 尝试重启的间隔时间(默认为 0s)
max_attempts # 尝试重启次数(默认一直尝试重启)
window # 检查重启是否成功之前的等待时间(即如果容器启动了, 隔多少秒之后去检测容器是否正常, 默认 0s)
update_config # 用于配置滚动更新配置
parallelism # 一次性更新的容器数量
delay # 更新一组容器之间的间隔时间
failure_action # 定义更新失败的策略
continue # 继续更新
rollback # 回滚更新
pause # 暂停更新(默认)
monitor # 每次更新后的持续时间以监视更新是否失败(单位: ns|us|ms|s|m|h) (默认为0)
max_failure_ratio # 回滚期间容忍的失败率(默认值为0)
order # v3.4 版本中新增的参数, 回滚期间的操作顺序
stop-first #旧任务在启动新任务之前停止(默认)
start-first #首先启动新任务, 并且正在运行的任务暂时重叠
rollback_config # v3.7 版本中新增的参数, 用于定义在 update_config 更新失败的回滚策略
parallelism # 一次回滚的容器数, 如果设置为0, 则所有容器同时回滚
delay # 每个组回滚之间的时间间隔(默认为0)
failure_action # 定义回滚失败的策略
continue # 继续回滚
pause # 暂停回滚
monitor # 每次回滚任务后的持续时间以监视失败(单位: ns|us|ms|s|m|h) (默认为0)
max_failure_ratio # 回滚期间容忍的失败率(默认值0)
order # 回滚期间的操作顺序
stop-first # 旧任务在启动新任务之前停止(默认)
start-first # 首先启动新任务, 并且正在运行的任务暂时重叠

注意:
支持 docker-compose up docker-compose run 但不支持 docker stack deploy 的子选项
security_opt container_name devices tmpfs stop_signal links cgroup_parent
network_mode external_links restart build userns_mode sysctls

devices # 指定设备映射列表 (等同于 docker run --device 的作用)

depends_on # 定义容器启动顺序 (此选项解决了容器之间的依赖关系, 此选项在 v3 版本中 使用 swarm 部署时将忽略该选项)
示例:
docker-compose up 以依赖顺序启动服务,下面例子中 redis db 服务在 web 启动前启动
默认情况下使用 docker-compose up web 这样的方式启动 web 服务时,也会启动 redis db 两个服务,因为在配置文件中定义了依赖关系

version: '3'
services:
web:
build: .
depends_on:
- db
- redis
redis:
image: redis
db:
image: postgres

dns # 设置 DNS 地址(等同于 docker run --dns 的作用)

dns_search # 设置 DNS 搜索域(等同于 docker run --dns-search 的作用)

tmpfs # v2 版本以上, 挂载目录到容器中, 作为容器的临时文件系统(等同于 docker run --tmpfs 的作用, 在使用 swarm 部署时将忽略该选项)

entrypoint # 覆盖容器的默认 entrypoint 指令 (等同于 docker run --entrypoint 的作用)

env_file # 从指定文件中读取变量设置为容器中的环境变量, 可以是单个值或者一个文件列表, 如果多个文件中的变量重名则后面的变量覆盖前面的变量, environment 的值覆盖 env_file 的值
文件格式:
RACK_ENV=development

environment # 设置环境变量, environment 的值可以覆盖 env_file 的值 (等同于 docker run --env 的作用)

expose # 暴露端口, 但是不能和宿主机建立映射关系, 类似于 Dockerfile 的 EXPOSE 指令

external_links # 连接不在 docker-compose.yml 中定义的容器或者不在 compose 管理的容器(docker run 启动的容器, 在 v3 版本中使用 swarm 部署时将忽略该选项)

extra_hosts # 添加 host 记录到容器中的 /etc/hosts 中 (等同于 docker run --add-host 的作用)

healthcheck # v2.1 以上版本, 定义容器健康状态检查, 类似于 Dockerfile 的 HEALTHCHECK 指令
test # 检查容器检查状态的命令, 该选项必须是一个字符串或者列表, 第一项必须是 NONE, CMD 或 CMD-SHELL, 如果其是一个字符串则相当于 CMD-SHELL 加该字符串
NONE # 禁用容器的健康状态检测
CMD # test: ["CMD", "curl", "-f", "http://localhost"]
CMD-SHELL # test: ["CMD-SHELL", "curl -f http://localhost || exit 1"] 或者 test: curl -f https://localhost || exit 1
interval: 1m30s # 每次检查之间的间隔时间
timeout: 10s # 运行命令的超时时间
retries: 3 # 重试次数
start_period: 40s # v3.4 以上新增的选项, 定义容器启动时间间隔
disable: true # true 或 false, 表示是否禁用健康状态检测和 test: NONE 相同

image # 指定 docker 镜像, 可以是远程仓库镜像、本地镜像

init # v3.7 中新增的参数, true 或 false 表示是否在容器中运行一个 init, 它接收信号并传递给进程

isolation # 隔离容器技术, 在 Linux 中仅支持 default 值

labels # 使用 Docker 标签将元数据添加到容器, 与 Dockerfile 中的 LABELS 类似

links # 链接到其它服务中的容器, 该选项是 docker 历史遗留的选项, 目前已被用户自定义网络名称空间取代, 最终有可能被废弃 (在使用 swarm 部署时将忽略该选项)

logging # 设置容器日志服务
driver # 指定日志记录驱动程序, 默认 json-file (等同于 docker run --log-driver 的作用)
options # 指定日志的相关参数 (等同于 docker run --log-opt 的作用)
max-size # 设置单个日志文件的大小, 当到达这个值后会进行日志滚动操作
max-file # 日志文件保留的数量

network_mode # 指定网络模式 (等同于 docker run --net 的作用, 在使用 swarm 部署时将忽略该选项)

networks # 将容器加入指定网络 (等同于 docker network connect 的作用), networks 可以位于 compose 文件顶级键和 services 键的二级键
aliases # 同一网络上的容器可以使用服务名称或别名连接到其中一个服务的容器
ipv4_address # IP V4 格式
ipv6_address # IP V6 格式

示例:
version: '3.7'
services:
test:
image: nginx:1.14-alpine
container_name: mynginx
command: ifconfig
networks:
app_net: # 调用下面 networks 定义的 app_net 网络
ipv4_address: 172.16.238.10
networks:
app_net:
driver: bridge
ipam:
driver: default
config:
- subnet: 172.16.238.0/24

pid: 'host' # 共享宿主机的 进程空间(PID)

ports # 建立宿主机和容器之间的端口映射关系, ports 支持两种语法格式
SHORT 语法格式示例:
- "3000" # 暴露容器的 3000 端口, 宿主机的端口由 docker 随机映射一个没有被占用的端口
- "3000-3005" # 暴露容器的 3000 到 3005 端口, 宿主机的端口由 docker 随机映射没有被占用的端口
- "8000:8000" # 容器的 8000 端口和宿主机的 8000 端口建立映射关系
- "9090-9091:8080-8081"
- "127.0.0.1:8001:8001" # 指定映射宿主机的指定地址的
- "127.0.0.1:5000-5010:5000-5010"
- "6060:6060/udp" # 指定协议

LONG 语法格式示例:(v3.2 新增的语法格式)
ports:
- target: 80 # 容器端口
published: 8080 # 宿主机端口
protocol: tcp # 协议类型
mode: host # host 在每个节点上发布主机端口, ingress 对于群模式端口进行负载均衡

secrets # 不知道怎么用

security_opt # 为每个容器覆盖默认的标签 (在使用 swarm 部署时将忽略该选项)

stop_grace_period # 指定在发送了 SIGTERM 信号之后, 容器等待多少秒之后退出(默认 10s)

stop_signal # 指定停止容器发送的信号 (默认为 SIGTERM 相当于 kill PID; SIGKILL 相当于 kill -9 PID; 在使用 swarm 部署时将忽略该选项)

sysctls # 设置容器中的内核参数 (在使用 swarm 部署时将忽略该选项)

ulimits # 设置容器的 limit

userns_mode # 如果Docker守护程序配置了用户名称空间, 则禁用此服务的用户名称空间 (在使用 swarm 部署时将忽略该选项)

volumes # 定义容器和宿主机的卷映射关系, 其和 networks 一样可以位于 services 键的二级键和 compose 顶级键, 如果需要跨服务间使用则在顶级键定义, 在 services 中引用
SHORT 语法格式示例:
volumes:
- /var/lib/mysql # 映射容器内的 /var/lib/mysql 到宿主机的一个随机目录中
- /opt/data:/var/lib/mysql # 映射容器内的 /var/lib/mysql 到宿主机的 /opt/data
- ./cache:/tmp/cache # 映射容器内的 /var/lib/mysql 到宿主机 compose 文件所在的位置
- ~/configs:/etc/configs/:ro # 映射容器宿主机的目录到容器中去, 权限只读
- datavolume:/var/lib/mysql # datavolume 为 volumes 顶级键定义的目录, 在此处直接调用

LONG 语法格式示例:(v3.2 新增的语法格式)
version: "3.2"
services:
web:
image: nginx:alpine
ports:
- "80:80"
volumes:
- type: volume # mount 的类型, 必须是 bind、volume 或 tmpfs
source: mydata # 宿主机目录
target: /data # 容器目录
volume: # 配置额外的选项, 其 key 必须和 type 的值相同
nocopy: true # volume 额外的选项, 在创建卷时禁用从容器复制数据
- type: bind # volume 模式只指定容器路径即可, 宿主机路径随机生成; bind 需要指定容器和数据机的映射路径
source: ./static
target: /opt/app/static
read_only: true # 设置文件系统为只读文件系统
volumes:
mydata: # 定义在 volume, 可在所有服务中调用

restart # 定义容器重启策略(在使用 swarm 部署时将忽略该选项, 在 swarm 使用 restart_policy 代替 restart)
no # 禁止自动重启容器(默认)
always # 无论如何容器都会重启
on-failure # 当出现 on-failure 报错时, 容器重新启动

其他选项:
domainname, hostname, ipc, mac_address, privileged, read_only, shm_size, stdin_open, tty, user, working_dir
上面这些选项都只接受单个值和 docker run 的对应参数类似对于值为时间的可接受的值:
2.5s
10s
1m30s
2h32m
5h34m56s
时间单位: us, ms, s, m, h
对于值为大小的可接受的值:
2b
1024kb
2048k
300m
1gb
单位: b, k, m, g 或者 kb, mb, gb
networks # 定义 networks 信息
driver # 指定网络模式, 大多数情况下, 它 bridge 于单个主机和 overlay Swarm 上
bridge # Docker 默认使用 bridge 连接单个主机上的网络
overlay # overlay 驱动程序创建一个跨多个节点命名的网络
host # 共享主机网络名称空间(等同于 docker run --net=host)
none # 等同于 docker run --net=none
driver_opts # v3.2以上版本, 传递给驱动程序的参数, 这些参数取决于驱动程序
attachable # driver 为 overlay 时使用, 如果设置为 true 则除了服务之外,独立容器也可以附加到该网络; 如果独立容器连接到该网络,则它可以与其他 Docker 守护进程连接到的该网络的服务和独立容器进行通信
ipam # 自定义 IPAM 配置. 这是一个具有多个属性的对象, 每个属性都是可选的
driver # IPAM 驱动程序, bridge 或者 default
config # 配置项
subnet # CIDR格式的子网,表示该网络的网段
external # 外部网络, 如果设置为 true 则 docker-compose up 不会尝试创建它, 如果它不存在则引发错误
name # v3.5 以上版本, 为此网络设置名称

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
version: "3"
services:
redis:
image: redis:alpine
ports:
- "6379"
networks:
- frontend
deploy:
replicas: 2
update_config:
parallelism: 2
delay: 10s
restart_policy:
condition: on-failure
db:
image: postgres:9.4
volumes:
- db-data:/var/lib/postgresql/data
networks:
- backend
deploy:
placement:
constraints: [node.role == manager]

Dokerfile – 构建镜像

Dockerfile reference | Docker Documentation

D 构建镜像时可以使用的参数有很多,主要包括以下几类参数:

  1. FROM:指定基础镜像名称及其版本,用于指定新镜像的基础镜像,例如

    1
    FROM ubuntu:20.04
  2. MAINTAINER/LABEL:用于指定该镜像的维护者和版本信息。

    1
    2
    3
    MAINTAINER docker-team@example.com
    LABEL version="1.0"
    LABEL description="My custom nginx image"
  3. RUN:在镜像构建期间执行指定的命令,用于在构建镜像时配置和初始化环境,例如

    1
    2
    RUN apt-get update && \
    apt-get install nginx -y
  4. COPY/ADD:将指定文件或目录拷贝到镜像中,用于向容器中添加文件、应用程序和配置文件,例如

    1
    2
    COPY ./src /app/src
    ADD https://example.com/archive.tar.gz /app/
  5. ENV:设置环境变量,用于容器内部的应用程序配置和运行,例如

    1
    ENV MYSQL_VERSION 5.7
  6. EXPOSE:指定容器需要映射的端口,用户指定容器端口暴露给主机,例如

    1
    EXPOSE 80
  7. USER:在容器中指定运行命令的用户,用于设置容器内应用程序的运行权限,例如

    1
    USER www-data
  8. WORKDIR:指定镜像中的工作目录,用于指定容器启动时的默认目录,例如

    1
    WORKDIR /app
  9. CMD/ENTRYPOINT:指定容器启动后需要执行的默认命令,用于启动和管理容器,例如

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
       CMD ["nginx", "-g", "daemon off;"]
    ENTRYPOINT ["sh", "-c", "echo Hello, $NAME"]

    总的来说,这些参数都可以用于指定镜像系统内运行时的配置信息



    # Docker部署前后端



    ## 后端部署

    后端应用程序使用 Docker 进行部署的步骤如下:

    1. 编写 Dockerfile 文件

    Dockerfile 是构建 Docker 镜像的核心文件,它定义了构建镜像的步骤。一个基本的 Dockerfile 文件如下所示:

    ```Dockerfile
    # 选择基础镜像(这里选择的是 OpenJDK 镜像)
    FROM openjdk:11-jre-slim

    # 配置镜像中的应用程序工作目录(这里选择的是 /app 目录)
    WORKDIR /app

    # 复制编译好的后端应用程序 JAR 文件(这里假设 JAR 文件已经通过 Gradle 或者 Maven 编译完成)
    COPY build/libs/myapp.jar /app

    # 暴露应用程序所使用的端口号(可以根据你自己的应用程序选择)
    EXPOSE 8080

    # 执行 JAR 文件的命令(这里的 myapp.jar 是上面 COPY 命令里复制进去的)
    CMD ["java", "-jar", "myapp.jar"]
  10. 构建 Docker 镜像

使用上述编写好的 Dockerfile,构建 Docker 镜像的命令如下:

1
docker build -t myapp:latest .

其中,.(点) 表示 Dockerfile 文件所在的目录。

在前面的 Dockerfile 例子中,执行完这个命令后,会生成一个名为 myapp 版本为 latest 的 Docker 镜像。

  1. 运行 Docker 镜像

使用前面构建好的 Docker 镜像,启动应用程序的命令如下:

1
docker run -p 8080:8080 myapp:latest

其中 -p 参数表示将容器内的应用程序端口号 8080 映射到主机的端口号 8080 上。

  1. 其他操作
  • 推送到 Docker Hub 或者私有仓库:如果需要,可以使用 docker push 命令将自己构建的 Docker 镜像推送到 Docker Hub 或者其他私

  • 有的镜像仓库中存储。命令如下:

    1
    2
    3
    4
    5
    # 登录到 Docker Hub 或者其他私有镜像仓库(根据实际情况填写)
    docker login docker.io

    # 将本地构建好的 Docker 镜像推送到 Docker Hub 上(根据实际情况填写)
    docker push mydockerhub/myapp:latest
    • 挂载数据卷:如果需要,可以使用 docker run 命令挂载数据卷,将应用程序中生成的数据文件存储到外部存储器中,防止容器删除或者建时丢失数据。具体命令如下:
    1
    docker run -p 8080:8080 -v /path/to/directory:/app/data myapp:latest

    其中 /path/to/directory 表示宿主机上的目录。在这个例子中,我们将容器内 /app/data 目录挂载到主机上的 /path/to/directory 目录(假设 /path/to/directory 已经存在),容器中的数据文件将会存储在 /path/to/directory 目录中。

    • 使用 Docker Compose:如果您的后端应用程序需要与多个其它容器(例如数据库、缓存、消息队列等等)协同工作,推荐使用 Docker Compose。Docker Compose 是 Docker 官方提供的一个工具,将多个容器打包成一个整体进行管理和部署。具体见 官方文档

    以上是部署后端应用程序时的主要步骤和细节。需要根据自己的实际情况进行相应的处理和调整。

前端部署

npm run build

在前端项目中,npm run build 命令用于构建生产环境下的前端资源。它会执行一系列的构建任务,如压缩文件、打包文件、生成 HTML、CSS 和 JavaScript 文件等,最终产生一些优化过的、可部署的前端资源。这些前端资源就是我们前端项目的核心内容,可以在生产环境中部署和运行。

相比之下,npm run start 命令是用来启动本地开发服务器,以便在开发过程中进行实时的调试和代码更改。

使用 npm run build 而不是 npm run start 是因为在正式部署前端应用程序时,我们通常会对前端项目进行构建处理。这意味着在部署之前,前端项目的源代码和构建后的版本是有区别的,构建过的版本可以更好地完善优化和减少加载时间。

在进行 Nginx 部署时,我们不需要运行 npm run start,因为 Nginx 只是一个 HTTP 服务器,它只需要提供静态文件服务就可以了。所以一般我们会使用 npm run build 命令预先处理好静态文件,并将其生成到指定的位置。Nginx 再将静态文件从该位置读取并进行相应的路由处理即可。

因此,在前端部署时,我们通常使用 npm run build 命令构建静态文件,然后得到的构建文件可以直接部署在 Nginx 静态文件夹中,并通过 Nginx 进行访问、路由等处理。

Dockerfile

Dockerfile 制定镜像的基础镜像是需要制定版本的。在生产环境中,为了保证稳定性和可靠性,通常需要使用特定版本的基础镜像并根据需要定期更新。

以下是一个简单的 Dockerfile 示例,可用于构建用于前端项目的镜像:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 使用官方的 Node.js v14 镜像作为基础镜像
FROM node:14

# 设置容器工作目录
WORKDIR /app

# 将本地的 package.json 和 package-lock.json 复制到容器内的 /app 目录下
COPY package*.json ./

# 安装项目依赖
RUN npm install

# 将本地的所有文件复制到容器内的 /app 目录下
COPY . .

# 运行命令构建生产环境下的前端资源
RUN npm run build

# 设置容器启动时执行的命令
CMD [ "npm", "start" ]

这个 Dockerfile 中的每行都很重要,请看下面的解读:

1
2
# 使用官方的 Node.js v14 镜像作为基础镜像
FROM node:14

这行指定了所使用的基础镜像,这里使用官方的 Node.js v14 镜像。

1
2
# 设置容器工作目录
WORKDIR /app

这一行设置了容器的工作目录,这里我们将工作目录设置为 /app

1
2
# 将本地的 package.json 和 package-lock.json 复制到容器内的 /app 目录下
COPY package*.json ./

这一行将本地的 package.jsonpackage-lock.json 文件复制到了容器内的 /app 目录下,以便后面安装项目依赖。

1
2
# 安装项目依赖
RUN npm install

这一行使用 npm 安装项目依赖,将在容器内的 /app 目录下执行。

1
2
# 将本地的所有文件复制到容器内的 /app 目录下
COPY . .

这一行将本地项目的所有文件,包括源代码、配置文件等复制到了容器内的 /app 目录下。

1
2
# 运行构建命令,生成生产环境下的前端资源
RUN npm run build

这一行运行命令构建生产环境下的前端资源。

1
2
# 设置容器启动时执行的命令
CMD [ "npm", "start" ]

这一行指定了容器启动时要运行的命令,这里我们设置为启动 npm start 命令。

综上,这个 Dockerfile 的作用是构建适用于前端项目的 Docker 镜像,包含了以下步骤:

  1. 基础镜像选择了官方的 Node.js v14 镜像作为基础镜像,这里使用的是特定版本的镜像。

  2. 设置了容器内的工作目录为 /app,在该目录下后续操作。

  3. 复制了本地项目中的 package.jsonpackage-lock.json 文件到容器内的 /app 目录下,以便安装依赖。

  4. 使用 npm 安装了项目依赖,在容器内的 /app 目录下。

  5. 复制本地项目的所有文件到容器内的 /app 目录下。

  6. 运行构建命令,生成生产环境下的前端资源。

  7. 设置了容器启动时默认运行的命令为 npm start

这个 Dockerfile 使得开发人员可以方便地将前端项目打包为镜像,以便在各种环境中快速部署。通过构建这个镜像,我们可以将前端项目和相关依赖打包为一个可移植的容器。


Docker
http://example.com/2023/06/01/工具/docker/
作者
where
发布于
2023年6月1日
许可协议