Cloud Platform Automation - Azure & GCP

1from azure.identity import DefaultAzureCredential, ClientSecretCredential
2from azure.mgmt.compute import ComputeManagementClient
3from azure.mgmt.storage import StorageManagementClient
4from azure.mgmt.network import NetworkManagementClient
5from azure.mgmt.resource import ResourceManagementClient
6from azure.mgmt.monitor import MonitorManagementClient
7from azure.mgmt.costmanagement import CostManagementClient
8from azure.storage.blob import BlobServiceClient
9from typing import Dict, List, Optional
10import logging
11
12logger = logging.getLogger(__name__)
13
14class AzureAutomationManager:
15    """Comprehensive Azure automation using official SDK"""
16
17    def __init__(self, subscription_id: str,
18                 tenant_id: str = None,
19                 client_id: str = None,
20                 client_secret: str = None):
21        """
22        Initialize Azure clients with authentication
23
24        Args:
25            subscription_id: Azure subscription ID
26            tenant_id: Azure AD tenant ID (for service principal)
27            client_id: Service principal application ID
28            client_secret: Service principal secret
29        """
30        # Authentication - supports both DefaultAzureCredential and Service Principal
31        if tenant_id and client_id and client_secret:
32            self.credential = ClientSecretCredential(
33                tenant_id=tenant_id,
34                client_id=client_id,
35                client_secret=client_secret
36            )
37            logger.info("🔐 Using Service Principal authentication")
38        else:
39            # Uses environment variables, managed identity, or Azure CLI login
40            self.credential = DefaultAzureCredential()
41            logger.info("🔐 Using DefaultAzureCredential authentication")
42
43        self.subscription_id = subscription_id
44
45        # Initialize management clients
46        self.resource_client = ResourceManagementClient(
47            self.credential, subscription_id
48        )
49        self.compute_client = ComputeManagementClient(
50            self.credential, subscription_id
51        )
52        self.storage_client = StorageManagementClient(
53            self.credential, subscription_id
54        )
55        self.network_client = NetworkManagementClient(
56            self.credential, subscription_id
57        )
58        self.monitor_client = MonitorManagementClient(
59            self.credential, subscription_id
60        )
61
62        logger.info(f"✅ Azure clients initialized for subscription {subscription_id}")
63
64    def create_resource_group(self, name: str, location: str,
65                            tags: Dict[str, str] = None) -> Dict:
66        """
67        Create or update Azure resource group
68
69        Args:
70            name: Resource group name
71            location: Azure region (e.g., 'eastus', 'westeurope')
72            tags: Optional tags for resource organization
73
74        Returns:
75            Resource group details
76        """
77        try:
78            rg_params = {
79                'location': location,
80                'tags': tags or {'Environment': 'Production', 'ManagedBy': 'Python'}
81            }
82
83            logger.info(f"📦 Creating resource group '{name}' in {location}...")
84
85            rg = self.resource_client.resource_groups.create_or_update(
86                name, rg_params
87            )
88
89            logger.info(f"✅ Resource group created: {rg.name}")
90
91            return {
92                'name': rg.name,
93                'location': rg.location,
94                'id': rg.id,
95                'tags': rg.tags,
96                'provisioning_state': rg.properties.provisioning_state
97            }
98
99        except Exception as e:
100            logger.error(f"❌ Failed to create resource group: {e}")
101            raise
102
103    def create_storage_account(self, resource_group: str,
104                              account_name: str,
105                              location: str,
106                              sku_name: str = 'Standard_LRS') -> Dict:
107        """
108        Create Azure Storage account
109
110        Args:
111            resource_group: Resource group name
112            account_name: Storage account name (globally unique)
113            location: Azure region
114            sku_name: SKU (Standard_LRS, Standard_GRS, Premium_LRS)
115
116        Returns:
117            Storage account details
118        """
119        from azure.mgmt.storage.models import (
120            StorageAccountCreateParameters,
121            Sku,
122            Kind
123        )
124
125        try:
126            logger.info(f"💾 Creating storage account '{account_name}'...")
127
128            storage_params = StorageAccountCreateParameters(
129                sku=Sku(name=sku_name),
130                kind=Kind.STORAGE_V2,
131                location=location,
132                tags={'Purpose': 'Automation', 'ManagedBy': 'Python'}
133            )
134
135            # Async operation - wait for completion
136            async_operation = self.storage_client.storage_accounts.begin_create(
137                resource_group,
138                account_name,
139                storage_params
140            )
141
142            storage_account = async_operation.result()
143
144            # Get access keys
145            keys = self.storage_client.storage_accounts.list_keys(
146                resource_group, account_name
147            )
148            primary_key = keys.keys[0].value
149
150            logger.info(f"✅ Storage account created: {storage_account.name}")
151
152            return {
153                'name': storage_account.name,
154                'location': storage_account.location,
155                'primary_endpoint': storage_account.primary_endpoints.blob,
156                'access_key': primary_key,
157                'provisioning_state': storage_account.provisioning_state
158            }
159
160        except Exception as e:
161            logger.error(f"❌ Failed to create storage account: {e}")
162            raise
163
164    def create_virtual_machine(self, resource_group: str,
165                              vm_name: str,
166                              location: str,
167                              vm_size: str = 'Standard_B2s',
168                              admin_username: str = 'azureuser',
169                              admin_password: str = None) -> Dict:
170        """
171        Create Azure Virtual Machine with networking
172
173        Args:
174            resource_group: Resource group name
175            vm_name: Virtual machine name
176            location: Azure region
177            vm_size: VM size (Standard_B2s, Standard_D2s_v3, etc.)
178            admin_username: Admin username
179            admin_password: Admin password (or use SSH keys)
180
181        Returns:
182            VM details
183        """
184        from azure.mgmt.network.models import (
185            VirtualNetwork, Subnet, NetworkInterface,
186            NetworkInterfaceIPConfiguration, PublicIPAddress
187        )
188        from azure.mgmt.compute.models import (
189            VirtualMachine, HardwareProfile, StorageProfile,
190            OSProfile, NetworkProfile, ImageReference,
191            ManagedDiskParameters, OSDisk, DiskCreateOptionTypes
192        )
193
194        try:
195            logger.info(f"🖥️  Creating VM '{vm_name}' with networking...")
196
197            # 1. Create Virtual Network
198            vnet_name = f"{vm_name}-vnet"
199            vnet_params = VirtualNetwork(
200                location=location,
201                address_space={'address_prefixes': ['10.0.0.0/16']}
202            )
203
204            vnet_op = self.network_client.virtual_networks.begin_create_or_update(
205                resource_group, vnet_name, vnet_params
206            )
207            vnet = vnet_op.result()
208            logger.info(f"  ✓ VNet created: {vnet.name}")
209
210            # 2. Create Subnet
211            subnet_name = f"{vm_name}-subnet"
212            subnet_params = Subnet(
213                address_prefix='10.0.0.0/24'
214            )
215
216            subnet_op = self.network_client.subnets.begin_create_or_update(
217                resource_group, vnet_name, subnet_name, subnet_params
218            )
219            subnet = subnet_op.result()
220            logger.info(f"  ✓ Subnet created: {subnet.name}")
221
222            # 3. Create Public IP
223            ip_name = f"{vm_name}-ip"
224            ip_params = PublicIPAddress(
225                location=location,
226                public_ip_allocation_method='Dynamic'
227            )
228
229            ip_op = self.network_client.public_ip_addresses.begin_create_or_update(
230                resource_group, ip_name, ip_params
231            )
232            public_ip = ip_op.result()
233            logger.info(f"  ✓ Public IP created: {public_ip.name}")
234
235            # 4. Create Network Interface
236            nic_name = f"{vm_name}-nic"
237            nic_params = NetworkInterface(
238                location=location,
239                ip_configurations=[NetworkInterfaceIPConfiguration(
240                    name=f"{vm_name}-ipconfig",
241                    subnet={'id': subnet.id},
242                    public_ip_address={'id': public_ip.id}
243                )]
244            )
245
246            nic_op = self.network_client.network_interfaces.begin_create_or_update(
247                resource_group, nic_name, nic_params
248            )
249            nic = nic_op.result()
250            logger.info(f"  ✓ NIC created: {nic.name}")
251
252            # 5. Create Virtual Machine
253            vm_params = VirtualMachine(
254                location=location,
255                hardware_profile=HardwareProfile(vm_size=vm_size),
256                storage_profile=StorageProfile(
257                    image_reference=ImageReference(
258                        publisher='Canonical',
259                        offer='UbuntuServer',
260                        sku='18.04-LTS',
261                        version='latest'
262                    ),
263                    os_disk=OSDisk(
264                        create_option=DiskCreateOptionTypes.FROM_IMAGE,
265                        managed_disk=ManagedDiskParameters(
266                            storage_account_type='Standard_LRS'
267                        )
268                    )
269                ),
270                os_profile=OSProfile(
271                    computer_name=vm_name,
272                    admin_username=admin_username,
273                    admin_password=admin_password
274                ),
275                network_profile=NetworkProfile(
276                    network_interfaces=[{'id': nic.id}]
277                )
278            )
279
280            vm_op = self.compute_client.virtual_machines.begin_create_or_update(
281                resource_group, vm_name, vm_params
282            )
283            vm = vm_op.result()
284
285            logger.info(f"✅ VM created: {vm.name} ({vm_size})")
286
287            return {
288                'name': vm.name,
289                'location': vm.location,
290                'vm_size': vm.hardware_profile.vm_size,
291                'vm_id': vm.vm_id,
292                'provisioning_state': vm.provisioning_state
293            }
294
295        except Exception as e:
296            logger.error(f"❌ Failed to create VM: {e}")
297            raise
298
299    def get_cost_report(self, resource_group: str = None) -> Dict:
300        """
301        Get Azure cost analysis
302
303        Args:
304            resource_group: Optional resource group filter
305
306        Returns:
307            Cost details
308        """
309        try:
310            logger.info("💰 Fetching Azure cost data...")
311
312            # Note: Cost Management API requires specific permissions
313            # This is a simplified example
314
315            return {
316                'period': 'last_30_days',
317                'total_cost': 'Cost data requires Cost Management permissions',
318                'note': 'Use Azure Cost Management API with proper permissions'
319            }
320
321        except Exception as e:
322            logger.warning(f"⚠️  Cost data unavailable: {e}")
323            return {'error': str(e)}

1from google.cloud import compute_v1
2from google.cloud import storage
3from google.cloud import sql_v1
4from google.cloud import monitoring_v3
5from google.cloud import billing_v1
6from google.oauth2 import service_account
7from typing import Dict, List, Optional
8import logging
9
10logger = logging.getLogger(__name__)
11
12class GCPAutomationManager:
13    """Comprehensive GCP automation using official client libraries"""
14
15    def __init__(self, project_id: str,
16                 credentials_path: str = None):
17        """
18        Initialize GCP clients with authentication
19
20        Args:
21            project_id: GCP project ID
22            credentials_path: Path to service account JSON key file
23                            (if None, uses Application Default Credentials)
24        """
25        self.project_id = project_id
26
27        # Authentication
28        if credentials_path:
29            self.credentials = service_account.Credentials.from_service_account_file(
30                credentials_path
31            )
32            logger.info(f"🔐 Using service account from {credentials_path}")
33        else:
34            # Uses Application Default Credentials (ADC)
35            # Set via GOOGLE_APPLICATION_CREDENTIALS env var or gcloud auth
36            self.credentials = None
37            logger.info("🔐 Using Application Default Credentials")
38
39        # Initialize service clients
40        self.instances_client = compute_v1.InstancesClient(
41            credentials=self.credentials
42        )
43        self.storage_client = storage.Client(
44            project=project_id,
45            credentials=self.credentials
46        )
47        self.sql_client = sql_v1.SqlInstancesServiceClient(
48            credentials=self.credentials
49        )
50
51        logger.info(f"✅ GCP clients initialized for project {project_id}")
52
53    def create_storage_bucket(self, bucket_name: str,
54                             location: str = 'US',
55                             storage_class: str = 'STANDARD') -> Dict:
56        """
57        Create GCS bucket
58
59        Args:
60            bucket_name: Globally unique bucket name
61            location: Bucket location (US, EU, ASIA, or specific region)
62            storage_class: STANDARD, NEARLINE, COLDLINE, ARCHIVE
63
64        Returns:
65            Bucket details
66        """
67        try:
68            logger.info(f"🪣 Creating GCS bucket '{bucket_name}'...")
69
70            bucket = self.storage_client.bucket(bucket_name)
71            bucket.storage_class = storage_class
72            bucket.location = location
73
74            # Versioning and lifecycle rules
75            bucket.versioning_enabled = True
76
77            # Create bucket
78            new_bucket = self.storage_client.create_bucket(
79                bucket,
80                project=self.project_id
81            )
82
83            logger.info(f"✅ Bucket created: {new_bucket.name} in {new_bucket.location}")
84
85            return {
86                'name': new_bucket.name,
87                'location': new_bucket.location,
88                'storage_class': new_bucket.storage_class,
89                'time_created': new_bucket.time_created.isoformat(),
90                'self_link': new_bucket.self_link
91            }
92
93        except Exception as e:
94            logger.error(f"❌ Failed to create bucket: {e}")
95            raise
96
97    def upload_to_bucket(self, bucket_name: str,
98                        source_file: str,
99                        destination_blob: str) -> Dict:
100        """
101        Upload file to GCS bucket
102
103        Args:
104            bucket_name: Bucket name
105            source_file: Local file path
106            destination_blob: Destination path in bucket
107
108        Returns:
109            Upload details
110        """
111        try:
112            logger.info(f"📤 Uploading {source_file} to gs://{bucket_name}/{destination_blob}")
113
114            bucket = self.storage_client.bucket(bucket_name)
115            blob = bucket.blob(destination_blob)
116
117            # Upload with metadata
118            blob.upload_from_filename(
119                source_file,
120                content_type='application/octet-stream'
121            )
122
123            # Make public (optional)
124            # blob.make_public()
125
126            logger.info(f"✅ File uploaded successfully")
127
128            return {
129                'bucket': bucket_name,
130                'blob': destination_blob,
131                'size': blob.size,
132                'md5_hash': blob.md5_hash,
133                'public_url': blob.public_url if blob.public_url else None
134            }
135
136        except Exception as e:
137            logger.error(f"❌ Failed to upload file: {e}")
138            raise
139
140    def create_compute_instance(self, zone: str,
141                               instance_name: str,
142                               machine_type: str = 'e2-medium',
143                               disk_image: str = 'projects/debian-cloud/global/images/family/debian-11') -> Dict:
144        """
145        Create GCE compute instance
146
147        Args:
148            zone: GCP zone (e.g., 'us-central1-a')
149            instance_name: Instance name
150            machine_type: Machine type (e2-micro, e2-medium, n1-standard-1)
151            disk_image: Boot disk image
152
153        Returns:
154            Instance details
155        """
156        try:
157            logger.info(f"🖥️  Creating compute instance '{instance_name}' in {zone}...")
158
159            # Define instance configuration
160            instance = compute_v1.Instance()
161            instance.name = instance_name
162            instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
163
164            # Boot disk
165            disk = compute_v1.AttachedDisk()
166            disk.boot = True
167            disk.auto_delete = True
168            disk.initialize_params = compute_v1.AttachedDiskInitializeParams()
169            disk.initialize_params.source_image = disk_image
170            disk.initialize_params.disk_size_gb = 10
171            instance.disks = [disk]
172
173            # Network interface with external IP
174            network_interface = compute_v1.NetworkInterface()
175            network_interface.name = 'global/networks/default'
176
177            # Add external IP access
178            access_config = compute_v1.AccessConfig()
179            access_config.name = 'External NAT'
180            access_config.type_ = 'ONE_TO_ONE_NAT'
181            network_interface.access_configs = [access_config]
182
183            instance.network_interfaces = [network_interface]
184
185            # Labels for organization
186            instance.labels = {
187                'environment': 'production',
188                'managed_by': 'python'
189            }
190
191            # Create instance request
192            request = compute_v1.InsertInstanceRequest()
193            request.zone = zone
194            request.project = self.project_id
195            request.instance_resource = instance
196
197            # Execute creation (async operation)
198            operation = self.instances_client.insert(request=request)
199
200            # Wait for completion
201            logger.info(f"  ⏳ Waiting for instance creation...")
202            self._wait_for_operation(operation, zone)
203
204            # Get instance details
205            get_request = compute_v1.GetInstanceRequest()
206            get_request.project = self.project_id
207            get_request.zone = zone
208            get_request.instance = instance_name
209
210            created_instance = self.instances_client.get(request=get_request)
211
212            logger.info(f"✅ Instance created: {created_instance.name}")
213
214            # Extract network info
215            external_ip = None
216            if created_instance.network_interfaces:
217                access_configs = created_instance.network_interfaces[0].access_configs
218                if access_configs:
219                    external_ip = access_configs[0].nat_i_p
220
221            return {
222                'name': created_instance.name,
223                'zone': zone,
224                'machine_type': machine_type,
225                'status': created_instance.status,
226                'internal_ip': created_instance.network_interfaces[0].network_i_p if created_instance.network_interfaces else None,
227                'external_ip': external_ip,
228                'self_link': created_instance.self_link
229            }
230
231        except Exception as e:
232            logger.error(f"❌ Failed to create instance: {e}")
233            raise
234
235    def _wait_for_operation(self, operation, zone: str, timeout: int = 300):
236        """Wait for GCP operation to complete"""
237        import time
238
239        operations_client = compute_v1.ZoneOperationsClient(
240            credentials=self.credentials
241        )
242
243        start_time = time.time()
244
245        while time.time() - start_time < timeout:
246            request = compute_v1.GetZoneOperationRequest()
247            request.project = self.project_id
248            request.zone = zone
249            request.operation = operation.name
250
251            result = operations_client.get(request=request)
252
253            if result.status == compute_v1.Operation.Status.DONE:
254                if result.error:
255                    raise Exception(f"Operation failed: {result.error}")
256                return result
257
258            time.sleep(5)
259
260        raise TimeoutError(f"Operation timed out after {timeout}s")
261
262    def list_all_instances(self, zone: str) -> List[Dict]:
263        """
264        List all compute instances in zone
265
266        Args:
267            zone: GCP zone
268
269        Returns:
270            List of instances
271        """
272        try:
273            logger.info(f"📋 Listing instances in {zone}...")
274
275            request = compute_v1.ListInstancesRequest()
276            request.project = self.project_id
277            request.zone = zone
278
279            instances = []
280
281            for instance in self.instances_client.list(request=request):
282                instances.append({
283                    'name': instance.name,
284                    'machine_type': instance.machine_type.split('/')[-1],
285                    'status': instance.status,
286                    'zone': zone
287                })
288
289            logger.info(f"✅ Found {len(instances)} instances")
290            return instances
291
292        except Exception as e:
293            logger.error(f"❌ Failed to list instances: {e}")
294            raise
295
296    def delete_instance(self, zone: str, instance_name: str) -> bool:
297        """
298        Delete compute instance
299
300        Args:
301            zone: GCP zone
302            instance_name: Instance name
303
304        Returns:
305            True if successful
306        """
307        try:
308            logger.info(f"🗑️  Deleting instance '{instance_name}'...")
309
310            request = compute_v1.DeleteInstanceRequest()
311            request.project = self.project_id
312            request.zone = zone
313            request.instance = instance_name
314
315            operation = self.instances_client.delete(request=request)
316            self._wait_for_operation(operation, zone)
317
318            logger.info(f"✅ Instance deleted: {instance_name}")
319            return True
320
321        except Exception as e:
322            logger.error(f"❌ Failed to delete instance: {e}")
323            raise

1from abc import ABC, abstractmethod
2from enum import Enum
3from dataclasses import dataclass
4from typing import Dict, List, Optional
5import logging
6
7logger = logging.getLogger(__name__)
8
9class CloudProvider(Enum):
10    """Supported cloud providers"""
11    AZURE = "azure"
12    GCP = "gcp"
13    AWS = "aws"
14
15@dataclass
16class CloudResource:
17    """Cloud-agnostic resource representation"""
18    provider: CloudProvider
19    resource_type: str
20    name: str
21    region: str
22    status: str
23    metadata: Dict
24    cost_per_hour: Optional[float] = None
25
26@dataclass
27class VirtualMachineConfig:
28    """Cloud-agnostic VM configuration"""
29    name: str
30    region: str
31    size: str  # Will be mapped to provider-specific sizes
32    image: str
33    disk_size_gb: int = 30
34    tags: Dict[str, str] = None
35
36class CloudProviderInterface(ABC):
37    """Abstract interface for cloud providers"""
38
39    @abstractmethod
40    def create_vm(self, config: VirtualMachineConfig) -> CloudResource:
41        """Create virtual machine"""
42        pass
43
44    @abstractmethod
45    def delete_vm(self, vm_name: str, region: str) -> bool:
46        """Delete virtual machine"""
47        pass
48
49    @abstractmethod
50    def list_vms(self, region: str) -> List[CloudResource]:
51        """List virtual machines"""
52        pass
53
54    @abstractmethod
55    def create_storage(self, name: str, region: str) -> CloudResource:
56        """Create storage bucket/container"""
57        pass
58
59    @abstractmethod
60    def get_cost_report(self, days: int = 30) -> Dict:
61        """Get cost analysis"""
62        pass
63
64class MultiCloudOrchestrator:
65    """
66    Orchestrate operations across multiple cloud providers
67    """
68
69    def __init__(self):
70        """Initialize orchestrator with provider managers"""
71        self.providers: Dict[CloudProvider, CloudProviderInterface] = {}
72        logger.info("🌐 Initializing multi-cloud orchestrator")
73
74    def register_provider(self, provider: CloudProvider,
75                         manager: CloudProviderInterface):
76        """
77        Register cloud provider
78
79        Args:
80            provider: Cloud provider enum
81            manager: Provider-specific manager instance
82        """
83        self.providers[provider] = manager
84        logger.info(f"✅ Registered {provider.value} provider")
85
86    def deploy_to_all_clouds(self, vm_config: VirtualMachineConfig) -> List[CloudResource]:
87        """
88        Deploy VM to all registered cloud providers
89
90        Args:
91            vm_config: VM configuration
92
93        Returns:
94            List of created resources across clouds
95        """
96        resources = []
97
98        for provider, manager in self.providers.items():
99            try:
100                logger.info(f"🚀 Deploying to {provider.value}...")
101
102                # Map generic config to provider-specific config
103                provider_config = self._map_vm_config(vm_config, provider)
104
105                resource = manager.create_vm(provider_config)
106                resources.append(resource)
107
108                logger.info(f"✅ Deployed to {provider.value}: {resource.name}")
109
110            except Exception as e:
111                logger.error(f"❌ Failed to deploy to {provider.value}: {e}")
112                # Continue with other providers
113
114        return resources
115
116    def _map_vm_config(self, config: VirtualMachineConfig,
117                      provider: CloudProvider) -> VirtualMachineConfig:
118        """
119        Map generic VM size to provider-specific size
120
121        Args:
122            config: Generic VM config
123            provider: Target cloud provider
124
125        Returns:
126            Provider-specific config
127        """
128        # VM size mapping
129        size_mappings = {
130            'small': {
131                CloudProvider.AZURE: 'Standard_B2s',
132                CloudProvider.GCP: 'e2-medium',
133                CloudProvider.AWS: 't3.medium'
134            },
135            'medium': {
136                CloudProvider.AZURE: 'Standard_D2s_v3',
137                CloudProvider.GCP: 'n2-standard-2',
138                CloudProvider.AWS: 't3.large'
139            },
140            'large': {
141                CloudProvider.AZURE: 'Standard_D4s_v3',
142                CloudProvider.GCP: 'n2-standard-4',
143                CloudProvider.AWS: 'm5.xlarge'
144            }
145        }
146
147        # Image mapping
148        image_mappings = {
149            'ubuntu-20.04': {
150                CloudProvider.AZURE: 'Canonical:UbuntuServer:20.04-LTS:latest',
151                CloudProvider.GCP: 'projects/ubuntu-os-cloud/global/images/family/ubuntu-2004-lts',
152                CloudProvider.AWS: 'ami-0c55b159cbfafe1f0'
153            }
154        }
155
156        mapped_config = VirtualMachineConfig(
157            name=config.name,
158            region=config.region,
159            size=size_mappings.get(config.size, {}).get(provider, config.size),
160            image=image_mappings.get(config.image, {}).get(provider, config.image),
161            disk_size_gb=config.disk_size_gb,
162            tags=config.tags
163        )
164
165        return mapped_config
166
167    def get_consolidated_costs(self) -> Dict:
168        """
169        Get cost report across all cloud providers
170
171        Returns:
172            Consolidated cost data
173        """
174        total_costs = {
175            'total': 0.0,
176            'by_provider': {},
177            'currency': 'USD'
178        }
179
180        for provider, manager in self.providers.items():
181            try:
182                cost_data = manager.get_cost_report(days=30)
183
184                provider_cost = cost_data.get('total_cost', 0)
185                total_costs['by_provider'][provider.value] = provider_cost
186                total_costs['total'] += provider_cost
187
188            except Exception as e:
189                logger.warning(f"⚠️  Failed to get costs from {provider.value}: {e}")
190
191        return total_costs
192
193    def optimize_placement(self, workload_requirements: Dict) -> CloudProvider:
194        """
195        Determine optimal cloud provider for workload
196
197        Args:
198            workload_requirements: Workload specs (cpu, memory, storage, etc.)
199
200        Returns:
201            Recommended cloud provider
202        """
203        scores = {}
204
205        for provider in self.providers.keys():
206            score = 0
207
208            # Cost optimization
209            if workload_requirements.get('cost_sensitive'):
210                # GCP often cheaper for compute
211                if provider == CloudProvider.GCP:
212                    score += 10
213
214            # Data locality
215            preferred_region = workload_requirements.get('region')
216            if preferred_region:
217                if provider == CloudProvider.AZURE and 'europe' in preferred_region.lower():
218                    score += 15
219                elif provider == CloudProvider.GCP and 'us' in preferred_region.lower():
220                    score += 15
221
222            # ML workloads
223            if workload_requirements.get('ml_workload'):
224                # GCP strong in ML
225                if provider == CloudProvider.GCP:
226                    score += 20
227
228            # Enterprise integration
229            if workload_requirements.get('enterprise_integration'):
230                # Azure strong in enterprise
231                if provider == CloudProvider.AZURE:
232                    score += 20
233
234            scores[provider] = score
235
236        # Return provider with highest score
237        optimal_provider = max(scores, key=scores.get)
238
239        logger.info(f"📊 Placement scores: {scores}")
240        logger.info(f"🎯 Optimal provider: {optimal_provider.value}")
241
242        return optimal_provider
243
244    def implement_disaster_recovery(self, primary_provider: CloudProvider,
245                                    vm_config: VirtualMachineConfig) -> Dict:
246        """
247        Implement cross-cloud disaster recovery
248
249        Args:
250            primary_provider: Primary cloud provider
251            vm_config: VM configuration
252
253        Returns:
254            DR setup details
255        """
256        logger.info(f"🛡️  Setting up DR from {primary_provider.value}...")
257
258        # Find secondary provider
259        available_providers = [p for p in self.providers.keys() if p != primary_provider]
260
261        if not available_providers:
262            raise ValueError("No secondary provider available for DR")
263
264        secondary_provider = available_providers[0]
265
266        dr_setup = {
267            'primary': {
268                'provider': primary_provider.value,
269                'status': 'active'
270            },
271            'secondary': {
272                'provider': secondary_provider.value,
273                'status': 'standby'
274            },
275            'replication': 'cross-cloud',
276            'rto': '15 minutes',
277            'rpo': '5 minutes'
278        }
279
280        logger.info(f"✅ DR configured: {primary_provider.value} → {secondary_provider.value}")
281
282        return dr_setup

1class CostOptimizer:
2    """Multi-cloud cost optimization"""
3
4    def analyze_workload_costs(self, orchestrator: MultiCloudOrchestrator) -> Dict:
5        """Compare costs across clouds"""
6
7        # Get current costs
8        current_costs = orchestrator.get_consolidated_costs()
9
10        # Simulate workload on different clouds
11        recommendations = []
12
13        # Example: Move storage-heavy workload to cheaper storage
14        azure_storage_cost = 0.018  # per GB/month
15        gcp_storage_cost = 0.020
16
17        if gcp_storage_cost > azure_storage_cost:
18            recommendations.append({
19                'action': 'migrate_storage',
20                'from': 'gcp',
21                'to': 'azure',
22                'estimated_savings': '10% monthly',
23                'reason': 'Azure blob storage cheaper for cold data'
24            })
25
26        return {
27            'current_costs': current_costs,
28            'recommendations': recommendations
29        }

1class MultiCloudNetworking:
2    """Set up cross-cloud networking"""
3
4    def setup_vpn_tunnel(self, azure_vnet: str, gcp_vpc: str) -> Dict:
5        """Create VPN between Azure VNet and GCP VPC"""
6
7        logger.info("🔐 Setting up cross-cloud VPN...")
8
9        # Azure side: Create VPN Gateway
10        # GCP side: Create Cloud VPN
11        # Configure BGP for dynamic routing
12
13        return {
14            'azure_gateway': azure_vnet,
15            'gcp_gateway': gcp_vpc,
16            'tunnel_status': 'active',
17            'bandwidth': '10 Gbps'
18        }

1class CrossCloudReplication:
2    """Replicate data across clouds"""
3
4    def setup_replication(self, source_bucket: str,
5                         dest_bucket: str,
6                         source_provider: CloudProvider,
7                         dest_provider: CloudProvider) -> Dict:
8        """Set up cross-cloud data replication"""
9
10        logger.info(f"🔄 Replicating {source_provider.value} → {dest_provider.value}")
11
12        # Use cloud-native tools or custom sync
13        replication_config = {
14            'source': {'provider': source_provider.value, 'bucket': source_bucket},
15            'destination': {'provider': dest_provider.value, 'bucket': dest_bucket},
16            'schedule': 'hourly',
17            'encryption': 'AES-256'
18        }
19
20        return replication_config