在Fedora系统上轻松搭建高效容器环境从基础安装到配置运行一步到位的完整实用指南

引言

容器技术已成为现代软件开发和部署的核心组成部分。它提供了一种轻量级、可移植且高效的方式来打包、分发和运行应用程序。Fedora作为一款领先的开源操作系统，为容器技术提供了出色的支持。本文将详细介绍如何在Fedora系统上从零开始搭建高效容器环境，涵盖基础安装、配置优化到实际运行的完整流程，帮助读者一步到位地掌握Fedora上的容器技术。

容器技术概述

容器是一种操作系统级别的虚拟化技术，它允许应用程序及其依赖项打包在一个隔离的环境中运行。与传统的虚拟机相比，容器共享主机操作系统的内核，因此更加轻量级，启动速度更快，资源利用率更高。

在Fedora系统中，我们主要使用以下容器技术：

Docker：最流行的容器平台，提供了一套完整的容器管理工具。
Podman：由Red Hat开发的容器引擎，与Docker兼容但无需守护进程，更符合Linux安全原则。
Buildah：用于构建OCI（Open Container Initiative）兼容容器的工具。
Skopeo：用于复制、检查、签名和存储容器镜像的工具。

系统准备

在开始安装容器工具之前，我们需要确保Fedora系统是最新的，并满足基本要求。

系统要求

Fedora 35或更高版本（推荐使用最新稳定版）
至少4GB RAM
至少20GB可用磁盘空间
具有sudo权限的用户账户
稳定的网络连接

更新系统

首先，打开终端并更新系统到最新状态：

sudo dnf update -y sudo dnf upgrade -y

安装必要的工具

安装一些基本的开发工具和依赖项：

sudo dnf groupinstall -y "Development Tools" sudo dnf install -y curl wget git

安装Docker

Docker是最广泛使用的容器平台，下面介绍在Fedora上安装Docker的步骤。

添加Docker仓库

首先，添加Docker的官方仓库：

sudo dnf config-manager --add-repo https://download.docker.com/linux/fedora/docker-ce.repo

安装Docker CE

安装Docker Community Edition及其相关组件：

sudo dnf install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

启动并启用Docker服务

安装完成后，启动Docker服务并设置为开机自启：

sudo systemctl start docker sudo systemctl enable docker

验证Docker安装

运行以下命令验证Docker是否正确安装：

sudo docker run hello-world

如果看到欢迎消息，说明Docker已成功安装并运行。

将用户添加到docker组

为了避免每次使用Docker命令时都需要sudo，可以将当前用户添加到docker组：

sudo usermod -aG docker $USER

注意：执行此命令后，需要注销并重新登录才能使更改生效。

安装Podman

Podman是Fedora和Red Hat生态系统中的首选容器管理工具，它提供了与Docker兼容的CLI，但具有更好的安全性和架构设计。

安装Podman

在Fedora上，Podman可以直接从官方仓库安装：

sudo dnf install -y podman

验证Podman安装

运行以下命令验证Podman是否正确安装：

podman run hello-world

安装Podman Compose

Podman Compose是一个用于运行多容器应用程序的工具，类似于Docker Compose：

sudo dnf install -y podman-compose

安装Buildah和Skopeo

Buildah和Skopeo是Podman生态系统的重要组成部分：

sudo dnf install -y buildah skopeo

容器网络配置

容器网络是容器环境中的重要组成部分，它允许容器之间以及容器与外部网络进行通信。

Docker网络配置

查看Docker网络

docker network ls

创建自定义网络

docker network create my-network

运行容器并连接到网络

docker run -d --name container1 --network my-network nginx docker run -d --name container2 --network my-network nginx

测试容器间通信

docker exec -it container1 ping container2

Podman网络配置

查看Podman网络

podman network ls

创建自定义网络

podman network create my-podman-network

运行容器并连接到网络

podman run -d --name podman-container1 --network my-podman-network nginx podman run -d --name podman-container2 --network my-podman-network nginx

测试容器间通信

podman exec -it podman-container1 ping podman-container2

高级网络配置

创建桥接网络

# Docker docker network create --driver=bridge --subnet=192.168.0.0/16 --ip-range=192.168.1.0/24 --gateway=192.168.1.1 my-bridge-network # Podman podman network create --driver=bridge --subnet=192.168.0.0/16 --ip-range=192.168.1.0/24 --gateway=192.168.1.1 my-podman-bridge-network

创建Macvlan网络

Macvlan网络允许容器直接连接到物理网络：

# Docker docker network create -d macvlan --subnet=192.168.1.0/24 --gateway=192.168.1.1 -o parent=eth0 my-macvlan-network # Podman podman network create -d macvlan --subnet=192.168.1.0/24 --gateway=192.168.1.1 -o parent=eth0 my-podman-macvlan-network

容器存储管理

容器存储是容器环境中的另一个关键组件，它管理容器数据的持久化和共享。

Docker存储管理

查看Docker存储信息

docker info | grep -i storage

使用卷（Volumes）

创建一个命名卷：

docker volume create my-volume

运行容器并挂载卷：

docker run -d -v my-volume:/app/data nginx

使用绑定挂载（Bind Mounts）

运行容器并挂载主机目录：

docker run -d -v /host/path:/container/path nginx

使用临时文件系统（tmpfs）

docker run -d --tmpfs /tmp:rw,size=100m nginx

Podman存储管理

查看Podman存储信息

podman info | grep -i storage

使用卷

创建一个命名卷：

podman volume create my-podman-volume

运行容器并挂载卷：

podman run -d -v my-podman-volume:/app/data nginx

使用绑定挂载

podman run -d -v /host/path:/container/path nginx

使用临时文件系统

podman run -d --tmpfs /tmp:rw,size=100m nginx

高级存储配置

创建共享存储卷

# Docker docker volume create --opt type=tmpfs --opt device=tmpfs --opt o=size=100m,uid=1000 my-shared-volume # Podman podman volume create --opt type=tmpfs --opt device=tmpfs --opt o=size=100m,uid=1000 my-podman-shared-volume

使用NFS存储

# Docker docker volume create --driver local --opt type=nfs --opt o=addr=192.168.1.1,rw --opt device=:/path/to/dir nfs-volume # Podman podman volume create --driver local --opt type=nfs --opt o=addr=192.168.1.1,rw --opt device=:/path/to/dir nfs-podman-volume

容器编排工具

容器编排工具用于管理多容器应用程序的部署、扩展和网络连接。

Docker Compose

Docker Compose是一个用于定义和运行多容器Docker应用程序的工具。

安装Docker Compose

在Fedora上，我们可以使用Docker Compose插件：

sudo dnf install -y docker-compose-plugin

创建Docker Compose文件

创建一个名为docker-compose.yml的文件：

version: '3.8' services: web: image: nginx:latest ports: - "80:80" volumes: - ./html:/usr/share/nginx/html networks: - app-network db: image: postgres:13 environment: POSTGRES_PASSWORD: example volumes: - db-data:/var/lib/postgresql/data networks: - app-network volumes: db-data: networks: app-network: driver: bridge

使用Docker Compose

启动服务：

docker compose up -d

查看运行状态：

docker compose ps

停止服务：

docker compose down

Podman Compose

Podman Compose是Podman的替代方案，用于运行多容器应用程序。

使用Podman Compose

使用与Docker Compose相同的docker-compose.yml文件：

启动服务：

podman-compose up -d

查看运行状态：

podman-compose ps

停止服务：

podman-compose down

Kubernetes集成

Kubernetes是一个开源的容器编排平台，Fedora提供了几种方式来使用Kubernetes。

安装Minikube

Minikube是一个工具，可以在本地运行Kubernetes集群：

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-latest.x86_64.rpm sudo rpm -Uvh minikube-latest.x86_64.rpm

启动Minikube集群：

minikube start --driver=podman

安装kubectl

kubectl是Kubernetes的命令行工具：

sudo dnf install -y kubectl

创建Kubernetes部署文件

创建一个名为deployment.yaml的文件：

apiVersion: apps/v1 kind: Deployment metadata: name: nginx-deployment spec: replicas: 3 selector: matchLabels: app: nginx template: metadata: labels: app: nginx spec: containers: - name: nginx image: nginx:1.21 ports: - containerPort: 80 --- apiVersion: v1 kind: Service metadata: name: nginx-service spec: selector: app: nginx ports: - protocol: TCP port: 80 targetPort: 80 type: LoadBalancer

部署到Kubernetes

kubectl apply -f deployment.yaml

查看部署状态：

kubectl get pods kubectl get services

实际应用示例

让我们通过几个实际应用示例来展示如何使用容器技术。

示例1：Web服务器部署

使用Docker部署Nginx

# 创建网站内容目录 mkdir -p ~/nginx-content echo "<h1>Hello from Docker Nginx!</h1>" > ~/nginx-content/index.html # 运行Nginx容器 docker run -d -p 8080:80 -v ~/nginx-content:/usr/share/nginx/html --name my-nginx nginx # 访问网站 curl http://localhost:8080

使用Podman部署Nginx

# 创建网站内容目录 mkdir -p ~/nginx-content echo "<h1>Hello from Podman Nginx!</h1>" > ~/nginx-content/index.html # 运行Nginx容器 podman run -d -p 8081:80 -v ~/nginx-content:/usr/share/nginx/html --name my-podman-nginx nginx # 访问网站 curl http://localhost:8081

示例2：数据库部署

使用Docker部署PostgreSQL

# 创建数据目录 mkdir -p ~/postgres-data # 运行PostgreSQL容器 docker run -d --name my-postgres -e POSTGRES_PASSWORD=mysecretpassword -e POSTGRES_DB=mydatabase -v ~/postgres-data:/var/lib/postgresql/data -p 5432:5432 postgres:13 # 连接到数据库 docker run -it --rm --link my-postgres:postgres postgres:13 psql -h postgres -U postgres -d mydatabase

使用Podman部署PostgreSQL

# 创建数据目录 mkdir -p ~/postgres-data # 运行PostgreSQL容器 podman run -d --name my-podman-postgres -e POSTGRES_PASSWORD=mysecretpassword -e POSTGRES_DB=mydatabase -v ~/postgres-data:/var/lib/postgresql/data -p 5433:5432 postgres:13 # 连接到数据库 podman run -it --rm --link my-podman-postgres:postgres postgres:13 psql -h postgres -U postgres -d mydatabase

示例3：全栈应用程序部署

创建Docker Compose文件

创建一个名为docker-compose.yml的文件：

version: '3.8' services: frontend: build: ./frontend ports: - "3000:3000" depends_on: - backend networks: - app-network backend: build: ./backend ports: - "5000:5000" depends_on: - db environment: - DATABASE_URL=postgresql://postgres:mysecretpassword@db:5432/mydatabase networks: - app-network db: image: postgres:13 environment: - POSTGRES_PASSWORD=mysecretpassword - POSTGRES_DB=mydatabase volumes: - postgres-data:/var/lib/postgresql/data networks: - app-network volumes: postgres-data: networks: app-network: driver: bridge

创建前端应用

创建frontend/Dockerfile文件：

FROM node:16-alpine WORKDIR /app COPY package*.json ./ RUN npm install COPY . . EXPOSE 3000 CMD ["npm", "start"]

创建frontend/package.json文件：

{ "name": "frontend", "version": "1.0.0", "description": "Frontend application", "main": "index.js", "scripts": { "start": "node index.js" }, "dependencies": { "express": "^4.17.1" } }

创建frontend/index.js文件：

const express = require('express'); const app = express(); const port = 3000; app.get('/', (req, res) => { res.send('Hello from Frontend!'); }); app.listen(port, () => { console.log(`Frontend app listening at http://localhost:${port}`); });

创建后端应用

创建backend/Dockerfile文件：

FROM node:16-alpine WORKDIR /app COPY package*.json ./ RUN npm install COPY . . EXPOSE 5000 CMD ["npm", "start"]

创建backend/package.json文件：

{ "name": "backend", "version": "1.0.0", "description": "Backend application", "main": "index.js", "scripts": { "start": "node index.js" }, "dependencies": { "express": "^4.17.1", "pg": "^8.7.1" } }

创建backend/index.js文件：

const express = require('express'); const { Pool } = require('pg'); const app = express(); const port = 5000; const pool = new Pool({ connectionString: process.env.DATABASE_URL, }); app.get('/', (req, res) => { res.send('Hello from Backend!'); }); app.get('/db-test', async (req, res) => { try { const result = await pool.query('SELECT NOW()'); res.send(`Database connection successful! Current time: ${result.rows[0].now}`); } catch (err) { console.error(err); res.send('Error connecting to database'); } }); app.listen(port, () => { console.log(`Backend app listening at http://localhost:${port}`); });

启动应用程序

docker compose up -d

测试应用程序

# 测试前端 curl http://localhost:3000 # 测试后端 curl http://localhost:5000 # 测试数据库连接 curl http://localhost:5000/db-test

性能优化

优化容器环境的性能可以显著提高应用程序的响应速度和资源利用率。

容器镜像优化

使用多阶段构建

多阶段构建可以减小最终镜像的大小：

# 第一阶段：构建应用程序 FROM node:16-alpine AS builder WORKDIR /app COPY package*.json ./ RUN npm install COPY . . RUN npm run build # 第二阶段：运行应用程序 FROM node:16-alpine WORKDIR /app COPY package*.json ./ RUN npm install --production COPY --from=builder /app/dist ./dist EXPOSE 3000 CMD ["npm", "start"]

使用 Alpine Linux 镜像

Alpine Linux是一个轻量级的Linux发行版，可以显著减小镜像大小：

# 使用Alpine镜像 FROM node:16-alpine # 或者，对于Python应用 FROM python:3.9-alpine

清理不必要的文件

在构建过程中删除不必要的文件和缓存：

FROM node:16-alpine WORKDIR /app COPY package*.json ./ RUN npm install && npm cache clean --force COPY . . RUN npm run build && rm -rf node_modules/.cache EXPOSE 3000 CMD ["npm", "start"]

资源限制

限制容器CPU使用

# Docker docker run -d --cpus="1.5" nginx # Podman podman run -d --cpus="1.5" nginx

限制容器内存使用

# Docker docker run -d --memory="512m" nginx # Podman podman run -d --memory="512m" nginx

设置资源预留

# Docker docker run -d --memory-reservation="256m" nginx # Podman podman run -d --memory-reservation="256m" nginx

存储优化

使用临时文件系统

# Docker docker run -d --tmpfs /tmp:rw,size=100m nginx # Podman podman run -d --tmpfs /tmp:rw,size=100m nginx

优化存储驱动

编辑Docker配置文件/etc/docker/daemon.json：

{ "storage-driver": "overlay2", "storage-opts": [ "overlay2.size=20G" ] }

重启Docker服务：

sudo systemctl restart docker

网络优化

使用主机网络

# Docker docker run -d --network host nginx # Podman podman run -d --network host nginx

优化网络缓冲区

# Docker docker run -d --sysctl net.core.rmem_max=16777216 --sysctl net.core.wmem_max=16777216 nginx # Podman podman run -d --sysctl net.core.rmem_max=16777216 --sysctl net.core.wmem_max=16777216 nginx

安全配置

容器安全是生产环境中不可忽视的重要方面。

容器运行时安全

以非特权用户运行容器

FROM node:16-alpine # 创建非特权用户 RUN addgroup -g 1001 -S nodejs && adduser -S nextjs -u 1001 WORKDIR /app COPY package*.json ./ RUN npm install && npm cache clean --force COPY . . RUN chown -R nextjs:nodejs /app USER nextjs EXPOSE 3000 CMD ["npm", "start"]

使用只读根文件系统

# Docker docker run -d --read-only nginx # Podman podman run -d --read-only nginx

限制容器能力

# Docker docker run -d --cap-drop ALL --cap-add CHOWN nginx # Podman podman run -d --cap-drop ALL --cap-add CHOWN nginx

镜像安全

扫描镜像漏洞

安装并使用Trivy进行镜像扫描：

# 安装Trivy sudo dnf install -y trivy # 扫描镜像 trivy image nginx:latest

使用签名镜像

安装并使用Cosign进行镜像签名：

# 安装Cosign sudo dnf install -y cosign # 生成密钥对 cosign generate-key-pair # 签名镜像 cosign sign --key cosign.key nginx:latest # 验证签名 cosign verify --key cosign.pub nginx:latest

网络安全

使用网络隔离

# Docker docker network create --internal isolated-network docker run -d --network isolated-network nginx # Podman podman network create --internal isolated-network podman run -d --network isolated-network nginx

加密网络通信

# 创建加密网络 # Docker docker network create -d overlay --opt encrypted my-encrypted-network # Podman podman network create -d macvlan --opt encrypted my-podman-encrypted-network

安全策略

使用Seccomp配置

# Docker docker run -d --security-opt seccomp=/path/to/seccomp-profile.json nginx # Podman podman run -d --security-opt seccomp=/path/to/seccomp-profile.json nginx

使用AppArmor或SELinux

# Docker docker run -d --security-opt apparmor=docker-default nginx # Podman podman run -d --security-opt label=level:svirt_sandbox_file_t nginx

故障排除

在使用容器环境时，可能会遇到各种问题。本节介绍一些常见问题的解决方法。

容器启动失败

查看容器日志

# Docker docker logs container_name # Podman podman logs container_name

查看容器详细信息

# Docker docker inspect container_name # Podman podman inspect container_name

检查资源使用情况

# Docker docker stats container_name # Podman podman stats container_name

网络连接问题

检查容器网络配置

# Docker docker network inspect network_name # Podman podman network inspect network_name

测试容器间连接

# Docker docker exec -it container1 ping container2 # Podman podman exec -it container1 ping container2

检查防火墙设置

sudo firewall-cmd --list-all sudo firewall-cmd --add-port=8080/tcp --permanent sudo firewall-cmd --reload

存储问题

检查卷状态

# Docker docker volume ls docker volume inspect volume_name # Podman podman volume ls podman volume inspect volume_name

清理未使用的资源

# Docker docker system prune -a # Podman podman system prune -a

检查磁盘空间

df -h du -sh /var/lib/docker du -sh /var/lib/containers

性能问题

监控容器资源使用

# Docker docker stats # Podman podman stats

检查系统资源使用

top htop free -h iostat

优化容器配置

# 增加内存限制 # Docker docker update --memory="1g" container_name # Podman podman update --memory="1g" container_name # 增加CPU限制 # Docker docker update --cpus="2" container_name # Podman podman update --cpus="2" container_name

高级主题

容器化微服务架构

微服务架构是一种将应用程序拆分为小型、独立服务的方法，容器技术非常适合部署和管理微服务。

创建微服务示例

创建一个简单的微服务架构，包含用户服务、订单服务和API网关。

用户服务

创建user-service/Dockerfile：

FROM node:16-alpine WORKDIR /app COPY package*.json ./ RUN npm install COPY . . EXPOSE 3001 CMD ["npm", "start"]

创建user-service/package.json：

{ "name": "user-service", "version": "1.0.0", "description": "User microservice", "main": "index.js", "scripts": { "start": "node index.js" }, "dependencies": { "express": "^4.17.1" } }

创建user-service/index.js：

const express = require('express'); const app = express(); const port = 3001; const users = [ { id: 1, name: 'Alice', email: 'alice@example.com' }, { id: 2, name: 'Bob', email: 'bob@example.com' } ]; app.get('/users', (req, res) => { res.json(users); }); app.get('/users/:id', (req, res) => { const user = users.find(u => u.id === parseInt(req.params.id)); if (!user) return res.status(404).send('User not found'); res.json(user); }); app.listen(port, () => { console.log(`User service listening at http://localhost:${port}`); });

订单服务

创建order-service/Dockerfile：

FROM node:16-alpine WORKDIR /app COPY package*.json ./ RUN npm install COPY . . EXPOSE 3002 CMD ["npm", "start"]

创建order-service/package.json：

{ "name": "order-service", "version": "1.0.0", "description": "Order microservice", "main": "index.js", "scripts": { "start": "node index.js" }, "dependencies": { "express": "^4.17.1" } }

创建order-service/index.js：

const express = require('express'); const app = express(); const port = 3002; const orders = [ { id: 1, userId: 1, product: 'Laptop', quantity: 1 }, { id: 2, userId: 2, product: 'Phone', quantity: 2 } ]; app.get('/orders', (req, res) => { res.json(orders); }); app.get('/orders/:id', (req, res) => { const order = orders.find(o => o.id === parseInt(req.params.id)); if (!order) return res.status(404).send('Order not found'); res.json(order); }); app.get('/users/:userId/orders', (req, res) => { const userOrders = orders.filter(o => o.userId === parseInt(req.params.userId)); res.json(userOrders); }); app.listen(port, () => { console.log(`Order service listening at http://localhost:${port}`); });

API网关

创建api-gateway/Dockerfile：

FROM node:16-alpine WORKDIR /app COPY package*.json ./ RUN npm install COPY . . EXPOSE 3000 CMD ["npm", "start"]

创建api-gateway/package.json：

{ "name": "api-gateway", "version": "1.0.0", "description": "API Gateway", "main": "index.js", "scripts": { "start": "node index.js" }, "dependencies": { "express": "^4.17.1", "http-proxy-middleware": "^2.0.1" } }

创建api-gateway/index.js：

const express = require('express'); const { createProxyMiddleware } = require('http-proxy-middleware'); const app = express(); const port = 3000; // 用户服务代理 app.use('/users', createProxyMiddleware({ target: 'http://user-service:3001', changeOrigin: true })); // 订单服务代理 app.use('/orders', createProxyMiddleware({ target: 'http://order-service:3002', changeOrigin: true })); // 根路径 app.get('/', (req, res) => { res.send('API Gateway is running'); }); app.listen(port, () => { console.log(`API Gateway listening at http://localhost:${port}`); });

Docker Compose配置

创建docker-compose.yml：

version: '3.8' services: api-gateway: build: ./api-gateway ports: - "3000:3000" depends_on: - user-service - order-service networks: - microservices-network user-service: build: ./user-service ports: - "3001:3001" networks: - microservices-network order-service: build: ./order-service ports: - "3002:3002" networks: - microservices-network networks: microservices-network: driver: bridge

启动微服务

docker compose up -d

测试微服务

# 测试API网关 curl http://localhost:3000 # 测试用户服务 curl http://localhost:3000/users curl http://localhost:3000/users/1 # 测试订单服务 curl http://localhost:3000/orders curl http://localhost:3000/orders/1 curl http://localhost:3000/users/1/orders

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

将容器技术与CI/CD流程结合可以实现自动化的应用程序构建、测试和部署。

使用GitHub Actions

创建.github/workflows/ci-cd.yml文件：

name: CI/CD Pipeline on: push: branches: [ main ] pull_request: branches: [ main ] jobs: build-and-test: runs-on: ubuntu-latest steps: - name: Checkout code uses: actions/checkout@v2 - name: Set up Docker Buildx uses: docker/setup-buildx-action@v1 - name: Login to DockerHub uses: docker/login-action@v1 with: username: ${{ secrets.DOCKERHUB_USERNAME }} password: ${{ secrets.DOCKERHUB_TOKEN }} - name: Build and push Docker image uses: docker/build-push-action@v2 with: context: . push: true tags: yourusername/yourapp:latest - name: Run tests run: | docker run yourusername/yourapp:latest npm test deploy: needs: build-and-test runs-on: ubuntu-latest if: github.ref == 'refs/heads/main' steps: - name: Checkout code uses: actions/checkout@v2 - name: Deploy to production uses: appleboy/ssh-action@master with: host: ${{ secrets.PRODUCTION_HOST }} username: ${{ secrets.PRODUCTION_USER }} key: ${{ secrets.PRODUCTION_SSH_KEY }} script: | cd /path/to/your/app docker-compose pull docker-compose up -d

使用GitLab CI/CD

创建.gitlab-ci.yml文件：

stages: - build - test - deploy variables: DOCKER_REGISTRY: "your-registry.com" DOCKER_IMAGE: "$DOCKER_REGISTRY/yourusername/yourapp" build: stage: build image: docker:latest services: - docker:dind script: - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY - docker build -t $DOCKER_IMAGE:$CI_COMMIT_SHA . - docker push $DOCKER_IMAGE:$CI_COMMIT_SHA test: stage: test image: $DOCKER_IMAGE:$CI_COMMIT_SHA services: - postgres:13 variables: POSTGRES_DB: testdb POSTGRES_USER: testuser POSTGRES_PASSWORD: testpass DATABASE_URL: "postgresql://testuser:testpass@postgres:5432/testdb" script: - npm install - npm test deploy: stage: deploy image: alpine:latest before_script: - 'which ssh-agent || ( apk update && apk add openssh-client )' - eval $(ssh-agent -s) - echo "$SSH_PRIVATE_KEY" | tr -d 'r' | ssh-add - - mkdir -p ~/.ssh - chmod 700 ~/.ssh - echo "$SSH_KNOWN_HOSTS" >> ~/.ssh/known_hosts - chmod 644 ~/.ssh/known_hosts script: - ssh $PRODUCTION_USER@$PRODUCTION_HOST "cd /path/to/your/app && docker-compose pull && docker-compose up -d" only: - main

容器监控和日志管理

监控容器环境并管理日志对于维护生产环境至关重要。

使用Prometheus和Grafana监控容器

创建monitoring/docker-compose.yml：

version: '3.8' services: prometheus: image: prom/prometheus:latest ports: - "9090:9090" volumes: - ./prometheus.yml:/etc/prometheus/prometheus.yml command: - '--config.file=/etc/prometheus/prometheus.yml' networks: - monitoring-network grafana: image: grafana/grafana:latest ports: - "3000:3000" environment: - GF_SECURITY_ADMIN_PASSWORD=admin volumes: - grafana-storage:/var/lib/grafana networks: - monitoring-network 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 networks: - monitoring-network volumes: grafana-storage: networks: monitoring-network: driver: bridge

创建monitoring/prometheus.yml：

global: scrape_interval: 15s scrape_configs: - job_name: 'prometheus' static_configs: - targets: ['prometheus:9090'] - job_name: 'cadvisor' static_configs: - targets: ['cadvisor:8080']

启动监控系统：

cd monitoring docker compose up -d

访问Grafana（http://localhost:3000）并配置Prometheus数据源。

使用ELK Stack管理容器日志

创建logging/docker-compose.yml：

version: '3.8' services: elasticsearch: image: docker.elastic.co/elasticsearch/elasticsearch:7.15.0 environment: - discovery.type=single-node - "ES_JAVA_OPTS=-Xms512m -Xmx512m" ports: - "9200:9200" volumes: - elasticsearch-data:/usr/share/elasticsearch/data networks: - logging-network logstash: image: docker.elastic.co/logstash/logstash:7.15.0 ports: - "5000:5000" volumes: - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf networks: - logging-network depends_on: - elasticsearch kibana: image: docker.elastic.co/kibana/kibana:7.15.0 ports: - "5601:5601" environment: - ELASTICSEARCH_HOSTS=http://elasticsearch:9200 networks: - logging-network depends_on: - elasticsearch volumes: elasticsearch-data: networks: logging-network: driver: bridge

创建logging/logstash.conf：

input { gelf { port => 5000 } } filter { # Add any filters here } output { elasticsearch { hosts => ["elasticsearch:9200"] } }

启动日志系统：

cd logging docker compose up -d

配置容器将日志发送到Logstash：

version: '3.8' services: app: image: your-app:latest logging: driver: gelf options: gelf-address: "udp://logstash:5000" tag: "my-app" networks: - app-network networks: app-network: driver: bridge