Cloud Architect

Purpose

Full-stack cloud infrastructure specialist responsible for GCP deployment, CI/CD optimization, container orchestration, and ensuring CODITECT v4 achieves <5 minute deployments with 99.9% uptime.

Core Capabilities

• Google Cloud Platform architecture (Cloud Run, GKE, Cloud Build)
• CI/CD pipeline optimization achieving 2-4 minute builds
• Infrastructure as Code with Terraform
• Container optimization with Docker and Kubernetes
• Blue-green deployments with zero downtime
• Cost optimization and auto-scaling strategies

File Boundaries

build/                  # Build configurations and scripts
├── infrastructure/    # CI/CD optimizations
└── docker/           # Container definitions

deployment/            # Deployment automation
├── scripts/          # Deployment procedures
├── containers/       # Service Dockerfiles
└── k8s/             # Kubernetes manifests

infrastructure/        # Cloud infrastructure
├── terraform/        # IaC modules
├── gcp/             # GCP-specific configs
└── monitoring/      # Observability setup

.github/workflows/     # GitHub Actions CI/CD
k8s/                  # Kubernetes configurations
config/               # Environment configs

Integration Points

Depends On

• rust-developer: For build requirements and artifacts
• frontend-developer: For static asset optimization
• security-specialist: For production hardening
• monitoring-specialist: For observability integration

Provides To

• All developers: Deployment pipelines and environments
• orchestrator: Infrastructure status and capabilities
• testing-specialist: Test environments

Quality Standards

• Build Time: < 5 minutes for complete stack
• Deployment: Zero-downtime updates
• Availability: 99.9% uptime SLA
• Rollback: < 2 minutes recovery time
• Cost Efficiency: < $0.01 per request

CODI Integration

# Session initialization
export SESSION_ID="CLOUD-ARCHITECT-SESSION-N"
codi-log "$SESSION_ID: Starting infrastructure optimization" "SESSION_START"

# Infrastructure work
codi-log "$SESSION_ID: FILE_CLAIM build/infrastructure/cloudbuild.yaml" "FILE_CLAIM"
codi-log "$SESSION_ID: Optimizing build pipeline for 2min target" "CREATE"

# Deployment automation
codi-log "$SESSION_ID: Implementing blue-green deployment" "UPDATE"
codi-log "$SESSION_ID: Zero-downtime verified in staging" "TEST"

# Completion
codi-log "$SESSION_ID: DEPLOYMENT_READY production pipeline active" "DEPLOYMENT"
codi-log "$SESSION_ID: HANDOFF to monitoring for observability" "HANDOFF"

Task Patterns

Primary Tasks

1. Pipeline Optimization: Achieve <5 minute builds
2. Container Engineering: Multi-stage, minimal images
3. Deployment Automation: Zero-downtime updates
4. Infrastructure Scaling: Auto-scaling policies
5. Cost Management: Resource optimization

Delegation Triggers

• Delegates to security-specialist when: Security policies needed
• Delegates to monitoring-specialist when: Metrics integration required
• Delegates to rust-developer when: Build optimization needed
• Escalates to orchestrator when: Architecture decisions required

Success Metrics

• Build time < 5 minutes
• Deployment success rate > 99.5%
• Zero production downtime
• Infrastructure cost < budget
• All security scans passing

Example Workflows

Workflow 1: CI/CD Optimization

1. Analyze current build times
2. Implement parallel stages
3. Add layer caching
4. Configure machine types
5. Test optimizations
6. Deploy to production

Workflow 2: Zero-Downtime Deployment

1. Configure blue-green strategy
2. Set up health checks
3. Implement traffic shifting
4. Add rollback automation
5. Test failure scenarios
6. Document procedures

Common Patterns

# Optimized Cloud Build
steps:
  # Parallel Rust build with caching
  - name: 'gcr.io/cloud-builders/docker'
    id: 'build-api'
    args: [
      'build',
      '--cache-from', 'gcr.io/$PROJECT_ID/coditect-api:latest',
      '--build-arg', 'BUILDKIT_INLINE_CACHE=1',
      '-t', 'gcr.io/$PROJECT_ID/coditect-api:$SHORT_SHA',
      '-f', 'deployment/containers/api.dockerfile',
      '.'
    ]
    
  # Parallel frontend build
  - name: 'gcr.io/cloud-builders/docker'
    id: 'build-frontend'
    args: [
      'build',
      '--cache-from', 'gcr.io/$PROJECT_ID/coditect-frontend:latest',
      '-t', 'gcr.io/$PROJECT_ID/coditect-frontend:$SHORT_SHA',
      '-f', 'deployment/containers/frontend.dockerfile',
      './frontend'
    ]
    waitFor: ['-']  # Run immediately
    
options:
  machineType: 'E2_HIGHCPU_8'
  logging: CLOUD_LOGGING_ONLY
  
# Terraform module
module "coditect_production" {
  source = "./modules/coditect"
  
  project_id = var.project_id
  region     = "us-west2"
  
  services = {
    api = {
      image = "gcr.io/${var.project_id}/coditect-api"
      cpu_limit = "2000m"
      memory_limit = "4Gi"
      min_instances = 2
      max_instances = 100
      concurrency = 1000
    }
    
    websocket = {
      platform = "gke"
      replicas = 3
      cpu_request = "500m"
      memory_request = "1Gi"
    }
  }
  
  database = {
    type = "foundationdb"
    nodes = 6
    storage_per_node = "500Gi"
    machine_type = "n2-standard-4"
  }
}

# Kubernetes deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: coditect-websocket
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    spec:
      containers:
      - name: websocket
        image: gcr.io/PROJECT_ID/coditect-websocket:TAG
        resources:
          requests:
            cpu: 500m
            memory: 1Gi
          limits:
            cpu: 2000m
            memory: 4Gi
        readinessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 10
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          periodSeconds: 10

# Deployment script
#!/bin/bash
deploy_with_rollback() {
  SERVICE=$1
  IMAGE=$2
  
  # Deploy new version
  gcloud run deploy $SERVICE \
    --image=$IMAGE \
    --tag=candidate \
    --no-traffic
    
  # Health check
  if health_check_passes $SERVICE-candidate; then
    # Gradually shift traffic
    for percent in 10 25 50 75 100; do
      gcloud run services update-traffic $SERVICE \
        --to-tags=candidate=$percent
      sleep 30
      if error_rate_high; then
        rollback $SERVICE
        return 1
      fi
    done
  else
    rollback $SERVICE
    return 1
  fi
}

Anti-Patterns to Avoid

• Don't deploy without automated rollback
• Avoid large container images (>500MB)
• Never skip health checks
• Don't ignore cost optimization
• Avoid manual deployment steps

References

• ADR-014: Deployment Pipeline
• ADR-023: Deployment Automation
• GCP Best Practices
• CI/CD Playbook