Otros servicios importantes de AWS: guía completa

Descubre otros servicios esenciales de AWS para el desarrollo y el despliegue de aplicaciones.

1. API Gateway y Lambda

Configuración de API Gateway

# Ejemplo de configuración de API Gateway
import boto3

def setup_api_gateway():
    apigateway = boto3.client('apigateway')
    
    # Creación de la API
    api = apigateway.create_rest_api(
        name='MonAPI',
        description='API pour mon application'
    )
    
    # Creación de un recurso
    resource = apigateway.create_resource(
        restApiId=api['id'],
        parentId=api['rootResourceId'],
        pathPart='items'
    )
    
    # Creación de un método
    method = apigateway.put_method(
        restApiId=api['id'],
        resourceId=resource['id'],
        httpMethod='GET',
        authorizationType='NONE'
    )
    
    return {
        'api_id': api['id'],
        'resource_id': resource['id']
    }

Integración con Lambda

# Ejemplo de integración de Lambda con API Gateway
def integrate_lambda_with_api():
    apigateway = boto3.client('apigateway')
    
    integration = apigateway.put_integration(
        restApiId='api-id',
        resourceId='resource-id',
        httpMethod='GET',
        type='AWS_PROXY',
        integrationHttpMethod='POST',
        uri='arn:aws:apigateway:region:lambda:path/2015-03-31/functions/arn:aws:lambda:region:account:function:MonFonction/invocations'
    )
    
    return integration['uri']

2. Amazon SQS y SNS

Configuración de SQS

# Ejemplo de configuración de SQS
def setup_sqs_queue():
    sqs = boto3.client('sqs')
    
    # Creación de la cola
    queue = sqs.create_queue(
        QueueName='MonFileAttente',
        Attributes={
            'VisibilityTimeout': '30',
            'MessageRetentionPeriod': '345600'
        }
    )
    
    # Configuración de los permisos
    sqs.add_permission(
        QueueUrl=queue['QueueUrl'],
        Label='MonLabel',
        AWSAccountIds=['123456789012'],
        Actions=['SendMessage', 'ReceiveMessage']
    )
    
    return queue['QueueUrl']

Configuración de SNS

# Ejemplo de configuración de SNS
def setup_sns_topic():
    sns = boto3.client('sns')
    
    # Creación del topic
    topic = sns.create_topic(
        Name='MonTopic',
        Attributes={
            'DisplayName': 'Mon Topic',
            'Policy': json.dumps({
                'Version': '2012-10-17',
                'Statement': [
                    {
                        'Effect': 'Allow',
                        'Principal': {'AWS': '*'},
                        'Action': 'SNS:Publish',
                        'Resource': '*'
                    }
                ]
            })
        }
    )
    
    # Suscripción a un endpoint
    subscription = sns.subscribe(
        TopicArn=topic['TopicArn'],
        Protocol='email',
        Endpoint='mon@email.com'
    )
    
    return {
        'topic_arn': topic['TopicArn'],
        'subscription_arn': subscription['SubscriptionArn']
    }

3. Amazon ElastiCache

Configuración de Redis

# Ejemplo de configuración de ElastiCache Redis
def setup_elasticache_redis():
    elasticache = boto3.client('elasticache')
    
    # Creación del clúster Redis
    cluster = elasticache.create_cache_cluster(
        CacheClusterId='mon-cluster',
        Engine='redis',
        CacheNodeType='cache.t3.micro',
        NumCacheNodes=1,
        EngineVersion='6.x',
        Port=6379,
        CacheParameterGroupFamily='redis6',
        CacheSubnetGroupName='mon-subnet-group',
        SecurityGroupIds=['sg-xxxxx']
    )
    
    return cluster['CacheCluster']['CacheClusterId']

Uso de la caché

# Ejemplo de uso de la caché Redis
import redis

def use_redis_cache():
    # Conexión al clúster Redis
    redis_client = redis.Redis(
        host='mon-cluster.xxxxx.region.cache.amazonaws.com',
        port=6379,
        decode_responses=True
    )
    
    # Almacenamiento de datos
    redis_client.set('ma_cle', 'ma_valeur')
    
    # Recuperación de datos
    valeur = redis_client.get('ma_cle')
    
    return valeur

4. Amazon CloudFront

Configuración de la CDN

# Ejemplo de configuración de CloudFront
def setup_cloudfront():
    cloudfront = boto3.client('cloudfront')
    
    # Creación de la distribución
    distribution = cloudfront.create_distribution(
        DistributionConfig={
            'Origins': {
                'Quantity': 1,
                'Items': [
                    {
                        'Id': 'MonOrigin',
                        'DomainName': 'mon-bucket.s3.amazonaws.com',
                        'S3OriginConfig': {
                            'OriginAccessIdentity': ''
                        }
                    }
                ]
            },
            'DefaultCacheBehavior': {
                'TargetOriginId': 'MonOrigin',
                'ForwardedValues': {
                    'QueryString': False,
                    'Cookies': {'Forward': 'none'}
                },
                'ViewerProtocolPolicy': 'redirect-to-https'
            },
            'Enabled': True,
            'DefaultRootObject': 'index.html'
        }
    )
    
    return distribution['Distribution']['Id']

Configuración de los behaviors

# Ejemplo de configuración de los behaviors de CloudFront
def setup_cloudfront_behaviors():
    cloudfront = boto3.client('cloudfront')
    
    # Creación de un behavior personalizado
    behavior = cloudfront.create_cache_policy(
        CachePolicyConfig={
            'Name': 'MonPolicy',
            'DefaultTTL': 86400,
            'MaxTTL': 31536000,
            'MinTTL': 0,
            'ParametersInCacheKeyAndForwardedToOrigin': {
                'EnableAcceptEncodingGzip': True,
                'EnableAcceptEncodingBrotli': True,
                'HeadersConfig': {
                    'HeaderBehavior': 'none'
                },
                'QueryStringsConfig': {
                    'QueryStringBehavior': 'none'
                },
                'CookiesConfig': {
                    'CookieBehavior': 'none'
                }
            }
        }
    )
    
    return behavior['CachePolicy']['Id']

5. Amazon Route 53 y CloudWatch

Configuración de DNS

# Ejemplo de configuración de Route 53
def setup_route53():
    route53 = boto3.client('route53')
    
    # Creación de una zona alojada
    zone = route53.create_hosted_zone(
        Name='mon-domaine.com',
        CallerReference=str(time.time())
    )
    
    # Creación de un registro
    record = route53.change_resource_record_sets(
        HostedZoneId=zone['HostedZone']['Id'],
        ChangeBatch={
            'Changes': [
                {
                    'Action': 'CREATE',
                    'ResourceRecordSet': {
                        'Name': 'api.mon-domaine.com',
                        'Type': 'A',
                        'AliasTarget': {
                            'DNSName': 'mon-distribution.cloudfront.net',
                            'HostedZoneId': 'Z2FDTNDATAQYW2CL',
                            'EvaluateTargetHealth': False
                        }
                    }
                }
            ]
        }
    )
    
    return {
        'zone_id': zone['HostedZone']['Id'],
        'change_id': record['ChangeInfo']['Id']
    }

Configuración de los health checks

# Ejemplo de configuración de los health checks
def setup_health_checks():
    route53 = boto3.client('route53')
    
    # Creación de un health check
    health_check = route53.create_health_check(
        CallerReference=str(time.time()),
        HealthCheckConfig={
            'IPAddress': '10.0.0.1',
            'Port': 80,
            'Type': 'HTTP',
            'ResourcePath': '/health',
            'FullyQualifiedDomainName': 'api.mon-domaine.com',
            'RequestInterval': 30,
            'FailureThreshold': 3
        }
    )
    
    return health_check['HealthCheck']['Id']

Conclusión

Puntos clave que recordar:

• Gestionar las API con API Gateway
• Utilizar los servicios de mensajería (SQS/SNS)
• Almacenar en caché con ElastiCache
• Distribuir el contenido con CloudFront
• Gestionar el DNS con Route 53

Recomendaciones:

• Elegir los servicios adecuados según las necesidades
• Optimizar el rendimiento
• Implantar una monitorización eficaz
• Proteger las comunicaciones
• Seguir las buenas prácticas de AWS