Other Important AWS Services: Complete Guide

Discover other essential AWS services for application development and deployment.

1. API Gateway and Lambda

API Gateway Configuration

# Example API Gateway configuration
import boto3

def setup_api_gateway():
    apigateway = boto3.client('apigateway')
    
    # Create the API
    api = apigateway.create_rest_api(
        name='MonAPI',
        description='API pour mon application'
    )
    
    # Create a resource
    resource = apigateway.create_resource(
        restApiId=api['id'],
        parentId=api['rootResourceId'],
        pathPart='items'
    )
    
    # Create a method
    method = apigateway.put_method(
        restApiId=api['id'],
        resourceId=resource['id'],
        httpMethod='GET',
        authorizationType='NONE'
    )
    
    return {
        'api_id': api['id'],
        'resource_id': resource['id']
    }

Lambda Integration

# Example Lambda integration with 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 and SNS

SQS Configuration

# Example SQS configuration
def setup_sqs_queue():
    sqs = boto3.client('sqs')
    
    # Create the queue
    queue = sqs.create_queue(
        QueueName='MonFileAttente',
        Attributes={
            'VisibilityTimeout': '30',
            'MessageRetentionPeriod': '345600'
        }
    )
    
    # Configure permissions
    sqs.add_permission(
        QueueUrl=queue['QueueUrl'],
        Label='MonLabel',
        AWSAccountIds=['123456789012'],
        Actions=['SendMessage', 'ReceiveMessage']
    )
    
    return queue['QueueUrl']

SNS Configuration

# Example SNS configuration
def setup_sns_topic():
    sns = boto3.client('sns')
    
    # Create the 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': '*'
                    }
                ]
            })
        }
    )
    
    # Subscribe an 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

Redis Configuration

# Example ElastiCache Redis configuration
def setup_elasticache_redis():
    elasticache = boto3.client('elasticache')
    
    # Create the Redis cluster
    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']

Using the Cache

# Example of using the Redis cache
import redis

def use_redis_cache():
    # Connect to the Redis cluster
    redis_client = redis.Redis(
        host='mon-cluster.xxxxx.region.cache.amazonaws.com',
        port=6379,
        decode_responses=True
    )
    
    # Store data
    redis_client.set('ma_cle', 'ma_valeur')
    
    # Retrieve data
    valeur = redis_client.get('ma_cle')
    
    return valeur

4. Amazon CloudFront

CDN Configuration

# Example CloudFront configuration
def setup_cloudfront():
    cloudfront = boto3.client('cloudfront')
    
    # Create the 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']

Behavior Configuration

# Example CloudFront behavior configuration
def setup_cloudfront_behaviors():
    cloudfront = boto3.client('cloudfront')
    
    # Create a custom behavior
    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 and CloudWatch

DNS Configuration

# Example Route 53 configuration
def setup_route53():
    route53 = boto3.client('route53')
    
    # Create a hosted zone
    zone = route53.create_hosted_zone(
        Name='mon-domaine.com',
        CallerReference=str(time.time())
    )
    
    # Create a record
    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']
    }

Health Check Configuration

# Example health check configuration
def setup_health_checks():
    route53 = boto3.client('route53')
    
    # Create a 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

Key takeaways:

• Manage APIs with API Gateway
• Use messaging services (SQS/SNS)
• Cache with ElastiCache
• Distribute content with CloudFront
• Manage DNS with Route 53

Recommendations:

• Choose the right services for your needs
• Optimize performance
• Set up effective monitoring
• Secure communications
• Follow AWS best practices