Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Tutoriel : Configuration de Lambda pour accéder à un ElastiCache VPC

Dans ce didacticiel, vous apprendrez à créer un cache ElastiCache sans serveur, à créer une fonction Lambda, puis à tester la fonction Lambda et éventuellement à la nettoyer ensuite.

Étape 1 : Création d'un cache ElastiCache sans serveur

Pour créer un cache sans serveur, procédez comme suit.

Étape 1.1 : Création d'un cache sans serveur

Au cours de cette étape, vous créez un cache sans serveur dans l'Amazon par défaut VPC dans la région us-east-1 de votre compte à l'aide du (). AWS Command Line Interface CLI Pour plus d'informations sur la création d'un cache sans serveur à l'aide de la ElastiCache console ou API consultezCréation d'un cache sans serveur Valkey.

aws elasticache create-serverless-cache \
  --serverless-cache-name cache-01  \
--description "ElastiCache IAM auth application" \
--engine valkey

Notez que la valeur du champ Statut est définie sur CREATING. La création de votre cache peut prendre une minute. ElastiCache

Étape 1.2 : Copier le point de terminaison du cache sans serveur

Vérifiez que ElastiCache (RedisOSS) a terminé de créer le cache à l'aide de la describe-serverless-caches commande.

aws elasticache describe-serverless-caches \
--serverless-cache-name cache-01 

Copiez l’adresse du point de terminaison affichée dans la sortie. Vous aurez besoin de cette adresse lorsque vous allez créer le package de déploiement de votre fonction Lambda.

Étape 1.3 : Création d'un IAM rôle

Étape 1.4 : Création d'un cache sans serveur

Étape 2 : Création d'une fonction Lambda pour ElastiCache

Pour créer une fonction Lambda permettant d'accéder au ElastiCache cache, procédez comme suit.

Étape 2.1 : Création d'une fonction Lambda

Dans ce didacticiel, nous fournissons un exemple de code en Python pour votre fonction Lambda.

Python

L'exemple de code Python suivant lit et écrit un élément dans votre ElastiCache cache. Copiez le code et enregistrez-le dans un fichier nommé app.py. Assurez-vous de remplacer la elasticache_endpoint valeur du code par l'adresse du point de terminaison que vous avez copiée à l'étape précédente.

from typing import Tuple, Union
from urllib.parse import ParseResult, urlencode, urlunparse

import botocore.session
import redis
from botocore.model import ServiceId
from botocore.signers import RequestSigner
from cachetools import TTLCache, cached
import uuid

class ElastiCacheIAMProvider(redis.CredentialProvider):
    def __init__(self, user, cache_name, is_serverless=False, region="us-east-1"):
        self.user = user
        self.cache_name = cache_name
        self.is_serverless = is_serverless
        self.region = region

        session = botocore.session.get_session()
        self.request_signer = RequestSigner(
            ServiceId("elasticache"),
            self.region,
            "elasticache",
            "v4",
            session.get_credentials(),
            session.get_component("event_emitter"),
        )

    # Generated IAM tokens are valid for 15 minutes
    @cached(cache=TTLCache(maxsize=128, ttl=900))
    def get_credentials(self) -> Union[Tuple[str], Tuple[str, str]]:
        query_params = {"Action": "connect", "User": self.user}
        if self.is_serverless:
            query_params["ResourceType"] = "ServerlessCache"
        url = urlunparse(
            ParseResult(
                scheme="https",
                netloc=self.cache_name,
                path="/",
                query=urlencode(query_params),
                params="",
                fragment="",
            )
        )
        signed_url = self.request_signer.generate_presigned_url(
            {"method": "GET", "url": url, "body": {}, "headers": {}, "context": {}},
            operation_name="connect",
            expires_in=900,
            region_name=self.region,
        )
        # RequestSigner only seems to work if the URL has a protocol, but
        # Elasticache only accepts the URL without a protocol
        # So strip it off the signed URL before returning
        return (self.user, signed_url.removeprefix("https://"))

def lambda_handler(event, context):
    username = "iam-user-01" # replace with your user id
    cache_name = "cache-01" # replace with your cache name
    elasticache_endpoint = "cache-01-xxxxx.serverless.use1.cache.amazonaws.com" # replace with your cache endpoint
    creds_provider = ElastiCacheIAMProvider(user=username, cache_name=cache_name, is_serverless=True)
    redis_client = redis.Redis(host=elasticache_endpoint, port=6379, credential_provider=creds_provider, ssl=True, ssl_cert_reqs="none")
    
    key='uuid'
    # create a random UUID - this will be the sample element we add to the cache
    uuid_in = uuid.uuid4().hex
    redis_client.set(key, uuid_in)
    result = redis_client.get(key)
    decoded_result = result.decode("utf-8")
    # check the retrieved item matches the item added to the cache and print
    # the results
    if decoded_result == uuid_in:
        print(f"Success: Inserted {uuid_in}. Fetched {decoded_result} from Valkey.")
    else:
        raise Exception(f"Bad value retrieved. Expected {uuid_in}, got {decoded_result}")
        
    return "Fetched value from Valkey"

Ce code utilise la bibliothèque Python redis-py pour mettre des éléments dans votre cache et les récupérer. Ce code utilise des outils de cache pour mettre en cache les jetons d'IAMauthentification générés pendant 15 minutes. Pour créer un package de déploiement contenant redis-py et cachetools, effectuez les étapes suivantes.

Dans le répertoire de votre projet contenant le fichier de code source app.py, créez un package de dossiers dans lequel installer les bibliothèques redis-py et cachetools.

mkdir package

Installez redis-py, cachetools en utilisant pip.

pip install --target ./package redis
pip install --target ./package cachetools

Créez un fichier .zip contenant les bibliothèques redis-py et cachetools. Sous Linux et macOS, exécutez la commande suivante. Sous Windows, utilisez l'utilitaire zip de votre choix pour créer un fichier .zip avec les bibliothèques redis-py et cachetools à la racine.

cd package
zip -r ../my_deployment_package.zip .

Ajoutez votre code de fonction dans le fichier .zip. Sous Linux et macOS, exécutez la commande suivante. Sous Windows, utilisez l'utilitaire zip de votre choix pour ajouter le fichier app.py à la racine de votre fichier .zip.

cd ..
zip my_deployment_package.zip app.py

Étape 2.2 : Création du IAM rôle (rôle d'exécution)

Attachez la politique AWS gérée nommée AWSLambdaVPCAccessExecutionRole au rôle.

aws iam attach-role-policy \
 --role-name "elasticache-iam-auth-app" \
 --policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"

Étape 2.3 : Charger le package de déploiement (créer la fonction Lambda)

Dans cette étape, vous créez la fonction Lambda (AccessValkey) à l'aide de la commande AWS CLI create-function.

Dans le répertoire du projet qui contient le fichier .zip de votre package de déploiement, exécutez la commande CLI create-function Lambda suivante.

Pour l'option de rôle, utilisez le rôle ARN d'exécution que vous avez créé à l'étape précédente. Pour le vpc-config, entrez des listes séparées par des virgules des sous-réseaux de vos sous-réseaux par défaut et VPC de votre ID de groupe VPC de sécurité par défaut. Vous pouvez trouver ces valeurs dans la VPC console Amazon. Pour trouver les sous-réseaux VPC de votre compte par défaut, sélectionnez Votre VPCs, puis choisissez celui par défaut VPC de votre AWS compte. Pour trouver le groupe de sécurité correspondantVPC, allez dans Sécurité et choisissez Groupes de sécurité. Assurez-vous que la région us-east-1 est sélectionnée.

aws lambda create-function \
--function-name AccessValkey  \
--region us-east-1 \
--zip-file fileb://my_deployment_package.zip \
--role arn:aws:iam::123456789012:role/elasticache-iam-auth-app \
--handler app.lambda_handler \
--runtime python3.12  \
--timeout 30 \
--vpc-config SubnetIds=comma-separated-vpc-subnet-ids,SecurityGroupIds=default-security-group-id

Étape 3 : tester la fonction Lambda avec ElastiCache

Au cours de cette étape, vous invoquez la fonction Lambda manuellement à l'aide de la commande invoke. Lorsque la fonction Lambda s'exécute, elle génère un UUID et l'écrit dans le ElastiCache cache que vous avez spécifié dans votre code Lambda. La fonction Lambda récupère ensuite l'élément à partir du cache.

Étape 4 : Nettoyage (facultatif)

Pour nettoyer, procédez comme suit.

Étape 4.1 : Supprimer la fonction Lambda

aws lambda delete-function \
 --function-name AccessValkey 

Étape 4.2 : Supprimer le cache sans serveur

Supprimez le cache.

aws elasticache delete-serverless-cache \
 --serverless-cache-name cache-01 

Supprimez des utilisateurs et des groupes d'utilisateurs.

aws elasticache delete-user \
 --user-id default-user-disabled

aws elasticache delete-user \
 --user-id iam-user-01

aws elasticache delete-user-group \
 --user-group-id iam-user-group-01

Étape 4.3 : Supprimer le IAM rôle et les politiques

aws iam detach-role-policy \
 --role-name "elasticache-iam-auth-app" \
 --policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
 
aws iam detach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
 
aws iam delete-role \
 --role-name "elasticache-iam-auth-app"
  
 aws iam delete-policy \
  --policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"