AWS Lambda et Serverless : Guide pour Débutants

Découvrez le concept de serverless et comment utiliser AWS Lambda.

1. Qu’est-ce que le Serverless ?

Définition Simple

• Serverless = Sans serveur à gérer
• Avantages :
  • Pas de gestion d’infrastructure
  • Paiement à l’utilisation
  • Mise à l’échelle automatique

Comparaison avec EC2

# Exemple de coût EC2 vs Lambda
def compare_costs():
    # EC2 : Paiement par heure
    ec2_cost = {
        't2.micro': 0.0116,  # par heure
        't2.small': 0.023,   # par heure
        't2.medium': 0.0464  # par heure
    }
    
    # Lambda : Paiement par requête
    lambda_cost = {
        'requests': 0.0000002,  # par requête
        'duration': 0.00001667  # par 100ms
    }
    
    return {
        'ec2': ec2_cost,
        'lambda': lambda_cost
    }

2. AWS Lambda en Pratique

Création d’une Fonction Simple

# Exemple de fonction Lambda
def lambda_handler(event, context):
    # Fonction simple qui retourne un message
    return {
        'statusCode': 200,
        'body': 'Bonjour depuis Lambda !'
    }

Configuration de la Fonction

# Exemple de configuration Lambda
def setup_lambda():
    lambda_client = boto3.client('lambda')
    
    # Création d'une fonction
    function = lambda_client.create_function(
        FunctionName='MaFonction',
        Runtime='python3.9',
        Handler='index.lambda_handler',
        Code={
            'ZipFile': open('mon-code.zip', 'rb').read()
        },
        Role='arn:aws:iam::account:role/lambda-role',
        Timeout=30,
        MemorySize=128
    )
    
    return function['FunctionArn']

3. Intégration avec d’autres Services

S3 Trigger

# Exemple de trigger S3
def s3_trigger_handler(event, context):
    # Traitement d'un fichier uploadé dans S3
    for record in event['Records']:
        bucket = record['s3']['bucket']['name']
        key = record['s3']['object']['key']
        
        # Lire le fichier
        s3 = boto3.client('s3')
        response = s3.get_object(Bucket=bucket, Key=key)
        content = response['Body'].read().decode('utf-8')
        
        # Traiter le contenu
        return {
            'statusCode': 200,
            'body': f'Fichier traité : {key}'
        }

API Gateway

# Exemple d'intégration API Gateway
def api_handler(event, context):
    # Traitement d'une requête HTTP
    http_method = event['httpMethod']
    
    if http_method == 'GET':
        return {
            'statusCode': 200,
            'body': 'GET request réussie'
        }
    elif http_method == 'POST':
        body = json.loads(event['body'])
        return {
            'statusCode': 200,
            'body': f'Données reçues : {body}'
        }

4. Bonnes Pratiques

Gestion des Dépendances

# Exemple de gestion des dépendances
def create_lambda_package():
    # Créer un environnement virtuel
    os.system('python -m venv venv')
    
    # Installer les dépendances
    os.system('pip install -r requirements.txt -t ./package')
    
    # Créer le ZIP
    shutil.make_archive('lambda-package', 'zip', './package')
    
    return 'lambda-package.zip'

Configuration de la Mémoire

# Exemple d'optimisation de la mémoire
def optimize_memory():
    lambda_client = boto3.client('lambda')
    
    # Mise à jour de la configuration
    lambda_client.update_function_configuration(
        FunctionName='MaFonction',
        MemorySize=256,  # Augmenter la mémoire
        Timeout=60,      # Augmenter le timeout
        Environment={
            'Variables': {
                'ENV': 'production',
                'DEBUG': 'false'
            }
        }
    )

5. Surveillance et Logs

CloudWatch Logs

# Exemple de logging
def lambda_with_logging(event, context):
    # Logging simple
    print('Démarrage de la fonction')
    
    try:
        # Code de la fonction
        result = process_data(event)
        
        print('Traitement réussi')
        return result
    except Exception as e:
        print(f'Erreur : {str(e)}')
        raise

Métriques

# Exemple de métriques personnalisées
def custom_metrics():
    cloudwatch = boto3.client('cloudwatch')
    
    # Envoyer une métrique
    cloudwatch.put_metric_data(
        Namespace='MonApplication',
        MetricData=[
            {
                'MetricName': 'TempsExecution',
                'Value': 1.5,
                'Unit': 'Seconds',
                'Dimensions': [
                    {
                        'Name': 'Fonction',
                        'Value': 'MaFonction'
                    }
                ]
            }
        ]
    )

6. Sécurité

Variables d’Environnement

# Exemple de gestion des secrets
def secure_lambda():
    lambda_client = boto3.client('lambda')
    
    # Configuration des variables d'environnement
    lambda_client.update_function_configuration(
        FunctionName='MaFonction',
        Environment={
            'Variables': {
                'API_KEY': 'mon-api-key',
                'DB_PASSWORD': 'mon-mot-de-passe'
            }
        }
    )

IAM Roles

# Exemple de configuration IAM
def setup_iam_role():
    iam = boto3.client('iam')
    
    # Création du rôle
    role = iam.create_role(
        RoleName='lambda-role',
        AssumeRolePolicyDocument=json.dumps({
            'Version': '2012-10-17',
            'Statement': [
                {
                    'Effect': 'Allow',
                    'Principal': {
                        'Service': 'lambda.amazonaws.com'
                    },
                    'Action': 'sts:AssumeRole'
                }
            ]
        })
    )
    
    return role['Role']['Arn']

Conclusion

Points clés à retenir :

• Serverless = pas de gestion d’infrastructure
• Lambda = fonctions exécutées à la demande
• Paiement uniquement pour l’utilisation
• Intégration facile avec d’autres services
• Mise à l’échelle automatique

Recommandations :

• Commencer par des fonctions simples
• Surveiller les coûts
• Utiliser les logs pour le debugging
• Sécuriser les fonctions
• Optimiser les performances