# 负载均衡器配置
upstream green_environment {
    server 10.0.1.10:8080;
    server 10.0.1.11:8080;
}

upstream blue_environment {
    server 10.0.2.10:8080;
    server 10.0.2.11:8080;
}

server {
    listen 80;
    server_name api.example.com;
    
    location / {
        proxy_pass http://green_environment;  # 切换此行实现环境切换
    }
}

切换脚本

#!/bin/bash
# 蓝绿环境切换脚本

CURRENT_ENV=$(cat /etc/nginx/conf.d/current_env.conf | grep proxy_pass | awk '{print $2}' | tr -d ';')

if [ "$CURRENT_ENV" = "http://green_environment" ]; then
    sed -i 's/proxy_pass http:\/\/green_environment/proxy_pass http:\/\/blue_environment/' /etc/nginx/conf.d/api.conf
    NEW_ENV="blue"
else
    sed -i 's/proxy_pass http:\/\/blue_environment/proxy_pass http:\/\/green_environment/' /etc/nginx/conf.d/api.conf
    NEW_ENV="green"
fi

# 重新加载Nginx配置
nginx -s reload

echo "Switched to $NEW_ENV environment"

基于Kubernetes的实现

使用Kubernetes Service和Ingress实现蓝绿部署：

Deployment配置

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service-green
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
      version: green
  template:
    metadata:
      labels:
        app: user-service
        version: green
    spec:
      containers:
      - name: user-service
        image: mycompany/user-service:1.0
        ports:
        - containerPort: 8080

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service-blue
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
      version: blue
  template:
    metadata:
      labels:
        app: user-service
        version: blue
    spec:
      containers:
      - name: user-service
        image: mycompany/user-service:2.0
        ports:
        - containerPort: 8080

Service配置

apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
    version: green  # 切换此标签实现环境切换
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080

Ingress配置

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: user-service-ingress
  annotations:
    nginx.ingress.kubernetes.io/canary: "false"
spec:
  rules:
  - host: api.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: user-service
            port:
              number: 80

蓝绿部署优势与挑战

优势

零停机时间：切换过程几乎无停机时间
快速回滚：出现问题时可以快速切换回原环境
风险隔离：新版本在独立环境中测试，风险可控
并行验证：可以在不影响生产环境的情况下验证新版本

挑战

资源成本：需要维护两套相同的生产环境
数据同步：需要处理两个环境间的数据同步
切换风险：切换过程中可能存在短暂的不一致
复杂性：实现和管理相对复杂

适用场景

高可用要求：对系统可用性要求极高的场景
关键业务：核心业务系统的部署
大版本更新：重大功能更新的部署
风险规避：需要最大程度规避部署风险的场景

滚动更新详解

滚动更新原理

滚动更新通过逐步替换旧版本实例来实现平滑的服务更新。在更新过程中，新旧版本实例同时存在，负载均衡器将流量分发到所有实例。通过控制更新的节奏，可以确保服务的连续性和稳定性。

核心机制

逐步替换：逐个或分批替换旧版本实例
健康检查：确保新实例健康后再继续更新
负载均衡：通过负载均衡器分发流量
回滚支持：支持更新失败时的回滚操作

更新流程

策略配置：配置滚动更新策略参数
实例替换：开始替换第一批旧版本实例
健康检查：检查新实例的健康状态
继续更新：健康检查通过后继续替换下一批
完成验证：验证所有实例更新完成
监控观察：持续监控更新后的系统状态

滚动更新实现

Kubernetes滚动更新

Kubernetes原生支持滚动更新：

Deployment配置

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 6
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1      # 最大不可用实例数
      maxSurge: 1           # 最大额外实例数
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: mycompany/user-service:2.0
        ports:
        - containerPort: 8080
        readinessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 60
          periodSeconds: 10

更新命令

# 更新镜像版本
kubectl set image deployment/user-service user-service=mycompany/user-service:2.0

# 查看更新状态
kubectl rollout status deployment/user-service

# 回滚到上一版本
kubectl rollout undo deployment/user-service

# 查看更新历史
kubectl rollout history deployment/user-service

自定义滚动更新

实现自定义的滚动更新逻辑：

更新脚本

#!/usr/bin/env python3
import subprocess
import time
import sys

def get_service_instances(service_name):
    """获取服务实例列表"""
    result = subprocess.run([
        'kubectl', 'get', 'pods', 
        '-l', f'app={service_name}',
        '-o', 'jsonpath={.items[*].metadata.name}'
    ], capture_output=True, text=True)
    return result.stdout.split()

def update_instance(instance_name, new_image):
    """更新单个实例"""
    # 删除旧实例
    subprocess.run(['kubectl', 'delete', 'pod', instance_name])
    
    # 等待新实例启动
    time.sleep(30)
    
    # 验证新实例健康状态
    for i in range(10):
        result = subprocess.run([
            'kubectl', 'exec', instance_name, 
            '--', 'curl', '-f', 'http://localhost:8080/health'
        ], capture_output=True)
        if result.returncode == 0:
            return True
        time.sleep(5)
    
    return False

def rolling_update(service_name, new_image, batch_size=1):
    """执行滚动更新"""
    instances = get_service_instances(service_name)
    
    for i in range(0, len(instances), batch_size):
        batch = instances[i:i+batch_size]
        
        print(f"Updating batch: {batch}")
        
        # 更新批次实例
        for instance in batch:
            if not update_instance(instance, new_image):
                print(f"Failed to update {instance}, rolling back...")
                # 实施回滚逻辑
                return False
        
        # 等待批次稳定
        time.sleep(60)
        
        print(f"Batch {batch} updated successfully")
    
    print("Rolling update completed")
    return True

if __name__ == "__main__":
    if len(sys.argv) != 3:
        print("Usage: rolling_update.py <service_name> <new_image>")
        sys.exit(1)
    
    service_name = sys.argv[1]
    new_image = sys.argv[2]
    
    if rolling_update(service_name, new_image):
        print("Update successful")
    else:
        print("Update failed")