🖥️ 后端技术 - DOCKER

What is Docker? What problems does it solve?

考察点：Docker基础概念。

答案：

Docker是一个开源的容器化平台，基于Linux容器技术，用于自动化应用程序的部署。它通过将应用程序及其依赖环境打包到轻量级、可移植的容器中，解决了"在我机器上能运行"的经典开发问题。

核心特点：

1. 容器化技术：将应用和环境打包成独立容器，实现环境隔离
2. 环境一致性：开发、测试、生产环境完全一致，消除环境差异
3. 轻量级：比虚拟机更少的资源消耗，启动速度快
4. 可移植性：容器可在任何支持Docker的平台运行

解决的主要问题：

• 环境不一致导致的"我的电脑上可以运行"问题
• 应用依赖冲突和版本管理复杂性
• 资源利用率低和部署流程复杂
• 微服务架构的管理和扩展困难

实际应用：

• 微服务部署和管理
• CI/CD流水线自动化
• 开发环境标准化
• 云原生应用开发

What are images, containers, and repositories in Docker?

考察点：核心概念理解。

答案：

Docker的三个核心概念构成了容器化技术的基础架构。镜像是静态的模板，容器是运行时实例，仓库是存储和分发的中心。

核心组件：

1. 镜像（Image）：只读的文件系统模板，包含运行应用所需的代码、运行时、库、环境变量和配置文件
2. 容器（Container）：镜像的运行实例，可以创建、启动、停止、删除和暂停
3. 仓库（Repository）：用于保存镜像的场所，分为公共仓库和私有仓库

关系说明：

• 镜像是容器的基础，容器是镜像的运行时表现
• 一个镜像可以创建多个容器实例
• 仓库用于镜像的版本管理和分发
• Docker Hub是最大的公共仓库

实际应用：

• 使用官方镜像快速部署应用
• 构建自定义镜像满足特定需求
• 通过私有仓库管理企业内部镜像
• 实现镜像的版本控制和回滚

How to build a Docker image? What is the basic syntax of Dockerfile?

考察点：镜像构建基础。

答案：

Docker镜像通过Dockerfile构建，Dockerfile是一个包含构建指令的文本文件。每条指令创建一个新的镜像层，Docker按顺序执行这些指令来构建最终镜像。

基本语法指令：

1. FROM：指定基础镜像，必须是第一条指令
2. RUN：在镜像中执行命令并创建新层
3. COPY/ADD：复制文件或目录到镜像中
4. WORKDIR：设置工作目录
5. EXPOSE：声明容器监听的端口
6. CMD：容器启动时执行的默认命令

代码示例：

# 基础镜像
FROM node:16-alpine

# 设置工作目录
WORKDIR /app

# 复制package.json
COPY package*.json ./

# 安装依赖
RUN npm install

# 复制源代码
COPY . .

# 暴露端口
EXPOSE 3000

# 启动命令
CMD ["npm", "start"]

构建命令：

# 构建镜像
docker build -t myapp:latest .

# 查看镜像
docker images

实际应用：

• 创建自定义的应用镜像
• 配置特定的运行环境
• 实现可重复的构建过程
• 版本化应用程序部署

What are the differences between Docker containers and virtual machines?

考察点：技术架构对比。

答案：

Docker容器和虚拟机都是虚拟化技术，但它们在架构、性能和资源利用方面存在显著差异。容器基于操作系统级虚拟化，而虚拟机基于硬件级虚拟化。

主要区别：

1. 架构层次：容器共享宿主机内核，虚拟机拥有独立的操作系统
2. 资源消耗：容器资源占用少，虚拟机需要完整的系统资源
3. 启动速度：容器秒级启动，虚拟机分钟级启动
4. 隔离级别：容器进程级隔离，虚拟机硬件级隔离

性能对比：

使用场景：

• 容器适用：微服务部署、CI/CD、开发环境统一
• 虚拟机适用：多租户隔离、不同操作系统、安全要求高的场景

实际应用：

• 容器用于应用程序打包和部署
• 虚拟机用于基础设施隔离
• 混合架构在企业中广泛应用
• 云服务通常提供两种选择

How to run and manage Docker containers?

考察点：容器操作基础。

答案：

Docker容器管理涉及容器的创建、启动、停止、删除等生命周期操作。掌握这些基本操作是使用Docker的前提，也是日常运维工作的核心技能。

基本操作命令：

1. 运行容器：docker run 创建并启动新容器
2. 查看容器：docker ps 查看运行中的容器状态
3. 停止容器：docker stop 优雅停止容器
4. 删除容器：docker rm 删除已停止的容器

常用管理命令：

# 运行容器（后台模式）
docker run -d --name myapp -p 8080:80 nginx

# 查看运行中的容器
docker ps

# 查看所有容器（包括停止的）
docker ps -a

# 进入容器
docker exec -it myapp /bin/bash

# 查看容器日志
docker logs myapp

# 停止容器
docker stop myapp

# 重启容器
docker restart myapp

# 删除容器
docker rm myapp

资源限制参数：

• --memory：限制内存使用
• --cpus：限制CPU使用
• --restart：设置重启策略

实际应用：

• 生产环境容器部署和监控
• 开发环境快速搭建和测试
• 容器资源管理和性能调优
• 故障排查和日志分析

What are volumes in Docker? How to use them?

考察点：数据持久化。

答案：

Docker数据卷是一种用于持久化和共享数据的机制，它独立于容器的生命周期存在。数据卷解决了容器数据丢失和容器间数据共享的问题，是生产环境中必不可少的功能。

主要类型：

1. 匿名卷（Anonymous Volume）：Docker自动创建和管理的卷
2. 具名卷（Named Volume）：用户指定名称的卷，便于管理
3. 绑定挂载（Bind Mount）：将宿主机目录挂载到容器中
4. 临时文件系统（tmpfs）：基于内存的临时存储

使用方式：

# 创建具名卷
docker volume create myvolume

# 使用具名卷运行容器
docker run -d -v myvolume:/data --name myapp nginx

# 绑定挂载宿主机目录
docker run -d -v /host/data:/container/data nginx

# 查看所有数据卷
docker volume ls

# 查看数据卷详情
docker volume inspect myvolume

# 删除数据卷
docker volume rm myvolume

实际应用：

• 数据库数据持久化存储
• 配置文件和日志文件管理
• 容器间数据共享和交换
• 开发环境代码热更新

How to configure networking in Docker?

考察点：网络配置基础。

答案：

Docker网络功能允许容器之间以及容器与外部网络进行通信。Docker提供了多种网络驱动程序，可以根据不同的使用场景选择合适的网络模式。

网络驱动类型：

1. bridge：默认网络驱动，适用于单机容器通信
2. host：容器直接使用宿主机网络
3. overlay：用于跨多个Docker主机的容器通信
4. none：禁用容器的网络功能

基本网络操作：

# 查看网络列表
docker network ls

# 创建自定义网络
docker network create --driver bridge mynetwork

# 运行容器并指定网络
docker run -d --network mynetwork --name app1 nginx

# 将运行中的容器连接到网络
docker network connect mynetwork app2

# 断开容器网络连接
docker network disconnect mynetwork app2

# 查看网络详细信息
docker network inspect mynetwork

端口映射配置：

# 映射单个端口
docker run -p 8080:80 nginx

# 映射多个端口
docker run -p 8080:80 -p 8443:443 nginx

# 映射到指定IP
docker run -p 127.0.0.1:8080:80 nginx

实际应用：

• 微服务间的安全通信
• 负载均衡和服务发现
• 开发环境网络隔离
• 多环境部署网络配置

What is Docker Compose? What is its purpose?

考察点：多容器编排。

答案：

Docker Compose是一个用于定义和运行多容器Docker应用程序的工具。它使用YAML文件来配置应用程序的服务，然后通过一个命令就可以启动所有相关的容器。

主要功能：

1. 多容器编排：同时管理多个相关容器的生命周期
2. 服务定义：通过YAML文件声明式定义服务配置
3. 依赖管理：自动处理容器间的依赖关系和启动顺序
4. 网络管理：自动创建隔离的网络环境

代码示例：

# docker-compose.yml
version: '3.8'

services:
  web:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - db
    environment:
      - NODE_ENV=production
  
  db:
    image: postgres:13
    environment:
      - POSTGRES_DB=myapp
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

常用命令：

# 启动所有服务
docker-compose up -d

# 停止所有服务
docker-compose down

# 查看服务状态
docker-compose ps

# 查看服务日志
docker-compose logs

实际应用：

• 开发环境一键搭建和部署
• 微服务应用的本地测试
• 多服务应用的集成部署
• CI/CD流水线中的自动化测试

How to containerize and deploy a Node.js application?

考察点：实际应用部署。

答案：

Node.js应用容器化是Web应用部署的常见场景，需要考虑依赖安装、环境配置、性能优化等多个方面。通过合理的Dockerfile设计可以实现高效、可靠的容器化部署。

部署步骤：

1. 创建Dockerfile：定义Node.js运行环境和应用配置
2. 优化镜像大小：使用Alpine版本和多阶段构建
3. 处理依赖：合理利用Docker缓存机制
4. 配置环境：设置生产环境变量和安全选项

代码示例：

# 多阶段构建优化
FROM node:16-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:16-alpine AS production

# 创建非root用户
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001

WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY . .

# 设置权限
RUN chown -R nextjs:nodejs /app
USER nextjs

EXPOSE 3000

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1

CMD ["node", "server.js"]

部署命令：

# 构建镜像
docker build -t mynode-app:latest .

# 运行容器
docker run -d \
  --name mynode-app \
  -p 3000:3000 \
  -e NODE_ENV=production \
  --restart unless-stopped \
  mynode-app:latest

实际应用：

• Express/Koa Web应用部署
• Next.js/Nuxt.js全栈应用容器化
• Node.js微服务架构部署
• CI/CD集成自动化部署

What are the basic Docker commands?

考察点：命令行操作。

答案：

Docker CLI提供了丰富的命令来管理镜像、容器、网络、数据卷等资源。熟练掌握这些基本命令是高效使用Docker的基础，也是日常开发运维工作的必备技能。

镜像相关命令：

1. docker images：列出本地镜像
2. docker build：从Dockerfile构建镜像
3. docker pull：从仓库拉取镜像
4. docker push：推送镜像到仓库

容器相关命令：

1. docker run：创建并运行容器
2. docker ps：查看容器状态
3. docker stop/start：停止/启动容器
4. docker exec：在运行的容器中执行命令

常用命令示例：

# 镜像操作
docker images                    # 查看镜像列表
docker build -t myapp .         # 构建镜像
docker pull nginx:latest        # 拉取镜像
docker rmi nginx:latest         # 删除镜像

# 容器操作
docker run -d -p 80:80 nginx    # 后台运行容器
docker ps -a                    # 查看所有容器
docker stop container_id        # 停止容器
docker exec -it container_id bash # 进入容器

# 系统管理
docker system df                # 查看空间使用情况
docker system prune            # 清理未使用的资源
docker logs container_id       # 查看容器日志
docker inspect container_id   # 查看容器详细信息

资源管理命令：

• docker volume：管理数据卷
• docker network：管理网络
• docker system：系统级操作

实际应用：

• 日常开发环境管理和调试
• 生产环境部署和监控
• CI/CD流水线脚本编写
• 容器化应用故障排查

How does Docker’s layered file system work?

考察点：存储机制理解。

答案：

Docker使用联合文件系统（Union File System）实现分层存储架构，每个镜像由多个只读层组成，容器在最上层添加可写层。这种设计实现了高效的存储共享和快速的容器启动。

工作原理：

1. 镜像层（Image Layers）：只读层，包含文件系统快照
2. 容器层（Container Layer）：可写层，记录容器运行时的变化
3. 写时复制（Copy-on-Write）：修改文件时从底层复制到容器层
4. 层缓存机制：相同的层可以被多个镜像共享

存储驱动类型：

• overlay2：推荐的存储驱动，性能最好
• devicemapper：适用于CentOS/RHEL系统
• aufs：较老的Ubuntu系统默认驱动
• btrfs/zfs：支持高级存储特性

层管理机制：

# 查看镜像层信息
docker history nginx:latest

# 查看镜像详细结构
docker inspect nginx:latest

# 查看存储驱动信息
docker info | grep "Storage Driver"

优势特点：

• 多个容器共享相同的镜像层，节省存储空间
• 镜像构建过程中可以复用已有层，加快构建速度
• 容器启动快速，只需添加轻量级的容器层
• 支持镜像的增量更新和版本控制

实际应用：

• 理解Dockerfile优化策略
• 设计高效的镜像构建流程
• 解决存储空间和性能问题
• 实现镜像的版本管理

How to optimize Docker image size? What are the best practices?

考察点：镜像优化策略。

答案：

Docker镜像大小直接影响部署速度、存储成本和网络传输效率。通过合理的优化策略可以显著减小镜像体积，提高应用部署和运行效率。

主要优化策略：

1. 选择精简基础镜像：使用Alpine、Distroless等轻量级镜像
2. 多阶段构建：分离构建环境和运行环境
3. 合并RUN指令：减少镜像层数量
4. 清理临时文件：及时删除缓存和临时文件

代码示例：

# 优化前 - 多层构建
FROM node:16
WORKDIR /app
COPY package*.json ./
RUN npm install
RUN npm cache clean --force
COPY . .
RUN npm run build

# 优化后 - 合并指令 + 多阶段
FROM node:16-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production && npm cache clean --force
COPY . .
RUN npm run build

FROM node:16-alpine AS production
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 3000
CMD ["node", "dist/server.js"]

最佳实践：

• 使用.dockerignore排除不必要的文件
• 将频繁变化的指令放在最后
• 使用--no-install-recommends减少包安装
• 及时清理包管理器缓存

实际应用：

• 生产环境镜像大小控制
• CI/CD流水线构建优化
• 容器注册表存储成本降低
• 网络带宽和部署时间优化

What is multi-stage build in Docker? How to use it?

考察点：高级构建技术。

答案：

Docker多阶段构建允许在单个Dockerfile中使用多个FROM指令，创建多个构建阶段。这种技术可以分离构建环境和运行环境，显著减小最终镜像大小，同时保持构建过程的简洁性。

核心概念：

1. 构建阶段分离：将编译/构建过程与运行环境分离
2. 选择性复制：只将需要的文件从构建阶段复制到运行阶段
3. 镜像优化：去除构建工具和中间文件，减小镜像体积
4. 安全增强：运行镜像不包含源代码和构建工具

实现方式：

# 第一阶段：构建阶段
FROM golang:1.19-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o main .

# 第二阶段：运行阶段
FROM alpine:latest AS production
RUN apk --no-cache add ca-certificates
WORKDIR /root/
# 只复制编译好的二进制文件
COPY --from=builder /app/main .
EXPOSE 8080
CMD ["./main"]

高级用法：

# 前端项目多阶段构建
FROM node:16-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM nginx:alpine AS production
COPY --from=build /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/nginx.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

实际应用：

• 编译型语言应用（Go、Rust、C++）的容器化
• 前端项目的构建和部署分离
• 减少生产镜像的攻击面和体积
• 实现更安全和高效的CI/CD流程

How to implement health checks for Docker containers?

考察点：容器监控机制。

答案：

Docker健康检查是一种监控机制，用于定期检测容器内应用程序的运行状态。通过健康检查可以及时发现应用故障，实现自动重启和负载均衡的智能调度。

实现方式：

1. Dockerfile中定义：使用HEALTHCHECK指令
2. 运行时指定：通过docker run参数设置
3. Compose配置：在docker-compose.yml中定义
4. Kubernetes探针：结合容器编排平台使用

Dockerfile健康检查：

FROM nginx:alpine

# 基本健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost/ || exit 1

# 自定义健康检查脚本
COPY health-check.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/health-check.sh
HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
  CMD /usr/local/bin/health-check.sh

运行时健康检查：

# 启动时指定健康检查
docker run -d \
  --name web-server \
  --health-cmd="curl -f http://localhost:8080/health || exit 1" \
  --health-interval=30s \
  --health-timeout=3s \
  --health-retries=3 \
  --health-start-period=40s \
  myapp:latest

# 查看容器健康状态
docker ps
docker inspect --format='{{.State.Health}}' web-server

健康检查脚本示例：

#!/bin/sh
# health-check.sh

# 检查应用端口
if ! nc -z localhost 8080; then
  echo "Port 8080 is not accessible"
  exit 1
fi

# 检查API端点
if ! curl -f -s http://localhost:8080/health > /dev/null; then
  echo "Health endpoint failed"
  exit 1
fi

echo "Health check passed"
exit 0

实际应用：

• 容器编排系统的自动故障恢复
• 负载均衡器的后端健康状态检查
• 监控系统的容器状态告警
• CI/CD流程中的部署验证

What are Docker’s security mechanisms? How to enhance container security?

考察点：安全防护策略。

答案：

Docker容器安全涉及多个层面的防护措施，从镜像构建到运行时环境都需要考虑安全因素。通过实施多层防护策略，可以显著降低容器化应用的安全风险。

内置安全机制：

1. 命名空间隔离：进程、网络、文件系统等资源隔离
2. 控制组限制：CPU、内存等资源使用限制
3. 能力限制：限制容器的系统调用权限
4. 安全计算模式：Seccomp过滤系统调用

镜像安全实践：

# 使用官方基础镜像
FROM node:16-alpine

# 创建非root用户
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001

# 安装安全更新
RUN apk update && apk upgrade && apk add --no-cache \
    dumb-init \
    && rm -rf /var/cache/apk/*

WORKDIR /app
COPY --chown=nextjs:nodejs package*.json ./
USER nextjs

# 使用dumb-init处理信号
ENTRYPOINT ["dumb-init", "--"]
CMD ["node", "server.js"]

运行时安全配置：

# 安全运行容器
docker run -d \
  --name secure-app \
  --user 1001:1001 \
  --read-only \
  --tmpfs /tmp \
  --cap-drop ALL \
  --cap-add NET_BIND_SERVICE \
  --security-opt no-new-privileges \
  --security-opt seccomp=security-profile.json \
  --memory=512m \
  --cpus=0.5 \
  myapp:latest

安全最佳实践：

• 定期扫描镜像漏洞
• 使用多阶段构建减少攻击面
• 实施最小权限原则
• 配置网络隔离和访问控制
• 启用日志审计和监控

实际应用：

• 生产环境容器安全加固
• 合规性要求的安全配置
• 多租户环境的隔离策略
• 安全事件的检测和响应

How to use Docker for CI/CD pipelines?

考察点：工程化应用。

答案：

Docker在CI/CD流水线中提供了标准化的构建、测试和部署环境，实现了"一次构建，到处运行"的目标。通过容器化技术可以消除环境差异，提高部署效率和可靠性。

CI/CD集成策略：

1. 构建阶段：使用Docker构建应用镜像
2. 测试阶段：在容器中运行自动化测试
3. 部署阶段：将镜像推送到注册表并部署
4. 监控阶段：容器化的监控和日志收集

GitLab CI配置示例：

# .gitlab-ci.yml
stages:
  - build
  - test
  - deploy

variables:
  DOCKER_IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
  DOCKER_LATEST: $CI_REGISTRY_IMAGE:latest

build:
  stage: build
  script:
    - docker build -t $DOCKER_IMAGE .
    - docker tag $DOCKER_IMAGE $DOCKER_LATEST
    - docker push $DOCKER_IMAGE
    - docker push $DOCKER_LATEST

test:
  stage: test
  script:
    - docker run --rm $DOCKER_IMAGE npm test
    - docker run --rm $DOCKER_IMAGE npm run lint

deploy:
  stage: deploy
  script:
    - docker pull $DOCKER_IMAGE
    - docker-compose down
    - docker-compose up -d
  only:
    - main

GitHub Actions配置：

# .github/workflows/ci-cd.yml
name: CI/CD Pipeline

on:
  push:
    branches: [main]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Build Docker image
        run: |
          docker build -t myapp:${{ github.sha }} .
          
      - name: Run tests
        run: |
          docker run --rm myapp:${{ github.sha }} npm test
          
      - name: Push to registry
        run: |
          echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
          docker push myapp:${{ github.sha }}

部署策略：

• 蓝绿部署：使用不同的容器组实现零停机部署
• 滚动更新：逐步替换老版本容器
• 金丝雀发布：小流量验证新版本稳定性

实际应用：

• 微服务应用的自动化部署
• 多环境一致性保证
• 快速回滚和版本管理
• 云原生应用的持续交付

What is Docker Swarm? How to perform cluster management?

考察点：集群编排。

答案：

Docker Swarm是Docker原生的容器编排和集群管理工具，提供了高可用、可扩展的容器集群解决方案。它将多个Docker主机组成一个虚拟的Docker主机，实现容器的自动调度和管理。

核心概念：

1. 节点（Node）：集群中的Docker主机，分为Manager节点和Worker节点
2. 服务（Service）：在集群中运行的容器应用的抽象定义
3. 任务（Task）：服务在节点上的具体实例
4. 网络（Network）：跨节点的容器通信网络

集群初始化：

# 初始化Swarm集群（Manager节点）
docker swarm init --advertise-addr 192.168.1.100

# 加入Worker节点
docker swarm join --token SWMTKN-1-xxx 192.168.1.100:2377

# 查看集群节点
docker node ls

# 创建服务
docker service create --name web --replicas 3 -p 8080:80 nginx

# 扩展服务
docker service scale web=5

# 更新服务
docker service update --image nginx:alpine web

服务管理命令：

# 查看服务列表
docker service ls

# 查看服务详情
docker service inspect web

# 查看服务任务
docker service ps web

# 删除服务
docker service rm web

高可用配置：

• 部署多个Manager节点（建议奇数个）
• 配置节点标签和约束条件
• 实现服务的滚动更新策略
• 设置健康检查和故障转移

实际应用：

• 中小规模容器集群管理
• 微服务应用的编排部署
• 负载均衡和服务发现
• 集群资源调度和自动扩展

How to monitor Docker container performance and resource usage?

考察点：性能监控。

答案：

Docker容器监控是确保应用正常运行和性能优化的重要手段。通过多层次的监控策略可以及时发现性能瓶颈，实现主动的运维管理和资源优化。

监控维度：

1. 资源使用：CPU、内存、磁盘I/O、网络流量
2. 容器状态：运行状态、健康检查、重启次数
3. 应用指标：响应时间、错误率、吞吐量
4. 日志分析：错误日志、访问日志、性能日志

内置监控工具：

# 实时查看容器资源使用
docker stats

# 查看特定容器统计
docker stats container_name

# 查看容器进程
docker top container_name

# 查看容器事件
docker events --filter container=container_name

# 导出资源使用数据
docker stats --no-stream --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}"

Prometheus + Grafana监控：

# docker-compose.yml
version: '3.8'

services:
  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro

  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

实际应用：

• 生产环境容器集群监控
• 性能瓶颈识别和优化
• 资源使用趋势分析
• 自动告警和故障响应

What are the network modes in Docker? What are their characteristics?

考察点：网络架构理解。

答案：

Docker提供了多种网络模式来满足不同的应用场景需求。每种网络模式都有其特定的用途和限制，理解这些模式有助于设计合适的容器网络架构。

主要网络模式：

1. bridge（默认）：容器连接到虚拟网桥，适用于单机容器通信
2. host：容器直接使用宿主机网络，性能最佳但隔离性差
3. overlay：跨主机容器通信，用于集群环境
4. none：禁用网络功能，完全隔离的容器

网络模式对比：

网络配置示例：

# 创建自定义网络
docker network create --driver bridge my-network

# 使用不同网络模式运行容器
docker run -d --network bridge nginx        # 默认桥接模式
docker run -d --network host nginx          # 主机网络模式
docker run -d --network none alpine         # 无网络模式
docker run -d --network my-network nginx    # 自定义网络

# 容器间通信配置
docker run -d --name db --network my-network postgres
docker run -d --name app --network my-network --link db myapp

实际应用：

• 微服务间的网络隔离和通信
• 高性能应用的网络优化
• 多租户环境的网络安全
• 容器集群的网络规划

How to handle log management for Docker containers?

考察点：日志系统设计。

答案：

Docker容器日志管理是运维监控的重要组成部分，需要考虑日志收集、存储、分析和告警等多个环节。合理的日志管理策略有助于快速定位问题和分析系统行为。

日志驱动类型：

1. json-file（默认）：将日志保存为JSON格式文件
2. syslog：发送日志到系统日志服务
3. journald：使用systemd journal日志系统
4. fluentd：发送到Fluentd日志收集器

基本日志操作：

# 查看容器日志
docker logs container_name

# 实时跟踪日志
docker logs -f container_name

# 查看最近的日志条目
docker logs --tail 100 container_name

# 查看指定时间范围的日志
docker logs --since "2023-01-01T00:00:00" --until "2023-01-02T00:00:00" container_name

日志驱动配置：

# 运行时指定日志驱动
docker run -d \
  --log-driver=fluentd \
  --log-opt fluentd-address=localhost:24224 \
  --log-opt tag="docker.{{.Name}}" \
  nginx

# 配置日志轮转
docker run -d \
  --log-driver=json-file \
  --log-opt max-size=10m \
  --log-opt max-file=3 \
  nginx

ELK Stack日志管理：

# docker-compose.yml
version: '3.8'

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.14.0
    environment:
      - discovery.type=single-node
    ports:
      - "9200:9200"

  kibana:
    image: docker.elastic.co/kibana/kibana:7.14.0
    ports:
      - "5601:5601"
    depends_on:
      - elasticsearch

  logstash:
    image: docker.elastic.co/logstash/logstash:7.14.0
    volumes:
      - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf

实际应用：

• 分布式系统的集中化日志管理
• 应用性能和错误监控
• 安全审计和合规性要求
• 故障排查和根因分析

How to design a microservices architecture based on Docker?

考察点：微服务架构设计。

答案：

基于Docker的微服务架构需要综合考虑服务拆分、容器编排、服务发现、数据管理等多个层面。通过合理的架构设计可以实现高可用、可扩展和易维护的分布式系统。

架构设计原则：

1. 单一职责：每个微服务负责单一业务功能
2. 无状态设计：服务实例可以随意创建和销毁
3. 数据隔离：每个服务拥有独立的数据存储
4. 松耦合：服务间通过API进行通信

核心组件设计：

# docker-compose.yml - 微服务架构示例
version: '3.8'

services:
  # API网关
  gateway:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - user-service
      - order-service

  # 用户服务
  user-service:
    build: ./services/user
    environment:
      - DB_HOST=user-db
      - REDIS_HOST=redis
    depends_on:
      - user-db
      - redis

  # 订单服务
  order-service:
    build: ./services/order
    environment:
      - DB_HOST=order-db
      - MESSAGE_QUEUE=rabbitmq
    depends_on:
      - order-db
      - rabbitmq

  # 数据库
  user-db:
    image: postgres:13
    environment:
      - POSTGRES_DB=users

  order-db:
    image: postgres:13
    environment:
      - POSTGRES_DB=orders

  # 缓存和消息队列
  redis:
    image: redis:alpine

  rabbitmq:
    image: rabbitmq:management

服务通信模式：

• 同步通信：HTTP/REST API，gRPC
• 异步通信：消息队列，事件驱动
• 服务发现：Consul、etcd、Kubernetes Service
• 负载均衡：Nginx、HAProxy、Istio

实际应用：

• 大型电商系统的服务拆分
• 金融系统的微服务改造
• 云原生应用架构设计
• DevOps团队的服务治理

What are the deployment strategies and best practices for Docker in production?

考察点：生产级部署。

答案：

Docker生产环境部署需要考虑高可用性、安全性、监控和运维等多个方面。通过制定完善的部署策略和遵循最佳实践，可以确保容器化应用在生产环境中稳定可靠地运行。

部署策略类型：

1. 蓝绿部署：维护两套完全相同的生产环境，实现零停机切换
2. 滚动更新：逐步替换旧版本容器，保证服务连续性
3. 金丝雀发布：小比例流量验证新版本，降低风险
4. A/B测试：并行运行多个版本，基于数据决策

生产环境最佳实践：

# 生产级容器运行配置
docker run -d \
  --name production-app \
  --restart=unless-stopped \
  --memory=2g \
  --cpus=1.5 \
  --read-only \
  --tmpfs /tmp \
  --user 1000:1000 \
  --cap-drop ALL \
  --cap-add NET_BIND_SERVICE \
  --security-opt no-new-privileges \
  --health-cmd="curl -f http://localhost:8080/health || exit 1" \
  --health-interval=30s \
  --log-driver=fluentd \
  --log-opt fluentd-address=logs.example.com:24224 \
  myapp:v1.2.3

镜像管理策略：

# 生产镜像标签策略
docker build -t myapp:${GIT_COMMIT} .
docker tag myapp:${GIT_COMMIT} myapp:latest
docker tag myapp:${GIT_COMMIT} myapp:v1.2.3

# 镜像安全扫描
docker scan myapp:v1.2.3

# 签名和验证
docker trust sign myapp:v1.2.3

监控和告警：

• 容器资源使用监控
• 应用性能指标收集
• 日志聚合和分析
• 自动故障恢复机制

实际应用：

• 大规模微服务生产部署
• 金融级应用的安全部署
• 云原生应用运维管理
• 多环境一致性保证

How to implement automatic scaling for Docker containers?

考察点：弹性伸缩机制。

答案：

Docker容器自动扩缩容是现代云原生应用的核心特性，通过动态调整容器实例数量来应对负载变化。这需要结合监控指标、编排平台和自动化策略来实现智能的资源管理。

扩缩容触发条件：

1. CPU使用率：基于CPU负载进行水平扩展
2. 内存使用率：监控内存压力进行调整
3. 网络流量：根据请求量动态扩容
4. 自定义指标：业务相关的性能指标

Kubernetes HPA配置：

# hpa.yaml - 水平Pod自动扩展器
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: webapp-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: webapp
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

Docker Swarm自动扩展：

# 创建可扩展的服务
docker service create \
  --name web-app \
  --replicas 3 \
  --constraint 'node.role==worker' \
  --reserve-cpu 0.5 \
  --reserve-memory 512M \
  --limit-cpu 1 \
  --limit-memory 1G \
  myapp:latest

# 基于负载手动扩展
docker service scale web-app=5

# 使用第三方工具自动扩展
# 例如：Prometheus + AlertManager + 自定义脚本

自定义扩缩容策略：

# 自动扩缩容脚本示例
import docker
import psutil
import time

client = docker.from_env()

def get_cpu_usage():
    return psutil.cpu_percent(interval=1)

def scale_containers(service_name, target_replicas):
    service = client.services.get(service_name)
    service.update(mode={'Replicated': {'Replicas': target_replicas}})

def auto_scale():
    while True:
        cpu_usage = get_cpu_usage()
        current_replicas = len(client.containers.list(
            filters={'label': 'com.docker.swarm.service.name=web-app'}
        ))
        
        if cpu_usage > 80 and current_replicas < 10:
            scale_containers('web-app', current_replicas + 2)
        elif cpu_usage < 30 and current_replicas > 2:
            scale_containers('web-app', current_replicas - 1)
        
        time.sleep(60)

实际应用：

• 电商平台的流量高峰应对
• 视频流媒体服务的动态扩展
• 金融交易系统的弹性伸缩
• IoT数据处理的自动调度

What is the relationship between Kubernetes and Docker? What are advanced container orchestration strategies?

考察点：容器编排架构。

答案：

Kubernetes是目前最主流的容器编排平台，虽然已经弃用Docker作为默认运行时，但仍然可以运行Docker构建的镜像。理解两者关系和编排策略对于构建现代云原生应用至关重要。

技术关系演变：

1. 早期关系：Kubernetes使用Docker作为默认容器运行时
2. CRI接口：Kubernetes引入容器运行时接口，支持多种运行时
3. Dockershim移除：v1.24版本移除Docker支持
4. 现状：使用containerd、CRI-O等符合CRI的运行时

高级编排策略：

# 高级Deployment配置
apiVersion: apps/v1
kind: Deployment
metadata:
  name: advanced-webapp
spec:
  replicas: 5
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 2
      maxUnavailable: 1
  selector:
    matchLabels:
      app: webapp
  template:
    spec:
      # 反亲和性规则 - 确保Pod分散部署
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchLabels:
                  app: webapp
              topologyKey: kubernetes.io/hostname
      
      # 资源限制和请求
      containers:
      - name: webapp
        image: myapp:v1.0.0
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        
        # 健康检查
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5

服务网格集成：

# Istio服务网格配置
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: webapp-vs
spec:
  http:
  - match:
    - headers:
        canary:
          exact: "true"
    route:
    - destination:
        host: webapp
        subset: v2
      weight: 100
  - route:
    - destination:
        host: webapp
        subset: v1
      weight: 90
    - destination:
        host: webapp
        subset: v2
      weight: 10

实际应用：

• 大规模微服务集群管理
• 多云和混合云部署策略
• 服务网格和零信任安全
• GitOps和声明式运维

How to handle fault recovery and high availability for Docker containers?

考察点：容灾机制设计。

答案：

Docker容器的故障恢复和高可用需要从多个层面进行设计，包括容器级别的自动重启、服务级别的健康检查、集群级别的故障转移等。通过完善的容灾机制可以确保服务的持续可用性。

故障恢复机制：

1. 自动重启策略：容器异常退出时的重启行为
2. 健康检查：定期检测应用状态并触发恢复
3. 服务发现：动态更新可用服务实例
4. 负载均衡：将流量重定向到健康实例

高可用架构设计：

# 高可用部署配置
version: '3.8'

services:
  webapp:
    image: myapp:latest
    deploy:
      replicas: 3
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
      update_config:
        parallelism: 1
        delay: 10s
        failure_action: rollback
      placement:
        constraints:
          - node.role == worker
        preferences:
          - spread: node.labels.zone
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  load-balancer:
    image: haproxy:alpine
    ports:
      - "80:80"
    volumes:
      - ./haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg
    deploy:
      replicas: 2
      placement:
        constraints:
          - node.role == manager

实际应用：

• 金融系统的99.99%可用性保证
• 电商平台的无缝故障切换
• 实时通信服务的连续性保障
• 关键业务系统的容灾备份

How do Docker network plugins and storage plugins work?

考察点：插件系统理解。

答案：

Docker通过插件架构提供了可扩展的网络和存储解决方案。插件系统允许第三方开发者和企业根据特定需求定制网络和存储功能，实现更灵活的容器基础设施。

网络插件工作原理：

1. CNI接口：容器网络接口，定义网络插件标准
2. 驱动注册：插件向Docker引擎注册网络驱动
3. 网络创建：通过插件API创建虚拟网络
4. 容器连接：将容器接入指定网络

常用网络插件：

# Calico网络插件安装
docker plugin install calico/node:latest

# Weave网络插件配置
docker run -d --name weave \
  --net=host \
  --privileged \
  -v /var/run/docker.sock:/var/run/docker.sock \
  weaveworks/weave:latest

# 创建overlay网络
docker network create \
  --driver=overlay \
  --attachable \
  --subnet=192.168.1.0/24 \
  my-overlay-network

存储插件机制：

# Volume插件管理
docker plugin ls

# 安装存储插件
docker plugin install rexray/ebs

# 使用插件创建卷
docker volume create \
  --driver rexray/ebs \
  --opt size=20 \
  --opt volumetype=gp2 \
  my-ebs-volume

# 容器使用外部存储
docker run -d \
  --name database \
  -v my-ebs-volume:/var/lib/mysql \
  mysql:8.0

实际应用：

• 多云环境的统一网络管理
• 企业级存储系统集成
• 高性能网络解决方案
• 分布式存储系统对接

How to implement cross-host Docker container communication?

考察点：分布式网络。

答案：

跨主机Docker容器通信是构建分布式应用的基础需求。通过overlay网络、服务发现、负载均衡等技术可以实现透明的跨主机容器通信，支持大规模微服务架构部署。

实现方案：

1. Overlay网络：Docker原生的跨主机网络方案
2. 第三方网络：Flannel、Calico、Weave等网络插件
3. 服务网格：Istio、Linkerd等高级网络管理
4. VPN隧道：传统VPN技术的容器化应用

Overlay网络配置：

# 初始化Swarm集群
docker swarm init --advertise-addr 192.168.1.100

# 在其他主机加入集群
docker swarm join --token SWMTKN-1-xxx 192.168.1.100:2377

# 创建overlay网络
docker network create \
  --driver overlay \
  --attachable \
  --subnet=10.0.0.0/16 \
  cross-host-network

# 在不同主机运行容器
# 主机A
docker run -d --name app1 --network cross-host-network nginx

# 主机B
docker run -d --name app2 --network cross-host-network alpine \
  sh -c "while true; do ping app1; sleep 5; done"

Kubernetes网络模型：

# 跨节点Pod通信
apiVersion: v1
kind: Service
metadata:
  name: backend-service
spec:
  selector:
    app: backend
  ports:
  - port: 80
    targetPort: 8080
  type: ClusterIP

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
spec:
  template:
    spec:
      containers:
      - name: frontend
        image: frontend:latest
        env:
        - name: BACKEND_URL
          value: "http://backend-service"

实际应用：

• 多数据中心的服务部署
• 混合云架构的网络连通
• 边缘计算节点通信
• 大规模集群网络管理

What is Docker’s role in cloud-native architecture and optimization strategies?

考察点：云原生架构。

答案：

Docker是云原生架构的重要组成部分，提供了应用容器化的基础能力。在现代云原生生态中，Docker需要与Kubernetes、服务网格、观测性工具等协同工作，实现高效的应用交付和运维。

在云原生架构中的角色：

1. 应用打包：标准化应用交付格式
2. 运行时基础：提供轻量级应用隔离
3. CI/CD集成：自动化构建和部署流程
4. 微服务支撑：支持分布式架构模式

云原生优化策略：

# 云原生应用配置
apiVersion: apps/v1
kind: Deployment
metadata:
  name: cloud-native-app
  labels:
    app.kubernetes.io/name: myapp
    app.kubernetes.io/version: "1.0.0"
spec:
  template:
    spec:
      containers:
      - name: app
        image: myapp:1.0.0
        # 12-factor应用配置
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: url
        # 资源限制
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"
        # 优雅关闭
        lifecycle:
          preStop:
            exec:
              command: ["/bin/sh", "-c", "sleep 15"]
        # 探针配置
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080

性能优化技术：

• 镜像分层优化：减少镜像构建时间
• 多架构镜像：支持ARM和x86平台
• 缓存策略：利用构建缓存加速CI/CD
• 资源调优：基于实际负载优化资源配置

实际应用：

• 企业数字化转型的技术底座
• 多云部署和云迁移策略
• DevOps文化的技术实现
• 现代应用架构的标准化

How to design version management and release strategies for Docker images?

考察点：版本管理体系。

答案：

Docker镜像版本管理是软件发布流程的关键环节，需要制定清晰的标签策略、版本控制规范和发布流程。良好的版本管理可以确保应用的可追溯性、回滚能力和环境一致性。

版本标签策略：

1. 语义化版本：遵循SemVer规范（major.minor.patch）
2. 环境标签：区分开发、测试、生产环境
3. 构建标签：包含构建信息和Git提交哈希
4. 稳定标签：latest、stable等便于使用的标签

标签管理实践：

# 语义化版本标签
docker build -t myapp:1.2.3 .
docker build -t myapp:1.2 .
docker build -t myapp:1 .

# 包含构建信息的标签
docker build -t myapp:${VERSION}-${BUILD_NUMBER} .
docker build -t myapp:${GIT_COMMIT} .

# 环境特定标签
docker build -t myapp:${VERSION}-dev .
docker build -t myapp:${VERSION}-staging .
docker build -t myapp:${VERSION}-prod .

# 推送策略
docker push myapp:${VERSION}
docker tag myapp:${VERSION} myapp:latest
docker push myapp:latest

自动化发布流程：

# GitLab CI发布流程
stages:
  - build
  - test
  - release

variables:
  IMAGE_TAG: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
  RELEASE_TAG: $CI_REGISTRY_IMAGE:$CI_COMMIT_TAG

release:
  stage: release
  script:
    - docker build -t $IMAGE_TAG .
    - docker tag $IMAGE_TAG $RELEASE_TAG
    - docker push $RELEASE_TAG
    # 更新latest标签（仅主分支）
    - if [ "$CI_COMMIT_BRANCH" == "main" ]; then
        docker tag $RELEASE_TAG $CI_REGISTRY_IMAGE:latest;
        docker push $CI_REGISTRY_IMAGE:latest;
      fi
  only:
    - tags

实际应用：

• 企业级软件发布管理
• 多环境部署版本控制
• 容器镜像安全和合规
• DevOps流程标准化

What are Docker’s performance tuning and resource limiting strategies?

考察点：性能优化能力。

答案：

Docker性能调优涉及容器资源限制、存储优化、网络调优等多个方面。通过合理的资源管理和性能优化可以提高容器运行效率，降低系统资源消耗，确保应用稳定运行。

资源限制策略：

1. CPU限制：控制CPU使用率和核心数量
2. 内存限制：设置内存使用上限和交换区限制
3. 磁盘I/O限制：控制读写速度和IOPS
4. 网络带宽限制：限制网络流量和连接数

资源限制配置：

# 运行时资源限制
docker run -d \
  --name optimized-app \
  --memory=1g \                    # 内存限制1GB
  --memory-swap=1g \               # 禁用swap
  --cpus="1.5" \                   # CPU限制1.5核
  --cpu-shares=1024 \              # CPU权重
  --blkio-weight=600 \             # 磁盘I/O权重
  --device-read-bps /dev/sda:1mb \ # 读取速度限制
  --device-write-bps /dev/sda:1mb \# 写入速度限制
  --pids-limit=100 \               # 进程数限制
  --ulimit nofile=1024:2048 \      # 文件句柄限制
  myapp:latest

# 容器运行时调优
docker update \
  --memory=2g \
  --cpus="2" \
  optimized-app

存储性能优化：

# 使用高性能存储驱动
docker run -d \
  --storage-opt size=20G \
  --tmpfs /tmp:rw,size=100m \
  --volume type=bind,source=/fast-ssd,target=/data \
  myapp:latest

# 优化镜像分层
# Dockerfile优化
FROM alpine:latest
RUN apk update && \
    apk add --no-cache app-deps && \
    rm -rf /var/cache/apk/*

系统级调优：

# Docker daemon配置
# /etc/docker/daemon.json
{
  "storage-driver": "overlay2",
  "storage-opts": [
    "overlay2.override_kernel_check=true"
  ],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  },
  "default-ulimits": {
    "nofile": {
      "Name": "nofile",
      "Hard": 64000,
      "Soft": 32000
    }
  }
}

监控和调优工具：

• docker stats：实时资源使用监控
• cAdvisor：容器性能数据收集
• Prometheus：指标收集和告警
• Jaeger：分布式追踪和性能分析

实际应用：

• 高并发Web应用优化
• 大数据处理容器调优
• 实时系统的性能保证
• 云成本控制和资源优化