[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6JDRA52972D6R4EWZ1R24Q6":3,"skill-same:01M6JDRA52972D6R4EWZ1R24Q6":69},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":37,"linkOnly":38,"markdownContent":39,"markdownBody":40,"frontMatter":41,"refName":42,"commitSha":43,"skillDirectory":44,"forksCount":13,"repositoryHtmlUrl":45,"repositoryHomepageUrl":6,"ownerHtmlUrl":46,"ownerBlogUrl":6,"ownerDescription":47,"updatedAt":48,"install":49,"resources":62},"01M6JDRA52972D6R4EWZ1R24Q6","cloud-native",null,"Generic Cloud-Native Deployment and Infrastructure as Code patterns for 2025. Provides comprehensive implementation strategies for multi-cloud deployments, GitOps workflows, progressive delivery, and platform engineering. Framework-agnostic approach supporting any cloud provider, deployment tool, and orchestration platform.","superhealth\u002Fskills-hub","superhealth","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F6292112?v=4","01M6JA6E7F21BYK5W3E4P270TT","01M6JA6EC0W8MPHKDJVBZDSEZ0",0,"MIT","https:\u002F\u002Fgithub.com\u002Fsuperhealth\u002Fskills-hub\u002Fblob\u002Fmaster\u002Fskills\u002Fazeem-2\u002Fcloud-native\u002FSKILL.md",[],[18,19,20,21,22,23,24,25,26,27,28,29,30,31,5,32,33,34,35,36],"cloud native","cloud","native","provider","for","framework-agnostic","code patterns","2025","as","platform","platform engineering","gitops","orchestration","deployments","tool","multi-cloud","infrastructure as code","deployment","workflows","2026-11-10 10:12:30",false,"---\nname: cloud-native\ndescription: Generic Cloud-Native Deployment and Infrastructure as Code patterns for 2025. Provides comprehensive implementation strategies for multi-cloud deployments, GitOps workflows, progressive delivery, and platform engineering. Framework-agnostic approach supporting any cloud provider, deployment tool, and orchestration platform.\nlicense: MIT\n---\n\n# Cloud-Native Deployment & Infrastructure Patterns\n\nThis skill provides comprehensive patterns for implementing cloud-native deployments using modern Infrastructure as Code, GitOps workflows, and progressive delivery strategies. The patterns are designed to be framework-agnostic and applicable across any cloud provider or orchestration platform.\n\n## When to Use This Skill\n\nUse this skill when you need to:\n- Implement Infrastructure as Code with any provider (Terraform, Pulumi, CDK)\n- Build GitOps workflows with Argo CD, Flux, or similar tools\n- Create multi-cloud or hybrid deployment strategies\n- Implement progressive delivery (canary, blue-green)\n- Build internal developer platforms\n- Set up policy as code and compliance automation\n- Implement zero-trust security architectures\n- Create disaster recovery and failover strategies\n- Optimize costs across multiple providers\n- Build observability into deployments\n\n## 1. Infrastructure as Code Patterns\n\n### Generic IaC Abstraction Layer\n\n```python\n# iac\u002Fcore\u002Fabstraction.py\nfrom abc import ABC, abstractmethod\nfrom typing import Dict, List, Any, Optional, Union\nfrom dataclasses import dataclass, field\nfrom enum import Enum\nfrom pathlib import Path\nimport json\nimport yaml\nimport asyncio\nfrom datetime import datetime\n\nclass IaCProvider(str, Enum):\n    \"\"\"Supported IaC providers\"\"\"\n    TERRAFORM = \"terraform\"\n    PULUMI = \"pulumi\"\n    CDK = \"cdk\"\n    CROSSPLANE = \"crossplane\"\n\nclass CloudProvider(str, Enum):\n    \"\"\"Cloud providers\"\"\"\n    AWS = \"aws\"\n    AZURE = \"azure\"\n    GCP = \"gcp\"\n    DIGITALOCEAN = \"digitalocean\"\n    ON_PREM = \"on-prem\"\n\n@dataclass\nclass Resource:\n    \"\"\"Generic resource definition\"\"\"\n    type: str\n    name: str\n    properties: Dict[str, Any] = field(default_factory=dict)\n    dependencies: List[str] = field(default_factory=list)\n    provider: Optional[CloudProvider] = None\n    tags: Dict[str, str] = field(default_factory=dict)\n\n@dataclass\nclass InfrastructureConfig:\n    \"\"\"Infrastructure configuration\"\"\"\n    name: str\n    environment: str\n    provider: CloudProvider\n    region: str\n    resources: List[Resource] = field(default_factory=list)\n    variables: Dict[str, Any] = field(default_factory=dict)\n    outputs: Dict[str, str] = field(default_factory=dict)\n\nclass IaCBackend(ABC):\n    \"\"\"Abstract IaC backend interface\"\"\"\n\n    @abstractmethod\n    async def initialize(self, config: InfrastructureConfig) -> None:\n        \"\"\"Initialize IaC backend\"\"\"\n        pass\n\n    @abstractmethod\n    async def plan(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Generate execution plan\"\"\"\n        pass\n\n    @abstractmethod\n    async def apply(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Apply infrastructure changes\"\"\"\n        pass\n\n    @abstractmethod\n    async def destroy(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Destroy infrastructure\"\"\"\n        pass\n\n    @abstractmethod\n    async def output(self, config: InfrastructureConfig, key: str) -> Any:\n        \"\"\"Get output value\"\"\"\n        pass\n\n    @abstractmethod\n    async def validate(self, config: InfrastructureConfig) -> List[str]:\n        \"\"\"Validate configuration\"\"\"\n        pass\n\nclass TerraformBackend(IaCBackend):\n    \"\"\"Terraform backend implementation\"\"\"\n\n    def __init__(self, working_dir: Path):\n        self.working_dir = working_dir\n        self.state_backend: Optional[str] = None\n\n    async def initialize(self, config: InfrastructureConfig) -> None:\n        \"\"\"Initialize Terraform\"\"\"\n        # Generate Terraform files\n        await self._generate_terraform_files(config)\n\n        # Run terraform init\n        cmd = [\"terraform\", \"init\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] != 0:\n            raise RuntimeError(f\"Terraform init failed: {result['stderr']}\")\n\n    async def plan(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Generate Terraform plan\"\"\"\n        cmd = [\"terraform\", \"plan\", \"-out=tfplan\", \"-json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return {\n            \"success\": result[\"returncode\"] == 0,\n            \"plan_file\": self.working_dir \u002F \"tfplan\",\n            \"output\": result[\"stdout\"],\n            \"changes\": json.loads(result[\"stdout\"]) if result[\"stdout\"] else {}\n        }\n\n    async def apply(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Apply Terraform changes\"\"\"\n        cmd = [\"terraform\", \"apply\", \"-auto-approve\", \"-json\", \"tfplan\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return {\n            \"success\": result[\"returncode\"] == 0,\n            \"output\": result[\"stdout\"],\n            \"applied_at\": datetime.utcnow().isoformat()\n        }\n\n    async def destroy(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Destroy Terraform resources\"\"\"\n        cmd = [\"terraform\", \"destroy\", \"-auto-approve\", \"-json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return {\n            \"success\": result[\"returncode\"] == 0,\n            \"output\": result[\"stdout\"],\n            \"destroyed_at\": datetime.utcnow().isoformat()\n        }\n\n    async def output(self, config: InfrastructureConfig, key: str) -> Any:\n        \"\"\"Get Terraform output\"\"\"\n        cmd = [\"terraform\", \"output\", \"-json\", key]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] == 0:\n            return json.loads(result[\"stdout\"])\n        return None\n\n    async def validate(self, config: InfrastructureConfig) -> List[str]:\n        \"\"\"Validate Terraform configuration\"\"\"\n        errors = []\n\n        # Run terraform validate\n        cmd = [\"terraform\", \"validate\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] != 0:\n            errors.append(f\"Validation failed: {result['stderr']}\")\n\n        # Run terraform fmt check\n        cmd = [\"terraform\", \"fmt\", \"-check\", \"-diff\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] != 0:\n            errors.append(\"Formatting check failed - run terraform fmt\")\n\n        # Check for required variables\n        cmd = [\"terraform\", \"validate\", \"-json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return errors\n\n    async def _generate_terraform_files(self, config: InfrastructureConfig) -> None:\n        \"\"\"Generate Terraform configuration files\"\"\"\n        # Generate main.tf\n        main_tf = {\n            \"terraform\": {\n                \"required_providers\": self._get_required_providers(config.provider),\n                \"backend\": self._get_backend_config()\n            },\n            \"provider\": {config.provider.value: self._get_provider_config(config)},\n            \"resource\": self._convert_resources(config.resources)\n        }\n\n        with open(self.working_dir \u002F \"main.tf\", \"w\") as f:\n            yaml.dump(main_tf, f, sort_keys=False)\n\n        # Generate variables.tf\n        if config.variables:\n            variables_tf = {\n                \"variable\": {\n                    k: {\"type\": self._infer_type(v), \"default\": v}\n                    for k, v in config.variables.items()\n                }\n            }\n\n            with open(self.working_dir \u002F \"variables.tf\", \"w\") as f:\n                yaml.dump(variables_tf, f, sort_keys=False)\n\n        # Generate outputs.tf\n        if config.outputs:\n            outputs_tf = {\n                \"output\": {\n                    k: {\"value\": v}\n                    for k, v in config.outputs.items()\n                }\n            }\n\n            with open(self.working_dir \u002F \"outputs.tf\", \"w\") as f:\n                yaml.dump(outputs_tf, f, sort_keys=False)\n\n    async def _run_command(self, cmd: List[str], cwd: Path) -> Dict[str, Any]:\n        \"\"\"Run command and return result\"\"\"\n        process = await asyncio.create_subprocess_exec(\n            *cmd,\n            cwd=cwd,\n            stdout=asyncio.subprocess.PIPE,\n            stderr=asyncio.subprocess.PIPE\n        )\n\n        stdout, stderr = await process.communicate()\n\n        return {\n            \"returncode\": process.returncode,\n            \"stdout\": stdout.decode(),\n            \"stderr\": stderr.decode()\n        }\n\n    def _get_required_providers(self, provider: CloudProvider) -> Dict[str, Any]:\n        \"\"\"Get required providers configuration\"\"\"\n        providers = {}\n\n        if provider == CloudProvider.AWS:\n            providers[\"aws\"] = {\"source\": \"hashicorp\u002Faws\", \"version\": \"~> 5.0\"}\n        elif provider == CloudProvider.AZURE:\n            providers[\"azurerm\"] = {\"source\": \"hashicorp\u002Fazurerm\", \"version\": \"~> 3.0\"}\n        elif provider == CloudProvider.GCP:\n            providers[\"google\"] = {\"source\": \"hashicorp\u002Fgoogle\", \"version\": \"~> 5.0\"}\n\n        return providers\n\n    def _get_backend_config(self) -> Dict[str, Any]:\n        \"\"\"Get Terraform backend configuration\"\"\"\n        if self.state_backend:\n            return {\"s3\": self.state_backend}\n        return {}\n\n    def _get_provider_config(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Get provider-specific configuration\"\"\"\n        base_config = {\"region\": config.region}\n\n        # Add provider-specific settings\n        if config.provider == CloudProvider.AWS:\n            base_config[\"default_tags\"] = {\n                \"tags\": {\n                    \"Environment\": config.environment,\n                    \"ManagedBy\": \"terraform\",\n                    \"Project\": config.name\n                }\n            }\n\n        return base_config\n\n    def _convert_resources(self, resources: List[Resource]) -> Dict[str, Any]:\n        \"\"\"Convert generic resources to Terraform format\"\"\"\n        terraform_resources = {}\n\n        for resource in resources:\n            resource_key = f\"{resource.type}_{resource.name}\"\n\n            resource_config = {\n                \"provider\": resource.provider.value if resource.provider else None,\n                **resource.properties\n            }\n\n            if resource.tags:\n                resource_config[\"tags\"] = resource.tags\n\n            terraform_resources[resource_key] = resource_config\n\n        return terraform_resources\n\n    def _infer_type(self, value: Any) -> str:\n        \"\"\"Infer Terraform variable type from value\"\"\"\n        if isinstance(value, bool):\n            return \"bool\"\n        elif isinstance(value, int):\n            return \"number\"\n        elif isinstance(value, list):\n            return \"list(string)\"\n        elif isinstance(value, dict):\n            return \"map(string)\"\n        else:\n            return \"string\"\n\nclass PulumiBackend(IaCBackend):\n    \"\"\"Pulumi backend implementation\"\"\"\n\n    def __init__(self, working_dir: Path, language: str = \"python\"):\n        self.working_dir = working_dir\n        self.language = language\n\n    async def initialize(self, config: InfrastructureConfig) -> None:\n        \"\"\"Initialize Pulumi\"\"\"\n        # Generate Pulumi program\n        await self._generate_pulumi_program(config)\n\n        # Run pulumi stack init\n        cmd = [\"pulumi\", \"stack\", \"init\", f\"{config.name}-{config.environment}\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] != 0:\n            raise RuntimeError(f\"Pulumi stack init failed: {result['stderr']}\")\n\n    async def plan(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Preview Pulumi changes\"\"\"\n        cmd = [\"pulumi\", \"preview\", \"--json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return {\n            \"success\": result[\"returncode\"] == 0,\n            \"output\": result[\"stdout\"],\n            \"changes\": json.loads(result[\"stdout\"]) if result[\"stdout\"] else {}\n        }\n\n    async def apply(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Apply Pulumi changes\"\"\"\n        cmd = [\"pulumi\", \"up\", \"--yes\", \"--json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return {\n            \"success\": result[\"returncode\"] == 0,\n            \"output\": result[\"stdout\"],\n            \"applied_at\": datetime.utcnow().isoformat()\n        }\n\n    async def destroy(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Destroy Pulumi resources\"\"\"\n        cmd = [\"pulumi\", \"destroy\", \"--yes\", \"--json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return {\n            \"success\": result[\"returncode\"] == 0,\n            \"output\": result[\"stdout\"],\n            \"destroyed_at\": datetime.utcnow().isoformat()\n        }\n\n    async def output(self, config: InfrastructureConfig, key: str) -> Any:\n        \"\"\"Get Pulumi stack output\"\"\"\n        cmd = [\"pulumi\", \"stack\", \"output\", \"--json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] == 0:\n            outputs = json.loads(result[\"stdout\"])\n            return outputs.get(key)\n        return None\n\n    async def validate(self, config: InfrastructureConfig) -> List[str]:\n        \"\"\"Validate Pulumi configuration\"\"\"\n        errors = []\n\n        # Run pulumi config validate\n        cmd = [\"pulumi\", \"config\", \"validate\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] != 0:\n            errors.append(f\"Validation failed: {result['stderr']}\")\n\n        return errors\n\n    async def _generate_pulumi_program(self, config: InfrastructureConfig) -> None:\n        \"\"\"Generate Pulumi program based on language\"\"\"\n        if self.language == \"python\":\n            await self._generate_python_program(config)\n        elif self.language == \"typescript\":\n            await self._generate_typescript_program(config)\n\n    async def _generate_python_program(self, config: InfrastructureConfig) -> None:\n        \"\"\"Generate Python Pulumi program\"\"\"\n        program = f'''\"\"\"\nPulumi program for {config.name} - {config.environment}\n\"\"\"\n\nimport pulumi\nimport pulumi_{config.provider.value} as provider\n\n# Configuration\nconfig = pulumi.Config()\n\n# Resources\n'''\n\n        # Generate resources\n        for resource in config.resources:\n            provider_module = f\"provider.{resource.type.replace('_', '.')}\"\n            program += f'''\n{resource.name}_resource = {provider_module}.{resource.title()}(\n    \"{resource.name}\",\n'''\n\n            # Add properties\n            for key, value in resource.properties.items():\n                if isinstance(value, str):\n                    program += f'    {key}=\"{value}\",\\n'\n                else:\n                    program += f'    {key}={value},\\n'\n\n            # Add tags if present\n            if resource.tags:\n                program += f'    tags={resource.tags},\\n'\n\n            program += ')\\n\\n'\n\n        # Generate outputs\n        for key, value in config.outputs.items():\n            program += f'pulumi.export(\"{key}\", {value})\\n'\n\n        # Write program file\n        with open(self.working_dir \u002F \"__main__.py\", \"w\") as f:\n            f.write(program)\n\n        # Generate requirements.txt\n        with open(self.working_dir \u002F \"requirements.txt\", \"w\") as f:\n            f.write(f\"pulumi>={config.provider.value}\\n\")\n\n    async def _run_command(self, cmd: List[str], cwd: Path) -> Dict[str, Any]:\n        \"\"\"Run command and return result\"\"\"\n        process = await asyncio.create_subprocess_exec(\n            *cmd,\n            cwd=cwd,\n            stdout=asyncio.subprocess.PIPE,\n            stderr=asyncio.subprocess.PIPE\n        )\n\n        stdout, stderr = await process.communicate()\n\n        return {\n            \"returncode\": process.returncode,\n            \"stdout\": stdout.decode(),\n            \"stderr\": stderr.decode()\n        }\n\n# Factory for creating IaC backends\nclass IaCFactory:\n    \"\"\"Factory for creating IaC backends\"\"\"\n\n    @staticmethod\n    def create(\n        provider: IaCProvider,\n        working_dir: Path,\n        **kwargs\n    ) -> IaCBackend:\n        \"\"\"Create IaC backend instance\"\"\"\n\n        working_dir.mkdir(parents=True, exist_ok=True)\n\n        if provider == IaCProvider.TERRAFORM:\n            return TerraformBackend(working_dir)\n        elif provider == IaCProvider.PULUMI:\n            return PulumiBackend(\n                working_dir,\n                language=kwargs.get(\"language\", \"python\")\n            )\n        else:\n            raise ValueError(f\"Unsupported IaC provider: {provider}\")\n```\n\n### Multi-Cloud Resource Manager\n\n```python\n# iac\u002Fmulticloud\u002Fmanager.py\nfrom typing import Dict, List, Any, Optional\nfrom dataclasses import dataclass\nimport asyncio\nfrom ..core.abstraction import (\n    InfrastructureConfig, Resource, CloudProvider, IaCBackend\n)\n\n@dataclass\nclass CloudDeployment:\n    \"\"\"Cloud deployment configuration\"\"\"\n    provider: CloudProvider\n    region: str\n    environment: str\n    resources: List[Resource]\n    priority: int = 0  # Higher priority = primary deployment\n    enabled: bool = True\n\nclass MultiCloudManager:\n    \"\"\"Manages deployments across multiple cloud providers\"\"\"\n\n    def __init__(self):\n        self.deployments: Dict[str, CloudDeployment] = {}\n        self.backends: Dict[str, IaCBackend] = {}\n        self.global_resources: List[Resource] = []\n        self.shared_state: Dict[str, Any] = {}\n\n    def add_deployment(self, name: str, deployment: CloudDeployment) -> None:\n        \"\"\"Add a cloud deployment\"\"\"\n        self.deployments[name] = deployment\n\n    def add_global_resource(self, resource: Resource) -> None:\n        \"\"\"Add a global resource (DNS, CDN, etc.)\"\"\"\n        self.global_resources.append(resource)\n\n    async def deploy_all(self) -> Dict[str, Any]:\n        \"\"\"Deploy to all configured clouds\"\"\"\n        results = {}\n\n        # Sort by priority (primary deployments first)\n        sorted_deployments = sorted(\n            self.deployments.items(),\n            key=lambda x: x[1].priority,\n            reverse=True\n        )\n\n        for name, deployment in sorted_deployments:\n            if not deployment.enabled:\n                continue\n\n            print(f\"Deploying to {name} ({deployment.provider.value})...\")\n\n            try:\n                result = await self._deploy_single(name, deployment)\n                results[name] = result\n\n                # Store shared outputs\n                if result[\"success\"]:\n                    self.shared_state[name] = result.get(\"outputs\", {})\n\n            except Exception as e:\n                results[name] = {\n                    \"success\": False,\n                    \"error\": str(e)\n                }\n                print(f\"Failed to deploy to {name}: {e}\")\n\n        return results\n\n    async def _deploy_single(\n        self,\n        name: str,\n        deployment: CloudDeployment\n    ) -> Dict[str, Any]:\n        \"\"\"Deploy to a single cloud provider\"\"\"\n\n        # Create IaC config\n        config = InfrastructureConfig(\n            name=name,\n            environment=deployment.environment,\n            provider=deployment.provider,\n            region=deployment.region,\n            resources=self._merge_resources(deployment),\n            variables=self._get_variables(deployment)\n        )\n\n        # Get or create backend\n        if name not in self.backends:\n            from ..core.abstraction import IaCFactory, IaCProvider\n            backend = IaCFactory.create(\n                IaCProvider.TERRAFORM,\n                Path(f\"iac\u002F{name}\")\n            )\n            self.backends[name] = backend\n\n        backend = self.backends[name]\n\n        # Initialize and deploy\n        await backend.initialize(config)\n\n        # Plan\n        plan = await backend.plan(config)\n        if not plan[\"success\"]:\n            return {\"success\": False, \"error\": \"Plan failed\"}\n\n        # Apply\n        apply_result = await backend.apply(config)\n\n        # Get outputs\n        outputs = {}\n        for key in deployment.resources:\n            if hasattr(key, 'name'):\n                output_value = await backend.output(config, key.name)\n                if output_value:\n                    outputs[key.name] = output_value\n\n        return {\n            \"success\": apply_result[\"success\"],\n            \"outputs\": outputs,\n            \"deployment_info\": {\n                \"provider\": deployment.provider.value,\n                \"region\": deployment.region,\n                \"environment\": deployment.environment\n            }\n        }\n\n    def _merge_resources(self, deployment: CloudDeployment) -> List[Resource]:\n        \"\"\"Merge global and deployment-specific resources\"\"\"\n        resources = []\n\n        # Add global resources first\n        resources.extend(self.global_resources)\n\n        # Add deployment-specific resources\n        resources.extend(deployment.resources)\n\n        return resources\n\n    def _get_variables(self, deployment: CloudDeployment) -> Dict[str, Any]:\n        \"\"\"Get variables for deployment\"\"\"\n        variables = {\n            \"environment\": deployment.environment,\n            \"region\": deployment.region\n        }\n\n        # Add shared state from other deployments\n        for name, state in self.shared_state.items():\n            if name != deployment.provider.value:\n                variables.update({\n                    f\"{name}_endpoint\": state.get(\"endpoint\"),\n                    f\"{name}_credentials\": state.get(\"credentials\")\n                })\n\n        return variables\n\n    async def failover(self, primary: str, backup: str) -> Dict[str, Any]:\n        \"\"\"Perform failover from primary to backup deployment\"\"\"\n\n        print(f\"Initiating failover from {primary} to {backup}\")\n\n        # Get backup deployment\n        backup_deployment = self.deployments.get(backup)\n        if not backup_deployment:\n            return {\"success\": False, \"error\": f\"Backup deployment {backup} not found\"}\n\n        # Update DNS to point to backup\n        dns_resource = Resource(\n            type=\"route53_record\",\n            name=\"failover\",\n            properties={\n                \"name\": \"api.example.com\",\n                \"type\": \"A\",\n                \"ttl\": 60,\n                \"records\": [self.shared_state[backup][\"endpoint\"]]\n            }\n        )\n\n        # Add DNS update to backup deployment\n        backup_deployment.resources.append(dns_resource)\n\n        # Deploy backup with updated DNS\n        result = await self._deploy_single(backup, backup_deployment)\n\n        if result[\"success\"]:\n            # Disable primary\n            if primary in self.deployments:\n                self.deployments[primary].enabled = False\n\n            print(f\"Failover to {backup} completed successfully\")\n\n        return result\n\n    async def sync_state(self) -> Dict[str, Any]:\n        \"\"\"Synchronize state across deployments\"\"\"\n\n        sync_results = {}\n\n        for name, deployment in self.deployments.items():\n            if not deployment.enabled:\n                continue\n\n            try:\n                backend = self.backends.get(name)\n                if not backend:\n                    continue\n\n                # Refresh state\n                config = InfrastructureConfig(\n                    name=name,\n                    environment=deployment.environment,\n                    provider=deployment.provider,\n                    region=deployment.region,\n                    resources=[]\n                )\n\n                # Get current state\n                outputs = {}\n                for resource in deployment.resources:\n                    if hasattr(resource, 'name'):\n                        output = await backend.output(config, resource.name)\n                        if output:\n                            outputs[resource.name] = output\n\n                sync_results[name] = {\n                    \"success\": True,\n                    \"outputs\": outputs\n                }\n\n            except Exception as e:\n                sync_results[name] = {\n                    \"success\": False,\n                    \"error\": str(e)\n                }\n\n        return sync_results\n```\n\n## 2. GitOps Patterns\n\n### Generic GitOps Engine\n\n```python\n# gitops\u002Fengine.py\nimport asyncio\nimport aiohttp\nfrom typing import Dict, List, Any, Optional, Callable\nfrom dataclasses import dataclass, field\nfrom enum import Enum\nfrom pathlib import Path\nimport yaml\nimport json\nfrom datetime import datetime\nimport logging\n\nlogger = logging.getLogger(__name__)\n\nclass GitOpsTool(str, Enum):\n    \"\"\"Supported GitOps tools\"\"\"\n    ARGOCD = \"argocd\"\n    FLUX = \"flux\"\n    JENKINS_X = \"jenkins-x\"\n\nclass DeploymentStrategy(str, Enum):\n    \"\"\"Deployment strategies\"\"\"\n    ROLLING = \"rolling\"\n    BLUE_GREEN = \"blue-green\"\n    CANARY = \"canary\"\n    A_B = \"a-b\"\n\n@dataclass\nclass Application:\n    \"\"\"Application definition for GitOps\"\"\"\n    name: str\n    repo_url: str\n    path: str\n    target_revision: str = \"HEAD\"\n    namespace: str = \"default\"\n    destination_server: str = \"https:\u002F\u002Fkubernetes.default.svc\"\n    sync_policy: Dict[str, Any] = field(default_factory=dict)\n    health_checks: List[Dict[str, Any]] = field(default_factory=list)\n    hooks: Dict[str, List[str]] = field(default_factory=dict)\n\n@dataclass\nclass GitOpsConfig:\n    \"\"\"GitOps configuration\"\"\"\n    tool: GitOpsTool\n    namespace: str = \"gitops-system\"\n    applications: List[Application] = field(default_factory=list)\n    repositories: Dict[str, str] = field(default_factory=dict)\n    policies: List[Dict[str, Any]] = field(default_factory=list)\n    notifications: Dict[str, Any] = field(default_factory=dict)\n\nclass GitOpsEngine:\n    \"\"\"Generic GitOps engine\"\"\"\n\n    def __init__(self, config: GitOpsConfig):\n        self.config = config\n        self.kubeconfig_path: Optional[Path] = None\n        self.tool_client = None\n\n    async def initialize(self) -> None:\n        \"\"\"Initialize GitOps tool\"\"\"\n\n        if self.config.tool == GitOpsTool.ARGOCD:\n            await self._init_argocd()\n        elif self.config.tool == GitOpsTool.FLUX:\n            await self._init_flux()\n        else:\n            raise ValueError(f\"Unsupported GitOps tool: {self.config.tool}\")\n\n    async def deploy_application(\n        self,\n        app: Application,\n        strategy: DeploymentStrategy = DeploymentStrategy.ROLLING\n    ) -> Dict[str, Any]:\n        \"\"\"Deploy application using GitOps\"\"\"\n\n        logger.info(f\"Deploying application {app.name} with {strategy.value} strategy\")\n\n        # Pre-deployment hooks\n        await self._execute_hooks(app, \"pre-deploy\")\n\n        # Deploy based on strategy\n        if strategy == DeploymentStrategy.CANARY:\n            result = await self._deploy_canary(app)\n        elif strategy == DeploymentStrategy.BLUE_GREEN:\n            result = await self._deploy_blue_green(app)\n        else:\n            result = await self._deploy_rolling(app)\n\n        # Post-deployment hooks\n        if result[\"success\"]:\n            await self._execute_hooks(app, \"post-deploy\")\n\n            # Health checks\n            health_status = await self._check_health(app)\n            result[\"health\"] = health_status\n\n        return result\n\n    async def _init_argocd(self) -> None:\n        \"\"\"Initialize ArgoCD\"\"\"\n\n        # Install ArgoCD if not present\n        install_cmd = [\n            \"kubectl\", \"apply\", \"-n\", self.config.namespace,\n            \"-f\", \"https:\u002F\u002Fraw.githubusercontent.com\u002Fargoproj\u002Fargo-cd\u002Fstable\u002Fmanifests\u002Finstall.yaml\"\n        ]\n\n        result = await self._run_kubectl_command(install_cmd)\n\n        if result[\"returncode\"] != 0 and \"AlreadyExists\" not in result[\"stderr\"]:\n            raise RuntimeError(f\"Failed to install ArgoCD: {result['stderr']}\")\n\n        # Wait for ArgoCD to be ready\n        await self._wait_for_deployment(\"argocd-server\", self.config.namespace)\n\n    async def _init_flux(self) -> None:\n        \"\"\"Initialize Flux\"\"\"\n\n        # Install Flux CLI\n        install_cmd = [\n            \"curl\", \"-s\", \"https:\u002F\u002Ffluxcd.io\u002Finstall.sh | bash\"\n        ]\n\n        result = await self._run_command(install_cmd, shell=True)\n\n        if result[\"returncode\"] != 0:\n            raise RuntimeError(f\"Failed to install Flux: {result['stderr']}\")\n\n        # Bootstrap Flux\n        bootstrap_cmd = [\n            \"flux\", \"bootstrap\", \"git\",\n            \"--url\", self.config.repositories.get(\"main\", \"\"),\n            \"--branch\", \"main\",\n            \"--path\", \"clusters\u002Fmy-cluster\"\n        ]\n\n        result = await self._run_command(bootstrap_cmd)\n\n        if result[\"returncode\"] != 0:\n            raise RuntimeError(f\"Failed to bootstrap Flux: {result['stderr']}\")\n\n    async def _deploy_rolling(self, app: Application) -> Dict[str, Any]:\n        \"\"\"Deploy using rolling update strategy\"\"\"\n\n        # Create ArgoCD application manifest\n        app_manifest = self._generate_argocd_app(app)\n\n        # Apply manifest\n        result = await self._apply_kubernetes_yaml(app_manifest)\n\n        # Wait for sync\n        if result[\"success\"]:\n            sync_result = await self._wait_for_sync(app.name)\n            result.update(sync_result)\n\n        return result\n\n    async def _deploy_canary(self, app: Application) -> Dict[str, Any]:\n        \"\"\"Deploy using canary strategy\"\"\"\n\n        # Create canary application\n        canary_app = Application(\n            name=f\"{app.name}-canary\",\n            repo_url=app.repo_url,\n            path=app.path,\n            target_revision=app.target_revision,\n            namespace=app.namespace,\n            sync_policy={\n                \"automated\": {\n                    \"prune\": False,\n                    \"self_heal\": False\n                }\n            }\n        )\n\n        # Create stable application\n        stable_app = Application(\n            name=f\"{app.name}-stable\",\n            repo_url=app.repo_url,\n            path=app.path,\n            target_revision=app.target_revision,\n            namespace=app.namespace,\n            sync_policy=app.sync_policy\n        )\n\n        results = {}\n\n        # Deploy stable first\n        results[\"stable\"] = await self._deploy_rolling(stable_app)\n\n        # Deploy canary with small traffic split\n        if results[\"stable\"][\"success\"]:\n            results[\"canary\"] = await self._deploy_rolling(canary_app)\n\n            # Set up traffic splitting\n            if results[\"canary\"][\"success\"]:\n                traffic_result = await self._setup_traffic_split(app, canary_weight=10)\n                results[\"traffic\"] = traffic_result\n\n        return {\n            \"success\": all(r.get(\"success\", False) for r in results.values()),\n            \"phases\": results\n        }\n\n    async def _deploy_blue_green(self, app: Application) -> Dict[str, Any]:\n        \"\"\"Deploy using blue-green strategy\"\"\"\n\n        # Determine active color\n        active_color = await self._get_active_color(app.name)\n        new_color = \"green\" if active_color == \"blue\" else \"blue\"\n\n        # Create new deployment\n        new_app = Application(\n            name=f\"{app.name}-{new_color}\",\n            repo_url=app.repo_url,\n            path=app.path,\n            target_revision=app.target_revision,\n            namespace=app.namespace,\n            sync_policy=app.sync_policy\n        )\n\n        # Deploy new color\n        deploy_result = await self._deploy_rolling(new_app)\n\n        if deploy_result[\"success\"]:\n            # Health check new deployment\n            health_result = await self._check_deployment_health(\n                f\"{app.name}-{new_color}\",\n                app.namespace\n            )\n\n            if health_result[\"healthy\"]:\n                # Switch traffic\n                switch_result = await self._switch_traffic(app.name, new_color)\n                deploy_result[\"traffic_switch\"] = switch_result\n\n                if switch_result[\"success\"]:\n                    # Clean up old deployment\n                    old_color = active_color\n                    cleanup_result = await self._cleanup_deployment(\n                        f\"{app.name}-{old_color}\",\n                        app.namespace\n                    )\n                    deploy_result[\"cleanup\"] = cleanup_result\n            else:\n                deploy_result[\"health_check\"] = health_result\n                deploy_result[\"success\"] = False\n\n        return deploy_result\n\n    def _generate_argocd_app(self, app: Application) -> str:\n        \"\"\"Generate ArgoCD application manifest\"\"\"\n\n        manifest = {\n            \"apiVersion\": \"argoproj.io\u002Fv1alpha1\",\n            \"kind\": \"Application\",\n            \"metadata\": {\n                \"name\": app.name,\n                \"namespace\": self.config.namespace\n            },\n            \"spec\": {\n                \"project\": \"default\",\n                \"source\": {\n                    \"repoURL\": app.repo_url,\n                    \"targetRevision\": app.target_revision,\n                    \"path\": app.path\n                },\n                \"destination\": {\n                    \"server\": app.destination_server,\n                    \"namespace\": app.namespace\n                },\n                \"syncPolicy\": {\n                    \"automated\": {\n                        \"prune\": app.sync_policy.get(\"prune\", True),\n                        \"selfHeal\": app.sync_policy.get(\"self_heal\", True)\n                    },\n                    \"syncOptions\": [\n                        \"CreateNamespace=true\"\n                    ]\n                }\n            }\n        }\n\n        return yaml.dump(manifest, sort_keys=False)\n\n    async def _apply_kubernetes_yaml(self, yaml_content: str) -> Dict[str, Any]:\n        \"\"\"Apply Kubernetes YAML manifest\"\"\"\n\n        cmd = [\"kubectl\", \"apply\", \"-f\", \"-\"]\n\n        process = await asyncio.create_subprocess_exec(\n            *cmd,\n            stdin=asyncio.subprocess.PIPE,\n            stdout=asyncio.subprocess.PIPE,\n            stderr=asyncio.subprocess.PIPE,\n            env={\"KUBECONFIG\": str(self.kubeconfig_path)} if self.kubeconfig_path else None\n        )\n\n        stdout, stderr = await process.communicate(yaml_content.encode())\n\n        return {\n            \"success\": process.returncode == 0,\n            \"stdout\": stdout.decode(),\n            \"stderr\": stderr.decode()\n        }\n\n    async def _wait_for_sync(self, app_name: str, timeout: int = 300) -> Dict[str, Any]:\n        \"\"\"Wait for ArgoCD application to sync\"\"\"\n\n        start_time = datetime.utcnow()\n\n        while (datetime.utcnow() - start_time).seconds \u003C timeout:\n            cmd = [\"argocd\", \"app\", \"get\", app_name, \"-o\", \"json\"]\n            result = await self._run_command(cmd)\n\n            if result[\"returncode\"] == 0:\n                app_data = json.loads(result[\"stdout\"])\n                status = app_data.get(\"status\", {})\n\n                sync_status = status.get(\"sync\", {}).get(\"status\", \"\")\n                health_status = status.get(\"health\", {}).get(\"status\", \"\")\n\n                if sync_status == \"Synced\" and health_status == \"Healthy\":\n                    return {\n                        \"success\": True,\n                        \"status\": \"Synced and Healthy\",\n                        \"duration\": (datetime.utcnow() - start_time).seconds\n                    }\n\n            await asyncio.sleep(5)\n\n        return {\n            \"success\": False,\n            \"error\": f\"Sync timeout after {timeout} seconds\"\n        }\n\n    async def _execute_hooks(self, app: Application, hook_type: str) -> None:\n        \"\"\"Execute deployment hooks\"\"\"\n\n        hooks = app.hooks.get(hook_type, [])\n\n        for hook in hooks:\n            logger.info(f\"Executing {hook_type} hook: {hook}\")\n\n            try:\n                result = await self._run_command(hook, shell=True)\n\n                if result[\"returncode\"] != 0:\n                    logger.error(f\"Hook failed: {result['stderr']}\")\n\n            except Exception as e:\n                logger.error(f\"Error executing hook: {e}\")\n\n    async def _check_health(self, app: Application) -> Dict[str, Any]:\n        \"\"\"Check application health\"\"\"\n\n        health_results = {}\n\n        for check in app.health_checks:\n            if check[\"type\"] == \"http\":\n                result = await self._check_http_health(check)\n            elif check[\"type\"] == \"kubernetes\":\n                result = await self._check_kubernetes_health(check)\n            else:\n                result = {\"healthy\": False, \"error\": f\"Unknown health check type: {check['type']}\"}\n\n            health_results[check[\"name\"]] = result\n\n        return health_results\n\n    async def _run_kubectl_command(self, cmd: List[str]) -> Dict[str, Any]:\n        \"\"\"Run kubectl command\"\"\"\n        return await self._run_command(\n            [\"kubectl\"] + cmd,\n            env={\"KUBECONFIG\": str(self.kubeconfig_path)} if self.kubeconfig_path else None\n        )\n\n    async def _run_command(\n        self,\n        cmd: List[str],\n        shell: bool = False,\n        env: Optional[Dict[str, str]] = None\n    ) -> Dict[str, Any]:\n        \"\"\"Run command\"\"\"\n\n        if shell:\n            cmd = [\"bash\", \"-c\", \" \".join(cmd) if isinstance(cmd, list) else cmd]\n\n        process = await asyncio.create_subprocess_exec(\n            *cmd,\n            stdout=asyncio.subprocess.PIPE,\n            stderr=asyncio.subprocess.PIPE,\n            env=env\n        )\n\n        stdout, stderr = await process.communicate()\n\n        return {\n            \"returncode\": process.returncode,\n            \"stdout\": stdout.decode(),\n            \"stderr\": stderr.decode()\n        }\n\n    async def _wait_for_deployment(\n        self,\n        deployment_name: str,\n        namespace: str,\n        timeout: int = 300\n    ) -> None:\n        \"\"\"Wait for deployment to be ready\"\"\"\n\n        cmd = [\n            \"kubectl\", \"wait\",\n            f\"deployment\u002F{deployment_name}\",\n            \"--for\", \"condition=available\",\n            f\"--namespace={namespace}\",\n            f\"--timeout={timeout}s\"\n        ]\n\n        result = await self._run_kubectl_command(cmd)\n\n        if result[\"returncode\"] != 0:\n            raise RuntimeError(f\"Deployment {deployment_name} not ready: {result['stderr']}\")\n```\n\n## 3. Progressive Delivery Patterns\n\n### Canary Analysis Engine\n\n```python\n# delivery\u002Fcanary.py\nimport asyncio\nimport aiohttp\nfrom typing import Dict, List, Any, Optional, Callable\nfrom dataclasses import dataclass, field\nfrom datetime import datetime, timedelta\nimport numpy as np\nimport logging\n\nlogger = logging.getLogger(__name__)\n\n@dataclass\nclass CanaryMetric:\n    \"\"\"Canary analysis metric\"\"\"\n    name: str\n    query: str\n    weight: float = 1.0\n    threshold: Optional[float] = None\n    comparison: str = \"less_than\"  # less_than, greater_than, equals\n\n@dataclass\nclass CanaryConfig:\n    \"\"\"Canary deployment configuration\"\"\"\n    application: str\n    namespace: str\n    baseline_label: str = \"version=baseline\"\n    canary_label: str = \"version=canary\"\n    traffic_step: int = 10\n    max_traffic: int = 50\n    analysis_interval: int = 60  # seconds\n    metrics: List[CanaryMetric] = field(default_factory=list)\n    success_criteria: Dict[str, float] = field(default_factory=dict)\n    rollback_on_failure: bool = True\n\nclass CanaryAnalyzer:\n    \"\"\"Analyzes canary deployment metrics\"\"\"\n\n    def __init__(self, prometheus_url: str):\n        self.prometheus_url = prometheus_url\n        self.session = None\n\n    async def analyze(\n        self,\n        config: CanaryConfig,\n        current_traffic: int\n    ) -> Dict[str, Any]:\n        \"\"\"Analyze canary vs baseline metrics\"\"\"\n\n        analysis = {\n            \"timestamp\": datetime.utcnow().isoformat(),\n            \"traffic_percentage\": current_traffic,\n            \"metrics\": {},\n            \"overall_score\": 0.0,\n            \"recommendation\": \"proceed\"\n        }\n\n        # Query metrics for both baseline and canary\n        baseline_metrics = await self._query_metrics(config, \"baseline\")\n        canary_metrics = await self._query_metrics(config, \"canary\")\n\n        # Analyze each metric\n        metric_scores = []\n\n        for metric in config.metrics:\n            baseline_value = baseline_metrics.get(metric.name, 0)\n            canary_value = canary_metrics.get(metric.name, 0)\n\n            # Calculate percentage difference\n            if baseline_value != 0:\n                diff_percentage = ((canary_value - baseline_value) \u002F baseline_value) * 100\n            else:\n                diff_percentage = 0\n\n            # Determine if metric passes threshold\n            passes = self._evaluate_metric(metric, canary_value, baseline_value)\n\n            # Calculate score\n            score = self._calculate_score(metric, diff_percentage, passes)\n            metric_scores.append(score * metric.weight)\n\n            analysis[\"metrics\"][metric.name] = {\n                \"baseline\": baseline_value,\n                \"canary\": canary_value,\n                \"difference_percentage\": diff_percentage,\n                \"passes\": passes,\n                \"score\": score\n            }\n\n        # Calculate overall score\n        if metric_scores:\n            analysis[\"overall_score\"] = np.mean(metric_scores)\n\n        # Determine recommendation\n        analysis[\"recommendation\"] = self._get_recommendation(\n            analysis[\"overall_score\"],\n            config,\n            current_traffic\n        )\n\n        return analysis\n\n    async def _query_metrics(\n        self,\n        config: CanaryConfig,\n        variant: str\n    ) -> Dict[str, float]:\n        \"\"\"Query metrics from Prometheus\"\"\"\n\n        label = config.canary_label if variant == \"canary\" else config.baseline_label\n        metrics = {}\n\n        for metric in config.metrics:\n            query = metric.query.format(label=label)\n\n            try:\n                value = await self._query_prometheus(query)\n                metrics[metric.name] = value\n            except Exception as e:\n                logger.error(f\"Failed to query metric {metric.name}: {e}\")\n                metrics[metric.name] = 0\n\n        return metrics\n\n    async def _query_prometheus(self, query: str) -> float:\n        \"\"\"Query single metric from Prometheus\"\"\"\n\n        if not self.session:\n            self.session = aiohttp.ClientSession()\n\n        url = f\"{self.prometheus_url}\u002Fapi\u002Fv1\u002Fquery\"\n        params = {\"query\": query}\n\n        async with self.session.get(url, params=params) as response:\n            data = await response.json()\n\n            if data[\"status\"] == \"success\" and data[\"data\"][\"result\"]:\n                return float(data[\"data\"][\"result\"][0][\"value\"][1])\n\n            return 0.0\n\n    def _evaluate_metric(\n        self,\n        metric: CanaryMetric,\n        canary_value: float,\n        baseline_value: float\n    ) -> bool:\n        \"\"\"Evaluate if metric passes threshold\"\"\"\n\n        if metric.threshold is None:\n            return True\n\n        if metric.comparison == \"less_than\":\n            return canary_value \u003C= metric.threshold\n        elif metric.comparison == \"greater_than\":\n            return canary_value >= metric.threshold\n        elif metric.comparison == \"equals\":\n            return abs(canary_value - metric.threshold) \u003C 0.01\n\n        return True\n\n    def _calculate_score(\n        self,\n        metric: CanaryMetric,\n        diff_percentage: float,\n        passes: bool\n    ) -> float:\n        \"\"\"Calculate metric score\"\"\"\n\n        if not passes:\n            return 0.0\n\n        # Score based on how close to baseline\n        if abs(diff_percentage) \u003C 5:\n            return 1.0\n        elif abs(diff_percentage) \u003C 10:\n            return 0.8\n        elif abs(diff_percentage) \u003C 20:\n            return 0.6\n        else:\n            return 0.4\n\n    def _get_recommendation(\n        self,\n        score: float,\n        config: CanaryConfig,\n        current_traffic: int\n    ) -> str:\n        \"\"\"Get deployment recommendation\"\"\"\n\n        if score \u003C 0.5:\n            return \"rollback\"\n        elif score \u003C 0.7:\n            if current_traffic >= config.max_traffic:\n                return \"rollback\"\n            return \"hold\"\n        else:\n            if current_traffic >= config.max_traffic:\n                return \"promote\"\n            return \"promote\"\n\nclass CanaryController:\n    \"\"\"Controls canary deployment lifecycle\"\"\"\n\n    def __init__(self, analyzer: CanaryAnalyzer, k8s_client):\n        self.analyzer = analyzer\n        self.k8s_client = k8s_client\n        self.active_canaries: Dict[str, Dict[str, Any]] = {}\n\n    async def start_canary(self, config: CanaryConfig) -> str:\n        \"\"\"Start canary deployment\"\"\"\n\n        canary_id = f\"{config.application}-{int(datetime.utcnow().timestamp())}\"\n\n        # Create initial canary deployment\n        await self._create_canary_deployment(config)\n\n        # Set up initial traffic split\n        await self._set_traffic_split(config, config.traffic_step)\n\n        # Start analysis loop\n        asyncio.create_task(self._analysis_loop(canary_id, config))\n\n        self.active_canaries[canary_id] = {\n            \"config\": config,\n            \"current_traffic\": config.traffic_step,\n            \"started_at\": datetime.utcnow(),\n            \"status\": \"running\"\n        }\n\n        logger.info(f\"Started canary deployment {canary_id}\")\n        return canary_id\n\n    async def _analysis_loop(self, canary_id: str, config: CanaryConfig) -> None:\n        \"\"\"Run continuous analysis\"\"\"\n\n        while canary_id in self.active_canaries:\n            canary_info = self.active_canaries[canary_id]\n\n            if canary_info[\"status\"] != \"running\":\n                break\n\n            # Run analysis\n            analysis = await self.analyzer.analyze(\n                config,\n                canary_info[\"current_traffic\"]\n            )\n\n            # Act on recommendation\n            await self._handle_recommendation(canary_id, analysis)\n\n            # Wait for next analysis\n            await asyncio.sleep(config.analysis_interval)\n\n    async def _handle_recommendation(\n        self,\n        canary_id: str,\n        analysis: Dict[str, Any]\n    ) -> None:\n        \"\"\"Handle analysis recommendation\"\"\"\n\n        canary_info = self.active_canaries.get(canary_id)\n        if not canary_info:\n            return\n\n        recommendation = analysis[\"recommendation\"]\n        config = canary_info[\"config\"]\n\n        if recommendation == \"rollback\":\n            logger.warning(f\"Rolling back canary {canary_id}\")\n            await self._rollback_canary(canary_id)\n\n        elif recommendation == \"hold\":\n            logger.info(f\"Holding canary {canary_id} at {canary_info['current_traffic']}% traffic\")\n\n        elif recommendation == \"promote\":\n            if canary_info[\"current_traffic\"] >= config.max_traffic:\n                # Full promotion\n                logger.info(f\"Promoting canary {canary_id} to production\")\n                await self._promote_canary(canary_id)\n            else:\n                # Increase traffic\n                new_traffic = min(\n                    canary_info[\"current_traffic\"] + config.traffic_step,\n                    config.max_traffic\n                )\n\n                logger.info(f\"Increasing canary {canary_id} traffic to {new_traffic}%\")\n                await self._set_traffic_split(config, new_traffic)\n                canary_info[\"current_traffic\"] = new_traffic\n\n    async def _set_traffic_split(\n        self,\n        config: CanaryConfig,\n        canary_percentage: int\n    ) -> None:\n        \"\"\"Set traffic split between baseline and canary\"\"\"\n\n        # Implementation depends on traffic management solution\n        # Could be Istio VirtualService, AWS ALB, Nginx Ingress, etc.\n\n        if config.namespace == \"istio-system\":\n            await self._set_istio_traffic_split(config, canary_percentage)\n        elif config.namespace == \"aws\":\n            await self._set_alb_traffic_split(config, canary_percentage)\n        else:\n            await self._set_service_mesh_traffic_split(config, canary_percentage)\n\n    async def _set_istio_traffic_split(\n        self,\n        config: CanaryConfig,\n        canary_percentage: int\n    ) -> None:\n        \"\"\"Set traffic split using Istio\"\"\"\n\n        # Update Istio VirtualService\n        virtual_service = {\n            \"apiVersion\": \"networking.istio.io\u002Fv1beta1\",\n            \"kind\": \"VirtualService\",\n            \"metadata\": {\n                \"name\": config.application,\n                \"namespace\": config.namespace\n            },\n            \"spec\": {\n                \"http\": [\n                    {\n                        \"name\": \"primary\",\n                        \"route\": [\n                            {\n                                \"destination\": {\n                                    \"host\": f\"{config.application}\",\n                                    \"subset\": \"canary\"\n                                },\n                                \"weight\": canary_percentage\n                            },\n                            {\n                                \"destination\": {\n                                    \"host\": f\"{config.application}\",\n                                    \"subset\": \"baseline\"\n                                },\n                                \"weight\": 100 - canary_percentage\n                            }\n                        ]\n                    }\n                ]\n            }\n        }\n\n        # Apply to Kubernetes\n        cmd = [\n            \"kubectl\", \"apply\", \"-f\", \"-\",\n            \"-n\", config.namespace\n        ]\n\n        # Implementation would apply the VirtualService\n        pass\n```\n\nThis comprehensive cloud-native deployment skill provides production-ready patterns for implementing modern infrastructure as code, GitOps workflows, and progressive delivery strategies across any cloud provider or platform.\n\n`★ Insight ─────────────────────────────────────`\nThe cloud-native patterns shown here emphasize several key 2025 best practices:\n1. **Provider Abstraction**: Generic interfaces allow switching between Terraform, Pulumi, and other IaC tools\n2. **Multi-Cloud Strategy**: Built-in support for managing deployments across multiple providers with failover capabilities\n3. **GitOps-First**: Declarative deployment through Git with support for ArgoCD, Flux, and custom tools\n4. **Progressive Delivery**: Safe deployments with canary analysis, blue-green strategies, and automated rollback\n5. **Policy as Code**: Integration with Open Policy Agent for automated compliance and security\n\nThese patterns ensure your cloud deployments are automated, secure, and resilient across any infrastructure.\n`─────────────────────────────────────────────────`","# Cloud-Native Deployment & Infrastructure Patterns\n\nThis skill provides comprehensive patterns for implementing cloud-native deployments using modern Infrastructure as Code, GitOps workflows, and progressive delivery strategies. The patterns are designed to be framework-agnostic and applicable across any cloud provider or orchestration platform.\n\n## When to Use This Skill\n\nUse this skill when you need to:\n- Implement Infrastructure as Code with any provider (Terraform, Pulumi, CDK)\n- Build GitOps workflows with Argo CD, Flux, or similar tools\n- Create multi-cloud or hybrid deployment strategies\n- Implement progressive delivery (canary, blue-green)\n- Build internal developer platforms\n- Set up policy as code and compliance automation\n- Implement zero-trust security architectures\n- Create disaster recovery and failover strategies\n- Optimize costs across multiple providers\n- Build observability into deployments\n\n## 1. Infrastructure as Code Patterns\n\n### Generic IaC Abstraction Layer\n\n```python\n# iac\u002Fcore\u002Fabstraction.py\nfrom abc import ABC, abstractmethod\nfrom typing import Dict, List, Any, Optional, Union\nfrom dataclasses import dataclass, field\nfrom enum import Enum\nfrom pathlib import Path\nimport json\nimport yaml\nimport asyncio\nfrom datetime import datetime\n\nclass IaCProvider(str, Enum):\n    \"\"\"Supported IaC providers\"\"\"\n    TERRAFORM = \"terraform\"\n    PULUMI = \"pulumi\"\n    CDK = \"cdk\"\n    CROSSPLANE = \"crossplane\"\n\nclass CloudProvider(str, Enum):\n    \"\"\"Cloud providers\"\"\"\n    AWS = \"aws\"\n    AZURE = \"azure\"\n    GCP = \"gcp\"\n    DIGITALOCEAN = \"digitalocean\"\n    ON_PREM = \"on-prem\"\n\n@dataclass\nclass Resource:\n    \"\"\"Generic resource definition\"\"\"\n    type: str\n    name: str\n    properties: Dict[str, Any] = field(default_factory=dict)\n    dependencies: List[str] = field(default_factory=list)\n    provider: Optional[CloudProvider] = None\n    tags: Dict[str, str] = field(default_factory=dict)\n\n@dataclass\nclass InfrastructureConfig:\n    \"\"\"Infrastructure configuration\"\"\"\n    name: str\n    environment: str\n    provider: CloudProvider\n    region: str\n    resources: List[Resource] = field(default_factory=list)\n    variables: Dict[str, Any] = field(default_factory=dict)\n    outputs: Dict[str, str] = field(default_factory=dict)\n\nclass IaCBackend(ABC):\n    \"\"\"Abstract IaC backend interface\"\"\"\n\n    @abstractmethod\n    async def initialize(self, config: InfrastructureConfig) -> None:\n        \"\"\"Initialize IaC backend\"\"\"\n        pass\n\n    @abstractmethod\n    async def plan(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Generate execution plan\"\"\"\n        pass\n\n    @abstractmethod\n    async def apply(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Apply infrastructure changes\"\"\"\n        pass\n\n    @abstractmethod\n    async def destroy(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Destroy infrastructure\"\"\"\n        pass\n\n    @abstractmethod\n    async def output(self, config: InfrastructureConfig, key: str) -> Any:\n        \"\"\"Get output value\"\"\"\n        pass\n\n    @abstractmethod\n    async def validate(self, config: InfrastructureConfig) -> List[str]:\n        \"\"\"Validate configuration\"\"\"\n        pass\n\nclass TerraformBackend(IaCBackend):\n    \"\"\"Terraform backend implementation\"\"\"\n\n    def __init__(self, working_dir: Path):\n        self.working_dir = working_dir\n        self.state_backend: Optional[str] = None\n\n    async def initialize(self, config: InfrastructureConfig) -> None:\n        \"\"\"Initialize Terraform\"\"\"\n        # Generate Terraform files\n        await self._generate_terraform_files(config)\n\n        # Run terraform init\n        cmd = [\"terraform\", \"init\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] != 0:\n            raise RuntimeError(f\"Terraform init failed: {result['stderr']}\")\n\n    async def plan(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Generate Terraform plan\"\"\"\n        cmd = [\"terraform\", \"plan\", \"-out=tfplan\", \"-json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return {\n            \"success\": result[\"returncode\"] == 0,\n            \"plan_file\": self.working_dir \u002F \"tfplan\",\n            \"output\": result[\"stdout\"],\n            \"changes\": json.loads(result[\"stdout\"]) if result[\"stdout\"] else {}\n        }\n\n    async def apply(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Apply Terraform changes\"\"\"\n        cmd = [\"terraform\", \"apply\", \"-auto-approve\", \"-json\", \"tfplan\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return {\n            \"success\": result[\"returncode\"] == 0,\n            \"output\": result[\"stdout\"],\n            \"applied_at\": datetime.utcnow().isoformat()\n        }\n\n    async def destroy(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Destroy Terraform resources\"\"\"\n        cmd = [\"terraform\", \"destroy\", \"-auto-approve\", \"-json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return {\n            \"success\": result[\"returncode\"] == 0,\n            \"output\": result[\"stdout\"],\n            \"destroyed_at\": datetime.utcnow().isoformat()\n        }\n\n    async def output(self, config: InfrastructureConfig, key: str) -> Any:\n        \"\"\"Get Terraform output\"\"\"\n        cmd = [\"terraform\", \"output\", \"-json\", key]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] == 0:\n            return json.loads(result[\"stdout\"])\n        return None\n\n    async def validate(self, config: InfrastructureConfig) -> List[str]:\n        \"\"\"Validate Terraform configuration\"\"\"\n        errors = []\n\n        # Run terraform validate\n        cmd = [\"terraform\", \"validate\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] != 0:\n            errors.append(f\"Validation failed: {result['stderr']}\")\n\n        # Run terraform fmt check\n        cmd = [\"terraform\", \"fmt\", \"-check\", \"-diff\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] != 0:\n            errors.append(\"Formatting check failed - run terraform fmt\")\n\n        # Check for required variables\n        cmd = [\"terraform\", \"validate\", \"-json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return errors\n\n    async def _generate_terraform_files(self, config: InfrastructureConfig) -> None:\n        \"\"\"Generate Terraform configuration files\"\"\"\n        # Generate main.tf\n        main_tf = {\n            \"terraform\": {\n                \"required_providers\": self._get_required_providers(config.provider),\n                \"backend\": self._get_backend_config()\n            },\n            \"provider\": {config.provider.value: self._get_provider_config(config)},\n            \"resource\": self._convert_resources(config.resources)\n        }\n\n        with open(self.working_dir \u002F \"main.tf\", \"w\") as f:\n            yaml.dump(main_tf, f, sort_keys=False)\n\n        # Generate variables.tf\n        if config.variables:\n            variables_tf = {\n                \"variable\": {\n                    k: {\"type\": self._infer_type(v), \"default\": v}\n                    for k, v in config.variables.items()\n                }\n            }\n\n            with open(self.working_dir \u002F \"variables.tf\", \"w\") as f:\n                yaml.dump(variables_tf, f, sort_keys=False)\n\n        # Generate outputs.tf\n        if config.outputs:\n            outputs_tf = {\n                \"output\": {\n                    k: {\"value\": v}\n                    for k, v in config.outputs.items()\n                }\n            }\n\n            with open(self.working_dir \u002F \"outputs.tf\", \"w\") as f:\n                yaml.dump(outputs_tf, f, sort_keys=False)\n\n    async def _run_command(self, cmd: List[str], cwd: Path) -> Dict[str, Any]:\n        \"\"\"Run command and return result\"\"\"\n        process = await asyncio.create_subprocess_exec(\n            *cmd,\n            cwd=cwd,\n            stdout=asyncio.subprocess.PIPE,\n            stderr=asyncio.subprocess.PIPE\n        )\n\n        stdout, stderr = await process.communicate()\n\n        return {\n            \"returncode\": process.returncode,\n            \"stdout\": stdout.decode(),\n            \"stderr\": stderr.decode()\n        }\n\n    def _get_required_providers(self, provider: CloudProvider) -> Dict[str, Any]:\n        \"\"\"Get required providers configuration\"\"\"\n        providers = {}\n\n        if provider == CloudProvider.AWS:\n            providers[\"aws\"] = {\"source\": \"hashicorp\u002Faws\", \"version\": \"~> 5.0\"}\n        elif provider == CloudProvider.AZURE:\n            providers[\"azurerm\"] = {\"source\": \"hashicorp\u002Fazurerm\", \"version\": \"~> 3.0\"}\n        elif provider == CloudProvider.GCP:\n            providers[\"google\"] = {\"source\": \"hashicorp\u002Fgoogle\", \"version\": \"~> 5.0\"}\n\n        return providers\n\n    def _get_backend_config(self) -> Dict[str, Any]:\n        \"\"\"Get Terraform backend configuration\"\"\"\n        if self.state_backend:\n            return {\"s3\": self.state_backend}\n        return {}\n\n    def _get_provider_config(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Get provider-specific configuration\"\"\"\n        base_config = {\"region\": config.region}\n\n        # Add provider-specific settings\n        if config.provider == CloudProvider.AWS:\n            base_config[\"default_tags\"] = {\n                \"tags\": {\n                    \"Environment\": config.environment,\n                    \"ManagedBy\": \"terraform\",\n                    \"Project\": config.name\n                }\n            }\n\n        return base_config\n\n    def _convert_resources(self, resources: List[Resource]) -> Dict[str, Any]:\n        \"\"\"Convert generic resources to Terraform format\"\"\"\n        terraform_resources = {}\n\n        for resource in resources:\n            resource_key = f\"{resource.type}_{resource.name}\"\n\n            resource_config = {\n                \"provider\": resource.provider.value if resource.provider else None,\n                **resource.properties\n            }\n\n            if resource.tags:\n                resource_config[\"tags\"] = resource.tags\n\n            terraform_resources[resource_key] = resource_config\n\n        return terraform_resources\n\n    def _infer_type(self, value: Any) -> str:\n        \"\"\"Infer Terraform variable type from value\"\"\"\n        if isinstance(value, bool):\n            return \"bool\"\n        elif isinstance(value, int):\n            return \"number\"\n        elif isinstance(value, list):\n            return \"list(string)\"\n        elif isinstance(value, dict):\n            return \"map(string)\"\n        else:\n            return \"string\"\n\nclass PulumiBackend(IaCBackend):\n    \"\"\"Pulumi backend implementation\"\"\"\n\n    def __init__(self, working_dir: Path, language: str = \"python\"):\n        self.working_dir = working_dir\n        self.language = language\n\n    async def initialize(self, config: InfrastructureConfig) -> None:\n        \"\"\"Initialize Pulumi\"\"\"\n        # Generate Pulumi program\n        await self._generate_pulumi_program(config)\n\n        # Run pulumi stack init\n        cmd = [\"pulumi\", \"stack\", \"init\", f\"{config.name}-{config.environment}\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] != 0:\n            raise RuntimeError(f\"Pulumi stack init failed: {result['stderr']}\")\n\n    async def plan(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Preview Pulumi changes\"\"\"\n        cmd = [\"pulumi\", \"preview\", \"--json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return {\n            \"success\": result[\"returncode\"] == 0,\n            \"output\": result[\"stdout\"],\n            \"changes\": json.loads(result[\"stdout\"]) if result[\"stdout\"] else {}\n        }\n\n    async def apply(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Apply Pulumi changes\"\"\"\n        cmd = [\"pulumi\", \"up\", \"--yes\", \"--json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return {\n            \"success\": result[\"returncode\"] == 0,\n            \"output\": result[\"stdout\"],\n            \"applied_at\": datetime.utcnow().isoformat()\n        }\n\n    async def destroy(self, config: InfrastructureConfig) -> Dict[str, Any]:\n        \"\"\"Destroy Pulumi resources\"\"\"\n        cmd = [\"pulumi\", \"destroy\", \"--yes\", \"--json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        return {\n            \"success\": result[\"returncode\"] == 0,\n            \"output\": result[\"stdout\"],\n            \"destroyed_at\": datetime.utcnow().isoformat()\n        }\n\n    async def output(self, config: InfrastructureConfig, key: str) -> Any:\n        \"\"\"Get Pulumi stack output\"\"\"\n        cmd = [\"pulumi\", \"stack\", \"output\", \"--json\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] == 0:\n            outputs = json.loads(result[\"stdout\"])\n            return outputs.get(key)\n        return None\n\n    async def validate(self, config: InfrastructureConfig) -> List[str]:\n        \"\"\"Validate Pulumi configuration\"\"\"\n        errors = []\n\n        # Run pulumi config validate\n        cmd = [\"pulumi\", \"config\", \"validate\"]\n        result = await self._run_command(cmd, cwd=self.working_dir)\n\n        if result[\"returncode\"] != 0:\n            errors.append(f\"Validation failed: {result['stderr']}\")\n\n        return errors\n\n    async def _generate_pulumi_program(self, config: InfrastructureConfig) -> None:\n        \"\"\"Generate Pulumi program based on language\"\"\"\n        if self.language == \"python\":\n            await self._generate_python_program(config)\n        elif self.language == \"typescript\":\n            await self._generate_typescript_program(config)\n\n    async def _generate_python_program(self, config: InfrastructureConfig) -> None:\n        \"\"\"Generate Python Pulumi program\"\"\"\n        program = f'''\"\"\"\nPulumi program for {config.name} - {config.environment}\n\"\"\"\n\nimport pulumi\nimport pulumi_{config.provider.value} as provider\n\n# Configuration\nconfig = pulumi.Config()\n\n# Resources\n'''\n\n        # Generate resources\n        for resource in config.resources:\n            provider_module = f\"provider.{resource.type.replace('_', '.')}\"\n            program += f'''\n{resource.name}_resource = {provider_module}.{resource.title()}(\n    \"{resource.name}\",\n'''\n\n            # Add properties\n            for key, value in resource.properties.items():\n                if isinstance(value, str):\n                    program += f'    {key}=\"{value}\",\\n'\n                else:\n                    program += f'    {key}={value},\\n'\n\n            # Add tags if present\n            if resource.tags:\n                program += f'    tags={resource.tags},\\n'\n\n            program += ')\\n\\n'\n\n        # Generate outputs\n        for key, value in config.outputs.items():\n            program += f'pulumi.export(\"{key}\", {value})\\n'\n\n        # Write program file\n        with open(self.working_dir \u002F \"__main__.py\", \"w\") as f:\n            f.write(program)\n\n        # Generate requirements.txt\n        with open(self.working_dir \u002F \"requirements.txt\", \"w\") as f:\n            f.write(f\"pulumi>={config.provider.value}\\n\")\n\n    async def _run_command(self, cmd: List[str], cwd: Path) -> Dict[str, Any]:\n        \"\"\"Run command and return result\"\"\"\n        process = await asyncio.create_subprocess_exec(\n            *cmd,\n            cwd=cwd,\n            stdout=asyncio.subprocess.PIPE,\n            stderr=asyncio.subprocess.PIPE\n        )\n\n        stdout, stderr = await process.communicate()\n\n        return {\n            \"returncode\": process.returncode,\n            \"stdout\": stdout.decode(),\n            \"stderr\": stderr.decode()\n        }\n\n# Factory for creating IaC backends\nclass IaCFactory:\n    \"\"\"Factory for creating IaC backends\"\"\"\n\n    @staticmethod\n    def create(\n        provider: IaCProvider,\n        working_dir: Path,\n        **kwargs\n    ) -> IaCBackend:\n        \"\"\"Create IaC backend instance\"\"\"\n\n        working_dir.mkdir(parents=True, exist_ok=True)\n\n        if provider == IaCProvider.TERRAFORM:\n            return TerraformBackend(working_dir)\n        elif provider == IaCProvider.PULUMI:\n            return PulumiBackend(\n                working_dir,\n                language=kwargs.get(\"language\", \"python\")\n            )\n        else:\n            raise ValueError(f\"Unsupported IaC provider: {provider}\")\n```\n\n### Multi-Cloud Resource Manager\n\n```python\n# iac\u002Fmulticloud\u002Fmanager.py\nfrom typing import Dict, List, Any, Optional\nfrom dataclasses import dataclass\nimport asyncio\nfrom ..core.abstraction import (\n    InfrastructureConfig, Resource, CloudProvider, IaCBackend\n)\n\n@dataclass\nclass CloudDeployment:\n    \"\"\"Cloud deployment configuration\"\"\"\n    provider: CloudProvider\n    region: str\n    environment: str\n    resources: List[Resource]\n    priority: int = 0  # Higher priority = primary deployment\n    enabled: bool = True\n\nclass MultiCloudManager:\n    \"\"\"Manages deployments across multiple cloud providers\"\"\"\n\n    def __init__(self):\n        self.deployments: Dict[str, CloudDeployment] = {}\n        self.backends: Dict[str, IaCBackend] = {}\n        self.global_resources: List[Resource] = []\n        self.shared_state: Dict[str, Any] = {}\n\n    def add_deployment(self, name: str, deployment: CloudDeployment) -> None:\n        \"\"\"Add a cloud deployment\"\"\"\n        self.deployments[name] = deployment\n\n    def add_global_resource(self, resource: Resource) -> None:\n        \"\"\"Add a global resource (DNS, CDN, etc.)\"\"\"\n        self.global_resources.append(resource)\n\n    async def deploy_all(self) -> Dict[str, Any]:\n        \"\"\"Deploy to all configured clouds\"\"\"\n        results = {}\n\n        # Sort by priority (primary deployments first)\n        sorted_deployments = sorted(\n            self.deployments.items(),\n            key=lambda x: x[1].priority,\n            reverse=True\n        )\n\n        for name, deployment in sorted_deployments:\n            if not deployment.enabled:\n                continue\n\n            print(f\"Deploying to {name} ({deployment.provider.value})...\")\n\n            try:\n                result = await self._deploy_single(name, deployment)\n                results[name] = result\n\n                # Store shared outputs\n                if result[\"success\"]:\n                    self.shared_state[name] = result.get(\"outputs\", {})\n\n            except Exception as e:\n                results[name] = {\n                    \"success\": False,\n                    \"error\": str(e)\n                }\n                print(f\"Failed to deploy to {name}: {e}\")\n\n        return results\n\n    async def _deploy_single(\n        self,\n        name: str,\n        deployment: CloudDeployment\n    ) -> Dict[str, Any]:\n        \"\"\"Deploy to a single cloud provider\"\"\"\n\n        # Create IaC config\n        config = InfrastructureConfig(\n            name=name,\n            environment=deployment.environment,\n            provider=deployment.provider,\n            region=deployment.region,\n            resources=self._merge_resources(deployment),\n            variables=self._get_variables(deployment)\n        )\n\n        # Get or create backend\n        if name not in self.backends:\n            from ..core.abstraction import IaCFactory, IaCProvider\n            backend = IaCFactory.create(\n                IaCProvider.TERRAFORM,\n                Path(f\"iac\u002F{name}\")\n            )\n            self.backends[name] = backend\n\n        backend = self.backends[name]\n\n        # Initialize and deploy\n        await backend.initialize(config)\n\n        # Plan\n        plan = await backend.plan(config)\n        if not plan[\"success\"]:\n            return {\"success\": False, \"error\": \"Plan failed\"}\n\n        # Apply\n        apply_result = await backend.apply(config)\n\n        # Get outputs\n        outputs = {}\n        for key in deployment.resources:\n            if hasattr(key, 'name'):\n                output_value = await backend.output(config, key.name)\n                if output_value:\n                    outputs[key.name] = output_value\n\n        return {\n            \"success\": apply_result[\"success\"],\n            \"outputs\": outputs,\n            \"deployment_info\": {\n                \"provider\": deployment.provider.value,\n                \"region\": deployment.region,\n                \"environment\": deployment.environment\n            }\n        }\n\n    def _merge_resources(self, deployment: CloudDeployment) -> List[Resource]:\n        \"\"\"Merge global and deployment-specific resources\"\"\"\n        resources = []\n\n        # Add global resources first\n        resources.extend(self.global_resources)\n\n        # Add deployment-specific resources\n        resources.extend(deployment.resources)\n\n        return resources\n\n    def _get_variables(self, deployment: CloudDeployment) -> Dict[str, Any]:\n        \"\"\"Get variables for deployment\"\"\"\n        variables = {\n            \"environment\": deployment.environment,\n            \"region\": deployment.region\n        }\n\n        # Add shared state from other deployments\n        for name, state in self.shared_state.items():\n            if name != deployment.provider.value:\n                variables.update({\n                    f\"{name}_endpoint\": state.get(\"endpoint\"),\n                    f\"{name}_credentials\": state.get(\"credentials\")\n                })\n\n        return variables\n\n    async def failover(self, primary: str, backup: str) -> Dict[str, Any]:\n        \"\"\"Perform failover from primary to backup deployment\"\"\"\n\n        print(f\"Initiating failover from {primary} to {backup}\")\n\n        # Get backup deployment\n        backup_deployment = self.deployments.get(backup)\n        if not backup_deployment:\n            return {\"success\": False, \"error\": f\"Backup deployment {backup} not found\"}\n\n        # Update DNS to point to backup\n        dns_resource = Resource(\n            type=\"route53_record\",\n            name=\"failover\",\n            properties={\n                \"name\": \"api.example.com\",\n                \"type\": \"A\",\n                \"ttl\": 60,\n                \"records\": [self.shared_state[backup][\"endpoint\"]]\n            }\n        )\n\n        # Add DNS update to backup deployment\n        backup_deployment.resources.append(dns_resource)\n\n        # Deploy backup with updated DNS\n        result = await self._deploy_single(backup, backup_deployment)\n\n        if result[\"success\"]:\n            # Disable primary\n            if primary in self.deployments:\n                self.deployments[primary].enabled = False\n\n            print(f\"Failover to {backup} completed successfully\")\n\n        return result\n\n    async def sync_state(self) -> Dict[str, Any]:\n        \"\"\"Synchronize state across deployments\"\"\"\n\n        sync_results = {}\n\n        for name, deployment in self.deployments.items():\n            if not deployment.enabled:\n                continue\n\n            try:\n                backend = self.backends.get(name)\n                if not backend:\n                    continue\n\n                # Refresh state\n                config = InfrastructureConfig(\n                    name=name,\n                    environment=deployment.environment,\n                    provider=deployment.provider,\n                    region=deployment.region,\n                    resources=[]\n                )\n\n                # Get current state\n                outputs = {}\n                for resource in deployment.resources:\n                    if hasattr(resource, 'name'):\n                        output = await backend.output(config, resource.name)\n                        if output:\n                            outputs[resource.name] = output\n\n                sync_results[name] = {\n                    \"success\": True,\n                    \"outputs\": outputs\n                }\n\n            except Exception as e:\n                sync_results[name] = {\n                    \"success\": False,\n                    \"error\": str(e)\n                }\n\n        return sync_results\n```\n\n## 2. GitOps Patterns\n\n### Generic GitOps Engine\n\n```python\n# gitops\u002Fengine.py\nimport asyncio\nimport aiohttp\nfrom typing import Dict, List, Any, Optional, Callable\nfrom dataclasses import dataclass, field\nfrom enum import Enum\nfrom pathlib import Path\nimport yaml\nimport json\nfrom datetime import datetime\nimport logging\n\nlogger = logging.getLogger(__name__)\n\nclass GitOpsTool(str, Enum):\n    \"\"\"Supported GitOps tools\"\"\"\n    ARGOCD = \"argocd\"\n    FLUX = \"flux\"\n    JENKINS_X = \"jenkins-x\"\n\nclass DeploymentStrategy(str, Enum):\n    \"\"\"Deployment strategies\"\"\"\n    ROLLING = \"rolling\"\n    BLUE_GREEN = \"blue-green\"\n    CANARY = \"canary\"\n    A_B = \"a-b\"\n\n@dataclass\nclass Application:\n    \"\"\"Application definition for GitOps\"\"\"\n    name: str\n    repo_url: str\n    path: str\n    target_revision: str = \"HEAD\"\n    namespace: str = \"default\"\n    destination_server: str = \"https:\u002F\u002Fkubernetes.default.svc\"\n    sync_policy: Dict[str, Any] = field(default_factory=dict)\n    health_checks: List[Dict[str, Any]] = field(default_factory=list)\n    hooks: Dict[str, List[str]] = field(default_factory=dict)\n\n@dataclass\nclass GitOpsConfig:\n    \"\"\"GitOps configuration\"\"\"\n    tool: GitOpsTool\n    namespace: str = \"gitops-system\"\n    applications: List[Application] = field(default_factory=list)\n    repositories: Dict[str, str] = field(default_factory=dict)\n    policies: List[Dict[str, Any]] = field(default_factory=list)\n    notifications: Dict[str, Any] = field(default_factory=dict)\n\nclass GitOpsEngine:\n    \"\"\"Generic GitOps engine\"\"\"\n\n    def __init__(self, config: GitOpsConfig):\n        self.config = config\n        self.kubeconfig_path: Optional[Path] = None\n        self.tool_client = None\n\n    async def initialize(self) -> None:\n        \"\"\"Initialize GitOps tool\"\"\"\n\n        if self.config.tool == GitOpsTool.ARGOCD:\n            await self._init_argocd()\n        elif self.config.tool == GitOpsTool.FLUX:\n            await self._init_flux()\n        else:\n            raise ValueError(f\"Unsupported GitOps tool: {self.config.tool}\")\n\n    async def deploy_application(\n        self,\n        app: Application,\n        strategy: DeploymentStrategy = DeploymentStrategy.ROLLING\n    ) -> Dict[str, Any]:\n        \"\"\"Deploy application using GitOps\"\"\"\n\n        logger.info(f\"Deploying application {app.name} with {strategy.value} strategy\")\n\n        # Pre-deployment hooks\n        await self._execute_hooks(app, \"pre-deploy\")\n\n        # Deploy based on strategy\n        if strategy == DeploymentStrategy.CANARY:\n            result = await self._deploy_canary(app)\n        elif strategy == DeploymentStrategy.BLUE_GREEN:\n            result = await self._deploy_blue_green(app)\n        else:\n            result = await self._deploy_rolling(app)\n\n        # Post-deployment hooks\n        if result[\"success\"]:\n            await self._execute_hooks(app, \"post-deploy\")\n\n            # Health checks\n            health_status = await self._check_health(app)\n            result[\"health\"] = health_status\n\n        return result\n\n    async def _init_argocd(self) -> None:\n        \"\"\"Initialize ArgoCD\"\"\"\n\n        # Install ArgoCD if not present\n        install_cmd = [\n            \"kubectl\", \"apply\", \"-n\", self.config.namespace,\n            \"-f\", \"https:\u002F\u002Fraw.githubusercontent.com\u002Fargoproj\u002Fargo-cd\u002Fstable\u002Fmanifests\u002Finstall.yaml\"\n        ]\n\n        result = await self._run_kubectl_command(install_cmd)\n\n        if result[\"returncode\"] != 0 and \"AlreadyExists\" not in result[\"stderr\"]:\n            raise RuntimeError(f\"Failed to install ArgoCD: {result['stderr']}\")\n\n        # Wait for ArgoCD to be ready\n        await self._wait_for_deployment(\"argocd-server\", self.config.namespace)\n\n    async def _init_flux(self) -> None:\n        \"\"\"Initialize Flux\"\"\"\n\n        # Install Flux CLI\n        install_cmd = [\n            \"curl\", \"-s\", \"https:\u002F\u002Ffluxcd.io\u002Finstall.sh | bash\"\n        ]\n\n        result = await self._run_command(install_cmd, shell=True)\n\n        if result[\"returncode\"] != 0:\n            raise RuntimeError(f\"Failed to install Flux: {result['stderr']}\")\n\n        # Bootstrap Flux\n        bootstrap_cmd = [\n            \"flux\", \"bootstrap\", \"git\",\n            \"--url\", self.config.repositories.get(\"main\", \"\"),\n            \"--branch\", \"main\",\n            \"--path\", \"clusters\u002Fmy-cluster\"\n        ]\n\n        result = await self._run_command(bootstrap_cmd)\n\n        if result[\"returncode\"] != 0:\n            raise RuntimeError(f\"Failed to bootstrap Flux: {result['stderr']}\")\n\n    async def _deploy_rolling(self, app: Application) -> Dict[str, Any]:\n        \"\"\"Deploy using rolling update strategy\"\"\"\n\n        # Create ArgoCD application manifest\n        app_manifest = self._generate_argocd_app(app)\n\n        # Apply manifest\n        result = await self._apply_kubernetes_yaml(app_manifest)\n\n        # Wait for sync\n        if result[\"success\"]:\n            sync_result = await self._wait_for_sync(app.name)\n            result.update(sync_result)\n\n        return result\n\n    async def _deploy_canary(self, app: Application) -> Dict[str, Any]:\n        \"\"\"Deploy using canary strategy\"\"\"\n\n        # Create canary application\n        canary_app = Application(\n            name=f\"{app.name}-canary\",\n            repo_url=app.repo_url,\n            path=app.path,\n            target_revision=app.target_revision,\n            namespace=app.namespace,\n            sync_policy={\n                \"automated\": {\n                    \"prune\": False,\n                    \"self_heal\": False\n                }\n            }\n        )\n\n        # Create stable application\n        stable_app = Application(\n            name=f\"{app.name}-stable\",\n            repo_url=app.repo_url,\n            path=app.path,\n            target_revision=app.target_revision,\n            namespace=app.namespace,\n            sync_policy=app.sync_policy\n        )\n\n        results = {}\n\n        # Deploy stable first\n        results[\"stable\"] = await self._deploy_rolling(stable_app)\n\n        # Deploy canary with small traffic split\n        if results[\"stable\"][\"success\"]:\n            results[\"canary\"] = await self._deploy_rolling(canary_app)\n\n            # Set up traffic splitting\n            if results[\"canary\"][\"success\"]:\n                traffic_result = await self._setup_traffic_split(app, canary_weight=10)\n                results[\"traffic\"] = traffic_result\n\n        return {\n            \"success\": all(r.get(\"success\", False) for r in results.values()),\n            \"phases\": results\n        }\n\n    async def _deploy_blue_green(self, app: Application) -> Dict[str, Any]:\n        \"\"\"Deploy using blue-green strategy\"\"\"\n\n        # Determine active color\n        active_color = await self._get_active_color(app.name)\n        new_color = \"green\" if active_color == \"blue\" else \"blue\"\n\n        # Create new deployment\n        new_app = Application(\n            name=f\"{app.name}-{new_color}\",\n            repo_url=app.repo_url,\n            path=app.path,\n            target_revision=app.target_revision,\n            namespace=app.namespace,\n            sync_policy=app.sync_policy\n        )\n\n        # Deploy new color\n        deploy_result = await self._deploy_rolling(new_app)\n\n        if deploy_result[\"success\"]:\n            # Health check new deployment\n            health_result = await self._check_deployment_health(\n                f\"{app.name}-{new_color}\",\n                app.namespace\n            )\n\n            if health_result[\"healthy\"]:\n                # Switch traffic\n                switch_result = await self._switch_traffic(app.name, new_color)\n                deploy_result[\"traffic_switch\"] = switch_result\n\n                if switch_result[\"success\"]:\n                    # Clean up old deployment\n                    old_color = active_color\n                    cleanup_result = await self._cleanup_deployment(\n                        f\"{app.name}-{old_color}\",\n                        app.namespace\n                    )\n                    deploy_result[\"cleanup\"] = cleanup_result\n            else:\n                deploy_result[\"health_check\"] = health_result\n                deploy_result[\"success\"] = False\n\n        return deploy_result\n\n    def _generate_argocd_app(self, app: Application) -> str:\n        \"\"\"Generate ArgoCD application manifest\"\"\"\n\n        manifest = {\n            \"apiVersion\": \"argoproj.io\u002Fv1alpha1\",\n            \"kind\": \"Application\",\n            \"metadata\": {\n                \"name\": app.name,\n                \"namespace\": self.config.namespace\n            },\n            \"spec\": {\n                \"project\": \"default\",\n                \"source\": {\n                    \"repoURL\": app.repo_url,\n                    \"targetRevision\": app.target_revision,\n                    \"path\": app.path\n                },\n                \"destination\": {\n                    \"server\": app.destination_server,\n                    \"namespace\": app.namespace\n                },\n                \"syncPolicy\": {\n                    \"automated\": {\n                        \"prune\": app.sync_policy.get(\"prune\", True),\n                        \"selfHeal\": app.sync_policy.get(\"self_heal\", True)\n                    },\n                    \"syncOptions\": [\n                        \"CreateNamespace=true\"\n                    ]\n                }\n            }\n        }\n\n        return yaml.dump(manifest, sort_keys=False)\n\n    async def _apply_kubernetes_yaml(self, yaml_content: str) -> Dict[str, Any]:\n        \"\"\"Apply Kubernetes YAML manifest\"\"\"\n\n        cmd = [\"kubectl\", \"apply\", \"-f\", \"-\"]\n\n        process = await asyncio.create_subprocess_exec(\n            *cmd,\n            stdin=asyncio.subprocess.PIPE,\n            stdout=asyncio.subprocess.PIPE,\n            stderr=asyncio.subprocess.PIPE,\n            env={\"KUBECONFIG\": str(self.kubeconfig_path)} if self.kubeconfig_path else None\n        )\n\n        stdout, stderr = await process.communicate(yaml_content.encode())\n\n        return {\n            \"success\": process.returncode == 0,\n            \"stdout\": stdout.decode(),\n            \"stderr\": stderr.decode()\n        }\n\n    async def _wait_for_sync(self, app_name: str, timeout: int = 300) -> Dict[str, Any]:\n        \"\"\"Wait for ArgoCD application to sync\"\"\"\n\n        start_time = datetime.utcnow()\n\n        while (datetime.utcnow() - start_time).seconds \u003C timeout:\n            cmd = [\"argocd\", \"app\", \"get\", app_name, \"-o\", \"json\"]\n            result = await self._run_command(cmd)\n\n            if result[\"returncode\"] == 0:\n                app_data = json.loads(result[\"stdout\"])\n                status = app_data.get(\"status\", {})\n\n                sync_status = status.get(\"sync\", {}).get(\"status\", \"\")\n                health_status = status.get(\"health\", {}).get(\"status\", \"\")\n\n                if sync_status == \"Synced\" and health_status == \"Healthy\":\n                    return {\n                        \"success\": True,\n                        \"status\": \"Synced and Healthy\",\n                        \"duration\": (datetime.utcnow() - start_time).seconds\n                    }\n\n            await asyncio.sleep(5)\n\n        return {\n            \"success\": False,\n            \"error\": f\"Sync timeout after {timeout} seconds\"\n        }\n\n    async def _execute_hooks(self, app: Application, hook_type: str) -> None:\n        \"\"\"Execute deployment hooks\"\"\"\n\n        hooks = app.hooks.get(hook_type, [])\n\n        for hook in hooks:\n            logger.info(f\"Executing {hook_type} hook: {hook}\")\n\n            try:\n                result = await self._run_command(hook, shell=True)\n\n                if result[\"returncode\"] != 0:\n                    logger.error(f\"Hook failed: {result['stderr']}\")\n\n            except Exception as e:\n                logger.error(f\"Error executing hook: {e}\")\n\n    async def _check_health(self, app: Application) -> Dict[str, Any]:\n        \"\"\"Check application health\"\"\"\n\n        health_results = {}\n\n        for check in app.health_checks:\n            if check[\"type\"] == \"http\":\n                result = await self._check_http_health(check)\n            elif check[\"type\"] == \"kubernetes\":\n                result = await self._check_kubernetes_health(check)\n            else:\n                result = {\"healthy\": False, \"error\": f\"Unknown health check type: {check['type']}\"}\n\n            health_results[check[\"name\"]] = result\n\n        return health_results\n\n    async def _run_kubectl_command(self, cmd: List[str]) -> Dict[str, Any]:\n        \"\"\"Run kubectl command\"\"\"\n        return await self._run_command(\n            [\"kubectl\"] + cmd,\n            env={\"KUBECONFIG\": str(self.kubeconfig_path)} if self.kubeconfig_path else None\n        )\n\n    async def _run_command(\n        self,\n        cmd: List[str],\n        shell: bool = False,\n        env: Optional[Dict[str, str]] = None\n    ) -> Dict[str, Any]:\n        \"\"\"Run command\"\"\"\n\n        if shell:\n            cmd = [\"bash\", \"-c\", \" \".join(cmd) if isinstance(cmd, list) else cmd]\n\n        process = await asyncio.create_subprocess_exec(\n            *cmd,\n            stdout=asyncio.subprocess.PIPE,\n            stderr=asyncio.subprocess.PIPE,\n            env=env\n        )\n\n        stdout, stderr = await process.communicate()\n\n        return {\n            \"returncode\": process.returncode,\n            \"stdout\": stdout.decode(),\n            \"stderr\": stderr.decode()\n        }\n\n    async def _wait_for_deployment(\n        self,\n        deployment_name: str,\n        namespace: str,\n        timeout: int = 300\n    ) -> None:\n        \"\"\"Wait for deployment to be ready\"\"\"\n\n        cmd = [\n            \"kubectl\", \"wait\",\n            f\"deployment\u002F{deployment_name}\",\n            \"--for\", \"condition=available\",\n            f\"--namespace={namespace}\",\n            f\"--timeout={timeout}s\"\n        ]\n\n        result = await self._run_kubectl_command(cmd)\n\n        if result[\"returncode\"] != 0:\n            raise RuntimeError(f\"Deployment {deployment_name} not ready: {result['stderr']}\")\n```\n\n## 3. Progressive Delivery Patterns\n\n### Canary Analysis Engine\n\n```python\n# delivery\u002Fcanary.py\nimport asyncio\nimport aiohttp\nfrom typing import Dict, List, Any, Optional, Callable\nfrom dataclasses import dataclass, field\nfrom datetime import datetime, timedelta\nimport numpy as np\nimport logging\n\nlogger = logging.getLogger(__name__)\n\n@dataclass\nclass CanaryMetric:\n    \"\"\"Canary analysis metric\"\"\"\n    name: str\n    query: str\n    weight: float = 1.0\n    threshold: Optional[float] = None\n    comparison: str = \"less_than\"  # less_than, greater_than, equals\n\n@dataclass\nclass CanaryConfig:\n    \"\"\"Canary deployment configuration\"\"\"\n    application: str\n    namespace: str\n    baseline_label: str = \"version=baseline\"\n    canary_label: str = \"version=canary\"\n    traffic_step: int = 10\n    max_traffic: int = 50\n    analysis_interval: int = 60  # seconds\n    metrics: List[CanaryMetric] = field(default_factory=list)\n    success_criteria: Dict[str, float] = field(default_factory=dict)\n    rollback_on_failure: bool = True\n\nclass CanaryAnalyzer:\n    \"\"\"Analyzes canary deployment metrics\"\"\"\n\n    def __init__(self, prometheus_url: str):\n        self.prometheus_url = prometheus_url\n        self.session = None\n\n    async def analyze(\n        self,\n        config: CanaryConfig,\n        current_traffic: int\n    ) -> Dict[str, Any]:\n        \"\"\"Analyze canary vs baseline metrics\"\"\"\n\n        analysis = {\n            \"timestamp\": datetime.utcnow().isoformat(),\n            \"traffic_percentage\": current_traffic,\n            \"metrics\": {},\n            \"overall_score\": 0.0,\n            \"recommendation\": \"proceed\"\n        }\n\n        # Query metrics for both baseline and canary\n        baseline_metrics = await self._query_metrics(config, \"baseline\")\n        canary_metrics = await self._query_metrics(config, \"canary\")\n\n        # Analyze each metric\n        metric_scores = []\n\n        for metric in config.metrics:\n            baseline_value = baseline_metrics.get(metric.name, 0)\n            canary_value = canary_metrics.get(metric.name, 0)\n\n            # Calculate percentage difference\n            if baseline_value != 0:\n                diff_percentage = ((canary_value - baseline_value) \u002F baseline_value) * 100\n            else:\n                diff_percentage = 0\n\n            # Determine if metric passes threshold\n            passes = self._evaluate_metric(metric, canary_value, baseline_value)\n\n            # Calculate score\n            score = self._calculate_score(metric, diff_percentage, passes)\n            metric_scores.append(score * metric.weight)\n\n            analysis[\"metrics\"][metric.name] = {\n                \"baseline\": baseline_value,\n                \"canary\": canary_value,\n                \"difference_percentage\": diff_percentage,\n                \"passes\": passes,\n                \"score\": score\n            }\n\n        # Calculate overall score\n        if metric_scores:\n            analysis[\"overall_score\"] = np.mean(metric_scores)\n\n        # Determine recommendation\n        analysis[\"recommendation\"] = self._get_recommendation(\n            analysis[\"overall_score\"],\n            config,\n            current_traffic\n        )\n\n        return analysis\n\n    async def _query_metrics(\n        self,\n        config: CanaryConfig,\n        variant: str\n    ) -> Dict[str, float]:\n        \"\"\"Query metrics from Prometheus\"\"\"\n\n        label = config.canary_label if variant == \"canary\" else config.baseline_label\n        metrics = {}\n\n        for metric in config.metrics:\n            query = metric.query.format(label=label)\n\n            try:\n                value = await self._query_prometheus(query)\n                metrics[metric.name] = value\n            except Exception as e:\n                logger.error(f\"Failed to query metric {metric.name}: {e}\")\n                metrics[metric.name] = 0\n\n        return metrics\n\n    async def _query_prometheus(self, query: str) -> float:\n        \"\"\"Query single metric from Prometheus\"\"\"\n\n        if not self.session:\n            self.session = aiohttp.ClientSession()\n\n        url = f\"{self.prometheus_url}\u002Fapi\u002Fv1\u002Fquery\"\n        params = {\"query\": query}\n\n        async with self.session.get(url, params=params) as response:\n            data = await response.json()\n\n            if data[\"status\"] == \"success\" and data[\"data\"][\"result\"]:\n                return float(data[\"data\"][\"result\"][0][\"value\"][1])\n\n            return 0.0\n\n    def _evaluate_metric(\n        self,\n        metric: CanaryMetric,\n        canary_value: float,\n        baseline_value: float\n    ) -> bool:\n        \"\"\"Evaluate if metric passes threshold\"\"\"\n\n        if metric.threshold is None:\n            return True\n\n        if metric.comparison == \"less_than\":\n            return canary_value \u003C= metric.threshold\n        elif metric.comparison == \"greater_than\":\n            return canary_value >= metric.threshold\n        elif metric.comparison == \"equals\":\n            return abs(canary_value - metric.threshold) \u003C 0.01\n\n        return True\n\n    def _calculate_score(\n        self,\n        metric: CanaryMetric,\n        diff_percentage: float,\n        passes: bool\n    ) -> float:\n        \"\"\"Calculate metric score\"\"\"\n\n        if not passes:\n            return 0.0\n\n        # Score based on how close to baseline\n        if abs(diff_percentage) \u003C 5:\n            return 1.0\n        elif abs(diff_percentage) \u003C 10:\n            return 0.8\n        elif abs(diff_percentage) \u003C 20:\n            return 0.6\n        else:\n            return 0.4\n\n    def _get_recommendation(\n        self,\n        score: float,\n        config: CanaryConfig,\n        current_traffic: int\n    ) -> str:\n        \"\"\"Get deployment recommendation\"\"\"\n\n        if score \u003C 0.5:\n            return \"rollback\"\n        elif score \u003C 0.7:\n            if current_traffic >= config.max_traffic:\n                return \"rollback\"\n            return \"hold\"\n        else:\n            if current_traffic >= config.max_traffic:\n                return \"promote\"\n            return \"promote\"\n\nclass CanaryController:\n    \"\"\"Controls canary deployment lifecycle\"\"\"\n\n    def __init__(self, analyzer: CanaryAnalyzer, k8s_client):\n        self.analyzer = analyzer\n        self.k8s_client = k8s_client\n        self.active_canaries: Dict[str, Dict[str, Any]] = {}\n\n    async def start_canary(self, config: CanaryConfig) -> str:\n        \"\"\"Start canary deployment\"\"\"\n\n        canary_id = f\"{config.application}-{int(datetime.utcnow().timestamp())}\"\n\n        # Create initial canary deployment\n        await self._create_canary_deployment(config)\n\n        # Set up initial traffic split\n        await self._set_traffic_split(config, config.traffic_step)\n\n        # Start analysis loop\n        asyncio.create_task(self._analysis_loop(canary_id, config))\n\n        self.active_canaries[canary_id] = {\n            \"config\": config,\n            \"current_traffic\": config.traffic_step,\n            \"started_at\": datetime.utcnow(),\n            \"status\": \"running\"\n        }\n\n        logger.info(f\"Started canary deployment {canary_id}\")\n        return canary_id\n\n    async def _analysis_loop(self, canary_id: str, config: CanaryConfig) -> None:\n        \"\"\"Run continuous analysis\"\"\"\n\n        while canary_id in self.active_canaries:\n            canary_info = self.active_canaries[canary_id]\n\n            if canary_info[\"status\"] != \"running\":\n                break\n\n            # Run analysis\n            analysis = await self.analyzer.analyze(\n                config,\n                canary_info[\"current_traffic\"]\n            )\n\n            # Act on recommendation\n            await self._handle_recommendation(canary_id, analysis)\n\n            # Wait for next analysis\n            await asyncio.sleep(config.analysis_interval)\n\n    async def _handle_recommendation(\n        self,\n        canary_id: str,\n        analysis: Dict[str, Any]\n    ) -> None:\n        \"\"\"Handle analysis recommendation\"\"\"\n\n        canary_info = self.active_canaries.get(canary_id)\n        if not canary_info:\n            return\n\n        recommendation = analysis[\"recommendation\"]\n        config = canary_info[\"config\"]\n\n        if recommendation == \"rollback\":\n            logger.warning(f\"Rolling back canary {canary_id}\")\n            await self._rollback_canary(canary_id)\n\n        elif recommendation == \"hold\":\n            logger.info(f\"Holding canary {canary_id} at {canary_info['current_traffic']}% traffic\")\n\n        elif recommendation == \"promote\":\n            if canary_info[\"current_traffic\"] >= config.max_traffic:\n                # Full promotion\n                logger.info(f\"Promoting canary {canary_id} to production\")\n                await self._promote_canary(canary_id)\n            else:\n                # Increase traffic\n                new_traffic = min(\n                    canary_info[\"current_traffic\"] + config.traffic_step,\n                    config.max_traffic\n                )\n\n                logger.info(f\"Increasing canary {canary_id} traffic to {new_traffic}%\")\n                await self._set_traffic_split(config, new_traffic)\n                canary_info[\"current_traffic\"] = new_traffic\n\n    async def _set_traffic_split(\n        self,\n        config: CanaryConfig,\n        canary_percentage: int\n    ) -> None:\n        \"\"\"Set traffic split between baseline and canary\"\"\"\n\n        # Implementation depends on traffic management solution\n        # Could be Istio VirtualService, AWS ALB, Nginx Ingress, etc.\n\n        if config.namespace == \"istio-system\":\n            await self._set_istio_traffic_split(config, canary_percentage)\n        elif config.namespace == \"aws\":\n            await self._set_alb_traffic_split(config, canary_percentage)\n        else:\n            await self._set_service_mesh_traffic_split(config, canary_percentage)\n\n    async def _set_istio_traffic_split(\n        self,\n        config: CanaryConfig,\n        canary_percentage: int\n    ) -> None:\n        \"\"\"Set traffic split using Istio\"\"\"\n\n        # Update Istio VirtualService\n        virtual_service = {\n            \"apiVersion\": \"networking.istio.io\u002Fv1beta1\",\n            \"kind\": \"VirtualService\",\n            \"metadata\": {\n                \"name\": config.application,\n                \"namespace\": config.namespace\n            },\n            \"spec\": {\n                \"http\": [\n                    {\n                        \"name\": \"primary\",\n                        \"route\": [\n                            {\n                                \"destination\": {\n                                    \"host\": f\"{config.application}\",\n                                    \"subset\": \"canary\"\n                                },\n                                \"weight\": canary_percentage\n                            },\n                            {\n                                \"destination\": {\n                                    \"host\": f\"{config.application}\",\n                                    \"subset\": \"baseline\"\n                                },\n                                \"weight\": 100 - canary_percentage\n                            }\n                        ]\n                    }\n                ]\n            }\n        }\n\n        # Apply to Kubernetes\n        cmd = [\n            \"kubectl\", \"apply\", \"-f\", \"-\",\n            \"-n\", config.namespace\n        ]\n\n        # Implementation would apply the VirtualService\n        pass\n```\n\nThis comprehensive cloud-native deployment skill provides production-ready patterns for implementing modern infrastructure as code, GitOps workflows, and progressive delivery strategies across any cloud provider or platform.\n\n`★ Insight ─────────────────────────────────────`\nThe cloud-native patterns shown here emphasize several key 2025 best practices:\n1. **Provider Abstraction**: Generic interfaces allow switching between Terraform, Pulumi, and other IaC tools\n2. **Multi-Cloud Strategy**: Built-in support for managing deployments across multiple providers with failover capabilities\n3. **GitOps-First**: Declarative deployment through Git with support for ArgoCD, Flux, and custom tools\n4. **Progressive Delivery**: Safe deployments with canary analysis, blue-green strategies, and automated rollback\n5. **Policy as Code**: Integration with Open Policy Agent for automated compliance and security\n\nThese patterns ensure your cloud deployments are automated, secure, and resilient across any infrastructure.\n`─────────────────────────────────────────────────`",{"name":5,"license":14,"description":7},"master","08cc2532077058aa50e6e18f54695bc256c88152","skills\u002Fazeem-2\u002Fcloud-native","https:\u002F\u002Fgithub.com\u002Fsuperhealth\u002Fskills-hub","https:\u002F\u002Fgithub.com\u002Fsuperhealth","java engineer","2026-04-06 22:07:23",{"source":8,"skillName":5,"commands":50,"prompt":60,"zipAvailable":61},[51,54,57],{"tool":52,"command":53},"npx","npx skills add superhealth\u002Fskills-hub --skill cloud-native",{"tool":55,"command":56},"bunx","bunx skills add superhealth\u002Fskills-hub --skill cloud-native",{"tool":58,"command":59},"pnpm","pnpm dlx skills add superhealth\u002Fskills-hub --skill cloud-native","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fsuperhealth\u002Fskills-hub\u002Fblob\u002Fmaster\u002Fskills\u002Fazeem-2\u002Fcloud-native\u002FSKILL.md",true,[63],{"path":64,"resourceType":65,"resourceTypeDesc":66,"sizeBytes":67,"sourceHtmlUrl":68},"skill-report.json","REFERENCE","参考文档",13741,"https:\u002F\u002Fgithub.com\u002Fsuperhealth\u002Fskills-hub\u002Fblob\u002Fmaster\u002Fskills\u002Fazeem-2\u002Fcloud-native\u002Fskill-report.json",[70,102,129,142,158,182],{"skillNo":71,"name":72,"nameZh":6,"description":73,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":74,"categories":75,"keywords":81,"publishedAt":37},"01M6MC9F3WHV8S8FZ2W4TRB0FE","vercel-react-best-practices","React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React\u002FNext.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.","https:\u002F\u002Fgithub.com\u002Fsuperhealth\u002Fskills-hub\u002Fblob\u002Fmaster\u002Fskills\u002Fzhanlincui\u002Fvercel-react-best-practices\u002FSKILL.md",[76],{"categoryNo":77,"categoryName":78,"taxonomyType":79,"taxonomyTypeDesc":80},"01JBSEEDCAT000000000000009","前端开发","SCENARIO","使用场景",[82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101],"react","vercel react best practices","best practices","vercel","react best practices","data fetching","code","triggers","pages","next","patterns","refactoring","data","Optimization","tasks","guidelines","react components","components","performance","writing",{"skillNo":103,"name":104,"nameZh":6,"description":105,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":106,"categories":107,"keywords":112,"publishedAt":37},"01M6MB8KWE1Q5A5KERR7RFTQWP","vue-testing-best-practices","Use for Vue.js testing. Covers Vitest, Vue Test Utils, component testing, mocking, testing patterns, and Playwright for E2E testing.","https:\u002F\u002Fgithub.com\u002Fsuperhealth\u002Fskills-hub\u002Fblob\u002Fmaster\u002Fskills\u002Fvuejs-ai\u002Fvue-testing-best-practices\u002FSKILL.md",[108,111],{"categoryNo":109,"categoryName":110,"taxonomyType":79,"taxonomyTypeDesc":80},"01JBSEEDCAT000000000000008","测试与质量",{"categoryNo":77,"categoryName":78,"taxonomyType":79,"taxonomyTypeDesc":80},[113,114,115,84,116,117,118,119,120,121,122,92,123,124,22,125,126,127,128],"vue testing best practices","testing best practices","vue","testing","testing patterns","js","e2e","vitest","use","component","test","mocking","utils","e2e testing","github","playwright",{"skillNo":130,"name":131,"nameZh":6,"description":132,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":133,"categories":134,"keywords":136,"publishedAt":37},"01M6MB8GK06M6GA4KVYNDV1BZP","vue-router-best-practices","Vue Router 4 patterns, navigation guards, route params, and route-component lifecycle interactions.","https:\u002F\u002Fgithub.com\u002Fsuperhealth\u002Fskills-hub\u002Fblob\u002Fmaster\u002Fskills\u002Fvuejs-ai\u002Fvue-router-best-practices\u002FSKILL.md",[135],{"categoryNo":77,"categoryName":78,"taxonomyType":79,"taxonomyTypeDesc":80},[84,115,137,138,139,92,140,141,122,127],"router","vue router best practices","route","navigation","lifecycle",{"skillNo":143,"name":144,"nameZh":6,"description":145,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":146,"categories":147,"keywords":149,"publishedAt":37},"01M6MB8DQF21TZMQ9XC3745ERW","vue-pinia-best-practices","Pinia stores, state management patterns, store setup, and reactivity with stores.","https:\u002F\u002Fgithub.com\u002Fsuperhealth\u002Fskills-hub\u002Fblob\u002Fmaster\u002Fskills\u002Fvuejs-ai\u002Fvue-pinia-best-practices\u002FSKILL.md",[148],{"categoryNo":77,"categoryName":78,"taxonomyType":79,"taxonomyTypeDesc":80},[150,151,115,84,152,153,92,154,155,156,157,127],"vue pinia best practices","pinia","with","store","management","state","state management","setup",{"skillNo":159,"name":160,"nameZh":6,"description":161,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":162,"categories":163,"keywords":173,"publishedAt":37},"01M6MB8A7MC08747J9TV4GWQ9A","vue-options-api-best-practices","Vue 3 Options API style (data(), methods, this context). Each reference shows Options API solution only.","https:\u002F\u002Fgithub.com\u002Fsuperhealth\u002Fskills-hub\u002Fblob\u002Fmaster\u002Fskills\u002Fvuejs-ai\u002Fvue-options-api-best-practices\u002FSKILL.md",[164,165,168],{"categoryNo":77,"categoryName":78,"taxonomyType":79,"taxonomyTypeDesc":80},{"categoryNo":166,"categoryName":167,"taxonomyType":79,"taxonomyTypeDesc":80},"01JBSEEDCAT000000000000010","后端与接口",{"categoryNo":169,"categoryName":170,"taxonomyType":171,"taxonomyTypeDesc":172},"01JBSEEDCAT000000000000030","开发工程师","PROFESSION","适用职业",[115,174,175,176,84,177,178,179,180,94,127,181],"options","vue options api best practices","api","methods","reference","only","context","style",{"skillNo":183,"name":184,"nameZh":6,"description":185,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":186,"categories":187,"keywords":189,"publishedAt":37},"01M6MB85ZTQC24Q04X49MM4YXN","vue-development-guides","A collection of best practices and tips for developing applications using Vue.js. This skill MUST be apply when developing, refactoring or reviewing Vue.js or Nuxt projects.","https:\u002F\u002Fgithub.com\u002Fsuperhealth\u002Fskills-hub\u002Fblob\u002Fmaster\u002Fskills\u002Fvuejs-ai\u002Fvue-development-guides\u002FSKILL.md",[188],{"categoryNo":77,"categoryName":78,"taxonomyType":79,"taxonomyTypeDesc":80},[190,115,191,192,127,193,194,22,195,196,197,118,93,198,199,84],"development","guides","vue development guides","tips","apply","project","nuxt","projects","collection","applications"]