05 | 如何从生命周期的视角看待应用运维体系建设？

# SLO Definition CRD示例
apiVersion: reliability/v1
kind: ServiceLevelObjective
metadata:
  name: user-service-slo
  labels:
    application: user-service
    environment: production
spec:
  target: 99.9%  # 月度可用性目标
  backend:
    prometheus:
      service: user-service
      namespace: production
  
  # SLI定义
  indicators:
    availability:
      name: "Service Availability"
      description: "Percentage of successful HTTP requests"
      query: |
        sum(rate(http_requests_total{service="user-service", code!~"5.."}[5m]))
        /
        sum(rate(http_requests_total{service="user-service"}[5m]))
    
    latency:
      name: "Request Latency (p99)"
      description: "99th percentile response time in milliseconds"
      query: |
        histogram_quantile(0.99,
          sum(rate(http_request_duration_seconds_bucket{service="user-service"}[5m]))
          by (le)
        ) * 1000
    
    errorRate:
      name: "Error Rate"
      description: "Percentage of requests returning 5xx errors"
      query: |
        sum(rate(http_requests_total{service="user-service", code=~"5.."}[5m]))
        /
        sum(rate(http_requests_total{service="user-service"}[5m]))

  # Error Budget计算
  errorBudget:
    calculationMethod: rolling  # rolling 或 calendar-based
    window: 30d  # 30天滚动窗口
    
  # 告警规则
  alerting:
    rules:
      - name: BurnRateAlert
        severity: critical
        condition: "error_budget_remaining < 25%"
        action: "Stop all non-essential deployments"
        
      - name: SlowBurnAlert
        severity: warning
        condition: "burn_rate > 2x for 24h"
        action: "Notify on-call, investigate root cause"

  # Dashboard链接
  dashboards:
    overview: https://grafana.company.com/d/user-service-overview
    slo: https://grafana.company.com/d/user-service-slo
    incidents: https://pagerduty.company.com/services/user-service

# Application Creation Request CRD
apiVersion: app.lifecycle/v1
kind: ApplicationCreationRequest
metadata:
  name: new-service-req-001
spec:
  # === 应用基本信息 ===
  application:
    name: recommendation-service
    displayName: "推荐服务"
    description: "基于ML的商品个性化推荐引擎"
    owner:
      team: ml-platform
      email: ml-team@company.com

  # === 关联的基础服务请求 ===
  dependencies:
    databases:
      - name: rec-db
        type: PostgreSQL
        version: "16"
        size: "100Gi"
        tier: gp3
    caches:
      - name: rec-cache
        type: Redis Cluster
        memory: "16Gi"
        nodeCount: 6
    messageQueues:
      - name: user-events
        type: Kafka
        partitions: 12
        replicationFactor: 3
        retentionDays: 7
    objectStorage:
      - name: model-artifacts
        type: S3 Compatible
        size: "500Gi"
        lifecyclePolicy: "Transition to IA after 30 days"

  # === 资源配额申请 ===
  resources:
    namespace: recommendation-service-ns
    quota:
      requests.cpu: "10"
      requests.memory: "20Gi"
      limits.cpu: "40"
      limits.memory: "80Gi"
      pods: "20"
      services: "10"
      secrets: "20"
      configmaps: "20"

  # === 可观测性配置 ===
  observability:
    slo:
      availabilityTarget: "99.9%"
      latencyP99: "500ms"
    tracing:
      enabled: true
      samplingRate: 0.1  # ML服务采样率可适当降低
    logging:
      format: json
      retentionDays: 30

  # === 安全配置 ===
  security:
    networkPolicy: strict
    podSecurityStandard: restricted
    rbac:
      serviceAccountName: recommendation-svc-sa
---
# 自动化审批流程（Argo Workflows示例）
apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  name: app-creation-workflow
spec:
  entrypoint: application-lifecycle
  templates:
  - name: application-lifecycle
    steps:
    - - name: validate-request
        template: validate
    - - name: create-namespace
        template: create-ns
    - - name: provision-database
        template: provision-db
    - - name: provision-cache
        template: provision-redis
    - - name: provision-kafka
        template: provision-kafka
    - - name: setup-monitoring
        template: setup-prometheus
    - - name: register-in-catalog
        template: backstage-register
    - - name: notify-owner
        template: send-notification

  - name: validate
    container:
      image: validator:v1.0
      command: [validate-app-request]
      args: ["{{workflow.parameters.requestFile}}"]

  # ... 其他template定义省略

# Application Retirement Workflow
apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: app-retirement-
spec:
  entrypoint: retire-application
  arguments:
    parameters:
    - name: appName
    - name: gracePeriodDays
      value: "30"

  templates:
  - name: retire-application
    steps:
    - - name: mark-deprecated
        template: update-lifecycle-phase
        arguments:
          parameters:
          - name: phase
            value: deprecated
            
    - - name: notify-stakeholders
        template: send-deprecation-notice
        
    - - name: wait-grace-period
        template: grace-period-wait
        arguments:
          parameters:
          - name: days
            value: "{{workflow.parameters.gracePeriodDays}}"
            
    - - name: scale-to-zero
        template: scale-deployment
        arguments:
          parameters:
          - name: replicas
            value: "0"
            
    - - name: backup-data
        template: final-backup
        
    - - name: cleanup-dependencies
        template: cleanup-resources
        arguments:
          parameters:
          - name: resources
            value: "database,cache,messages,storage,dns,certs,monitoring"
            
    - - name: delete-namespace
        template: delete-ns
        
    - - name: archive-documentation
        template: move-docs-to-archive
        
    - - name: update-catalog
        template: mark-retired
        arguments:
          parameters:
          - name: phase
            value: retired
            
    - - name: send-completion-notice
        template: final-notification

  # ... 各个template的具体实现略

// 示例：Application Lifecycle Controller (Go伪代码)
package v1

import (
    appsv1 "k8s.io/api/apps/v1"
    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// ApplicationLifecyclePhase 定义应用生命周期阶段
type ApplicationLifecyclePhase string

const (
    PhasePlanning     ApplicationLifecyclePhase = "Planning"
    PhaseDevelopment  ApplicationLifecyclePhase = "Development"
    PhaseStaging      ApplicationLifecyclePhase = "Staging"
    PhaseProduction   ApplicationLifecyclePhase = "Production"
    PhaseDeprecation  ApplicationLifecyclePhase = "Deprecation"
    PhaseRetired      ApplicationLifecyclePhase = "Retired"
)

// ApplicationLifecycleSpec 定义应用生命周期规格
type ApplicationLifecycleSpec struct {
    // 当前阶段
    CurrentPhase ApplicationLifecyclePhase `json:"currentPhase"`
    
    // 目标阶段（用于阶段转换）
    TargetPhase ApplicationLifecyclePhase `json:"targetPhase,omitempty"`
    
    // 各阶段的配置
    PhaseConfigs map[ApplicationLifecyclePhase]PhaseConfig `json:"phaseConfigs,omitempty"`
}

// PhaseConfig 定义各阶段的配置
type PhaseConfig struct {
    // 资源配额
    ResourceQuota *corev1.ResourceQuotaSpec `json:"resourceQuota,omitempty"`
    
    // SLO目标
    SLO *SLOConfig `json:"slo,omitempty"`
    
    // 备份策略
    BackupPolicy *BackupPolicy `json:"backupPolicy,omitempty"`
    
    // 网络策略
    NetworkPolicy *NetworkPolicyConfig `json:"networkPolicy,omitempty"`
    
    // 自动扩缩容配置
    Autoscaling *AutoscalingConfig `json:"autoscaling,omitempty"`
}

// Reconcile 是Controller的主调协循环
func (r *ApplicationLifecycleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    // 1. 获取Application实例
    app := &Application{}
    if err := r.Get(ctx, req.NamespacedName, app); err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }

    // 2. 检查是否需要阶段转换
    if app.Spec.TargetPhase != "" && app.Spec.TargetPhase != app.Spec.CurrentPhase {
        return r.transitionPhase(ctx, app)
    }

    // 3. 根据当前阶段执行对应的Reconcile逻辑
    switch app.Spec.CurrentPhase {
    case PhasePlanning:
        return r.reconcilePlanning(ctx, app)
    case PhaseDevelopment:
        return r.reconcileDevelopment(ctx, app)
    case PhaseStaging:
        return r.reconcileStaging(ctx, app)
    case PhaseProduction:
        return r.reconcileProduction(ctx, app)
    case PhaseDeprecation:
        return r.reconcileDeprecation(ctx, app)
    case PhaseRetired:
        return r.reconcileRetired(ctx, app)
    default:
        return ctrl.Result{}, fmt.Errorf("unknown phase: %s", app.Spec.CurrentPhase)
    }
}