Inicio / Inteligencia Artificial / AI Engineering Pro / AWS: IAM, Networking y Seguridad

AWS: IAM, Networking y Seguridad

IAM policies, VPC, security groups, WAF y CloudTrail.

Avanzado
🔒 Solo lectura
📖

Estás en modo lectura

Puedes leer toda la lección, pero para marcar progreso, hacer ejercicios y ganar XP necesitas una cuenta Pro.

Desbloquear por $9/mes

AWS para IA: IAM, Networking y Seguridad

AWS como Plataforma para AI Engineering

AWS ofrece la infraestructura más madura para desplegar aplicaciones de IA. Como AI Engineer necesitas dominar los servicios fundamentales antes de lanzar workloads de IA.

IAM: Identity and Access Management

Principio de Menor Privilegio

Anatomía de una IAM Policy:

  • Version "2012-10-17" — versión del lenguaje de políticas IAM (siempre esta fecha, no cambiarla)
  • Sid — identificador legible para cada statement (ej: BedrockInvokeOnly), es opcional pero recomendado
  • ¿Por qué dos recursos S3? — arn:aws:s3:::my-rag-documents aplica al bucket (para ListBucket), mientras que arn:aws:s3:::my-rag-documents/* aplica a los objetos dentro (para GetObject). Sin ambos, los permisos no funcionan correctamente
  • Los wildcards en Resource (*) aplican solo al segmento donde aparecen: anthropic.claude-* matchea todos los modelos Claude, no todos los recursos de Bedrock
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "BedrockInvokeOnly",
            "Effect": "Allow",
            "Action": [
                "bedrock:InvokeModel",
                "bedrock:InvokeModelWithResponseStream"
            ],
            "Resource": [
                "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-*",
                "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-embed-*"
            ]
        },
        {
            "Sid": "S3ReadDocuments",
            "Effect": "Allow",
            "Action": ["s3:GetObject", "s3:ListBucket"],
            "Resource": [
                "arn:aws:s3:::my-rag-documents",
                "arn:aws:s3:::my-rag-documents/*"
            ]
        }
    ]
}

Roles para Servicios de IA

┌─────────────────────────────────────────────┐
│              IAM ARCHITECTURE                │
│                                              │
│  Lambda Function ──► Role: rag-lambda-role   │
│    ├── bedrock:InvokeModel                   │
│    ├── s3:GetObject (documents bucket)       │
│    └── logs:PutLogEvents                     │
│                                              │
│  ECS Task ──► Role: rag-service-role         │
│    ├── bedrock:InvokeModel                   │
│    ├── opensearch:ESHttp*                    │
│    ├── sqs:ReceiveMessage / SendMessage      │
│    └── secretsmanager:GetSecretValue         │
│                                              │
│  SageMaker ──► Role: ml-training-role        │
│    ├── s3:* (training data + artifacts)      │
│    ├── ecr:GetAuthorizationToken             │
│    └── cloudwatch:PutMetricData              │
└─────────────────────────────────────────────┘

Service Control Policies (SCPs)

{
    "Sid": "RestrictRegions",
    "Effect": "Deny",
    "Action": "*",
    "Resource": "*",
    "Condition": {
        "StringNotEquals": {
            "aws:RequestedRegion": ["us-east-1", "us-west-2", "eu-west-1"]
        }
    }
}

Networking para IA

VPC para Workloads de IA

┌──────────────────── VPC 10.0.0.0/16 ────────────────────┐
│                                                           │
│  ┌─── Public Subnet 10.0.1.0/24 ───┐                    │
│  │  ALB (Application Load Balancer) │                    │
│  │  NAT Gateway                     │                    │
│  └──────────────────────────────────┘                    │
│                                                           │
│  ┌─── Private Subnet 10.0.10.0/24 ──┐                   │
│  │  ECS Tasks (API de IA)            │                   │
│  │  Lambda Functions                  │                   │
│  └───────────────────────────────────┘                   │
│                                                           │
│  ┌─── Private Subnet 10.0.20.0/24 ──┐                   │
│  │  OpenSearch (Vector DB)           │                   │
│  │  RDS PostgreSQL + pgvector        │                   │
│  │  ElastiCache Redis                │                   │
│  └───────────────────────────────────┘                   │
│                                                           │
│  VPC Endpoints:                                          │
│  ├── com.amazonaws.bedrock-runtime                       │
│  ├── com.amazonaws.s3                                    │
│  ├── com.amazonaws.secretsmanager                        │
│  └── com.amazonaws.sqs                                   │
└──────────────────────────────────────────────────────────┘

VPC Endpoints para IA (Ahorro de costos y latencia)

# VPC Endpoint: conectividad PRIVADA a servicios AWS sin pasar por internet.
# Reduce latencia, mejora seguridad y ahorra costos de NAT Gateway.
#
# --vpc-endpoint-type Interface: crea una ENI en tu subnet (para la mayoría de servicios).
#   Alternativa: Gateway (solo para S3 y DynamoDB, sin costo adicional).
# --subnet-ids: en qué subnets crear la ENI del endpoint (accesible desde ahí).
# --security-group-ids: controla qué recursos de tu VPC pueden usar el endpoint.

aws ec2 create-vpc-endpoint \
    --vpc-id vpc-xxx \
    --service-name com.amazonaws.us-east-1.bedrock-runtime \
    --vpc-endpoint-type Interface \
    --subnet-ids subnet-xxx \
    --security-group-ids sg-xxx

Seguridad para Aplicaciones de IA

Secrets Management

import boto3
import json

# ¿Por qué Secrets Manager en vez de variables de entorno?
# - Rotación automática de secrets (sin redesplegar)
# - Auditoría: cada acceso se registra en CloudTrail
# - Encriptación con KMS (at rest + in transit)
# - Control de acceso granular via IAM policies

def get_secret(secret_name: str) -> dict:
    client = boto3.client("secretsmanager")
    response = client.get_secret_value(SecretId=secret_name)
    # SecretString: para texto/JSON (API keys, passwords, configs)
    # SecretBinary: para datos binarios (certificados, keystores)
    return json.loads(response["SecretString"])

# Convención de nombres: {entorno}/{servicio}/{tipo}
# Ejemplo: prod/ai-service/api-keys
secrets = get_secret("prod/ai-service/api-keys")
openai_key = secrets["OPENAI_API_KEY"]
pinecone_key = secrets["PINECONE_API_KEY"]

Encriptación

Datos en reposo:
  ├── S3: SSE-KMS (clave administrada)
  ├── RDS: Encrypted storage
  ├── OpenSearch: Node-to-node + at-rest encryption
  └── EBS: Encrypted volumes

Datos en tránsito:
  ├── ALB: TLS 1.3 terminación
  ├── VPC Endpoints: Tráfico privado
  └── Service-to-service: mTLS o SigV4

WAF para APIs de IA

AWS WAF ──► ALB ──► API de IA

Reglas:
  ├── Rate limiting: 100 req/min por IP
  ├── Geo-blocking: solo regiones permitidas
  ├── SQL injection protection
  ├── XSS protection
  ├── Input size limit: 64KB (prompts máx)
  └── Custom rule: bloquear prompt injection patterns

GuardDuty y Threat Detection

GuardDuty monitorea:
  ├── Accesos anómalos a modelos de Bedrock
  ├── Exfiltración de datos a través de API calls
  ├── Uso inusual de tokens/embeddings
  └── Acceso desde IPs desconocidas

Logging y Auditoría

CloudTrail para IA

# Todas las invocaciones a Bedrock se registran en CloudTrail
# Incluye: modelo, usuario, timestamp, región

# CloudWatch Logs para trazabilidad
import logging
# aws_lambda_powertools: librería oficial de AWS para best practices en Lambda.
# Incluye logging estructurado, tracing (X-Ray), métricas y más.
import aws_lambda_powertools

logger = aws_lambda_powertools.Logger(service="rag-api")

# @logger.inject_lambda_context: agrega automáticamente al log:
# request_id, function_name, memory_size, cold_start, etc.
# Esto permite correlacionar logs con invocaciones específicas.
@logger.inject_lambda_context
def handler(event, context):
    # extra={}: patrón de logging estructurado. Los campos se agregan
    # como JSON al log, permitiendo filtrar en CloudWatch Insights:
    #   filter @message like "RAG query" | stats avg(query_length) by model
    logger.info("RAG query received", extra={
        "user_id": event.get("user_id"),
        "query_length": len(event.get("query", "")),
        "model": "claude-sonnet-4-20250514",
    })

Resumen

La seguridad en AWS para IA require:

  1. IAM de menor privilegio — roles específicos por servicio
  2. VPC con aislamiento — subnets privadas + VPC endpoints
  3. Encriptación total — en reposo y en tránsito con KMS
  4. WAF protegiendo APIs — rate limiting, injection protection
  5. Logging completo — CloudTrail + CloudWatch para auditoría

🧠 Preguntas de Repaso

1. En una política IAM para S3, ¿por qué se necesitan dos ARNs diferentes (con y sin /*)?

  • A) Por redundancia en caso de que uno falle
  • B) arn:aws:s3:::bucket es para acciones a nivel bucket (ListBucket) y arn:aws:s3:::bucket/* es para acciones a nivel objeto (GetObject, PutObject)
  • C) Uno es para lectura y otro para escritura
  • D) El primero es para la consola web y el segundo para la CLI

Respuesta: B) — Los dos ARNs son necesarios porque las acciones IAM operan en niveles diferentes: ListBucket opera sobre el bucket como recurso, mientras que GetObject/PutObject operan sobre los objetos dentro del bucket (necesitan el /*).

2. ¿Cuál es la ventaja de usar VPC Endpoints tipo Gateway para S3 y DynamoDB?

  • A) Son más rápidos que los endpoints Interface
  • B) Proporcionan conectividad privada sin costo adicional, sin pasar por internet ni NAT Gateway
  • C) Soportan más servicios que los endpoints Interface
  • D) Permiten acceso público a los recursos

Respuesta: B) — Los VPC Endpoints Gateway (solo para S3 y DynamoDB) proporcionan conectividad privada sin costo adicional, a diferencia de los Interface endpoints que usan ENI con costo. Además reducen latencia, mejoran seguridad y ahorran costos de NAT Gateway.

3. ¿Por qué se recomienda AWS Secrets Manager en vez de variables de entorno para API keys?

  • A) Las variables de entorno son más lentas
  • B) Secrets Manager ofrece rotación automática, auditoría en CloudTrail, encriptación KMS y control IAM granular
  • C) Las variables de entorno no funcionan en Lambda
  • D) Secrets Manager es gratuito y las variables de entorno tienen costo

Respuesta: B) — Secrets Manager proporciona: rotación automática de secretos, registro de cada acceso en CloudTrail (auditoría), encriptación con KMS, y control de acceso granular con IAM. Las variables de entorno no ofrecen ninguna de estas protecciones.

4. ¿Qué protección ofrece AWS WAF contra prompt injection en APIs de IA?

  • A) WAF puede detectar y bloquear alucinaciones del modelo
  • B) WAF aplica rate limiting (100 req/min), bloquea SQL injection, limita tamaño de input (64KB) y soporta reglas custom anti prompt-injection
  • C) WAF reemplaza la necesidad de guardrails en el código
  • D) WAF solo protege contra ataques DDoS

Respuesta: B) — AWS WAF protege APIs de IA con múltiples capas: rate limiting (100 req/min), detección de SQL injection y XSS, límite de tamaño de input (64KB), geo-blocking, y reglas customizadas para detectar patrones de prompt injection.

¿Te gustó esta lección?

Con Pro puedes marcar progreso, hacer ejercicios, tomar quizzes, ganar XP y obtener tu constancia.

Ver planes desde $9/mes
← Evaluación de Agentes 🔒 Desbloquear siguiente lección →