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.
# Didacticiel : utilisation de Lambda avec Amazon SQS
Dans ce didacticiel, vous créerez une fonction Lambda qui consomme les messages d’une file d’attente [Amazon Simple Queue Service (Amazon SQS)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html). La fonction Lambda s’exécute chaque fois qu’un nouveau message est ajouté à la file d’attente. La fonction écrit les messages dans un flux Amazon CloudWatch Logs. Le diagramme suivant montre les ressources AWS utilisées pour compléter ce tutoriel.
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/sqs_tut_resources.png)
Pour compléter ce didacticiel, effectuez les tâches suivantes :
1. Créez une fonction Lambda qui écrit des messages dans Logs. CloudWatch
1. Créer une file d’attente Amazon SQS.
1. Créez un mappage des sources d’événements Lambda. Le mappage des sources d’événements lit la file d’attente Amazon SQS et invoque votre fonction Lambda lorsqu’un nouveau message est ajouté.
1. Testez la configuration en ajoutant des messages à votre file d'attente et en surveillant les résultats dans CloudWatch Logs.
## Conditions préalables
### Installez le AWS Command Line Interface
Si vous ne l'avez pas encore installé AWS Command Line Interface, suivez les étapes décrites dans la [section Installation ou mise à jour de la dernière version du AWS CLI pour l'](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)installer.
Ce tutoriel nécessite un terminal de ligne de commande ou un shell pour exécuter les commandes. Sous Linux et macOS, utilisez votre gestionnaire de shell et de package préféré.
**Note**
Sous Windows, certaines commandes CLI Bash que vous utilisez couramment avec Lambda (par exemple `zip`) ne sont pas prises en charge par les terminaux intégrés du système d’exploitation. [Installez le sous-système Windows pour Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) afin d’obtenir une version intégrée à Windows d’Ubuntu et Bash.
## Créer le rôle d’exécution
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/sqs_tut_steps1.png)
Un [rôle d'exécution](lambda-intro-execution-role.md) est un rôle Gestion des identités et des accès AWS (IAM) qui accorde à une fonction Lambda l'autorisation d' Services AWS accès et de ressources. Pour permettre à votre fonction de lire des éléments depuis Amazon SQS, joignez la politique d'**AWSLambdaSQSQueueExecutionRole**autorisation.
**Pour créer un rôle d’exécution et attacher une politique d’autorisations Amazon SQS**
1. Ouvrez la [page Rôles](https://console.aws.amazon.com/iam/home#/roles) de la console IAM.
1. Sélectionnez **Créer un rôle**.
1. Pour **Type d’entité de confiance**, choisissez **Service AWS **.
1. Pour **Cas d’utilisation**, choisissez **Lambda**.
1. Choisissez **Suivant**.
1. Dans le champ de recherche **Politiques d’autorisations**, saisissez **AWSLambdaSQSQueueExecutionRole**.
1. Sélectionnez la **AWSLambdaSQSQueueExecutionRole**politique, puis cliquez sur **Suivant**.
1. Sous **Détails du rôle**, pour **Nom du rôle**, saisissez **lambda-sqs-role**, puis sélectionnez **Créer un rôle**.
Après la création du rôle, notez l’Amazon Resource Name (ARN) de votre rôle d’exécution. Vous en aurez besoin dans les étapes suivantes.
## Créer la fonction
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/sqs_tut_steps2.png)
Créez une fonction Lambda qui traite vos messages Amazon SQS. Le code de fonction enregistre le corps du message Amazon SQS dans Logs. CloudWatch
Ce didacticiel utilise le runtime Node.js 24, mais nous avons également fourni des exemples de code dans d'autres langages d'exécution. Vous pouvez sélectionner l’onglet dans la zone suivante pour voir le code de l’exécution qui vous intéresse. Le JavaScript code que vous allez utiliser dans cette étape se trouve dans le premier exemple présenté dans l'**JavaScript**onglet.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Utilisation d’un événement SQS avec Lambda en utilisant .NET.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
using Amazon.Lambda.Core;
using Amazon.Lambda.SQSEvents;
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace SqsIntegrationSampleCode
{
public async Task FunctionHandler(SQSEvent evnt, ILambdaContext context)
{
foreach (var message in evnt.Records)
{
await ProcessMessageAsync(message, context);
}
context.Logger.LogInformation("done");
}
private async Task ProcessMessageAsync(SQSEvent.SQSMessage message, ILambdaContext context)
{
try
{
context.Logger.LogInformation($"Processed message {message.Body}");
// TODO: Do interesting work based on the new message
await Task.CompletedTask;
}
catch (Exception e)
{
//You can use Dead Letter Queue to handle failures. By configuring a Lambda DLQ.
context.Logger.LogError($"An error occurred");
throw;
}
}
}
```
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Consommation d’un événement SQS avec Lambda à l’aide de Go.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package integration_sqs_to_lambda
import (
"fmt"
"github.com/aws/aws-lambda-go/events"
"github.com/aws/aws-lambda-go/lambda"
)
func handler(event events.SQSEvent) error {
for _, record := range event.Records {
err := processMessage(record)
if err != nil {
return err
}
}
fmt.Println("done")
return nil
}
func processMessage(record events.SQSMessage) error {
fmt.Printf("Processed message %s\n", record.Body)
// TODO: Do interesting work based on the new message
return nil
}
func main() {
lambda.Start(handler)
}
```
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Utilisation d’un événement SQS avec Lambda à l’aide de Java.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.SQSEvent;
import com.amazonaws.services.lambda.runtime.events.SQSEvent.SQSMessage;
public class Function implements RequestHandler {
@Override
public Void handleRequest(SQSEvent sqsEvent, Context context) {
for (SQSMessage msg : sqsEvent.getRecords()) {
processMessage(msg, context);
}
context.getLogger().log("done");
return null;
}
private void processMessage(SQSMessage msg, Context context) {
try {
context.getLogger().log("Processed message " + msg.getBody());
// TODO: Do interesting work based on the new message
} catch (Exception e) {
context.getLogger().log("An error occurred");
throw e;
}
}
}
```
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/blob/main/integration-sqs-to-lambda).
Consommation d'un événement SQS avec JavaScript Lambda en utilisant.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
exports.handler = async (event, context) => {
for (const message of event.Records) {
await processMessageAsync(message);
}
console.info("done");
};
async function processMessageAsync(message) {
try {
console.log(`Processed message ${message.body}`);
// TODO: Do interesting work based on the new message
await Promise.resolve(1); //Placeholder for actual async work
} catch (err) {
console.error("An error occurred");
throw err;
}
}
```
Consommation d'un événement SQS avec TypeScript Lambda en utilisant.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import { SQSEvent, Context, SQSHandler, SQSRecord } from "aws-lambda";
export const functionHandler: SQSHandler = async (
event: SQSEvent,
context: Context
): Promise => {
for (const message of event.Records) {
await processMessageAsync(message);
}
console.info("done");
};
async function processMessageAsync(message: SQSRecord): Promise {
try {
console.log(`Processed message ${message.body}`);
// TODO: Do interesting work based on the new message
await Promise.resolve(1); //Placeholder for actual async work
} catch (err) {
console.error("An error occurred");
throw err;
}
}
```
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Consommation d’un événement SQS avec Lambda à l’aide de PHP.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
logger = $logger;
}
/**
* @throws InvalidLambdaEvent
*/
public function handleSqs(SqsEvent $event, Context $context): void
{
foreach ($event->getRecords() as $record) {
$body = $record->getBody();
// TODO: Do interesting work based on the new message
}
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Utilisation d’un événement SQS avec Lambda à l’aide de Python.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
def lambda_handler(event, context):
for message in event['Records']:
process_message(message)
print("done")
def process_message(message):
try:
print(f"Processed message {message['body']}")
# TODO: Do interesting work based on the new message
except Exception as err:
print("An error occurred")
raise err
```
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Utilisation d’un événement SQS avec Lambda à l’aide de Ruby.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
def lambda_handler(event:, context:)
event['Records'].each do |message|
process_message(message)
end
puts "done"
end
def process_message(message)
begin
puts "Processed message #{message['body']}"
# TODO: Do interesting work based on the new message
rescue StandardError => err
puts "An error occurred"
raise err
end
end
```
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Consommation d’un événement SQS avec Lambda à l’aide de Rust.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
use aws_lambda_events::event::sqs::SqsEvent;
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
async fn function_handler(event: LambdaEvent) -> Result<(), Error> {
event.payload.records.iter().for_each(|record| {
// process the record
tracing::info!("Message body: {}", record.body.as_deref().unwrap_or_default())
});
Ok(())
}
#[tokio::main]
async fn main() -> Result<(), Error> {
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
// disable printing the name of the module in every log line.
.with_target(false)
// disabling time is handy because CloudWatch will add the ingestion time.
.without_time()
.init();
run(service_fn(function_handler)).await
}
```
------
**Pour créer une fonction Lambda Node.js.**
1. Créez un répertoire pour le projet, puis passez à ce répertoire.
```
mkdir sqs-tutorial
cd sqs-tutorial
```
1. Copiez l'exemple de JavaScript code dans un nouveau fichier nommé`index.js`.
1. Créez un package de déploiement à l’aide de la commande `zip` suivante.
```
zip function.zip index.js
```
1. Créez une fonction Lambda à l’aide de la commande AWS CLI [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html). Pour le paramètre `role`, entrez l’ARN du rôle d’exécution que vous avez créé précédemment.
**Note**
La fonction Lambda et la file d’attente Amazon SQS doivent se trouver dans la même Région AWS.
```
aws lambda create-function --function-name ProcessSQSRecord \
--zip-file fileb://function.zip --handler index.handler --runtime nodejs24.x \
--role arn:aws:iam::111122223333:role/lambda-sqs-role
```
## Tester la fonction
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/sqs_tut_steps3.png)
Appelez votre fonction Lambda manuellement à l'aide de la `invoke` AWS CLI commande et d'un exemple d'événement Amazon SQS.
**Pour invoquer la fonction Lambda avec un exemple d’événement**
1. Enregistrez le JSON suivant en tant que fichier nommé `input.json`. Ce JSON simule un événement qu’Amazon SQS pourrait envoyer à votre fonction Lambda, où `"body"` contient le message réel de la file d’attente. Dans cet exemple, le message est `"test"`.
**Example Événement Amazon SQS**
Il s’agit d’un événement de test : vous n’avez pas besoin de modifier le message ou le numéro de compte.
```
{
"Records": [
{
"messageId": "059f36b4-87a3-44ab-83d2-661975830a7d",
"receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...",
"body": "test",
"attributes": {
"ApproximateReceiveCount": "1",
"SentTimestamp": "1545082649183",
"SenderId": "AIDAIENQZJOLO23YVJ4VO",
"ApproximateFirstReceiveTimestamp": "1545082649185"
},
"messageAttributes": {},
"md5OfBody": "098f6bcd4621d373cade4e832627b4f6",
"eventSource": "aws:sqs",
"eventSourceARN": "arn:aws:sqs:us-east-1:111122223333:my-queue",
"awsRegion": "us-east-1"
}
]
}
```
1. Exécutez la AWS CLI commande [d'appel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/invoke.html) suivante. Cette commande renvoie CloudWatch les journaux dans la réponse. Pour de plus amples informations sur la récupération des journaux, veuillez consulter [Accédez aux journaux avec AWS CLI](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-cli).
```
aws lambda invoke --function-name ProcessSQSRecord --payload file://input.json out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
L'**cli-binary-format**option est obligatoire si vous utilisez AWS CLI la version 2. Pour faire de ce paramètre le paramètre par défaut, exécutez `aws configure set cli-binary-format raw-in-base64-out`. Pour plus d’informations, consultez les [options de ligne de commande globales prises en charge par l’AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) dans le *Guide de l’utilisateur AWS Command Line Interface version 2*.
1. Recherchez le journal `INFO` dans la réponse. C’est ici que la fonction Lambda enregistre le corps du message. Vous devriez voir des journaux qui ressemblent à ceci :
```
2023-09-11T22:45:04.271Z 348529ce-2211-4222-9099-59d07d837b60 INFO Processed message test
2023-09-11T22:45:04.288Z 348529ce-2211-4222-9099-59d07d837b60 INFO done
```
## Créez une file d’attente Amazon SQS.
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/sqs_tut_steps4.png)
Créez une file d’attente Amazon SQS que la fonction Lambda peut utiliser en tant que source d’événement. La fonction Lambda et la file d’attente Amazon SQS doivent se trouver dans la même Région AWS.
**Pour créer une file d’attente**
1. Ouvrez la [console Amazon SQS](https://console.aws.amazon.com/sqs).
1. Choisissez **Créez une file d’attente**.
1. Entrez un nom pour la queue. Conservez les paramètres par défaut de toutes les autres options.
1. Choisissez **Créez une file d’attente**.
Une fois la file d’attente créée, notez son ARN. Vous en aurez besoin à l’étape suivante lorsque vous associerez la file d’attente à votre fonction Lambda.
## Configurer la source de l’événement
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/sqs_tut_steps5.png)
Connectez la file d’attente Amazon SQS à votre fonction Lambda en créant un [mappage des sources d’événements](invocation-eventsourcemapping.md). Le mappage des sources d’événements lit la file d’attente Amazon SQS et invoque votre fonction Lambda lorsqu’un nouveau message est ajouté.
Pour créer un mappage entre votre file d'attente Amazon SQS et votre fonction Lambda, utilisez la commande. [create-event-source-mapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-event-source-mapping.html) AWS CLI Exemple :
```
aws lambda create-event-source-mapping --function-name ProcessSQSRecord --batch-size 10 \
--event-source-arn arn:aws:sqs:us-east-1:111122223333:my-queue
```
Pour obtenir la liste de vos mappages de sources d'événements, utilisez la [list-event-source-mappings](https://awscli.amazonaws.com/v2/documentation/api/2.1.29/reference/lambda/list-event-source-mappings.html)commande. Exemple :
```
aws lambda list-event-source-mappings --function-name ProcessSQSRecord
```
## Envoyer un message de test
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/sqs_tut_steps6.png)
**Pour envoyer un message Amazon SQS à la fonction Lambda**
1. Ouvrez la [console Amazon SQS](https://console.aws.amazon.com/sqs).
1. Choisissez la queue que vous avez créée précédemment.
1. Choisissez **Envoyer et recevoir des messages**.
1. Sous **Corps du message**, entrez un message de test, tel que « ceci est un message de test ».
1. Choisissez **Send Message** (Envoyer un message).
Lambda interroge la file d’attente concernant les mises à jour. Lorsqu’il y a un nouveau message, Lambda invoque votre fonction avec ces nouvelles données d’événement de la file d’attente. Si le gestionnaire de la fonction revient sans exception, Lambda considère le message comme traité avec succès et commence à lire de nouveaux messages dans la file d’attente. Après avoir traité un message avec succès, Lambda le supprime automatiquement de la file d’attente. Si le gestionnaire renvoie une exception, Lambda considère que le traitement du lot de messages a échoué et invoque la fonction avec le même lot de messages.
## Consultez les CloudWatch journaux
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/sqs_tut_steps7.png)
**Pour confirmer que la fonction a traité le message**
1. Ouvrez la [page Functions](https://console.aws.amazon.com/lambda/home#/functions) (Fonctions) de la console Lambda.
1. Choisissez la SQSRecord fonction **Process**.
1. Sélectionnez **Monitor (Surveiller)**.
1. Choisissez **Afficher CloudWatch les journaux**.
1. Dans la CloudWatch console, choisissez le **flux de log** pour la fonction.
1. Recherchez le journal `INFO`. C’est ici que la fonction Lambda enregistre le corps du message. Vous devriez voir le message que vous avez envoyé depuis la file d’attente Amazon SQS. Exemple :
```
2023-09-11T22:49:12.730Z b0c41e9c-0556-5a8b-af83-43e59efeec71 INFO Processed message this is a test message.
```
## Nettoyage de vos ressources
Vous pouvez maintenant supprimer les ressources que vous avez créées pour ce didacticiel, sauf si vous souhaitez les conserver. En supprimant AWS les ressources que vous n'utilisez plus, vous évitez des frais inutiles pour votre Compte AWS.
**Pour supprimer le rôle d’exécution**
1. Ouvrez la [page Roles (Rôles)](https://console.aws.amazon.com/iam/home#/roles) de la console IAM.
1. Sélectionnez le rôle d’exécution que vous avez créé.
1. Sélectionnez **Delete (Supprimer)**.
1. Saisissez le nom du rôle dans le champ de saisie de texte et choisissez **Delete** (Supprimer).
**Pour supprimer la fonction Lambda**
1. Ouvrez la [page Functions (Fonctions)](https://console.aws.amazon.com/lambda/home#/functions) de la console Lambda.
1. Sélectionnez la fonction que vous avez créée.
1. Sélectionnez **Actions**, **Supprimer**.
1. Saisissez **confirm** dans la zone de saisie de texte et choisissez **Delete** (Supprimer).
**Pour supprimer la file d’attente Amazon SQS**
1. Connectez-vous à la console Amazon SQS AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/sqs/](https://console.aws.amazon.com/sqs/)
1. Sélectionnez la file d’attente que vous avez créée.
1. Sélectionnez **Delete (Supprimer)**.
1. Saisissez **confirm** dans le champ de saisie de texte.
1. Sélectionnez **Supprimer**.