1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# Arquitectura simplificada en SAM
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  # API Gateway
  EcommerceAPI:
    Type: AWS::Serverless::Api
    Properties:
      StageName: prod
      Cors:
        AllowMethods: "'*'"
        AllowHeaders: "'*'"
        AllowOrigin: "'*'"

  # Lambda Functions
  ProductsFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: src/products/
      Handler: handler.main
      Runtime: python3.9
      Events:
        GetProducts:
          Type: Api
          Properties:
            RestApiId: !Ref EcommerceAPI
            Path: /products
            Method: get

  # DynamoDB Tables
  ProductsTable:
    Type: AWS::DynamoDB::Table
    Properties:
      BillingMode: PAY_PER_REQUEST
      AttributeDefinitions:
        - AttributeName: productId
          AttributeType: S
      KeySchema:
        - AttributeName: productId
          KeyType: HASH

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# Pipeline de procesamiento de datos médicos
import boto3
import pandas as pd
from datetime import datetime

class MedicalDataProcessor:
    def __init__(self):
        self.s3 = boto3.client('s3')
        self.glue = boto3.client('glue')
        self.athena = boto3.client('athena')
        
    def process_patient_data(self, raw_data):
        """
        Procesa datos de pacientes con anonimización
        """
        # Anonimizar datos sensibles
        processed_data = self.anonymize_pii(raw_data)
        
        # Validar formato FHIR
        validated_data = self.validate_fhir_format(processed_data)
        
        # Guardar en S3 con particionado
        self.save_to_data_lake(validated_data)
        
        return validated_data
    
    def anonymize_pii(self, data):
        """
        Anonimiza información personal identificable
        """
        # Implementar técnicas de anonimización
        # Hash de identificadores, generalización de fechas, etc.
        pass

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

import boto3
import json
from datetime import datetime

class IoTDataProcessor:
    def __init__(self):
        self.timestream = boto3.client('timestream-write')
        self.sagemaker = boto3.client('sagemaker-runtime')
        
    def process_sensor_data(self, event, context):
        """
        Procesa datos de sensores IoT en tiempo real
        """
        for record in event['Records']:
            # Decodificar datos del sensor
            sensor_data = json.loads(record['body'])
            
            # Validar y limpiar datos
            cleaned_data = self.validate_sensor_data(sensor_data)
            
            # Guardar en TimeStream
            self.write_to_timestream(cleaned_data)
            
            # Detectar anomalías
            if self.detect_anomaly(cleaned_data):
                self.trigger_alert(cleaned_data)
    
    def detect_anomaly(self, data):
        """
        Detecta anomalías usando modelo ML
        """
        endpoint_name = 'anomaly-detection-endpoint'
        
        response = self.sagemaker.invoke_endpoint(
            EndpointName=endpoint_name,
            ContentType='application/json',
            Body=json.dumps(data)
        )
        
        result = json.loads(response['Body'].read())
        return result['anomaly_score'] > 0.8

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#!/bin/bash
# Script de migración automatizada

# Fase 1: Preparación
echo "Iniciando migración de aplicación: $APP_NAME"

# Crear snapshot de base de datos
aws rds create-db-snapshot \
    --db-instance-identifier $DB_INSTANCE \
    --db-snapshot-identifier $APP_NAME-migration-$(date +%Y%m%d)

# Sincronizar archivos a S3
aws s3 sync /app/data s3://$MIGRATION_BUCKET/$APP_NAME/data/

# Fase 2: Migración de base de datos
aws dms start-replication-task \
    --replication-task-arn $REPLICATION_TASK_ARN

# Fase 3: Despliegue de aplicación
aws ecs update-service \
    --cluster $ECS_CLUSTER \
    --service $APP_NAME \
    --desired-count 2

# Fase 4: Validación
./validate-migration.sh $APP_NAME

echo "Migración completada para: $APP_NAME"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// Template para API serverless
import * as cdk from '@aws-cdk/core';
import * as lambda from '@aws-cdk/aws-lambda';
import * as apigateway from '@aws-cdk/aws-apigateway';
import * as dynamodb from '@aws-cdk/aws-dynamodb';

export class ServerlessApiStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // DynamoDB Table
    const table = new dynamodb.Table(this, 'ApiTable', {
      partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });

    // Lambda Function
    const handler = new lambda.Function(this, 'ApiHandler', {
      runtime: lambda.Runtime.PYTHON_3_9,
      code: lambda.Code.fromAsset('lambda'),
      handler: 'index.handler',
      environment: {
        TABLE_NAME: table.tableName,
      },
    });

    // Grant permissions
    table.grantReadWriteData(handler);

    // API Gateway
    const api = new apigateway.RestApi(this, 'ServerlessApi', {
      restApiName: 'Serverless API',
      description: 'This service serves a serverless API.',
    });

    const integration = new apigateway.LambdaIntegration(handler);
    api.root.addMethod('ANY', integration);
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# modules/vpc/main.tf
resource "aws_vpc" "main" {
  cidr_block           = var.cidr_block
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = merge(var.tags, {
    Name = "${var.name}-vpc"
  })
}

resource "aws_subnet" "private" {
  count             = length(var.private_subnets)
  vpc_id            = aws_vpc.main.id
  cidr_block        = var.private_subnets[count.index]
  availability_zone = data.aws_availability_zones.available.names[count.index]

  tags = merge(var.tags, {
    Name = "${var.name}-private-${count.index + 1}"
    Type = "Private"
  })
}

resource "aws_subnet" "public" {
  count                   = length(var.public_subnets)
  vpc_id                  = aws_vpc.main.id
  cidr_block              = var.public_subnets[count.index]
  availability_zone       = data.aws_availability_zones.available.names[count.index]
  map_public_ip_on_launch = true

  tags = merge(var.tags, {
    Name = "${var.name}-public-${count.index + 1}"
    Type = "Public"
  })
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# Análisis de tecnologías por proyecto
technologies_usage = {
    'AWS Lambda': 95,
    'Amazon S3': 90,
    'DynamoDB': 80,
    'API Gateway': 85,
    'CloudFormation': 100,
    'EC2': 70,
    'RDS': 60,
    'Kinesis': 45,
    'SageMaker': 35,
    'ECS/Fargate': 55
}

# Visualización de uso
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 8))
plt.barh(list(technologies_usage.keys()), list(technologies_usage.values()))
plt.xlabel('Porcentaje de Uso en Proyectos')
plt.title('Tecnologías AWS Más Utilizadas')
plt.tight_layout()
plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# .github/workflows/deploy.yml
name: Deploy to AWS
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      
      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v1
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: us-east-1
      
      - name: Deploy to AWS
        run: |
          sam build
          sam deploy --no-confirm-changeset --no-fail-on-empty-changeset