Autres Services AWS Importants : Guide Complet

Découvrez d’autres services AWS essentiels pour le développement et le déploiement d’applications.

1. API Gateway et Lambda

Configuration API Gateway

# Exemple de configuration API Gateway
import boto3

def setup_api_gateway():
    apigateway = boto3.client('apigateway')
    
    # Création de l'API
    api = apigateway.create_rest_api(
        name='MonAPI',
        description='API pour mon application'
    )
    
    # Création d'une ressource
    resource = apigateway.create_resource(
        restApiId=api['id'],
        parentId=api['rootResourceId'],
        pathPart='items'
    )
    
    # Création d'une méthode
    method = apigateway.put_method(
        restApiId=api['id'],
        resourceId=resource['id'],
        httpMethod='GET',
        authorizationType='NONE'
    )
    
    return {
        'api_id': api['id'],
        'resource_id': resource['id']
    }

Intégration Lambda

# Exemple d'intégration Lambda avec 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 et SNS

Configuration SQS

# Exemple de configuration SQS
def setup_sqs_queue():
    sqs = boto3.client('sqs')
    
    # Création de la file d'attente
    queue = sqs.create_queue(
        QueueName='MonFileAttente',
        Attributes={
            'VisibilityTimeout': '30',
            'MessageRetentionPeriod': '345600'
        }
    )
    
    # Configuration des permissions
    sqs.add_permission(
        QueueUrl=queue['QueueUrl'],
        Label='MonLabel',
        AWSAccountIds=['123456789012'],
        Actions=['SendMessage', 'ReceiveMessage']
    )
    
    return queue['QueueUrl']

Configuration SNS

# Exemple de configuration SNS
def setup_sns_topic():
    sns = boto3.client('sns')
    
    # Création du 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': '*'
                    }
                ]
            })
        }
    )
    
    # Abonnement à 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

Configuration Redis

# Exemple de configuration ElastiCache Redis
def setup_elasticache_redis():
    elasticache = boto3.client('elasticache')
    
    # Création du cluster 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']

Utilisation du Cache

# Exemple d'utilisation du cache Redis
import redis

def use_redis_cache():
    # Connexion au cluster Redis
    redis_client = redis.Redis(
        host='mon-cluster.xxxxx.region.cache.amazonaws.com',
        port=6379,
        decode_responses=True
    )
    
    # Stockage de données
    redis_client.set('ma_cle', 'ma_valeur')
    
    # Récupération de données
    valeur = redis_client.get('ma_cle')
    
    return valeur

4. Amazon CloudFront

Configuration CDN

# Exemple de configuration CloudFront
def setup_cloudfront():
    cloudfront = boto3.client('cloudfront')
    
    # Création de la distribution
    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']

Configuration des Behaviors

# Exemple de configuration des behaviors CloudFront
def setup_cloudfront_behaviors():
    cloudfront = boto3.client('cloudfront')
    
    # Création d'un behavior personnalisé
    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 et CloudWatch

Configuration DNS

# Exemple de configuration Route 53
def setup_route53():
    route53 = boto3.client('route53')
    
    # Création d'une zone hébergée
    zone = route53.create_hosted_zone(
        Name='mon-domaine.com',
        CallerReference=str(time.time())
    )
    
    # Création d'un enregistrement
    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']
    }

Configuration des Health Checks

# Exemple de configuration des health checks
def setup_health_checks():
    route53 = boto3.client('route53')
    
    # Création d'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']

Conclusion

Points clés à retenir :

• Gérer les API avec API Gateway
• Utiliser les services de messagerie (SQS/SNS)
• Mettre en cache avec ElastiCache
• Distribuer le contenu avec CloudFront
• Gérer le DNS avec Route 53

Recommandations :

• Choisir les bons services selon les besoins
• Optimiser les performances
• Mettre en place une surveillance efficace
• Sécuriser les communications
• Suivre les bonnes pratiques AWS