Services AWS Essentiels : Guide Complet

Découvrez les services AWS les plus importants et leurs cas d’utilisation courants.

1. Services de Calcul

Amazon EC2 (Elastic Compute Cloud)

# Exemple de création d'une instance EC2 avec boto3
import boto3

def create_ec2_instance():
    ec2 = boto3.client('ec2')
    
    response = ec2.run_instances(
        ImageId='ami-0c55b159cbfafe1f0',  # Amazon Linux 2 AMI
        InstanceType='t2.micro',
        MinCount=1,
        MaxCount=1,
        KeyName='ma-clé',
        SecurityGroupIds=['sg-xxxxxxxx'],
        TagSpecifications=[
            {
                'ResourceType': 'instance',
                'Tags': [
                    {'Key': 'Name', 'Value': 'mon-instance'},
                    {'Key': 'Environnement', 'Value': 'Production'}
                ]
            }
        ]
    )
    
    return response['Instances'][0]['InstanceId']

AWS Lambda

# Exemple de fonction Lambda
import json

def lambda_handler(event, context):
    try:
        # Traitement des données
        body = json.loads(event['body'])
        result = process_data(body)
        
        return {
            'statusCode': 200,
            'body': json.dumps({
                'message': 'Succès',
                'result': result
            })
        }
    except Exception as e:
        return {
            'statusCode': 500,
            'body': json.dumps({
                'message': 'Erreur',
                'error': str(e)
            })
        }

2. Services de Stockage

Amazon S3 (Simple Storage Service)

# Exemple d'utilisation de S3
import boto3

def upload_to_s3(file_path, bucket_name, object_name):
    s3 = boto3.client('s3')
    
    try:
        s3.upload_file(file_path, bucket_name, object_name)
        return True
    except Exception as e:
        print(f"Erreur lors de l'upload: {e}")
        return False

def download_from_s3(bucket_name, object_name, file_path):
    s3 = boto3.client('s3')
    
    try:
        s3.download_file(bucket_name, object_name, file_path)
        return True
    except Exception as e:
        print(f"Erreur lors du téléchargement: {e}")
        return False

Amazon EBS (Elastic Block Store)

# Exemple de gestion des volumes EBS
import boto3

def create_ebs_volume(availability_zone, size_gb):
    ec2 = boto3.client('ec2')
    
    response = ec2.create_volume(
        AvailabilityZone=availability_zone,
        Size=size_gb,
        VolumeType='gp3',
        TagSpecifications=[
            {
                'ResourceType': 'volume',
                'Tags': [
                    {'Key': 'Name', 'Value': 'mon-volume'},
                    {'Key': 'Type', 'Value': 'Données'}
                ]
            }
        ]
    )
    
    return response['VolumeId']

3. Services de Base de Données

Amazon RDS (Relational Database Service)

# Exemple de connexion à RDS
import mysql.connector

def connect_to_rds():
    try:
        connection = mysql.connector.connect(
            host='mon-instance.xxxxx.region.rds.amazonaws.com',
            user='admin',
            password='mon-mot-de-passe',
            database='ma_base'
        )
        return connection
    except Exception as e:
        print(f"Erreur de connexion: {e}")
        return None

Amazon DynamoDB

# Exemple d'utilisation de DynamoDB
import boto3

def create_dynamodb_item(table_name, item):
    dynamodb = boto3.resource('dynamodb')
    table = dynamodb.Table(table_name)
    
    try:
        response = table.put_item(Item=item)
        return response
    except Exception as e:
        print(f"Erreur lors de la création: {e}")
        return None

4. Services de Réseau

Amazon VPC (Virtual Private Cloud)

# Exemple de création de VPC
import boto3

def create_vpc():
    ec2 = boto3.client('ec2')
    
    # Création du VPC
    vpc_response = ec2.create_vpc(
        CidrBlock='10.0.0.0/16',
        TagSpecifications=[
            {
                'ResourceType': 'vpc',
                'Tags': [
                    {'Key': 'Name', 'Value': 'mon-vpc'},
                    {'Key': 'Environnement', 'Value': 'Production'}
                ]
            }
        ]
    )
    
    # Création d'un sous-réseau public
    subnet_response = ec2.create_subnet(
        VpcId=vpc_response['Vpc']['VpcId'],
        CidrBlock='10.0.1.0/24',
        AvailabilityZone='eu-west-3a'
    )
    
    return {
        'vpc_id': vpc_response['Vpc']['VpcId'],
        'subnet_id': subnet_response['Subnet']['SubnetId']
    }

Amazon Route 53

# Exemple de gestion DNS avec Route 53
import boto3

def create_dns_record(zone_id, domain_name, record_type, value):
    route53 = boto3.client('route53')
    
    response = route53.change_resource_record_sets(
        HostedZoneId=zone_id,
        ChangeBatch={
            'Changes': [
                {
                    'Action': 'CREATE',
                    'ResourceRecordSet': {
                        'Name': domain_name,
                        'Type': record_type,
                        'TTL': 300,
                        'ResourceRecords': [
                            {'Value': value}
                        ]
                    }
                }
            ]
        }
    )
    
    return response['ChangeInfo']['Id']

5. Services de Sécurité

AWS IAM (Identity and Access Management)

# Exemple de création d'utilisateur IAM
import boto3

def create_iam_user(username):
    iam = boto3.client('iam')
    
    try:
        # Création de l'utilisateur
        user_response = iam.create_user(UserName=username)
        
        # Attachement d'une politique
        iam.attach_user_policy(
            UserName=username,
            PolicyArn='arn:aws:iam::aws:policy/PowerUserAccess'
        )
        
        return user_response['User']['UserName']
    except Exception as e:
        print(f"Erreur lors de la création: {e}")
        return None

AWS KMS (Key Management Service)

# Exemple d'utilisation de KMS
import boto3

def encrypt_data(key_id, data):
    kms = boto3.client('kms')
    
    try:
        response = kms.encrypt(
            KeyId=key_id,
            Plaintext=data.encode('utf-8')
        )
        return response['CiphertextBlob']
    except Exception as e:
        print(f"Erreur de chiffrement: {e}")
        return None

Conclusion

Points clés à retenir :

• Choisir les services appropriés selon les besoins
• Optimiser les coûts
• Mettre en place la sécurité dès le début
• Utiliser les bonnes pratiques AWS
• Surveiller les performances

Services essentiels :

• EC2 pour le calcul
• S3 pour le stockage
• RDS pour les bases de données relationnelles
• DynamoDB pour les bases NoSQL
• VPC pour le réseau
• IAM pour la sécurité