伸缩性架构与容器编排

const networkServices = {
  loadBalancing: {
    type: ['Layer 4 (TCP)', 'Layer 7 (HTTP)'],
    algorithms: ['轮询', '加权轮询', '最少连接', 'IP 哈希'],
    tools: ['Nginx', 'HAProxy', 'Envoy', 'Traefik']
  },
  serviceDiscovery: {
    tools: ['Consul', 'Etcd', 'Zookeeper', 'Eureka'],
    mechanism: ['客户端发现', '服务端发现']
  },
  trafficManagement: {
    features: ['流量分割', '金丝雀发布', '蓝绿部署', '熔断降级'],
    tools: ['Istio', 'Linkerd', 'Envoy']
  }
}

# 阶段1: 构建阶段
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
RUN npm run build
 
# 阶段2: 生产阶段（最小化镜像）
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

version: '3.8'
services:
  frontend:
    build: ./frontend
    ports:
      - "80:80"
    depends_on:
      - backend
    networks:
      - app-network
    restart: always
 
  backend:
    build: ./backend
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
    depends_on:
      - db
      - redis
    networks:
      - app-network
    restart: always
 
  db:
    image: postgres:15-alpine
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - app-network
 
  redis:
    image: redis:7-alpine
    networks:
      - app-network
 
networks:
  app-network:
    driver: bridge
volumes:
  postgres-data:

apiVersion: v1
kind: Pod
metadata:
  name: frontend-pod
  labels:
    app: frontend
    tier: web
spec:
  containers:
  - name: nginx
    image: nginx:1.21-alpine
    ports:
    - containerPort: 80
    resources:
      requests:
        memory: "128Mi"
        cpu: "100m"
      limits:
        memory: "256Mi"
        cpu: "200m"
    livenessProbe:
      httpGet:
        path: /health
        port: 80
      initialDelaySeconds: 30
      periodSeconds: 10
    readinessProbe:
      httpGet:
        path: /ready
        port: 80
      initialDelaySeconds: 5
      periodSeconds: 5

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: frontend
        image: my-registry/frontend:v1.0
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "256Mi"
            cpu: "200m"
          limits:
            memory: "512Mi"
            cpu: "500m"
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0

apiVersion: v1
kind: Service
metadata:
  name: frontend-service
spec:
  selector:
    app: frontend
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer  # ClusterIP | NodePort | LoadBalancer

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: frontend-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: frontend-deployment
  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
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 60
      policies:
      - type: Percent
        value: 100
        periodSeconds: 15
      - type: Pods
        value: 4
        periodSeconds: 15
      selectPolicy: Max
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
      - type: Percent
        value: 10
        periodSeconds: 60

const scalingStrategies = {
  // 预测性伸缩：基于历史数据提前扩容
  predictive: {
    method: '基于历史数据预测',
    scenarios: ['定时任务', '促销活动', '节假日'],
    implementation: 'CronJob + HPA'
  },
  // 响应式伸缩：基于实时指标触发
  reactive: {
    method: '基于实时指标伸缩',
    metrics: ['CPU', '内存', 'QPS', '自定义指标'],
    implementation: 'HPA + VPA'
  },
  // 混合伸缩：预测 + 响应式结合
  hybrid: {
    method: '预测 + 响应式结合',
    advantage: '应对突发流量，减少响应延迟',
    implementation: 'KEDA + HPA'
  }
}

class AutoScaler {
  constructor(k8sClient) {
    this.client = k8sClient
  }
 
  async monitorAndScale(deploymentName, namespace = 'default') {
    // 1. 获取当前指标
    const metrics = await this.getMetrics(deploymentName, namespace)
    // 2. 获取当前副本数
    const deployment = await this.client.apis.apps.v1
      .namespaces(namespace).deployments(deploymentName).get()
    const currentReplicas = deployment.body.spec.replicas
 
    // 3. 计算目标副本数
    const cpuUtilization = metrics.cpu.current / metrics.cpu.request
    const targetUtilization = 0.7
    let targetReplicas = Math.ceil(currentReplicas * (cpuUtilization / targetUtilization))
    targetReplicas = Math.max(2, Math.min(targetReplicas, 10))
 
    // 4. 执行伸缩
    if (targetReplicas !== currentReplicas) {
      await this.client.apis.apps.v1
        .namespaces(namespace).deployments(deploymentName)
        .patch({ body: { spec: { replicas: targetReplicas } } })
    }
  }
 
  startMonitoring(deploymentName, interval = 60000) {
    setInterval(() => this.monitorAndScale(deploymentName).catch(console.error), interval)
  }
}

<service-name>.<namespace>.svc.cluster.local

# 三种探针协同工作
livenessProbe:        # 存活探针：失败则重启容器
  httpGet:
    path: /health
    port: 80
  initialDelaySeconds: 30
  periodSeconds: 10
  failureThreshold: 3
 
readinessProbe:       # 就绪探针：失败则从 Service 摘除
  httpGet:
    path: /ready
    port: 80
  initialDelaySeconds: 5
  periodSeconds: 5
 
startupProbe:         # 启动探针：保护慢启动应用
  httpGet:
    path: /health
    port: 80
  periodSeconds: 10
  failureThreshold: 30

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  database_url: "postgresql://db:5432/mydb"
  redis_url: "redis://redis:6379"
  log_level: "info"
---
apiVersion: v1
kind: Secret
metadata:
  name: app-secret
type: Opaque
data:
  database_password: cGFzc3dvcmQxMjM=   # base64 编码
---
# Pod 中引用
apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: my-app:v1
    envFrom:
    - configMapRef:
        name: app-config
    - secretRef:
        name: app-secret

apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-storage
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: standard
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-storage
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
  storageClassName: standard

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
  namespace: ecommerce
spec:
  replicas: 3
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: frontend
        image: registry.example.com/ecommerce/frontend:v1.0
        ports:
        - containerPort: 80
        resources:
          requests:
            cpu: 200m
            memory: 256Mi
          limits:
            cpu: 500m
            memory: 512Mi
        livenessProbe:
          httpGet:
            path: /health
            port: 80
          initialDelaySeconds: 10
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: frontend-hpa
  namespace: ecommerce
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: frontend
  minReplicas: 3
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ecommerce-ingress
  namespace: ecommerce
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: www.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: frontend-service
            port:
              number: 80