# Ejemplo: Instancia optimizada para compute
aws ec2 run-instances \
  --image-id ami-0abcdef1234567890 \
  --instance-type c6i.xlarge \
  --key-name my-key \
  --security-group-ids sg-12345678 \
  --subnet-id subnet-12345678 \
  --tag-specifications 'ResourceType=instance,Tags=[{Key=Environment,Value=production}]'

# Ejemplo: VM con Azure CLI
az vm create \
  --resource-group myResourceGroup \
  --name myVM \
  --image UbuntuLTS \
  --size Standard_D4s_v4 \
  --admin-username azureuser \
  --ssh-key-values ~/.ssh/id_rsa.pub \
  --priority Spot \
  --max-price 0.05

# Ejemplo: Instancia con gcloud CLI
gcloud compute instances create my-vm \
  --zone=us-central1-a \
  --machine-type=e2-standard-4 \
  --network-interface=network-tier=PREMIUM,subnet=default \
  --preemptible \
  --maintenance-policy=MIGRATE \
  --image-family=ubuntu-2004-lts \
  --image-project=ubuntu-os-cloud

# Ejemplo: Deployment en GKE con autopilot
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  namespace: production
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: web-app
        image: gcr.io/my-project/web-app:v1.2.3
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: url

import json
import boto3

def lambda_handler(event, context):
    # Procesamiento de eventos S3
    s3_client = boto3.client('s3')
    
    for record in event['Records']:
        bucket = record['s3']['bucket']['name']
        key = record['s3']['object']['key']
        
        # Procesar archivo
        response = s3_client.get_object(Bucket=bucket, Key=key)
        data = response['Body'].read()
        
        # Lógica de negocio aquí
        processed_data = process_data(data)
        
        # Guardar resultado
        s3_client.put_object(
            Bucket=f"{bucket}-processed",
            Key=key,
            Body=processed_data
        )
    
    return {
        'statusCode': 200,
        'body': json.dumps('Processing completed')
    }

def process_data(data):
    # Implementar lógica específica
    return data.decode('utf-8').upper().encode('utf-8')

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
using Microsoft.Azure.Functions.Worker.Http;

public class HttpTriggerFunction
{
    private readonly ILogger _logger;

    public HttpTriggerFunction(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory.CreateLogger<HttpTriggerFunction>();
    }

    [Function("ProcessOrder")]
    public async Task<HttpResponseData> Run(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
        [CosmosDBOutput("orders", "processed", 
            ConnectionStringSetting = "CosmosDbConnectionString")] IAsyncCollector<OrderData> outputDocuments)
    {
        _logger.LogInformation("Processing order request");

        string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
        var orderData = JsonSerializer.Deserialize<OrderData>(requestBody);
        
        // Procesar orden
        orderData.ProcessedAt = DateTime.UtcNow;
        orderData.Status = "Completed";
        
        await outputDocuments.AddAsync(orderData);

        var response = req.CreateResponse(HttpStatusCode.OK);
        await response.WriteStringAsync("Order processed successfully");
        return response;
    }
}

const {Storage} = require('@google-cloud/storage');
const {PubSub} = require('@google-cloud/pubsub');

const storage = new Storage();
const pubsub = new PubSub();

exports.processImage = async (file, context) => {
  console.log(`Processing file: ${file.name}`);
  
  const bucket = storage.bucket(file.bucket);
  const fileObj = bucket.file(file.name);
  
  // Descargar imagen
  const [imageBuffer] = await fileObj.download();
  
  // Procesar imagen (ej: redimensionar, aplicar filtros)
  const processedImage = await processImageBuffer(imageBuffer);
  
  // Guardar imagen procesada
  const processedFileName = `processed/${file.name}`;
  const processedFile = bucket.file(processedFileName);
  
  await processedFile.save(processedImage, {
    metadata: {
      contentType: file.contentType,
    },
  });
  
  // Publicar evento de completado
  const message = {
    originalFile: file.name,
    processedFile: processedFileName,
    timestamp: new Date().toISOString(),
  };
  
  await pubsub.topic('image-processing-completed').publish(Buffer.from(JSON.stringify(message)));
  
  console.log(`Image processing completed: ${processedFileName}`);
};

async function processImageBuffer(buffer) {
  // Implementar procesamiento de imagen
  // Por ejemplo, usando Sharp para redimensionamiento
  const sharp = require('sharp');
  return await sharp(buffer)
    .resize(800, 600)
    .jpeg({ quality: 85 })
    .toBuffer();
}

# Ejemplo: DynamoDB con Python boto3
import boto3
from boto3.dynamodb.conditions import Key

dynamodb = boto3.resource('dynamodb', region_name='us-east-1')
table = dynamodb.Table('UserSessions')

# Escritura con TTL
def create_user_session(user_id, session_data):
    import time
    ttl = int(time.time()) + (24 * 60 * 60)  # 24 horas
    
    response = table.put_item(
        Item={
            'user_id': user_id,
            'session_id': session_data['session_id'],
            'created_at': session_data['created_at'],
            'data': session_data['data'],
            'ttl': ttl
        }
    )
    return response

# Consulta con GSI
def get_active_sessions_by_date(date_start):
    response = table.query(
        IndexName='created_at-index',
        KeyConditionExpression=Key('created_at').gte(date_start)
    )
    return response['Items']

// Ejemplo: Cosmos DB con .NET SDK
using Microsoft.Azure.Cosmos;

public class CosmosDbService
{
    private readonly CosmosClient _cosmosClient;
    private readonly Database _database;
    private readonly Container _container;

    public CosmosDbService(string connectionString, string databaseName, string containerName)
    {
        _cosmosClient = new CosmosClient(connectionString);
        _database = _cosmosClient.GetDatabase(databaseName);
        _container = _database.GetContainer(containerName);
    }

    public async Task<T> CreateItemAsync<T>(T item, string partitionKey)
    {
        try
        {
            ItemResponse<T> response = await _container.CreateItemAsync(item, new PartitionKey(partitionKey));
            return response.Resource;
        }
        catch (CosmosException ex) when (ex.StatusCode == HttpStatusCode.Conflict)
        {
            throw new InvalidOperationException("Item already exists");
        }
    }

    public async Task<IEnumerable<T>> QueryItemsAsync<T>(string queryString)
    {
        var query = _container.GetItemQueryIterator<T>(new QueryDefinition(queryString));
        var results = new List<T>();

        while (query.HasMoreResults)
        {
            FeedResponse<T> response = await query.ReadNextAsync();
            results.AddRange(response.ToList());
        }

        return results;
    }
}

# Ejemplo: Calculadora de costos automatizada
#!/bin/bash

# Obtener precios actuales de EC2
aws pricing get-products \
    --service-code AmazonEC2 \
    --filters "Type=TERM_MATCH,Field=instanceType,Value=m5.large" \
    --format-version aws_v1 \
    --max-items 1

# Calcular costos de Reserved Instances
calculate_ri_savings() {
    local instance_type=$1
    local hours_per_month=730
    
    on_demand_price=$(aws pricing get-products \
        --service-code AmazonEC2 \
        --filters "Type=TERM_MATCH,Field=instanceType,Value=$instance_type" \
        --query 'PriceList[0]' --output text | jq '.terms.OnDemand[].priceDimensions[].pricePerUnit.USD')
    
    # Cálculo de ahorro con RI (ejemplo: 40% descuento)
    ri_savings=$(echo "$on_demand_price * 0.4 * $hours_per_month" | bc)
    echo "Monthly savings with RI: $ri_savings USD"
}

# Script para optimización de costos en Azure
$subscriptionId = "your-subscription-id"
$resourceGroupName = "your-rg"

# Obtener recomendaciones de costos
$costRecommendations = Get-AzAdvisorRecommendation -Category Cost

# Identificar recursos subutilizados
$vmMetrics = Get-AzMetric -ResourceId "/subscriptions/$subscriptionId/resourceGroups/$resourceGroupName/providers/Microsoft.Compute/virtualMachines/myVM" `
    -MetricName "Percentage CPU" `
    -TimeGrain "PT1H" `
    -StartTime (Get-Date).AddDays(-30) `
    -EndTime (Get-Date)

# Calcular utilización promedio
$avgCpuUtilization = ($vmMetrics.Data | Measure-Object -Property Average -Average).Average

if ($avgCpuUtilization -lt 10) {
    Write-Host "VM is underutilized. Consider resizing or shutting down." -ForegroundColor Yellow
    
    # Obtener recomendaciones de tamaño
    $sizingRecommendation = Get-AzAdvisorRecommendation -ResourceGroupName $resourceGroupName | 
        Where-Object {$_.Category -eq "Cost" -and $_.ResourceName -eq "myVM"}
    
    Write-Host "Recommendation: $($sizingRecommendation.ShortDescription)"
}

# Configuración AWS
Resources:
  - t3.micro EC2: $8.5/month
  - RDS t3.micro: $15/month
  - ALB: $22.5/month
  - S3 (50GB): $1.15/month
  - CloudFront: $1/month
Total AWS: ~$48/month

# Configuración Azure  
Resources:
  - B1S VM: $7.59/month
  - Basic SQL Database: $4.90/month
  - Application Gateway: $22.56/month
  - Blob Storage (50GB): $1.15/month
  - CDN: $0.87/month
Total Azure: ~$37/month

# Configuración GCP
Resources:
  - e2-micro (always free): $0/month
  - Cloud SQL micro: $7/month
  - Load Balancer: $18/month
  - Cloud Storage (50GB): $1.30/month
  - Cloud CDN: $1/month
Total GCP: ~$27/month

# AWS Enterprise Setup
Resources:
  - Auto Scaling Group (3x m5.xlarge): $450/month
  - RDS Multi-AZ (db.r5.xlarge): $580/month
  - ElastiCache (cache.r5.large): $145/month
  - ALB + Target Groups: $22.5/month
  - S3 + CloudFront: $50/month
  - WAF: $30/month
Total AWS: ~$1,277/month

# Azure Enterprise Setup
Resources:
  - VMSS (3x Standard_D4s_v4): $420/month
  - Azure SQL Database (S4): $120/month
  - Azure Cache for Redis (C2): $123/month
  - Application Gateway v2: $45/month
  - Storage + CDN: $45/month
  - Web Application Firewall: $25/month
Total Azure: ~$778/month

# GCP Enterprise Setup
Resources:
  - Managed Instance Group (3x n2-standard-4): $390/month
  - Cloud SQL (db-n1-standard-4): $280/month
  - Memorystore (M2): $115/month
  - Cloud Load Balancing: $18/month
  - Storage + CDN: $40/month
  - Cloud Armor: $20/month
Total GCP: ~$863/month

{
  "SecurityPolicy": {
    "Version": "2012-10-17",
    "Statement": [
      {
        "Sid": "EnforceSSLRequestsOnly",
        "Effect": "Deny",
        "Principal": "*",
        "Action": "s3:*",
        "Resource": [
          "arn:aws:s3:::secure-bucket/*",
          "arn:aws:s3:::secure-bucket"
        ],
        "Condition": {
          "Bool": {
            "aws:SecureTransport": "false"
          }
        }
      },
      {
        "Sid": "RestrictToVPCEndpoint",
        "Effect": "Deny",
        "Principal": "*",
        "Action": "s3:*",
        "Resource": [
          "arn:aws:s3:::secure-bucket/*",
          "arn:aws:s3:::secure-bucket"
        ],
        "Condition": {
          "StringNotEquals": {
            "aws:SourceVpce": "vpce-12345678"
          }
        }
      }
    ]
  }
}

# Configuración de Conditional Access con PowerShell
$policy = @{
    DisplayName = "Block Legacy Authentication"
    State = "Enabled"
    Conditions = @{
        Users = @{
            IncludeUsers = @("All")
            ExcludeUsers = @("emergency-access-account@domain.com")
        }
        Applications = @{
            IncludeApplications = @("All")
        }
        ClientAppTypes = @("ExchangeActiveSync", "Other")
    }
    GrantControls = @{
        Operator = "OR"
        BuiltInControls = @("Block")
    }
}

New-AzureADMSConditionalAccessPolicy -BodyParameter $policy

# Configuración IAP con Terraform
resource "google_iap_web_iam_binding" "web_iam_binding" {
  project = var.project_id
  role    = "roles/iap.httpsResourceAccessor"
  
  members = [
    "group:developers@company.com",
    "user:admin@company.com"
  ]
}

resource "google_compute_backend_service" "default" {
  name        = "web-backend-service"
  port_name   = "http"
  protocol    = "HTTP"
  timeout_sec = 30

  backend {
    group = google_compute_instance_group_manager.web.instance_group
  }

  iap {
    oauth2_client_id     = google_iap_client.project_client.client_id
    oauth2_client_secret = google_iap_client.project_client.secret
  }

  log_config {
    enable      = true
    sample_rate = 1.0
  }
}

# Benchmark script para comparar rendimiento
#!/bin/bash

# Test de latencia de red
test_network_latency() {
    local provider=$1
    local endpoint=$2
    
    echo "Testing $provider latency..."
    for i in {1..100}; do
        curl -w "%{time_total}\n" -o /dev/null -s "$endpoint"
    done | awk '{sum+=$1; n++} END {print "Average latency: " sum/n " seconds"}'
}

# Test de throughput de storage
test_storage_throughput() {
    local provider=$1
    local bucket=$2
    
    echo "Testing $provider storage throughput..."
    
    # Generar archivo de prueba de 1GB
    dd if=/dev/zero of=test_1gb.dat bs=1M count=1024
    
    # Upload test
    start_time=$(date +%s.%N)
    case $provider in
        "aws")
            aws s3 cp test_1gb.dat s3://$bucket/test_1gb.dat
            ;;
        "azure")
            az storage blob upload --file test_1gb.dat --container-name $bucket --name test_1gb.dat
            ;;
        "gcp")
            gsutil cp test_1gb.dat gs://$bucket/test_1gb.dat
            ;;
    esac
    end_time=$(date +%s.%N)
    
    duration=$(echo "$end_time - $start_time" | bc)
    throughput=$(echo "1024 / $duration" | bc)
    
    echo "$provider upload throughput: $throughput MB/s"
    
    # Cleanup
    rm test_1gb.dat
}

# Ejecutar tests
test_network_latency "AWS" "https://aws.amazon.com"
test_network_latency "Azure" "https://azure.microsoft.com"
test_network_latency "GCP" "https://cloud.google.com"

test_storage_throughput "aws" "my-aws-bucket"
test_storage_throughput "azure" "my-azure-container"
test_storage_throughput "gcp" "my-gcp-bucket"

Justificación:
  - Créditos generosos para startups ($100,000)
  - Herramientas de AI/ML listas para usar
  - Escalabilidad automática sin configuración
  - Excelente relación precio/rendimiento
  
Stack Recomendado:
  - Cloud Run para microservicios
  - Firestore para base de datos NoSQL
  - Cloud Functions para procesamiento de eventos
  - BigQuery para analytics
  - Cloud Build para CI/CD

Justificación:
  - Azure Hybrid Benefit para licencias existentes
  - Integración nativa con Active Directory
  - Migración simplificada desde on-premises
  - Herramientas familiares para equipos .NET
  
Stack Recomendado:
  - Azure Virtual Machines con Windows Server
  - Azure SQL Database
  - Azure Active Directory
  - Azure DevOps para CI/CD
  - Power Platform para aplicaciones de negocio

Justificación:
  - Infraestructura global más extensa (31 regiones)
  - Servicios maduros y battle-tested
  - Ecosistema de partners más amplio
  - Mejor soporte para arquitecturas complejas
  
Stack Recomendado:
  - Auto Scaling Groups con ELB
  - RDS con read replicas globales
  - CloudFront para CDN
  - Route 53 para DNS geográfico
  - ElastiCache para caching distribuido

# AWS Application Migration Service
aws mgn initialize-service --region us-east-1

# Database Migration Service
aws dms create-replication-instance \
    --replication-instance-identifier myrepinstance \
    --replication-instance-class dms.t3.micro \
    --allocated-storage 20

# Azure Site Recovery para VMs
$vault = Get-AzRecoveryServicesVault -Name "myVault" -ResourceGroupName "myRG"
Set-AzRecoveryServicesAsrVaultContext -Vault $vault

# Configurar protección para VM
$protectionContainer = Get-AzRecoveryServicesAsrProtectionContainer
$replicationPolicy = Get-AzRecoveryServicesAsrPolicy -Name "DefaultPolicy"

Enable-AzRecoveryServicesAsrProtection `
    -ReplicationProvider "HyperVReplicaAzure" `
    -SourceProtectionContainer $protectionContainer `
    -Name "myVM" `
    -Policy $replicationPolicy

# Terraform multi-cloud configuration
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 3.0"
    }
    google = {
      source  = "hashicorp/google"
      version = "~> 4.0"
    }
  }
}

# AWS resources for compute-heavy workloads
resource "aws_instance" "compute_cluster" {
  provider      = aws
  ami           = "ami-0abcdef1234567890"
  instance_type = "c6i.8xlarge"
  count         = 5
}

# Azure resources for enterprise integration
resource "azurerm_virtual_machine" "app_servers" {
  provider            = azurerm
  location            = "East US"
  resource_group_name = azurerm_resource_group.main.name
  vm_size             = "Standard_D4s_v4"
}

# GCP resources for ML workloads
resource "google_compute_instance" "ml_workers" {
  provider     = google
  machine_type = "n1-standard-4"
  zone         = "us-central1-a"
  
  boot_disk {
    initialize_params {
      image = "deeplearning-platform-release/tf2-ent-2-8-cu113"
    }
  }
}

class CloudProviderEvaluator:
    def __init__(self):
        self.criteria = {
            'cost': 0.25,
            'performance': 0.20,
            'ecosystem': 0.15,
            'security': 0.15,
            'innovation': 0.10,
            'support': 0.10,
            'compliance': 0.05
        }
    
    def evaluate_provider(self, provider_scores):
        total_score = 0
        for criterion, weight in self.criteria.items():
            total_score += provider_scores.get(criterion, 0) * weight
        return total_score
    
    def recommend_provider(self, requirements):
        # Scores de 1-10 para cada proveedor
        aws_scores = {
            'cost': 7, 'performance': 9, 'ecosystem': 10,
            'security': 9, 'innovation': 7, 'support': 9, 'compliance': 9
        }
        
        azure_scores = {
            'cost': 8, 'performance': 8, 'ecosystem': 8,
            'security': 9, 'innovation': 7, 'support': 8, 'compliance': 9
        }
        
        gcp_scores = {
            'cost': 9, 'performance': 8, 'ecosystem': 6,
            'security': 8, 'innovation': 10, 'support': 7, 'compliance': 8
        }
        
        aws_final = self.evaluate_provider(aws_scores)
        azure_final = self.evaluate_provider(azure_scores)
        gcp_final = self.evaluate_provider(gcp_scores)
        
        scores = {
            'AWS': aws_final,
            'Azure': azure_final,
            'GCP': gcp_final
        }
        
        return max(scores, key=scores.get), scores

# Ejemplo de uso
evaluator = CloudProviderEvaluator()
recommendation, all_scores = evaluator.recommend_provider({})
print(f"Recommended provider: {recommendation}")
print(f"Scores: {all_scores}")