Invocation d'une AWS Lambda fonction depuis une instance de base de données Aurora PostgreSQL pour PostgreSQL - Amazon Aurora
Étape 1 : configurer les connexions sortantesÉtape 2 : configurer IAM pour votre cluster et LambdaÉtape 3 : installer l'extensionÉtape 4 : utiliser les fonctions d'assistance LambdaÉtape 5 : appeler une fonction Lambda. Étape 6 : accorder des autorisations aux utilisateurs Exemples : appel de fonctions Lambda Messages d'erreur de fonction Lambda

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.

Invocation d'une AWS Lambda fonction depuis une instance de base de données Aurora PostgreSQL pour PostgreSQL

AWS Lambda est un service de calcul piloté par les événements qui vous permet d'exécuter du code sans provisionner ni gérer de serveurs. Il peut être utilisé avec de nombreux AWS services, notamment Aurora PostgreSQL . Par exemple, vous pouvez utiliser des fonctions Lambda pour traiter les notifications d'événements à partir d'une base de données ou pour charger des données à partir de fichiers chaque fois qu'un nouveau fichier est chargé sur Amazon S3. Pour en savoir plus sur Lambda, consultez Qu'est-ce que c'est ? AWS Lambda dans le Guide AWS Lambda du développeur.

Note

L'appel de AWS Lambda fonctions est pris en charge dans Aurora PostgreSQL 11.9 et versions ultérieures (y compris). Aurora Serverless v2

Vous trouverez ci-après des résumés des étapes nécessaires.

Pour plus d'informations sur les fonctions Lambda, veuillez consulter Mise en route avec Lambda et Principes de base d'AWS  Lambda dans le Guide du développeur AWS Lambda .

Rubriques

Étape 1 : configurer votre instance de base de données Aurora PostgreSQL RDS pour PostgreSQL vers AWS Lambda

Les fonctions Lambda s'exécutent toujours au sein d'un Amazon VPC appartenant au service. AWS Lambda Lambda applique des règles d'accès réseau et de sécurité à ce VPC, le maintient et le surveille automatiquement. Votre cluster de base de données Aurora PostgreSQL envoie du trafic réseau vers le VPC du service Lambda. La façon dont vous configurez cela dépend de si votre instance de base de données primaire du cluster de base de données Aurora est publique ou privée.

  • PubliclyAccessible true Pour trouver la valeur de cette propriété, vous pouvez utiliser la describe-db-instances AWS CLI commande. Vous pouvez également utiliser la AWS Management Console afin d'ouvrir l'onglet Connectivity & security (Connectivité et sécurité) et vérifier que l'option Publicly accessible (Accessible publiquement) est définie sur Yes (Oui). Pour vérifier que l'instance se trouve dans le sous-réseau public de votre VPC, vous pouvez utiliser la AWS Management Console ou AWS CLI.

    Pour configurer l'accès à Lambda, vous utilisez le AWS Management Console ou AWS CLI pour créer une règle sortante sur le groupe de sécurité de votre VPC. La règle de sortie spécifie que TCP peut utiliser le port 443 pour envoyer des paquets à n'importe quelle adresse IPv4 (0.0.0.0/0).

  • Cluster de base de données Aurora PostgreSQL — Dans ce cas, la propriété PubliclyAccessible false « » de l'instance est ou se trouve dans un sous-réseau privé. Pour permettre à l'instance de fonctionner avec Lambda, vous pouvez utiliser une passerelle traduction d'adresses réseau (NAT). Pour plus d'informations, veuillez consulter Passerelles NAT. Vous pouvez également configurer votre VPC avec un point de terminaison VPC pour Lambda. Pour de plus amples informations, consultez Points de terminaison VPC dans le Guide de l’utilisateur Amazon VPC. Le point de terminaison répond aux appels faits par votre cluster de base de données Aurora PostgreSQL à vos fonctions Lambda.

Votre VPC peut désormais interagir avec le AWS Lambda VPC au niveau du réseau. Ensuite, vous configurez les autorisations à l'aide d'IAM.

Étape 2 : configurer IAM pour votre instance de base de données Aurora PostgreSQL pour PostgreSQL et AWS Lambda

L'appel de fonctions Lambda depuis votre cluster de base de données Aurora PostgreSQL requiert certains privilèges. Pour configurer les privilèges requis, nous vous recommandons de créer une politique IAM qui permet d'appeler des fonctions Lambda, d'attribuer cette politique à un rôle, puis d'appliquer le rôle à votre cluster de base de données. Cette approche accorde au cluster de base de données des privilèges pour appeler la fonction Lambda spécifiée en votre nom. Les étapes suivantes expliquent comment procéder à l'aide de l' AWS CLI.

Pour configurer les autorisations IAM pour l'utilisation de votre clusteravec Lambda

  1. Utilisez la AWS CLI commande create-policy pour créer une politique IAM qui permet à votre instance de base de données Aurora PostgreSQL d'appeler la fonction Lambda spécifiée. (L'ID d'instruction (Sid) est une description facultative pour votre instruction de politique et n'a aucun effet sur l'utilisation.) Cette politique accorde à votre cluster de base de données Aurora les autorisations minimales requises pour appeler la fonction Lambda spécifiée. 

    aws iam create-policy  --policy-name rds-lambda-policy --policy-document '{
    "Version": "2012-10-17",
    "Statement": [
        {
        "Sid": "AllowAccessToExampleFunction",
        "Effect": "Allow",
        "Action": "lambda:InvokeFunction",
        "Resource": "arn:aws:lambda:aws-region:444455556666:function:my-function"
        }
    ]
}'

    Vous pouvez également utiliser la politique AWSLambdaRole prédéfinie qui vous permet d'appeler n'importe laquelle de vos fonctions Lambda. Pour de plus amples informations, veuillez consulter la rubrique Politiques IAM basées sur l'identité pour Lambda.

  2. Utilisez la AWS CLI commande create-role pour créer un rôle IAM que la politique peut assumer lors de l'exécution.

    aws iam create-role  --role-name rds-lambda-role --assume-role-policy-document '{
    "Version": "2012-10-17",
    "Statement": [
        {
        "Effect": "Allow",
        "Principal": {
            "Service": "rds.amazonaws.com"
        },
        "Action": "sts:AssumeRole"
        }
    ]
}'

  3. Appliquez la politique au rôle à l'aide de la attach-role-policy AWS CLI commande.

    aws iam attach-role-policy \
    --policy-arn arn:aws:iam::444455556666:policy/rds-lambda-policy \
    --role-name rds-lambda-role --region aws-region

  4. https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/add-role-to-db-cluster.html AWS CLI Cette dernière étape permet aux utilisateurs de base de données de votre cluster de base de données d'appeler des fonctions Lambda. 

    aws rds add-role-to-db-cluster \
       --db-cluster-identifier my-cluster-name \
       --feature-name Lambda \
       --role-arn  arn:aws:iam::444455556666:role/rds-lambda-role   \
       --region aws-region

Une fois le VPC et les configurations IAM terminées, vous pouvez désormais installer l'extension aws_lambda. (Notez que vous pouvez installer l'extension à tout moment, mais tant que vous n'avez pas configuré la prise en charge du VPC et les privilèges IAM corrects, l'extension aws_lambda n'ajoute rien aux fonctionnalités de votre cluster de base de données Aurora PostgreSQL.)

Étape 3 : installer l'extension aws_lambda pour un cluster de base de données Aurora PostgreSQL

Cette extension offre à votre cluster de base de données Aurora PostgreSQL la capacité d'appeler des fonctions Lambda depuis PostgreSQL.

Pour installer l'extension aws_lambda dans votre cluster de base de données Aurora PostgreSQL

Utilisez la ligne de commande psql de PostgreSQL ou l'outil pgAdmin afin de vous connecter à votre cluster de base de données Aurora PostgreSQL.

  1. Connectez-vous à votre cluster de base de données Aurora PostgreSQL en tant qu'utilisateur doté de privilèges rds_superuser. L'utilisateur postgres par défaut est illustré dans l'exemple.

    psql -h cluster-instance.444455556666.aws-region.rds.amazonaws.com -U postgres -p 5432

  2. Installez l'extension aws_lambda. L'extension aws_commons est également requise. Elle fournit des fonctions d'assistance pour aws_lambda et de nombreuses autres extensions Aurora pour PostgreSQL. Si elle n'est pas déjà sur votre cluster de base de données Aurora PostgreSQL, elle est installée avec aws_lambda comme illustré ci-dessous. 

    CREATE EXTENSION IF NOT EXISTS aws_lambda CASCADE;
NOTICE:  installing required extension "aws_commons"
CREATE EXTENSION

L'extension aws_lambda est installée dans l'instance de base de données primaire de votre cluster de base de données Aurora PostgreSQL. Vous pouvez désormais créer des structures de commodité pour appeler vos fonctions Lambda.

Étape 4 : utiliser les fonctions d'assistance Lambda avec votre cluster de base de données Aurora PostgreSQL (Facultatif)

Vous pouvez utiliser les fonctions d'assistance de l'extension aws_commons pour préparer les entités que vous pouvez appeler plus facilement depuis PostgreSQL. Pour ce faire, vous avez besoin des informations suivantes concernant vos fonctions Lambda :

  • Function name (Nom de la fonction) — Le nom, l'Amazon Resource Name (ARN), la version ou l'alias de la fonction Lambda. La politique IAM créée dans Étape 2 : configurer IAM pour votre cluster et Lambda nécessite l'ARN, nous vous recommandons donc d'utiliser l'ARN de votre fonction.

  • AWS Région

Pour conserver les informations de nom de la fonction Lambda, utilisez la fonction aws_commons.create_lambda_function_arn. Cette fonction d'assistance crée une structure composite aws_commons._lambda_function_arn_1 avec les détails requis par la fonction d'appel. Vous trouverez ci-dessous trois autres approches pour configurer cette structure composite.

SELECT aws_commons.create_lambda_function_arn(
   'my-function',
   'aws-region'
) AS aws_lambda_arn_1 \gset

SELECT aws_commons.create_lambda_function_arn(
   '111122223333:function:my-function',
   'aws-region'
) AS lambda_partial_arn_1 \gset

SELECT aws_commons.create_lambda_function_arn(
   'arn:aws:lambda:aws-region:111122223333:function:my-function'
) AS lambda_arn_1 \gset

N'importe laquelle de ces valeurs peut être utilisée dans les appels à la fonction aws_lambda.invoke. Pour obtenir des exemples, consultez Étape 5 : appeler une fonction Lambda à partir de votre cluster de base de données Aurora PostgreSQL..

Étape 5 : appeler une fonction Lambda à partir de votre cluster de base de données Aurora PostgreSQL.

La fonction aws_lambda.invoke se comporte de manière synchrone ou asynchrone, en fonction du invocation_type. Les deux alternatives à ce paramètre sont RequestResponse (valeur par défaut) et Event, comme suit.

  • RequestResponse — Ce type d'appel est synchrone. Il s'agit du comportement par défaut lorsque l'appel est effectué sans spécifier de type d'appel. La charge utile de réponse inclut les résultats de la fonction aws_lambda.invoke. Utilisez ce type d'appel lorsque votre flux de travail nécessite la réception des résultats de la fonction Lambda avant de continuer.

  • Event — Ce type d'appel est asynchrone. La réponse n'inclut pas de charge utile contenant des résultats. Utilisez ce type d'appel lorsque votre flux de travail n'a pas besoin de résultat de la fonction Lambda pour continuer le traitement.

Pour tester simplement votre configuration, vous pouvez vous connecter à votre instance de base de données en utilisant psql et appeler un exemple de fonction depuis la ligne de commande. Supposons que l'une des fonctions de base soit configurée sur votre service Lambda, telle que la fonction simple Python affichée dans la capture d'écran suivante.

Exemple de fonction Lambda illustré dans le fichier pour AWS CLI AWS Lambda
Pour invoquer un exemple de fonction

  1. Connectez-vous à votre instance de base de données primaire avec psql ou pgAdmin.

    psql -h cluster.444455556666.aws-region.rds.amazonaws.com -U postgres -p 5432

  2. Appelez la fonction en utilisant son ARN.

    SELECT * from aws_lambda.invoke(aws_commons.create_lambda_function_arn('arn:aws:lambda:aws-region:444455556666:function:simple', 'us-west-1'), '{"body": "Hello from Postgres!"}'::json );

    La réponse se présente comme suit.

    status_code |                        payload                        | executed_version | log_result
-------------+-------------------------------------------------------+------------------+------------
         200 | {"statusCode": 200, "body": "\"Hello from Lambda!\""} | $LATEST          |
(1 row)

Si votre tentative d'appel ne réussit pas, veuillez consulter la section Messages d'erreur de fonction Lambda .

Étape 6 : accorder aux autres utilisateurs l'autorisation d'appeler les fonctions Lambda

À ce stade des procédures, vous êtes le seul, en tant que rds_superuser, à pouvoir appeler vos fonctions Lambda. Pour permettre à d'autres utilisateurs d'appeler les fonctions que vous avez créées, vous devez leur accorder des autorisations.

Pour accorder à d'autres personnes l'autorisation d'appeler les fonctions Lambda

  1. Connectez-vous à votre instance de base de données primaire avec psql ou pgAdmin.

    psql -h cluster.444455556666.aws-region.rds.amazonaws.com -U postgres -p 5432

  2. Exécutez les commandes SQL suivantes :

    postgres=>  GRANT USAGE ON SCHEMA aws_lambda TO db_username;
GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA aws_lambda TO db_username;

Exemples : appel de fonctions Lambda à partir de votre cluster de base de données Aurora PostgreSQL

Ci-dessous, vous pouvez trouver plusieurs exemples d'appel de la fonction aws_lambda.invoke. La plupart des exemples utilisent la structure composite aws_lambda_arn_1 que vous créez dans Étape 4 : utiliser les fonctions d'assistance Lambda avec votre cluster de base de données Aurora PostgreSQL (Facultatif) pour simplifier la transmission des détails de la fonction. Pour obtenir un exemple d'appel asynchrone, reportez-vous à la section Exemple : appel asynchrone (Event) de fonctions Lambda. Tous les autres exemples répertoriés utilisent l'appel synchrone.

Pour en savoir plus sur les types d'appel Lambda, veuillez consulter Appel de fonctions Lambda dans le Guide du développeur AWS Lambda . Pour plus d’informations sur aws_lambda_arn_1, consultez aws_commons.create_lambda_function_arn.

Exemple : appel synchrone (RequestResponse) de fonctions Lambda

Voici deux exemples d'appel synchrone de fonction Lambda. Les résultats de ces appels de fonction aws_lambda.invoke sont identiques.

SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json);

SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'RequestResponse');

Les paramètres sont décrits comme suit :

  • :'aws_lambda_arn_1' — Ce paramètre identifie la structure composite créée dans Étape 4 : utiliser les fonctions d'assistance Lambda avec votre cluster de base de données Aurora PostgreSQL (Facultatif), avec la fonction d'assistance aws_commons.create_lambda_function_arn. Vous pouvez également créer cette structure en ligne dans votre appel aws_lambda.invoke comme suit. 

    SELECT * FROM aws_lambda.invoke(aws_commons.create_lambda_function_arn('my-function', 'aws-region'),
'{"body": "Hello from Postgres!"}'::json
);

  • '{"body": "Hello from PostgreSQL!"}'::json – Charge utile JSON à passer à la fonction Lambda.

  • 'RequestResponse' – Type d'appel Lambda.

Exemple : appel asynchrone (Event) de fonctions Lambda

Voici un exemple d'appel de fonction Lambda asynchrone. Le type d'appel Event planifie l'appel de fonction Lambda avec la charge utile d'entrée spécifiée et renvoie une réponse immédiatement. Utiliser le type d'appel Event dans certains flux de travail qui ne dépendent pas des résultats de la fonction Lambda.

SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'Event');

Exemple : capture du journal d'exécution Lambda dans une réponse de fonction

Vous pouvez inclure les 4 derniers Ko du journal d'exécution dans la réponse de la fonction à l'aide du paramètre log_type dans votre appel de fonction aws_lambda.invoke. Par défaut, ce paramètre est défini sur None, mais vous pouvez spécifier Tail afin de capturer les résultats du journal d'exécution Lambda dans la réponse, comme indiqué ci-dessous.

SELECT *, select convert_from(decode(log_result, 'base64'), 'utf-8') as log FROM aws_lambda.invoke(:'aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'RequestResponse', 'Tail');

Définissez le paramètre aws_lambda.invoke de la fonction log_type sur Tail pour inclure le journal d'exécution dans la réponse. La valeur par défaut du paramètre log_type est None.

Le log_result qui est retourné est une chaîne base64 encodée. Vous pouvez décoder le contenu à l'aide d'une combinaison des fonctions PostgreSQL decode et convert_from.

Pour plus d’informations sur log_type, consultez aws_lambda.invoke.

Exemple : inclusion du contexte client dans une fonction Lambda

La fonction aws_lambda.invoke possède un paramètre context que vous pouvez utiliser pour transférer des informations séparées de la charge utile, comme indiqué ci-dessous. 

SELECT *, convert_from(decode(log_result, 'base64'), 'utf-8') as log FROM aws_lambda.invoke(:'aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'RequestResponse', 'Tail');

Pour inclure le contexte client, utilisez un objet JSON pour le paramètre aws_lambda.invoke de la fonction context.

Pour plus d'informations sur le paramètre context, veuillez consulter la référence aws_lambda.invoke.

Exemple : appel d'une version spécifique d'une fonction Lambda

Vous pouvez spécifier une version particulière d'une fonction Lambda en incluant le paramètre qualifier avec l'appel aws_lambda.invoke. Vous trouverez ci-dessous un exemple de ce procédé qui utilise 'custom_version' comme alias pour la version.

SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json, 'RequestResponse', 'None', NULL, 'custom_version');

Vous pouvez également fournir un qualificatif de fonction Lambda avec les informations de nom de la fonction à la place, comme suit.

SELECT * FROM aws_lambda.invoke(aws_commons.create_lambda_function_arn('my-function:custom_version', 'us-west-2'),
'{"body": "Hello from Postgres!"}'::json);

Pour de plus amples informations sur qualifier et d'autres paramètres, veuillez consulter la référence aws_lambda.invoke.

Messages d'erreur de fonction Lambda

Dans la liste suivante, vous trouverez des informations sur les messages d'erreur, avec les causes et les solutions possibles.

  • Problèmes de configuration de VPC

    Les problèmes de configuration du VPC peuvent entraîner les messages d'erreur suivants lors de la tentative de connexion : 

    ERROR:  invoke API failed
DETAIL: AWS Lambda client returned 'Unable to connect to endpoint'.
CONTEXT:  SQL function "invoke" statement 1

    Une cause fréquente de cette erreur est un groupe de sécurité VPC mal configuré. Assurez-vous que vous disposez d'une règle sortante pour TCP ouverte sur le port 443 de votre groupe de sécurité VPC afin que votre VPC puisse se connecter au VPC Lambda.

  • Manque d'autorisations nécessaires pour appeler les fonctions Lambda

    Si l'un des messages d'erreur suivants s'affiche, l'utilisateur (rôle) qui appelle la fonction ne dispose pas des autorisations nécessaires.

    ERROR:  permission denied for schema aws_lambda
    ERROR:  permission denied for function invoke

    Un utilisateur (rôle) doit recevoir des autorisations spécifiques pour appeler les fonctions Lambda. Pour plus d’informations, consultez Étape 6 : accorder aux autres utilisateurs l'autorisation d'appeler les fonctions Lambda.

  • Traitement inapproprié des erreurs dans vos fonctions Lambda4

    Si une fonction Lambda lance une exception pendant le traitement de la demande, aws_lambda.invoke échoue avec une erreur PostgreSQL telle que la suivante.

    SELECT * FROM aws_lambda.invoke('aws_lambda_arn_1', '{"body": "Hello from Postgres!"}'::json);
ERROR:  lambda invocation failed
DETAIL:  "arn:aws:lambda:us-west-2:555555555555:function:my-function" returned error "Unhandled", details: "<Error details string>".

    Assurez-vous de gérer les erreurs dans vos fonctions Lambda ou dans votre application PostgreSQL.