AWS: Infraestructura Cloud para Cargas de Producción

EC2 (Elastic Compute Cloud)

EC2 da control total sobre máquinas virtuales. Seleccionas tipos de instancia, configuras networking y gestionas el SO. Ideal para cargas que necesitan estado persistente, acceso a GPU o configuraciones específicas de kernel.

• Familias de instancias: Propósito general (t3, m6i), optimizadas para compute (c6i), optimizadas para memoria (r6i), GPU (p4d, g5)
• Modelos de precio: On-Demand, Instancias Reservadas (compromisos 1/3 años con 40-60% ahorro), Spot (hasta 90% ahorro para cargas tolerantes a fallos)
• Auto Scaling Groups con launch templates, políticas de target tracking y escalado predictivo
• Placement groups para comunicación de baja latencia entre instancias (cluster, spread, partition)
• Tipos de volúmenes EBS: gp3 (general), io2 (alto IOPS), st1 (throughput), sc1 (almacenamiento frío)

ECS (Elastic Container Service)

ECS es la plataforma nativa de orquestación de contenedores de AWS. Ejecuta contenedores Docker sin la complejidad de Kubernetes. Dos tipos de lanzamiento: EC2 (gestionas instancias) y Fargate (serverless).

• Task definitions: Límites CPU/memoria, imágenes de contenedor, variables de entorno, secretos desde SSM Parameter Store o Secrets Manager
• Services: Cantidad deseada, estrategias de deploy (rolling update, blue/green vía CodeDeploy), circuit breaker para deploys fallidos
• Precio Fargate: Pagas por vCPU-segundo y GB-segundo. Sin gestión de instancias EC2. Ideal para cargas variables
• Service Connect y Cloud Map para descubrimiento de servicios entre microservicios
• Integración con ALB: routing basado en path y host, health checks y sticky sessions

# ECS task definition (key fields)
{
  "family": "api-service",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "512",
  "memory": "1024",
  "containerDefinitions": [{
    "name": "api",
    "image": "123456789.dkr.ecr.us-east-1.amazonaws.com/api:latest",
    "portMappings": [{"containerPort": 3000, "protocol": "tcp"}],
    "secrets": [
      {"name": "DB_PASSWORD", "valueFrom": "arn:aws:ssm:us-east-1:123456789:parameter/prod/db-password"}
    ],
    "logConfiguration": {
      "logDriver": "awslogs",
      "options": {"awslogs-group": "/ecs/api-service", "awslogs-region": "us-east-1"}
    }
  }]
}

EKS (Elastic Kubernetes Service)

EKS es el servicio de Kubernetes gestionado de AWS. AWS maneja el control plane (API server, etcd, scheduler) mientras tú gestionas los nodos worker o usas Fargate para pods serverless. Ideal para equipos ya invertidos en el ecosistema Kubernetes o con cargas multi-cloud.

• Managed node groups: AWS aprovisiona y gestiona instancias EC2 como nodos worker. Actualizaciones automáticas de AMI y draining
• Fargate profiles: Ejecuta pods sin gestionar nodos. Define qué pods corren en Fargate por namespace/selectores de label
• Add-ons: CoreDNS, kube-proxy, VPC CNI, EBS CSI driver. Gestionados por AWS con actualizaciones automáticas
• IAM Roles for Service Accounts (IRSA): Mapea service accounts de Kubernetes a roles IAM. Permisos granulares a nivel de pod
• Cluster Autoscaler / Karpenter: Escala nodos según requests de recursos de pods pendientes. Karpenter es más rápido y flexible

Lambda (Funciones Serverless)

Lambda ejecuta código sin aprovisionar servidores. Pagas solo por tiempo de ejecución (facturado por 1ms). Ideal para arquitecturas event-driven, endpoints API con tráfico variable y tareas programadas.

• Triggers: API Gateway, eventos S3, SQS, SNS, DynamoDB Streams, EventBridge, CloudWatch Events
• Mitigación de cold starts: Provisioned Concurrency (mantiene instancias calientes), SnapStart (Java 11+, Python 3.12+, .NET 8+ -- GA), paquetes más pequeños
• Configuración de memoria: 128MB a 10,240MB. CPU escala proporcionalmente con la memoria
• Layers: Comparte código/dependencias entre funciones. Hasta 5 layers por función
• Límites: 15 minutos máx ejecución, 10GB máx memoria, 250MB paquete (descomprimido), 1000 ejecuciones concurrentes (por defecto)

Aurora es una base de datos relacional compatible con MySQL/PostgreSQL construida para la nube. Separa compute de almacenamiento, replica datos 6 veces en 3 AZs y entrega hasta 5x el throughput de MySQL estándar en el mismo hardware.

• Almacenamiento: Auto-escala de 10GB a 128TB. Sin necesidad de pre-aprovisionar. Datos replicados 6 veces en 3 AZs
• Réplicas de lectura: Hasta 15 réplicas con lag de replicación sub-10ms. Auto-failover en <30 segundos
• Aurora Serverless v2: Escala de 0 a 256 ACUs en incrementos de 0.5 ACU. En 0 ACUs la instancia se pausa automáticamente durante inactividad (reanuda en ~15 segundos), sin pagar por compute ocioso. Ideal para cargas variables
• Backtrack: Revierte la base de datos a cualquier punto en las últimas 72 horas sin restaurar backup
• Global Database: Replicación cross-region con lag <1 segundo. RPO de 1 segundo, RTO de <1 minuto
• Performance Insights: Identifica las queries SQL top, eventos de espera y cuellos de botella. Gratis por 7 días de retención

# Aurora cluster endpoint configuration (TypeORM)
{
  type: 'mysql',
  replication: {
    master: {
      host: 'mydb-cluster.cluster-xxxxx.us-east-1.rds.amazonaws.com',
      port: 3306,
      username: 'admin',
      password: process.env.DB_PASSWORD,
      database: 'myapp_prod'
    },
    slaves: [{
      host: 'mydb-cluster.cluster-ro-xxxxx.us-east-1.rds.amazonaws.com',
      port: 3306,
      username: 'admin',
      password: process.env.DB_PASSWORD,
      database: 'myapp_prod'
    }]
  },
  extra: {
    connectionLimit: 20,
    connectTimeout: 10000,
    waitForConnections: true
  }
}

Patrón de Producción: S3 + CloudFront + OAC

# CloudFormation: S3 bucket with CloudFront distribution
Resources:
  AssetsBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: app-static-assets
      PublicAccessBlockConfiguration:
        BlockPublicAcls: true
        BlockPublicPolicy: true
        IgnorePublicAcls: true
        RestrictPublicBuckets: true
      LifecycleConfiguration:
        Rules:
          - Id: TransitionToIA
            Status: Enabled
            Transitions:
              - StorageClass: STANDARD_IA
                TransitionInDays: 90

  CDN:
    Type: AWS::CloudFront::Distribution
    Properties:
      DistributionConfig:
        Origins:
          - Id: S3Origin
            DomainName: !GetAtt AssetsBucket.RegionalDomainName
            OriginAccessControlId: !Ref OAC
            S3OriginConfig:
              OriginAccessIdentity: ''
        DefaultCacheBehavior:
          TargetOriginId: S3Origin
          ViewerProtocolPolicy: redirect-to-https
          CachePolicyId: 658327ea-f89d-4fab-a63d-7e88639e58f6  # CachingOptimized
          Compress: true
        PriceClass: PriceClass_100
        ViewerCertificate:
          AcmCertificateArn: !Ref SSLCert
          MinimumProtocolVersion: TLSv1.2_2021

Amazon SES (Simple Email Service) maneja email transaccional y de marketing a $0.10 por 1,000 emails. Provee alta entregabilidad cuando se configura correctamente con registros de autenticación y gestión de reputación.

• Autenticación: SPF (Sender Policy Framework), DKIM (DomainKeys Identified Mail), alineación DMARC
• Modos de envío: Interfaz SMTP (puerto 587), AWS SDK (API SendEmail/SendRawEmail), SendBulkTemplatedEmail para batch
• Configuration sets: Rastrea entregas, rebotes, quejas, aperturas y clics. Rutea eventos a SNS, Kinesis o CloudWatch
• Lista de supresión: Deja de enviar automáticamente a direcciones que rebotaron o se quejaron. Reduce tasa de rebote
• IPs dedicadas: Aísla tu reputación de envío de otros usuarios SES. Requerido para volúmenes altos
• Templates: Almacena plantillas de email en SES. Usa placeholders estilo Handlebars para personalización

// Node.js: Send transactional email via SES SDK v3
import { SESv2Client, SendEmailCommand } from '@aws-sdk/client-sesv2';

const ses = new SESv2Client({ region: 'us-east-1' });

await ses.send(new SendEmailCommand({
  FromEmailAddress: '[email protected]',
  Destination: { ToAddresses: [userEmail] },
  Content: {
    Template: {
      TemplateName: 'BookingConfirmation',
      TemplateData: JSON.stringify({
        userName: 'Jose',
        className: 'CrossFit 7AM',
        date: '2026-03-17',
        location: 'Santiago Centro'
      })
    }
  },
  ConfigurationSetName: 'app-transactional'
}));

Arquitectura VPC

Una VPC (Virtual Private Cloud) es tu red aislada dentro de AWS. Cada carga de producción corre dentro de una VPC. El diseño de red correcto es la base de la seguridad AWS -- determina qué puede comunicarse con qué.

• Planificación CIDR: Usa /16 para VPCs de producción (65,536 IPs). Evita CIDRs superpuestos si necesitas VPC peering o Transit Gateway
• Subnets públicas: Contienen ALBs y NAT Gateways. La tabla de rutas apunta 0.0.0.0/0 al Internet Gateway
• Subnets privadas: Contienen instancias EC2, tareas ECS, bases de datos RDS, ElastiCache. La tabla de rutas apunta 0.0.0.0/0 al NAT Gateway para internet saliente
• Multi-AZ: Deploya subnets en al menos 2 Availability Zones para alta disponibilidad. 3 AZs para cargas de producción
• VPC Endpoints: Gateway endpoints (S3, DynamoDB) son gratis. Interface endpoints (la mayoría de servicios) cuestan ~$0.01/hora + cargos de datos. Eliminan costos de procesamiento del NAT Gateway
• VPC Flow Logs: Captura metadata de tráfico IP de todas las interfaces de red. Envía a CloudWatch Logs o S3 para análisis de seguridad

Layout de VPC de Producción

# Terraform: Multi-AZ VPC with public and private subnets
resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true
  tags = { Name = "myapp-prod" }
}

resource "aws_subnet" "public" {
  count             = 3
  vpc_id            = aws_vpc.main.id
  cidr_block        = cidrsubnet("10.0.0.0/16", 8, count.index)       # 10.0.0.0/24, 10.0.1.0/24, 10.0.2.0/24
  availability_zone = data.aws_availability_zones.az.names[count.index]
  map_public_ip_on_launch = true
  tags = { Name = "public-${count.index}" }
}

resource "aws_subnet" "private" {
  count             = 3
  vpc_id            = aws_vpc.main.id
  cidr_block        = cidrsubnet("10.0.0.0/16", 8, count.index + 10)  # 10.0.10.0/24, 10.0.11.0/24, 10.0.12.0/24
  availability_zone = data.aws_availability_zones.az.names[count.index]
  tags = { Name = "private-${count.index}" }
}

# Security group chain: ALB -> App -> DB
resource "aws_security_group" "alb" {
  vpc_id = aws_vpc.main.id
  ingress { from_port = 443; to_port = 443; protocol = "tcp"; cidr_blocks = ["0.0.0.0/0"] }
}

resource "aws_security_group" "app" {
  vpc_id = aws_vpc.main.id
  ingress { from_port = 3000; to_port = 3000; protocol = "tcp"; security_groups = [aws_security_group.alb.id] }
}

resource "aws_security_group" "db" {
  vpc_id = aws_vpc.main.id
  ingress { from_port = 3306; to_port = 3306; protocol = "tcp"; security_groups = [aws_security_group.app.id] }
}

Principio de Mínimo Privilegio

IAM (Identity and Access Management) controla quién puede hacer qué en tu cuenta AWS. Cada llamada API se evalúa contra políticas IAM. Una política mal configurada es la causa más común de brechas de seguridad en AWS.

• Nunca uses la cuenta root para operaciones diarias. Habilita MFA en root y todos los usuarios IAM
• Usa roles IAM (no access keys de larga duración) para instancias EC2, tareas ECS y funciones Lambda
• Tipos de políticas: Basadas en identidad (adjuntas a usuarios/roles), basadas en recursos (adjuntas a S3/SQS/etc.), límites de permisos
• Usa AWS Organizations con SCPs (Service Control Policies) para restringir lo que las cuentas miembro pueden hacer
• IAM Access Analyzer: Identifica recursos compartidos con cuentas externas. Ejecuta continuamente
• CloudTrail: Registra cada llamada API en todos los servicios AWS. Habilita en todas las regiones. Envía a bucket S3 centralizado

// Least-privilege policy for an ECS task that reads from S3 and writes to SQS
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::app-static-assets/*"
    },
    {
      "Effect": "Allow",
      "Action": ["sqs:SendMessage"],
      "Resource": "arn:aws:sqs:us-east-1:123456789:notification-queue"
    },
    {
      "Effect": "Allow",
      "Action": [
        "ssm:GetParameter",
        "ssm:GetParameters"
      ],
      "Resource": "arn:aws:ssm:us-east-1:123456789:parameter/prod/*"
    }
  ]
}

Servicios de Seguridad Adicionales

• AWS WAF: Protege ALBs y CloudFront de SQL injection, XSS y limitación de IPs abusivas
• Secrets Manager: Rota passwords de bases de datos automáticamente. Nunca almacenes secretos en variables de entorno o código
• GuardDuty: Detección de amenazas basada en ML. Monitorea CloudTrail, VPC Flow Logs y logs DNS
• AWS Config: Rastrea historial de configuración de recursos y evalúa reglas de compliance continuamente
• Security Hub: Agrega hallazgos de GuardDuty, Inspector, Macie y herramientas de terceros en un solo dashboard

Los costos de AWS pueden escalar rápidamente sin gestión activa. Estas estrategias reducen consistentemente el gasto en 30-60% en cargas de producción.

• Right-sizing: Usa AWS Compute Optimizer para analizar utilización de CPU/memoria. Reduce instancias sobre-aprovisionadas. La mayoría de equipos sobre-aprovisionan en 40-60%
• Reserved Instances / Savings Plans: Compromete uso a 1 o 3 años para 30-60% de descuento. Compute Savings Plans son los más flexibles (aplican a EC2, Fargate, Lambda)
• Spot Instances: Usa para cargas stateless, procesamiento batch, runners CI/CD. Combina con On-Demand vía políticas de instancias mixtas en ASGs
• Políticas de ciclo de vida S3: Mueve datos poco accedidos a Standard-IA después de 30 días, Glacier después de 90. Archiva logs viejos en Deep Archive
• Costos de NAT Gateway: NAT Gateways cobran $0.045/GB de datos procesados. Usa VPC endpoints para S3, DynamoDB y otros servicios AWS para evitar cargos NAT
• Apaga dev/staging: Programa ambientes no productivos para apagarse fuera de horario laboral. Usa Instance Scheduler o automatización basada en Lambda
• Transferencia de datos: Mantén tráfico dentro de la misma AZ cuando sea posible. Usa CloudFront para reducir costos de transferencia del origen. Evita replicación cross-region salvo que se requiera para DR
• Monitoreo de costos: Configura AWS Budgets con alertas al 50%, 80% y 100%. Usa granularidad diaria de Cost Explorer para detectar anomalías temprano

Ejemplo Terraform: Aurora + VPC

resource "aws_rds_cluster" "aurora" {
  cluster_identifier     = "myapp-prod"
  engine                 = "aurora-mysql"
  engine_version         = "8.0.mysql_aurora.3.04.0"
  database_name          = "myapp"
  master_username        = "admin"
  master_password        = var.db_password
  db_subnet_group_name   = aws_db_subnet_group.private.name
  vpc_security_group_ids = [aws_security_group.aurora.id]
  backup_retention_period = 14
  preferred_backup_window = "03:00-04:00"
  deletion_protection     = true
  storage_encrypted       = true
  kms_key_id             = aws_kms_key.rds.arn

  serverlessv2_scaling_configuration {
    min_capacity = 0.5
    max_capacity = 16
  }
}

resource "aws_rds_cluster_instance" "writer" {
  identifier         = "myapp-prod-writer"
  cluster_identifier = aws_rds_cluster.aurora.id
  instance_class     = "db.serverless"
  engine             = aws_rds_cluster.aurora.engine
  engine_version     = aws_rds_cluster.aurora.engine_version
}

resource "aws_rds_cluster_instance" "reader" {
  identifier         = "myapp-prod-reader"
  cluster_identifier = aws_rds_cluster.aurora.id
  instance_class     = "db.serverless"
  engine             = aws_rds_cluster.aurora.engine
  engine_version     = aws_rds_cluster.aurora.engine_version
}

CloudWatch es el servicio central de monitoreo y observabilidad para todos los recursos AWS. Recolecta métricas, logs y trazas. Sin configuración correcta de CloudWatch, los incidentes de producción pasan desapercibidos hasta que los usuarios los reportan.

• Métricas: Cada servicio AWS emite métricas por defecto (CPU, red, errores). Métricas custom para datos a nivel de aplicación (profundidad de cola, usuarios activos, tiempos de respuesta)
• Alarmas: Dispara notificaciones o acciones de Auto Scaling cuando las métricas cruzan umbrales. Usa alarmas compuestas para combinar múltiples condiciones
• Logs: Centraliza logs de tareas ECS, funciones Lambda, instancias EC2 y API Gateway. Usa Logs Insights para consultar con sintaxis tipo SQL
• Dashboards: Construye dashboards operativos en tiempo real. Dashboards cross-account y cross-region para setups multi-cuenta
• Container Insights: Métricas automáticas para clusters ECS y EKS: CPU, memoria, red y disco por tarea/pod
• Detección de Anomalías: Detección de anomalías basada en ML sobre métricas. Se ajusta automáticamente a patrones estacionales. Reduce ruido de alertas
• Filtros de métricas: Extrae valores numéricos de datos de log y crea métricas CloudWatch. Ejemplo: cuenta errores 5xx por minuto de logs del ALB

# CloudWatch alarm for high API error rate
resource "aws_cloudwatch_metric_alarm" "api_5xx" {
  alarm_name          = "app-api-5xx-rate"
  comparison_operator = "GreaterThanThreshold"
  evaluation_periods  = 2
  metric_name         = "HTTPCode_Target_5XX_Count"
  namespace           = "AWS/ApplicationELB"
  period              = 300
  statistic           = "Sum"
  threshold           = 50
  alarm_description   = "API 5xx errors exceeded 50 in 5 minutes"
  alarm_actions       = [aws_sns_topic.alerts.arn]

  dimensions = {
    TargetGroup  = aws_lb_target_group.api.arn_suffix
    LoadBalancer = aws_lb.main.arn_suffix
  }
}

Route 53 es el servicio DNS de AWS con 100% de SLA de uptime. Maneja registro de dominios, resolución DNS y routing basado en health checks. Soporta hosted zones públicas y privadas.

• Políticas de routing: Simple, weighted (A/B testing), basado en latencia (rutear a la región más cercana), failover (DR activo-pasivo), geolocalización, multi-value answer
• Registros Alias: Tipo de registro específico de AWS que mapea directamente a ALBs, CloudFront, endpoints de sitio web S3 y otros recursos AWS. Sin costo por queries alias a recursos AWS
• Health checks: Monitorea disponibilidad de endpoints desde múltiples ubicaciones globales. Failover al standby cuando el primario no está saludable. Se integra con alarmas CloudWatch
• Hosted zones privadas: Resolución DNS dentro de VPCs. Nombres de servicios internos (api.internal.example.com) que resuelven a IPs privadas
• DNSSEC: Firma hosted zones para proteger contra DNS spoofing. Route 53 gestiona claves KMS para la firma

# Route 53: Latency-based routing with health checks
resource "aws_route53_record" "api" {
  zone_id = aws_route53_zone.main.zone_id
  name    = "api.example.com"
  type    = "A"

  alias {
    name                   = aws_lb.main.dns_name
    zone_id                = aws_lb.main.zone_id
    evaluate_target_health = true
  }

  set_identifier = "us-east-1"
  latency_routing_policy {
    region = "us-east-1"
  }
}

Secrets Manager almacena y rota credenciales de bases de datos, API keys y tokens. Elimina secretos hardcodeados y provee rotación automática con actualización de credenciales sin downtime.

• Rotación automática: Rotación basada en Lambda para credenciales de RDS, Redshift y DocumentDB. Rotación custom para cualquier tipo de secreto. Intervalos configurables (30, 60, 90 días)
• Acceso cross-account: Comparte secretos entre cuentas AWS usando políticas basadas en recursos. Útil para servicios compartidos en arquitecturas multi-cuenta
• Integración ECS/Lambda: Referencia secretos directamente en task definitions de ECS y variables de entorno de Lambda. Los secretos se descifran en runtime, nunca se almacenan en texto plano
• Versionado: Cada secreto mantiene versiones actual y anterior. Las aplicaciones pueden referenciar versiones específicas o siempre obtener la última
• Precio: $0.40/secreto/mes + $0.05/10,000 llamadas API. Mucho más barato que un incidente de fuga de credenciales

// Fetch secret from Secrets Manager in Node.js
import { SecretsManagerClient, GetSecretValueCommand } from '@aws-sdk/client-secrets-manager';

const client = new SecretsManagerClient({ region: 'us-east-1' });

async function getDbCredentials() {
  const response = await client.send(
    new GetSecretValueCommand({ SecretId: 'myapp/prod/aurora-credentials' })
  );
  return JSON.parse(response.SecretString);
  // { username: "admin", password: "rotated-password-xyz", host: "...", port: 3306 }
}

EventBridge es un event bus serverless que conecta aplicaciones usando eventos. Desacopla productores de consumidores, habilitando arquitecturas event-driven escalables. Reemplaza CloudWatch Events con filtrado más rico y más targets.

• Event buses: El bus default recibe eventos de servicios AWS. Buses custom para eventos de aplicación. Buses partner para integraciones SaaS (Datadog, PagerDuty, Stripe)
• Rules y patterns: Filtra eventos usando matching basado en contenido. Match por source, detail-type y cualquier campo del payload usando patrones prefix, suffix, numéricos y exists
• Targets: Rutea eventos matcheados a Lambda, SQS, SNS, Step Functions, API Gateway, Kinesis, tareas ECS y 20+ otros targets
• Scheduler: EventBridge Scheduler para schedules cron y rate. Reemplaza CloudWatch Events para tareas programadas. Schedules únicos para acciones diferidas
• Archivo y replay: Archiva eventos para replay durante debugging o recovery. Filtra por rango de fechas y patrón de evento
• Schema registry: Descubre automáticamente schemas de eventos de tu bus. Genera bindings de código para TypeScript, Python, Java

// EventBridge: Send custom application event
import { EventBridgeClient, PutEventsCommand } from '@aws-sdk/client-eventbridge';

const eb = new EventBridgeClient({ region: 'us-east-1' });

await eb.send(new PutEventsCommand({
  Entries: [{
    Source: 'myapp.bookings',
    DetailType: 'BookingConfirmed',
    Detail: JSON.stringify({
      bookingId: 'bk-12345',
      userId: 'usr-67890',
      className: 'CrossFit 7AM',
      locationId: 'loc-santiago-centro',
      timestamp: new Date().toISOString()
    }),
    EventBusName: 'app-events'
  }]
}));
// Rule targets: Lambda (send confirmation email via SES),
// SQS (update analytics), Step Functions (trigger post-booking workflow)

Amazon Bedrock es el servicio completamente gestionado de AWS para construir aplicaciones de AI generativa. Provee acceso a modelos fundacionales de Anthropic (Claude), Amazon (Titan), Meta (Llama), Mistral, Cohere y otros a través de una API unificada. Bedrock maneja infraestructura, escalado y seguridad para que te enfoques en la lógica de aplicación en vez de hosting de modelos.

• Modelos Claude en Bedrock: Claude Fable 5 (GA en Bedrock el 9 de junio de 2026 -- el primer modelo clase Mythos y el Claude más inteligente), Claude Opus 4.8 (28 de mayo de 2026), Claude Sonnet 5 (30 de junio de 2026 -- contexto de 1M, 128K de salida máxima), Claude Opus 4.7 (abril 2026), Claude Opus 4.6, Claude Sonnet 4.6, Claude Haiku 4.5 y Claude Opus 4.1 están todos disponibles. El motor de inferencia de nueva generación de Bedrock con scheduling dinámico mejora la disponibilidad para workloads estables. Soporta ventanas de contexto de 200K y 1M para procesar documentos extensos y codebases. El Marketplace de Bedrock ahora aloja casi 100 modelos fundacionales serverless de 10+ proveedores
• Bedrock Agents: Construye agentes AI autónomos que pueden razonar, planificar y ejecutar tareas multi-paso. Define grupos de acciones especificando APIs que el agente puede llamar, conecta knowledge bases para RAG específico de dominio y orquesta workflows complejos sin escribir código de orquestación
• Knowledge Bases (RAG): Retrieval Augmented Generation completamente gestionado. Ingesta documentos desde S3, chunkea y embede automáticamente, almacena en base de datos vectorial gestionada y consulta con inyección de contexto automática. Elimina desarrollo de pipelines RAG custom
• Guardrails: Políticas de seguridad configurables para aplicaciones AI. Filtros de contenido y palabras, detección de ataques de prompt, clasificación de temas denegados, redacción de PII y detección de alucinaciones con verificaciones de Razonamiento Automatizado. Bloquea hasta 88% de contenido dañino con 99% de precisión en identificación de respuestas correctas
• Seguridad y privacidad: Los datos nunca salen de tu cuenta AWS y nunca se usan para entrenar modelos. Aislamiento VPC, acceso basado en roles IAM, encriptación en tránsito y en reposo. Todas las llamadas API se registran en CloudTrail para auditoría de compliance
• Integración con Claude Code: Configura CLAUDE_CODE_USE_BEDROCK=1 para rutear todo el tráfico de Claude Code a través de Bedrock. El tráfico queda dentro de tu VPC, los costos aparecen en tu factura AWS y las políticas IAM controlan quién puede usar servicios AI

En producción, diseñé y gestioné infraestructura AWS de producción soportando 26 microservicios en múltiples países latinoamericanos. Componentes clave:

• Aurora RDS MySQL: Base de datos principal para todos los servicios. Separación de endpoints writer + reader, backups automatizados con 14 días de retención, Performance Insights para optimización de queries
• S3 + CloudFront: Entrega de assets estáticos (imágenes, documentos, exportaciones) vía CDN CloudFront con OAC. URLs pre-firmadas para subidas seguras desde apps móviles
• SES: Email transaccional (confirmaciones de reserva, resets de contraseña, facturas) con autenticación DKIM/SPF e IP dedicada para entregabilidad
• Gestión de costos: Implementé Compute Savings Plans, políticas de ciclo de vida S3 y VPC endpoints que redujeron el gasto mensual AWS en ~35%
• Seguridad: Subnets privadas para todas las bases de datos, roles IAM para tareas ECS, Secrets Manager para rotación de credenciales, CloudTrail para logging de auditoría