Deployment & Lifecycle Service

# .sindhan/pipeline.yaml - Pipeline configuration
apiVersion: pipeline/v1
kind: Pipeline
metadata:
  name: user-service-pipeline
  application: user-service
  team: platform-team
 
spec:
  # Source configuration
  source:
    repository: github.com/sindhan-ai/user-service
    branch_patterns:
      - main
      - release/*
      - feature/*
    webhook_secret: ${WEBHOOK_SECRET}
 
  # Build configuration
  build:
    dockerfile: Dockerfile
    context: .
    build_args:
      - NODE_ENV=production
      - API_VERSION=${VERSION}
    platforms:
      - linux/amd64
      - linux/arm64
    
    # Build steps
    steps:
      - name: install-dependencies
        image: node:18-alpine
        commands:
          - npm ci --only=production
          - npm audit --audit-level=moderate
      
      - name: run-tests
        image: node:18-alpine
        commands:
          - npm run test:unit
          - npm run test:integration
        artifacts:
          - coverage/
          - test-results.xml
      
      - name: security-scan
        image: sindhan/security-scanner:latest
        commands:
          - security-scan --source . --format json --output security-report.json
        artifacts:
          - security-report.json
      
      - name: quality-gate
        image: sindhan/quality-gate:latest
        commands:
          - quality-gate --coverage-threshold 80 --security-threshold high
        depends_on:
          - run-tests
          - security-scan
 
  # Deployment configuration
  deployment:
    environments:
      - name: development
        auto_deploy: true
        branch_filter: feature/*
        cluster: dev-cluster
        namespace: dev-user-service
        
      - name: staging
        auto_deploy: true
        branch_filter: main
        cluster: staging-cluster
        namespace: staging-user-service
        approval_required: false
        
      - name: production
        auto_deploy: false
        branch_filter: main
        cluster: prod-cluster
        namespace: prod-user-service
        approval_required: true
        approvers:
          - platform-team
          - security-team
        
        # Production deployment strategy
        strategy:
          type: blue-green
          health_check:
            path: /health
            interval: 30s
            timeout: 10s
            success_threshold: 3
          
          canary:
            enabled: true
            steps:
              - traffic_percentage: 10
                duration: 10m
              - traffic_percentage: 50
                duration: 20m
              - traffic_percentage: 100
 
  # Notification configuration
  notifications:
    channels:
      - type: slack
        webhook: ${SLACK_WEBHOOK}
        events: [build_failed, deployment_failed, deployment_success]
        mentions: ["@platform-team"]
      
      - type: email
        recipients: [platform-team@sindhan.ai]
        events: [production_deployment_success, production_deployment_failed]
 
  # Security and compliance
  security:
    vulnerability_scanning: true
    compliance_checks:
      - soc2
      - gdpr
    secret_scanning: true
    container_scanning: true

import asyncio
import yaml
from typing import Dict, Any, List, Optional
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
import kubernetes
from kubernetes import client, config
 
class DeploymentStatus(Enum):
    PENDING = "pending"
    IN_PROGRESS = "in_progress"
    SUCCESS = "success"
    FAILED = "failed"
    ROLLING_BACK = "rolling_back"
    ROLLED_BACK = "rolled_back"
 
class DeploymentStrategy(Enum):
    ROLLING_UPDATE = "rolling_update"
    BLUE_GREEN = "blue_green"
    CANARY = "canary"
    RECREATE = "recreate"
 
@dataclass
class DeploymentRequest:
    application: str
    version: str
    environment: str
    strategy: DeploymentStrategy
    configuration: Dict[str, Any]
    secrets: Dict[str, str] = field(default_factory=dict)
    health_check: Dict[str, Any] = field(default_factory=dict)
    rollback_on_failure: bool = True
    approval_required: bool = False
    approvers: List[str] = field(default_factory=list)
 
@dataclass
class DeploymentExecution:
    deployment_id: str
    request: DeploymentRequest
    status: DeploymentStatus
    started_at: datetime
    completed_at: Optional[datetime] = None
    current_step: str = ""
    logs: List[str] = field(default_factory=list)
    health_status: Dict[str, Any] = field(default_factory=dict)
    rollback_deployment_id: Optional[str] = None
 
class DeploymentEngine:
    def __init__(self, config: Dict[str, Any]):
        self.config = config
        self.kubernetes_client = self._initialize_k8s_client()
        self.active_deployments = {}
        self.deployment_history = {}
        
        # Initialize components
        self.strategy_handlers = {
            DeploymentStrategy.ROLLING_UPDATE: self._handle_rolling_update,
            DeploymentStrategy.BLUE_GREEN: self._handle_blue_green,
            DeploymentStrategy.CANARY: self._handle_canary,
            DeploymentStrategy.RECREATE: self._handle_recreate
        }
    
    def _initialize_k8s_client(self):
        """Initialize Kubernetes client"""
        try:
            config.load_incluster_config()  # For in-cluster execution
        except:
            config.load_kube_config()  # For local development
        
        return client.ApiClient()
    
    async def deploy(self, request: DeploymentRequest) -> str:
        """Initiate application deployment"""
        deployment_id = f"{request.application}-{request.version}-{int(datetime.utcnow().timestamp())}"
        
        execution = DeploymentExecution(
            deployment_id=deployment_id,
            request=request,
            status=DeploymentStatus.PENDING,
            started_at=datetime.utcnow()
        )
        
        self.active_deployments[deployment_id] = execution
        
        # Start deployment process
        asyncio.create_task(self._execute_deployment(deployment_id))
        
        return deployment_id
    
    async def _execute_deployment(self, deployment_id: str):
        """Execute deployment process"""
        execution = self.active_deployments[deployment_id]
        request = execution.request
        
        try:
            execution.status = DeploymentStatus.IN_PROGRESS
            execution.current_step = "pre_deployment_validation"
            
            # Pre-deployment validation
            await self._validate_deployment_request(request)
            execution.logs.append(f"Deployment validation completed successfully")
            
            # Check for approval requirement
            if request.approval_required:
                execution.current_step = "waiting_for_approval"
                execution.logs.append(f"Waiting for approval from: {', '.join(request.approvers)}")
                
                approved = await self._wait_for_approval(deployment_id)
                if not approved:
                    raise Exception("Deployment not approved within timeout period")
            
            # Prepare deployment
            execution.current_step = "preparing_deployment"
            await self._prepare_deployment(request)
            execution.logs.append(f"Deployment preparation completed")
            
            # Execute deployment strategy
            execution.current_step = f"executing_{request.strategy.value}"
            strategy_handler = self.strategy_handlers[request.strategy]
            await strategy_handler(execution)
            
            # Post-deployment validation
            execution.current_step = "post_deployment_validation"
            health_status = await self._validate_deployment_health(request)
            execution.health_status = health_status
            
            if health_status['healthy']:
                execution.status = DeploymentStatus.SUCCESS
                execution.logs.append(f"Deployment completed successfully")
            else:
                raise Exception(f"Health check failed: {health_status['error']}")
        
        except Exception as e:
            execution.status = DeploymentStatus.FAILED
            execution.logs.append(f"Deployment failed: {str(e)}")
            
            # Automatic rollback if enabled
            if request.rollback_on_failure:
                await self._initiate_rollback(deployment_id)
        
        finally:
            execution.completed_at = datetime.utcnow()
            await self._cleanup_deployment_resources(deployment_id)
            
            # Move to history
            self.deployment_history[deployment_id] = execution
            if deployment_id in self.active_deployments:
                del self.active_deployments[deployment_id]
    
    async def _handle_blue_green(self, execution: DeploymentExecution):
        """Handle blue/green deployment strategy"""
        request = execution.request
        
        # Get current active deployment (blue)
        current_deployment = await self._get_current_deployment(request.application, request.environment)
        
        # Create new deployment (green)
        execution.logs.append("Creating green deployment")
        green_deployment = await self._create_green_deployment(request)
        
        # Wait for green deployment to be ready
        execution.logs.append("Waiting for green deployment to be ready")
        await self._wait_for_deployment_ready(green_deployment)
        
        # Perform health checks on green deployment
        execution.logs.append("Performing health checks on green deployment")
        health_status = await self._check_deployment_health(green_deployment, request.health_check)
        
        if not health_status['healthy']:
            # Cleanup green deployment and fail
            await self._cleanup_deployment(green_deployment)
            raise Exception(f"Green deployment health check failed: {health_status['error']}")
        
        # Switch traffic to green deployment
        execution.logs.append("Switching traffic to green deployment")
        await self._switch_traffic(request.application, request.environment, green_deployment)
        
        # Verify traffic switch success
        execution.logs.append("Verifying traffic switch")
        await asyncio.sleep(30)  # Grace period
        
        final_health = await self._check_deployment_health(green_deployment, request.health_check)
        if not final_health['healthy']:
            # Rollback traffic to blue
            await self._switch_traffic(request.application, request.environment, current_deployment)
            raise Exception(f"Post-switch health check failed: {final_health['error']}")
        
        # Cleanup old blue deployment
        execution.logs.append("Cleaning up blue deployment")
        if current_deployment:
            await self._cleanup_deployment(current_deployment)
        
        execution.logs.append("Blue/green deployment completed successfully")
    
    async def _handle_canary(self, execution: DeploymentExecution):
        """Handle canary deployment strategy"""
        request = execution.request
        canary_config = request.configuration.get('canary', {})
        steps = canary_config.get('steps', [{'traffic_percentage': 100}])
        
        # Create canary deployment
        execution.logs.append("Creating canary deployment")
        canary_deployment = await self._create_canary_deployment(request)
        
        # Wait for canary to be ready
        await self._wait_for_deployment_ready(canary_deployment)
        
        # Execute canary steps
        for i, step in enumerate(steps):
            traffic_percentage = step['traffic_percentage']
            duration = step.get('duration', '5m')
            
            execution.logs.append(f"Canary step {i+1}: {traffic_percentage}% traffic")
            
            # Route percentage of traffic to canary
            await self._route_canary_traffic(
                request.application, 
                request.environment, 
                canary_deployment, 
                traffic_percentage
            )
            
            # Monitor for specified duration
            await self._monitor_canary(canary_deployment, duration, request.health_check)
            
            # Check if we should continue or abort
            health_status = await self._check_deployment_health(canary_deployment, request.health_check)
            if not health_status['healthy']:
                # Abort canary and rollback
                await self._abort_canary(request.application, request.environment)
                raise Exception(f"Canary health check failed at {traffic_percentage}%: {health_status['error']}")
        
        # Promote canary to full deployment
        execution.logs.append("Promoting canary to full deployment")
        await self._promote_canary(request.application, request.environment, canary_deployment)
        
        execution.logs.append("Canary deployment completed successfully")
    
    async def _create_kubernetes_deployment(self, request: DeploymentRequest, 
                                           deployment_suffix: str = "") -> Dict[str, Any]:
        """Create Kubernetes deployment"""
        deployment_name = f"{request.application}{deployment_suffix}"
        
        deployment_spec = {
            'apiVersion': 'apps/v1',
            'kind': 'Deployment',
            'metadata': {
                'name': deployment_name,
                'namespace': request.environment,
                'labels': {
                    'app': request.application,
                    'version': request.version,
                    'deployment-strategy': request.strategy.value
                }
            },
            'spec': {
                'replicas': request.configuration.get('replicas', 3),
                'selector': {
                    'matchLabels': {
                        'app': request.application,
                        'version': request.version
                    }
                },
                'template': {
                    'metadata': {
                        'labels': {
                            'app': request.application,
                            'version': request.version
                        }
                    },
                    'spec': {
                        'containers': [{
                            'name': request.application,
                            'image': f"{request.application}:{request.version}",
                            'ports': [{
                                'containerPort': request.configuration.get('port', 8080)
                            }],
                            'env': [
                                {'name': k, 'value': str(v)} 
                                for k, v in request.configuration.get('env', {}).items()
                            ],
                            'resources': request.configuration.get('resources', {
                                'requests': {'memory': '256Mi', 'cpu': '100m'},
                                'limits': {'memory': '512Mi', 'cpu': '500m'}
                            }),
                            'livenessProbe': {
                                'httpGet': {
                                    'path': request.health_check.get('path', '/health'),
                                    'port': request.configuration.get('port', 8080)
                                },
                                'initialDelaySeconds': 30,
                                'periodSeconds': 10
                            },
                            'readinessProbe': {
                                'httpGet': {
                                    'path': request.health_check.get('path', '/health'),
                                    'port': request.configuration.get('port', 8080)
                                },
                                'initialDelaySeconds': 5,
                                'periodSeconds': 5
                            }
                        }]
                    }
                }
            }
        }
        
        # Create deployment
        apps_v1 = client.AppsV1Api(self.kubernetes_client)
        deployment = apps_v1.create_namespaced_deployment(
            namespace=request.environment,
            body=deployment_spec
        )
        
        return {
            'name': deployment_name,
            'namespace': request.environment,
            'deployment': deployment
        }
 
# Usage example
deployment_config = {
    'kubernetes_config_path': '/etc/kubernetes/config',
    'default_timeout': 600,  # 10 minutes
    'health_check_retries': 3
}
 
# Initialize deployment engine
engine = DeploymentEngine(deployment_config)
 
# Create deployment request
deployment_request = DeploymentRequest(
    application='user-service',
    version='v1.2.3',
    environment='production',
    strategy=DeploymentStrategy.BLUE_GREEN,
    configuration={
        'replicas': 5,
        'port': 8080,
        'env': {
            'DATABASE_URL': 'postgres://prod-db:5432/users',
            'REDIS_URL': 'redis://prod-redis:6379'
        },
        'resources': {
            'requests': {'memory': '512Mi', 'cpu': '200m'},
            'limits': {'memory': '1Gi', 'cpu': '1000m'}
        }
    },
    health_check={
        'path': '/health',
        'interval': '30s',
        'timeout': '10s',
        'success_threshold': 3
    },
    approval_required=True,
    approvers=['platform-team', 'security-team']
)
 
# Execute deployment
deployment_id = await engine.deploy(deployment_request)
print(f"Deployment started: {deployment_id}")
 
# Monitor deployment progress
while True:
    status = await engine.get_deployment_status(deployment_id)
    print(f"Status: {status.status.value} - Step: {status.current_step}")
    
    if status.status in [DeploymentStatus.SUCCESS, DeploymentStatus.FAILED]:
        break
    
    await asyncio.sleep(10)
 
print(f"Deployment {status.status.value}")
for log in status.logs:
    print(f"  {log}")