3万主题	2717 科技点	3万积分

执行版主

碾压王

积分: 32881

发消息

发表于 2025-8-31 20:30:01 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

x

引言

Docker作为容器化技术的代表，已经彻底改变了软件开发、测试和部署的方式。它通过将应用程序及其依赖项打包到轻量级、可移植的容器中，解决了”在我机器上可以运行”的古老问题，使DevOps工作流程更加顺畅高效。本文将带你从Docker镜像构建的基础知识开始，逐步深入到高级技巧和实战应用，帮助你全面掌握Docker技术，并解决容器化部署中遇到的常见问题。

Docker基础概念

在开始构建Docker镜像之前，我们需要了解一些基本概念：

镜像(Image)

Docker镜像是一个只读的模板，用于创建容器。它包含了运行应用程序所需的所有内容——代码、运行时、库、环境变量和配置文件。镜像是分层构建的，每一层都是只读的，除了最上层。当镜像被修改时，实际上是创建了一个新的顶层可写层。

容器(Container)

容器是镜像的运行实例。你可以创建、启动、停止、移动或删除容器。容器之间是相互隔离的，每个容器都有自己独立的文件系统、网络和进程空间。

仓库(Repository)

Docker仓库是用来存储和分发镜像的地方。最著名的公共仓库是Docker Hub，此外你也可以搭建私有仓库，如Harbor、Nexus等。

Dockerfile

Dockerfile是一个文本文件，包含了一系列命令，用户可以通过调用这些命令来创建一个镜像。每个命令都会在镜像上创建一个新的层。

Docker镜像构建入门

基本Dockerfile指令

让我们从一个简单的Dockerfile开始，了解基本指令：

# 使用官方Python运行时作为基础镜像
FROM python:3.9-slim
# 设置工作目录
WORKDIR /app
# 将当前目录内容复制到容器的/app目录
COPY . /app
# 安装依赖
RUN pip install --no-cache-dir -r requirements.txt
# 设置环境变量
ENV NAME World
# 容器启动时运行的命令
CMD ["python", "app.py"]

复制代码

构建第一个镜像

假设我们有一个简单的Flask应用：

app.py

from flask import Flask
import os
app = Flask(__name__)
@app.route('/')
def hello():
name = os.environ.get('NAME', 'World')
return f'Hello, {name}!'
if __name__ == '__main__':
app.run(host='0.0.0.0', port=80)

复制代码

requirements.txt

Flask==2.0.1

复制代码

要构建这个应用的镜像，我们需要在项目根目录下创建上面的Dockerfile，然后运行以下命令：

docker build -t my-flask-app .

复制代码

• -t参数给镜像打标签，格式为name:tag，如果不指定tag，默认为latest
• .表示构建上下文是当前目录

构建完成后，我们可以运行容器：

docker run -p 4000:80 my-flask-app

复制代码

现在访问http://localhost:4000，你将看到 “Hello, World!“。

Dockerfile常用指令详解

指定基础镜像，必须是第一条指令：

FROM <image>[:<tag>] [AS <name>]

复制代码

例如：

FROM ubuntu:20.04
FROM python:3.9-slim AS builder

复制代码

设置工作目录，后续的指令（如RUN、CMD、ENTRYPOINT、COPY、ADD）都会在这个目录下执行：

WORKDIR /path/to/workdir

复制代码

执行命令并创建新的镜像层：

RUN <command> # shell格式
RUN ["executable", "param1", "param2"] # exec格式

复制代码

例如：

RUN apt-get update && apt-get install -y python3
RUN ["pip", "install", "-r", "requirements.txt"]

复制代码

复制文件到镜像中：

COPY <src>... <dest>
ADD <src>... <dest>

复制代码

COPY和ADD的区别在于，ADD还支持URL和自动解压tar包：

COPY requirements.txt /app/
ADD https://example.com/file.tar.gz /app/

复制代码

容器启动时执行的命令，一个Dockerfile中只有最后一个CMD会生效：

CMD ["executable", "param1", "param2"] # exec格式，推荐
CMD command param1 param2 # shell格式
CMD ["param1", "param2"] # 作为ENTRYPOINT的参数

复制代码

配置容器启动时运行的命令，与CMD类似，但不会被docker run的命令行参数覆盖：

ENTRYPOINT ["executable", "param1", "param2"]
ENTRYPOINT command param1 param2

复制代码

设置环境变量：

ENV <key> <value>
ENV <key>=<value>

复制代码

例如：

ENV APP_VERSION=1.0
ENV PATH /usr/local/nginx/bin:$PATH

复制代码

声明容器运行时监听的端口，但实际上不会发布端口，只是作为文档记录：

EXPOSE <port> [<port>/<protocol>...]

复制代码

例如：

EXPOSE 80 443
EXPOSE 8080/tcp

复制代码

定义匿名数据卷，用于持久化数据或共享数据：

VOLUME ["/path/to/dir"]

复制代码

例如：

VOLUME ["/data"]

复制代码

指定运行容器时的用户名或UID：

USER <user>[:<group>]
USER <UID>[:<GID>]

复制代码

例如：

USER nginx

复制代码

定义构建时变量，只在构建过程中有效：

ARG <name>[=<default value>]

复制代码

例如：

ARG VERSION=1.0
RUN echo $VERSION

复制代码

添加元数据到镜像，以键值对的形式：

LABEL <key>=<value> <key>=<value> ...

复制代码

例如：

LABEL version="1.0" description="This is a sample application"

复制代码

Docker镜像构建进阶

多阶段构建

多阶段构建允许你在单个Dockerfile中使用多个FROM指令，每个FROM指令开始一个新的构建阶段。你可以选择性地将构件从一个阶段复制到另一个阶段，这可以创建更小、更安全的最终镜像。

下面是一个使用多阶段构建的Go应用示例：

# 第一阶段：构建应用
FROM golang:1.16 AS builder
WORKDIR /app
# 复制依赖文件
COPY go.mod go.sum ./
RUN go mod download
# 复制源代码并构建
COPY *.go .
RUN CGO_ENABLED=0 GOOS=linux go build -o /server
# 第二阶段：创建最终镜像
FROM alpine:latest
WORKDIR /root/
# 从第一阶段复制构建的二进制文件
COPY --from=builder /server .
# 暴露端口
EXPOSE 8080
# 运行应用
CMD ["./server"]

复制代码

在这个例子中，第一阶段使用Go SDK构建应用，第二阶段只复制构建好的二进制文件到干净的Alpine Linux镜像中。这样最终的镜像只包含运行应用所需的最小文件，大大减小了镜像大小。

镜像优化技巧

选择合适的基础镜像可以显著减小最终镜像的大小：

# 大镜像
FROM ubuntu:20.04
# 小镜像
FROM alpine:3.13
# 更小的镜像
FROM scratch

复制代码

每个RUN指令都会创建一个新的镜像层，合并RUN指令可以减少层数：

# 不推荐
RUN apt-get update
RUN apt-get install -y python3
RUN pip install flask
# 推荐
RUN apt-get update && \
apt-get install -y python3 && \
pip install flask && \
rm -rf /var/lib/apt/lists/*

复制代码

类似于.gitignore，.dockerignore可以排除不需要的文件和目录：

.git
.gitignore
node_modules
npm-debug.log
Dockerfile
.dockerignore

复制代码

将不常变化的文件放在前面，常变化的文件放在后面，这样可以利用Docker的层缓存机制：

# 先复制依赖文件
COPY package*.json ./
RUN npm install
# 再复制源代码
COPY . .

复制代码

如前所述，多阶段构建可以帮助你创建更小的镜像。

在安装包后清理缓存和不必要的文件：

RUN apt-get update && \
apt-get install -y python3 && \
pip install flask && \
rm -rf /var/lib/apt/lists/* && \
apt-get clean

复制代码

高级Dockerfile技巧

HEALTHCHECK指令告诉Docker如何测试容器是否仍在工作：

HEALTHCHECK --interval=30s --timeout=3s \
CMD curl -f http://localhost:80/ || exit 1

复制代码

参数说明：

• --interval：检查间隔，默认30秒
• --timeout：超时时间，默认30秒
• --start-period：容器启动后等待多久开始健康检查，默认0秒
• --retries：重试次数，默认3次

ONBUILD指令在当前镜像构建时不会执行，而是在以当前镜像为基础镜像的下一个镜像构建时执行：

FROM node:10
WORKDIR /app
ONBUILD COPY package.json /app
ONBUILD RUN npm install
ONBUILD COPY . /app
CMD ["node", "app.js"]

复制代码

SHELL指令可以覆盖默认的shell格式：

SHELL ["powershell", "-command"]
RUN Write-Host hello

复制代码

STOPSIGNAL指令设置发送给容器以退出的系统调用信号：

STOPSIGNAL SIGTERM

复制代码

Docker仓库管理

公共仓库：Docker Hub

Docker Hub是Docker官方提供的公共镜像仓库服务，拥有大量官方和社区维护的镜像。

docker login

复制代码

# 给镜像打标签
docker tag my-flask-app username/my-flask-app:v1.0
# 推送镜像
docker push username/my-flask-app:v1.0

复制代码

docker pull username/my-flask-app:v1.0

复制代码

私有仓库：Harbor

Harbor是一个开源的企业级Docker Registry项目，提供了安全、标识和管理等功能。

1. 下载Harbor安装包：

wget https://github.com/goharbor/harbor/releases/download/v2.3.2/harbor-offline-installer-v2.3.2.tgz
tar xvf harbor-offline-installer-v2.3.2.tgz

复制代码

1. 配置Harbor：

cd harbor
cp harbor.yml.tmpl harbor.yml

复制代码

编辑harbor.yml文件，设置hostname、端口、密码等参数。

1. 安装Harbor：

./install.sh

复制代码

1. 登录Harbor：

docker login harbor.example.com

复制代码

1. 推送镜像到Harbor：

# 给镜像打标签
docker tag my-flask-app harbor.example.com/library/my-flask-app:v1.0
# 推送镜像
docker push harbor.example.com/library/my-flask-app:v1.0

复制代码

1. 从Harbor拉取镜像：

docker pull harbor.example.com/library/my-flask-app:v1.0

复制代码

其他私有仓库选项

除了Harbor，还有其他一些流行的私有仓库选项：

Docker官方提供的开源Registry实现：

# 运行Registry容器
docker run -d -p 5000:5000 --restart=always --name registry registry:2
# 推送镜像到私有Registry
docker tag my-flask-app localhost:5000/my-flask-app
docker push localhost:5000/my-flask-app
# 从私有Registry拉取镜像
docker pull localhost:5000/my-flask-app

复制代码

Sonatype提供的仓库管理器，支持多种包格式，包括Docker镜像：

# 运行Nexus容器
docker run -d -p 8081:8081 --name nexus sonatype/nexus3
# 登录Nexus
docker login localhost:8081
# 推送镜像到Nexus
docker tag my-flask-app localhost:8081/my-flask-app
docker push localhost:8081/my-flask-app

复制代码

容器化部署常见问题及解决方案

1. 镜像过大

问题：构建的镜像体积过大，导致存储和传输效率低下。

解决方案：

• 使用更小的基础镜像，如alpine、scratch
• 使用多阶段构建
• 合并RUN指令，并在同一行中清理缓存
• 使用.dockerignore文件排除不必要的文件
• 删除不必要的包和文件

示例：

# 优化前
FROM ubuntu:20.04
RUN apt-get update
RUN apt-get install -y python3 python3-pip
RUN pip install flask
COPY . /app
WORKDIR /app
CMD ["python3", "app.py"]
# 优化后
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "app.py"]

复制代码

2. 构建速度慢

问题：镜像构建过程耗时太长。

解决方案：

• 利用Docker层缓存，将不常变化的文件放在前面
• 使用多阶段构建，避免重复构建
• 使用缓存服务，如APT缓存、PIP缓存
• 并行构建（使用BuildKit）

示例：

# 利用Docker层缓存
FROM node:14
WORKDIR /app
# 先复制依赖文件
COPY package*.json ./
RUN npm install
# 再复制源代码
COPY . .
CMD ["node", "app.js"]

复制代码

启用BuildKit进行并行构建：

DOCKER_BUILDKIT=1 docker build -t my-app .

复制代码

3. 容器启动失败

问题：容器启动后立即退出或无法正常启动。

解决方案：

• 使用正确的启动命令（CMD或ENTRYPOINT）
• 确保应用程序在前台运行
• 检查日志输出：docker logs <container_id>
• 使用docker exec进入容器调试
• 使用HEALTHCHECK监控容器状态

示例：

# 确保应用在前台运行
CMD ["node", "app.js"] # 推荐，exec格式
# 而不是
CMD node app.js # shell格式，可能会创建额外的shell进程
# 添加健康检查
HEALTHCHECK --interval=30s --timeout=3s \
CMD curl -f http://localhost:3000/ || exit 1

复制代码

4. 数据持久化问题

问题：容器删除后数据丢失。

解决方案：

• 使用数据卷（Volumes）或绑定挂载（Bind Mounts）
• 将数据存储在容器外的持久化存储中
• 考虑使用数据卷容器

示例：

# 使用数据卷
docker run -d -v mydata:/data my-app
# 使用绑定挂载
docker run -d -v /host/path:/container/path my-app
# 使用数据卷容器
docker create -v /data --name data-container busybox
docker run --volumes-from data-container my-app

复制代码

5. 网络连接问题

问题：容器之间或容器与外部网络之间的通信问题。

解决方案：

• 正确配置端口映射
• 使用自定义网络
• 使用容器名称进行通信
• 配置DNS解析

示例：

# 创建自定义网络
docker network create my-network
# 连接容器到网络
docker run -d --name web --network my-network nginx
docker run -d --name app --network my-network my-app
# 使用容器名称通信
# 在app容器中，可以使用http://web访问nginx服务

复制代码

6. 安全问题

问题：容器安全配置不当，可能导致安全风险。

解决方案：

• 使用非root用户运行容器
• 限制容器能力
• 使用安全扫描工具扫描镜像
• 定期更新基础镜像和依赖
• 使用内容信任（Docker Content Trust）

示例：

# 使用非root用户
FROM node:14
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN groupadd -r appuser && useradd -r -g appuser appuser
USER appuser
CMD ["node", "app.js"]
# 限制容器能力
docker run --cap-drop ALL --cap-add CHOWN my-app

复制代码

Docker在DevOps工作流程中的最佳实践

1. 持续集成/持续部署（CI/CD）

将Docker集成到CI/CD流程中，实现自动化构建、测试和部署。

pipeline {
agent any
stages {
stage('Build') {
steps {
script {
docker.build('my-app:${BUILD_ID}')
}
}
}
stage('Test') {
steps {
script {
docker.image('my-app:${BUILD_ID}').inside {
sh 'npm test'
}
}
}
}
stage('Deploy') {
steps {
script {
docker.withRegistry('https://registry.example.com', 'registry-credentials') {
docker.image('my-app:${BUILD_ID}').push()
}
}
}
}
}
}

复制代码

stages:
- build
- test
- deploy
build_image:
stage: build
script:
- docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
- docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
test_image:
stage: test
script:
- docker pull $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
- docker run --rm $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA npm test
deploy_image:
stage: deploy
script:
- docker pull $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
- docker tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA $CI_REGISTRY_IMAGE:latest
- docker push $CI_REGISTRY_IMAGE:latest
only:
- main

复制代码

2. 环境一致性

使用Docker确保开发、测试和生产环境的一致性。

version: '3'
services:
app:
build: .
ports:
- "3000:3000"
environment:
- NODE_ENV=development
volumes:
- .:/app
- /app/node_modules
db:
image: postgres:13
environment:
POSTGRES_PASSWORD: example
volumes:
- postgres-data:/var/lib/postgresql/data
volumes:
postgres-data:

复制代码

3. 微服务架构

使用Docker容器化微服务，便于部署、扩展和管理。

version: '3'
services:
api-gateway:
build: ./api-gateway
ports:
- "80:80"
depends_on:
- user-service
- product-service
user-service:
build: ./user-service
environment:
- DB_HOST=user-db
depends_on:
- user-db
product-service:
build: ./product-service
environment:
- DB_HOST=product-db
depends_on:
- product-db
user-db:
image: postgres:13
environment:
POSTGRES_PASSWORD: user_password
volumes:
- user-db-data:/var/lib/postgresql/data
product-db:
image: postgres:13
environment:
POSTGRES_PASSWORD: product_password
volumes:
- product-db-data:/var/lib/postgresql/data
volumes:
user-db-data:
product-db-data:

复制代码

4. 日志管理

集中管理容器日志，便于监控和故障排除。

version: '3'
services:
app:
build: .
logging:
driver: "gelf"
options:
gelf-address: "udp://localhost:12201"
tag: "my-app"
elasticsearch:
image: docker.elastic.co/elasticsearch/elasticsearch:7.10.1
environment:
- discovery.type=single-node
volumes:
- es-data:/usr/share/elasticsearch/data
logstash:
image: docker.elastic.co/logstash/logstash:7.10.1
ports:
- "12201:12201/udp"
volumes:
- ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf
depends_on:
- elasticsearch
kibana:
image: docker.elastic.co/kibana/kibana:7.10.1
ports:
- "5601:5601"
depends_on:
- elasticsearch
volumes:
es-data:

复制代码

5. 监控和告警

监控容器性能和健康状态，设置告警机制。

version: '3'
services:
app:
build: .
labels:
- "prometheus.io/scrape=true"
- "prometheus.io/port=8080"
prometheus:
image: prom/prometheus
ports:
- "9090:9090"
volumes:
- ./prometheus.yml:/etc/prometheus/prometheus.yml
command:
- '--config.file=/etc/prometheus/prometheus.yml'
grafana:
image: grafana/grafana
ports:
- "3000:3000"
environment:
- GF_SECURITY_ADMIN_PASSWORD=admin
volumes:
- grafana-storage:/var/lib/grafana
alertmanager:
image: prom/alertmanager
ports:
- "9093:9093"
volumes:
- ./alertmanager.yml:/etc/alertmanager/alertmanager.yml
volumes:
grafana-storage:

复制代码

实战案例：完整的项目容器化部署流程

让我们通过一个完整的示例，展示如何将一个Web应用容器化并部署到生产环境。

项目结构

my-web-app/
├── src/
│ ├── app.py
│ ├── requirements.txt
│ └── config.py
├── tests/
│ └── test_app.py
├── docker/
│ ├── Dockerfile
│ ├── docker-compose.yml
│ └── docker-compose.prod.yml
├── .dockerignore
├── .gitlab-ci.yml
└── README.md

复制代码

应用代码

src/app.py

from flask import Flask, jsonify
import os
from config import Config
app = Flask(__name__)
app.config.from_object(Config)
@app.route('/')
def index():
return jsonify({
'message': 'Welcome to My Web App',
'environment': app.config['ENV']
})
@app.route('/health')
def health():
return jsonify({'status': 'healthy'})
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)

复制代码

src/config.py

import os
class Config:
SECRET_KEY = os.environ.get('SECRET_KEY') or 'dev-secret-key'
ENV = os.environ.get('FLASK_ENV') or 'development'

复制代码

src/requirements.txt

Flask==2.0.1
gunicorn==20.1.0

复制代码

tests/test_app.py

import pytest
import sys
import os
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../src')))
from app import app
@pytest.fixture
def client():
app.config['TESTING'] = True
with app.test_client() as client:
yield client
def test_index(client):
rv = client.get('/')
assert rv.status_code == 200
assert b'Welcome to My Web App' in rv.data
def test_health(client):
rv = client.get('/health')
assert rv.status_code == 200
assert b'healthy' in rv.data

复制代码

Docker配置

.dockerignore

.git
.gitignore
tests/
README.md

复制代码

docker/Dockerfile

# 多阶段构建
# 第一阶段：构建
FROM python:3.9-slim as builder
WORKDIR /app
# 安装依赖
COPY src/requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# 第二阶段：运行
FROM python:3.9-slim
WORKDIR /app
# 从第一阶段复制安装的依赖
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
# 复制应用代码
COPY src/ .
# 创建非root用户
RUN useradd --create-home --shell /bin/bash app && \
chown -R app:app /app
USER app
# 暴露端口
EXPOSE 5000
# 健康检查
HEALTHCHECK --interval=30s --timeout=3s \
CMD curl -f http://localhost:5000/health || exit 1
# 启动命令
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "--workers", "4", "app:app"]

复制代码

docker/docker-compose.yml

version: '3.8'
services:
web:
build:
context: ..
dockerfile: docker/Dockerfile
ports:
- "5000:5000"
environment:
- FLASK_ENV=development
volumes:
- ../src:/app
depends_on:
- redis
redis:
image: redis:6-alpine
ports:
- "6379:6379"
tests:
build:
context: ..
dockerfile: docker/Dockerfile.test
volumes:
- ../tests:/app/tests
depends_on:
- web

复制代码

docker/docker-compose.prod.yml

version: '3.8'
services:
web:
image: registry.example.com/my-web-app:${VERSION:-latest}
ports:
- "80:5000"
environment:
- FLASK_ENV=production
- SECRET_KEY=${SECRET_KEY}
restart: unless-stopped
depends_on:
- redis
logging:
driver: "json-file"
options:
max-size: "10m"
max-file: "3"
redis:
image: redis:6-alpine
restart: unless-stopped
volumes:
- redis-data:/data
nginx:
image: nginx:1.20-alpine
ports:
- "443:443"
volumes:
- ./nginx.conf:/etc/nginx/nginx.conf
- ./ssl:/etc/nginx/ssl
depends_on:
- web
restart: unless-stopped
volumes:
redis-data:

复制代码

CI/CD配置

.gitlab-ci.yml

stages:
- test
- build
- deploy
variables:
DOCKER_REGISTRY: registry.example.com
DOCKER_IMAGE: $DOCKER_REGISTRY/my-web-app
test:
stage: test
image: python:3.9
script:
- pip install -r src/requirements.txt
- pip install pytest
- pytest tests/
build:
stage: build
image: docker:20.10
services:
- docker:20.10-dind
script:
- docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
- docker build -f docker/Dockerfile -t $DOCKER_IMAGE:$CI_COMMIT_SHA .
- docker push $DOCKER_IMAGE:$CI_COMMIT_SHA
- docker tag $DOCKER_IMAGE:$CI_COMMIT_SHA $DOCKER_IMAGE:latest
- docker push $DOCKER_IMAGE:latest
only:
- main
- develop
deploy_staging:
stage: deploy
script:
- ssh deploy@staging.example.com "cd /opt/my-web-app && VERSION=$CI_COMMIT_SHA docker-compose -f docker-compose.prod.yml pull && VERSION=$CI_COMMIT_SHA docker-compose -f docker-compose.prod.yml up -d"
environment:
name: staging
url: https://staging.example.com
only:
- develop
deploy_production:
stage: deploy
script:
- ssh deploy@production.example.com "cd /opt/my-web-app && VERSION=$CI_COMMIT_SHA docker-compose -f docker-compose.prod.yml pull && VERSION=$CI_COMMIT_SHA docker-compose -f docker-compose.prod.yml up -d"
environment:
name: production
url: https://example.com
when: manual
only:
- main

复制代码

部署脚本

deploy.sh

#!/bin/bash
# 设置变量
REGISTRY="registry.example.com"
IMAGE_NAME="my-web-app"
VERSION=${1:-latest}
ENVIRONMENT=${2:-staging}
# 根据环境设置服务器
if [ "$ENVIRONMENT" = "production" ]; then
SERVER="deploy@production.example.com"
else
SERVER="deploy@staging.example.com"
fi
# 构建镜像
echo "Building Docker image..."
docker build -f docker/Dockerfile -t $REGISTRY/$IMAGE_NAME:$VERSION .
# 推送镜像
echo "Pushing Docker image..."
docker push $REGISTRY/$IMAGE_NAME:$VERSION
# 部署到服务器
echo "Deploying to $ENVIRONMENT..."
ssh $SERVER "cd /opt/my-web-app && VERSION=$VERSION docker-compose -f docker-compose.prod.yml pull && VERSION=$VERSION docker-compose -f docker-compose.prod.yml up -d"
echo "Deployment completed!"

复制代码

监控配置

monitoring/prometheus.yml

global:
scrape_interval: 15s
scrape_configs:
- job_name: 'my-web-app'
static_configs:
- targets: ['web:5000']
metrics_path: '/metrics'
scrape_interval: 5s
- job_name: 'redis'
static_configs:
- targets: ['redis:6379']
- job_name: 'node-exporter'
static_configs:
- targets: ['node-exporter:9100']

复制代码

monitoring/grafana/dashboards/dashboard.json

{
"dashboard": {
"title": "My Web App Metrics",
"panels": [
{
"title": "HTTP Requests",
"type": "graph",
"targets": [
{
"expr": "rate(http_requests_total[5m])",
"legendFormat": "{{method}} {{status}}"
}
]
},
{
"title": "Response Time",
"type": "graph",
"targets": [
{
"expr": "histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))",
"legendFormat": "95th percentile"
}
]
},
{
"title": "System Resources",
"type": "graph",
"targets": [
{
"expr": "100 - (avg by (instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)",
"legendFormat": "CPU Usage"
},
{
"expr": "(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100",
"legendFormat": "Memory Usage"
}
]
}
]
}
}

复制代码

完整的部署流程

1. 开发阶段：开发人员使用docker-compose在本地运行应用运行测试确保代码质量提交代码到Git仓库
2. 开发人员使用docker-compose在本地运行应用
3. 运行测试确保代码质量
4. 提交代码到Git仓库
5. CI阶段：GitLab CI自动触发测试测试通过后构建Docker镜像将镜像推送到镜像仓库
6. GitLab CI自动触发测试
7. 测试通过后构建Docker镜像
8. 将镜像推送到镜像仓库
9. 部署到测试环境：自动部署到测试环境进行集成测试和用户验收测试
10. 自动部署到测试环境
11. 进行集成测试和用户验收测试
12. 部署到生产环境：手动触发生产环境部署使用蓝绿部署或滚动更新策略监控应用性能和健康状态
13. 手动触发生产环境部署
14. 使用蓝绿部署或滚动更新策略
15. 监控应用性能和健康状态
16. 监控和维护：使用Prometheus和Grafana监控应用设置告警规则定期更新镜像和依赖
17. 使用Prometheus和Grafana监控应用
18. 设置告警规则
19. 定期更新镜像和依赖

开发阶段：

• 开发人员使用docker-compose在本地运行应用
• 运行测试确保代码质量
• 提交代码到Git仓库

CI阶段：

• GitLab CI自动触发测试
• 测试通过后构建Docker镜像
• 将镜像推送到镜像仓库

部署到测试环境：

• 自动部署到测试环境
• 进行集成测试和用户验收测试

部署到生产环境：

• 手动触发生产环境部署
• 使用蓝绿部署或滚动更新策略
• 监控应用性能和健康状态

监控和维护：

• 使用Prometheus和Grafana监控应用
• 设置告警规则
• 定期更新镜像和依赖

总结与展望

通过本文的学习，我们从Docker的基础概念开始，逐步深入到镜像构建的高级技巧、仓库管理、常见问题解决以及DevOps最佳实践。Docker作为容器化技术的代表，已经深刻改变了软件开发和部署的方式，使DevOps工作流程更加顺畅高效。

关键要点回顾

1. Docker基础：理解镜像、容器、仓库等基本概念是掌握Docker的第一步。
2. 镜像构建：通过Dockerfile可以定义镜像的构建过程，使用多阶段构建和优化技巧可以创建更小、更安全的镜像。
3. 仓库管理：无论是使用公共仓库如Docker Hub，还是私有仓库如Harbor，都需要掌握镜像的推送和拉取操作。
4. 问题解决：容器化部署中常见的问题如镜像过大、构建速度慢、容器启动失败等，都有相应的解决方案。
5. DevOps集成：将Docker集成到CI/CD流程中，可以实现自动化构建、测试和部署，提高开发效率。
6. 实战应用：通过完整的示例，我们了解了如何将一个Web应用容器化并部署到生产环境。

Docker基础：理解镜像、容器、仓库等基本概念是掌握Docker的第一步。

镜像构建：通过Dockerfile可以定义镜像的构建过程，使用多阶段构建和优化技巧可以创建更小、更安全的镜像。

仓库管理：无论是使用公共仓库如Docker Hub，还是私有仓库如Harbor，都需要掌握镜像的推送和拉取操作。

问题解决：容器化部署中常见的问题如镜像过大、构建速度慢、容器启动失败等，都有相应的解决方案。

DevOps集成：将Docker集成到CI/CD流程中，可以实现自动化构建、测试和部署，提高开发效率。

实战应用：通过完整的示例，我们了解了如何将一个Web应用容器化并部署到生产环境。

未来展望

随着云原生技术的发展，Docker和容器技术也在不断演进：

1. Kubernetes：作为容器编排的事实标准，Kubernetes与Docker的结合将更加紧密，提供更强大的容器管理能力。
2. Serverless：无服务器架构与容器技术的结合，如Knative，将提供更灵活的应用部署方式。
3. 安全增强：容器安全将得到更多关注，包括镜像扫描、运行时安全、网络隔离等方面。
4. 边缘计算：Docker在边缘计算场景中的应用将更加广泛，支持更轻量级的容器运行时。
5. WebAssembly：WASM与容器的结合可能带来新的应用打包和运行方式。

Kubernetes：作为容器编排的事实标准，Kubernetes与Docker的结合将更加紧密，提供更强大的容器管理能力。

Serverless：无服务器架构与容器技术的结合，如Knative，将提供更灵活的应用部署方式。

安全增强：容器安全将得到更多关注，包括镜像扫描、运行时安全、网络隔离等方面。

边缘计算：Docker在边缘计算场景中的应用将更加广泛，支持更轻量级的容器运行时。

WebAssembly：WASM与容器的结合可能带来新的应用打包和运行方式。

作为DevOps工程师或开发者，掌握Docker及其生态系统将成为必备技能。通过不断学习和实践，我们可以更好地利用容器技术，构建更加高效、可靠的应用部署流程。

希望本文能够帮助你从入门到精通Docker镜像构建，并在实际工作中解决容器化部署中的常见问题，让你的DevOps工作流程更加顺畅高效。如果你有任何问题或建议，欢迎交流讨论。

手把手

「七転び八起き（ななころびやおき）」

使用道具举报