

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.

# Streaming de réponses pour les fonctions Lambda
<a name="configuration-response-streaming"></a>

Les fonctions Lambda peuvent renvoyer nativement les charges utiles de réponse aux clients via la [fonction Lambda](urls-configuration.md) ou à l'aide de l'[InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html)API (via le AWS SDK URLs ou des appels d'API directs). Votre fonction Lambda peut également diffuser des charges utiles de réponse via l'[intégration du proxy Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html), qui utilise l'[InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html)API pour appeler votre fonction. Le streaming de réponses peut profiter aux applications sensibles à la latence en améliorant les performances de temps au premier octet (TTFB). En effet, vous pouvez renvoyer des réponses partielles au client dès qu'elles sont disponibles. En outre, les fonctions de diffusion des réponses peuvent renvoyer des données utiles allant jusqu’à 200 Mo, contre un maximum de 6 Mo pour les réponses mises en mémoire tampon. La diffusion d'une réponse signifie également que votre fonction n'a pas besoin de stocker l'intégralité de la réponse en mémoire. Pour les réponses très volumineuses, cela peut réduire la quantité de mémoire que vous devez configurer pour votre fonction. 

**Note**  
Le streaming des réponses Lambda n'est pas encore entièrement disponible. Régions AWS Consultez la section [AWS Capacités par région](https://builder.aws.com/build/capabilities) du Builder Center pour connaître la disponibilité des fonctionnalités par région.

La vitesse à laquelle Lambda diffuse vos réponses dépend de la taille de la réponse. Le débit de diffusion pour les 6 premiers Mo de réponse de votre fonction n’est pas plafonné. Pour les réponses supérieures à 6 Mo, le reste de la réponse est soumis à une limite de bande passante. Pour plus d'informations sur la bande passante de diffusion, consultez [Limitation de la bande passante pour la diffusion des réponses](#config-rs-bandwidth-cap).

Les réponses en streaming entraînent des coûts et les réponses diffusées en continu ne sont ni interrompues ni arrêtées lorsque la connexion du client appelant est interrompue. Les clients seront facturés pour la durée complète des fonctions. Les clients doivent donc faire preuve de prudence lorsqu'ils configurent des délais d'expiration de fonction prolongés.

Lambda prend en charge le streaming des réponses sur les exécutions gérées par Node.js. Pour les autres langages, y compris Python, vous pouvez [utiliser un environnement d'exécution personnalisé avec une intégration d'API d'exécution personnalisée](runtimes-custom.md#runtimes-custom-response-streaming) pour diffuser les réponses ou utiliser l'adaptateur [Web Lambda](https://github.com/awslabs/aws-lambda-web-adapter).

**Note**  
Lorsque vous testez votre fonction via la console Lambda, vous verrez toujours les réponses comme étant mises en mémoire tampon.

**Topics**
+ [Limitation de la bande passante pour la diffusion des réponses](#config-rs-bandwidth-cap)
+ [Compatibilité du VPC avec la diffusion en continu de réponses](#config-rs-vpc-compatibility)
+ [Écriture de fonctions Lambda compatibles avec le streaming de réponses](config-rs-write-functions.md)
+ [Invocation d'une fonction activée pour le streaming de réponses à l'aide de la fonction Lambda URLs](config-rs-invoke-furls.md)
+ [Tutoriel : création d’une fonction Lambda de streaming de réponses avec une URL de la fonction](response-streaming-tutorial.md)

## Limitation de la bande passante pour la diffusion des réponses
<a name="config-rs-bandwidth-cap"></a>

Les 6 premiers Mo des données utiles de la réponse de votre fonction disposent d’une bande passante non plafonnée. Après cette première rafale, Lambda diffuse votre réponse à un débit maximum de 2. MBps Si les réponses de votre fonction ne dépassent jamais 6 Mo, cette limite de bande passante ne s’applique pas. 

**Note**  
Les limites de bande passante s'appliquent uniquement à la charge utile de la réponse de votre fonction, et non à l'accès au réseau par votre fonction.

Le débit de bande passante non plafonnée varie en fonction d'un certain nombre de facteurs, notamment la vitesse de traitement de votre fonction. Vous pouvez normalement vous attendre à un débit supérieur à 2 MBps pour les 6 premiers Mo de réponse de votre fonction. Si votre fonction diffuse une réponse vers une destination située à l'extérieur AWS, le débit de diffusion dépend également de la vitesse de la connexion Internet externe. 

## Compatibilité du VPC avec la diffusion en continu de réponses
<a name="config-rs-vpc-compatibility"></a>

Lorsque vous utilisez des fonctions Lambda dans un environnement VPC, la diffusion en continu des réponses doit tenir compte de certaines considérations importantes :
+ La fonction Lambda ne prend URLs pas en charge le streaming des réponses dans un environnement VPC.
+ Vous pouvez utiliser le streaming de réponses au sein d'un VPC en appelant votre fonction Lambda via le SDK à l'aide de l' AWS API. `InvokeWithResponseStream` Pour cela, vous devez configurer les points de terminaison VPC appropriés pour Lambda.
+ Pour les environnements VPC, vous devez créer un point de terminaison de VPC d’interface pour Lambda afin de permettre la communication entre vos ressources dans le VPC et dans le service Lambda.

Une architecture typique pour la diffusion en continu des réponses dans un VPC peut inclure :

```
Client in VPC -> Interface VPC endpoint for Lambda -> Lambda function -> Response streaming back through the same path
```

# Écriture de fonctions Lambda compatibles avec le streaming de réponses
<a name="config-rs-write-functions"></a>

L'écriture du gestionnaire pour les fonctions de streaming de réponses est différente des modèles de gestionnaire typiques. Lorsque vous écrivez des fonctions de streaming, assurez-vous de faire ce qui suit :
+ Encapsulez votre événement avec le décorateur `awslambda.streamifyResponse()`. L’objet global `awslambda` est fourni par l’environnement d’exécution Node.js de Lambda.
+ Terminez la diffusion de manière élégante afin de vous assurer que le traitement des données est terminé.

## Configuration d'une fonction gestionnaire pour diffuser les réponses
<a name="config-rs-write-functions-handler"></a>

Pour indiquer à l'exécution que Lambda doit diffuser les réponses de votre fonction, vous devez envelopper votre fonction avec le décorateur `streamifyResponse()`. Cela indique à l'exécution d'utiliser le chemin logique approprié pour le streaming des réponses et permet à la fonction de diffuser les réponses.

Le décorateur `streamifyResponse()` accepte une fonction qui accepte les paramètres suivants :
+ `event` : fournit des informations sur l'événement d'invocation de l'URL de la fonction, telles que la méthode HTTP, les paramètres de la requête et le corps de la requête.
+ `responseStream` : fournit un flux inscriptible.
+ `context` : fournit des méthodes et des propriétés avec des informations sur l'invocation, la fonction et l'environnement d'exécution.

L'objet `responseStream` est un [`writableStream` Node.js](https://nodesource.com/blog/understanding-streams-in-nodejs/). Comme pour tout flux de ce type, vous devez utiliser la méthode `pipeline()`.

**Note**  
L’objet global `awslambda` est automatiquement fourni par l’environnement d’exécution Node.js de Lambda et aucune importation n’est requise.

**Example gestionnaire compatible avec le streaming de réponses**  

```
import { pipeline } from 'node:stream/promises';
import { Readable } from 'node:stream';

export const echo = awslambda.streamifyResponse(async (event, responseStream, _context) => {
  // As an example, convert event to a readable stream.
  const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));

  await pipeline(requestStream, responseStream);
});
```

Bien que `responseStream` propose la méthode `write()` pour écrire dans le flux, nous vous recommandons d'utiliser [https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback](https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback) dans la mesure du possible. L'utilisation de `pipeline()` permet de s'assurer que le flux accessible en écriture n'est pas submergé par un flux accessible en lecture plus rapide.

## Fin du flux
<a name="config-rs-write-functions-end"></a>

Assurez-vous de terminer correctement le flux avant le retour du gestionnaire. La méthode `pipeline()` s'en charge automatiquement.

Pour les autres cas d'utilisation, appelez la méthode `responseStream.end()` pour terminer correctement un flux. Cette méthode signale que plus aucune donnée ne doit être écrite dans le flux. Cette méthode n'est pas nécessaire si vous écrivez dans le flux avec `pipeline()` ou `pipe()`.

À partir de Node.js 24, Lambda n'attend plus que les promesses non résolues se terminent après le retour de votre gestionnaire ou la fin du flux de réponses. Si votre fonction dépend d'opérations asynchrones supplémentaires, telles que des temporisations ou des extractions, vous devez `await` les inclure dans votre gestionnaire.

**Example Exemple de fin d'un flux avec pipeline()**  

```
import { pipeline } from 'node:stream/promises';

export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => {
  await pipeline(requestStream, responseStream);
});
```

**Example Exemple de fin d'un flux sans pipeline()**  

```
export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => {
  responseStream.write("Hello ");
  responseStream.write("world ");
  responseStream.write("from ");
  responseStream.write("Lambda!");
  responseStream.end();
});
```

# Invocation d'une fonction activée pour le streaming de réponses à l'aide de la fonction Lambda URLs
<a name="config-rs-invoke-furls"></a>

**Note**  
Votre fonction Lambda peut désormais diffuser les charges utiles des réponses via l'intégration du proxy [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html).

Vous pouvez invoquer des fonctions compatibles avec le streaming de réponses en modifiant le mode d'invocation de l'URL de votre fonction. Le mode d'invocation détermine l'opération d'API que Lambda utilise pour invoquer votre fonction. Les modes d'invocation disponibles sont les suivants :
+ `BUFFERED` : il s'agit de l'option par défaut. Lambda invoque votre fonction en utilisant l’opération d’API `Invoke`. Les résultats de l’invocation sont disponibles lorsque la charge utile est complète. La taille de la charge utile maximale est de 6 Mo.
+ `RESPONSE_STREAM` : permet à votre fonction de diffuser les résultats de la charge utile au fur et à mesure qu'ils sont disponibles. Lambda invoque votre fonction en utilisant l'opération d'API `InvokeWithResponseStream`. La taille maximale de la charge utile de réponse est de 200 Mo.

Vous pouvez toujours invoquer votre fonction sans streaming de réponses en appelant directement l'opération d'API `Invoke`. Cependant, Lambda diffuse toutes les charges utiles de réponse pour les invocations qui passent par l'URL de la fonction jusqu'à ce que vous changiez le mode d'invocation en `BUFFERED`.

------
#### [ Console ]

**Pour définir le mode d'invocation d'une URL de la fonction (console)**

1. Ouvrez la [page Functions](https://console.aws.amazon.com/lambda/home#/functions) (Fonctions) de la console Lambda.

1. Sélectionnez le nom de la fonction pour laquelle vous voulez définir le mode d'invocation.

1. Choisissez l'onglet **Configuration**, puis **Function URL** (URL de fonction).

1. Sélectionnez **Modifier**, puis **Paramètres supplémentaires**.

1. Sous **Mode d'invocation**, sélectionnez le mode d'invocation de votre choix.

1. Choisissez **Enregistrer**.

------
#### [ AWS CLI ]

**Pour définir le mode d’invocation d’une URL de fonction (AWS CLI)**

```
aws lambda update-function-url-config \
  --function-name my-function \
  --invoke-mode RESPONSE_STREAM
```

------
#### [ CloudFormation ]

**Pour définir le mode d’invocation d’une URL de fonction (CloudFormation)**

```
MyFunctionUrl:
  Type: AWS::Lambda::Url
  Properties:
    AuthType: AWS_IAM
    InvokeMode: RESPONSE_STREAM
```

------

Pour plus d'informations sur la configuration de la fonction URLs, consultez la section Fonction [Lambda](urls-configuration.md). URLs

# Tutoriel : création d’une fonction Lambda de streaming de réponses avec une URL de la fonction
<a name="response-streaming-tutorial"></a>

Dans ce didacticiel, vous créez une fonction Lambda définie comme archive de fichier ZIP avec un point de terminaison d’URL de la fonction qui renvoie un flux de réponses. Pour plus d'informations sur la configuration de la fonction URLs, consultez[Fonction URLs](urls-configuration.md).

## Conditions préalables
<a name="response-streaming-prepare"></a>

Ce didacticiel suppose que vous avez quelques connaissances des opérations Lambda de base et de la console Lambda. Si ce n’est déjà fait, suivez les instructions fournies dans [Créer une fonction Lambda à l'aide de la console](getting-started.md#getting-started-create-function) pour créer votre première fonction Lambda.

Pour effectuer les étapes suivantes, vous avez besoin de l’[AWS CLI version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). Les commandes et la sortie attendue sont répertoriées dans des blocs distincts :

```
aws --version
```

Vous devriez voir la sortie suivante:

```
aws-cli/2.13.27 Python/3.11.6 Linux/4.14.328-248.540.amzn2.x86_64 exe/x86_64.amzn.2
```

Pour les commandes longues, un caractère d’échappement (`\`) est utilisé pour les fractionner en plusieurs lignes.

Sur 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. Les exemples de commandes CLI de ce guide utilisent le formatage Linux. Les commandes qui incluent des documents JSON en ligne doivent être reformatées si vous utilisez la CLI Windows. 

## Créer un rôle d’exécution
<a name="response-streaming-create-iam-role"></a>

Créez le [rôle d’exécution](lambda-intro-execution-role.md) qui donne à votre fonction Lambda l’autorisation d’accéder aux ressources AWS .

**Pour créer un rôle d’exécution**

1. Accédez à la [page Roles (Rôles)](https://console.aws.amazon.com/iam/home#/roles) de la Gestion des identités et des accès AWS console (IAM).

1. Sélectionnez **Créer un rôle**.

1. Créez un rôle avec les propriétés suivantes :
   + **Type d’entité sécurisée** – **Service AWS **
   + **Cas d’utilisation** – **Lambda**
   + **Permissions (Autorisations** – **AWSLambdaBasicExecutionRole**
   + **Nom de rôle** – **response-streaming-role**

La **AWSLambdaBasicExecutionRole**politique dispose des autorisations dont la fonction a besoin pour écrire des CloudWatch journaux sur Amazon Logs. Après avoir créé le rôle, notez son Amazon Resource Name (ARN). Vous en aurez besoin à l’étape suivante.

## Création d’une fonction de streaming de réponses (AWS CLI)
<a name="response-streaming-tutorial-create-function-cli"></a>

Créez une fonction Lambda de streaming de réponses avec un point de terminaison d’URL de la fonction à l’aide de l’ AWS Command Line Interface (AWS CLI).

**Pour créer une fonction capable de diffuser des réponses**

1. Copiez l’exemple de code suivant dans un fichier nommé `index.js`. Cette fonction diffuse trois réponses, séparées de 1 seconde.

   ```
   exports.handler = awslambda.streamifyResponse(
   	async (event, responseStream, _context) => {
   		// Metadata is a JSON serializable JS object. Its shape is not defined here.
   		const metadata = {
   		statusCode: 200,
   		headers: {
   			"Content-Type": "application/json",
   			"CustomHeader": "outerspace"
   		}
   		};
   	
   		// Assign to the responseStream parameter to prevent accidental reuse of the non-wrapped stream.
   		responseStream = awslambda.HttpResponseStream.from(responseStream, metadata);
   	
   		responseStream.write("Streaming with Helper \n");
   		await new Promise(r => setTimeout(r, 1000));
   		responseStream.write("Hello 0 \n");
   		await new Promise(r => setTimeout(r, 1000));
   		responseStream.write("Hello 1 \n");
   		await new Promise(r => setTimeout(r, 1000));
   		responseStream.write("Hello 2 \n");
   		await new Promise(r => setTimeout(r, 1000));
   		responseStream.end();
   		await responseStream.finished();
   	}
     );
   ```

1. Créez un package de déploiement.

   ```
   zip function.zip index.js
   ```

1. Créez une fonction Lambda à l’aide de la commande `create-function`. Remplacez la valeur de `--role` par l’ARN de rôle de l’étape précédente. Cette commande définit le délai d’expiration de la fonction à 10 secondes, ce qui permet à la fonction de diffuser trois réponses.

   ```
   aws lambda create-function \
     --function-name my-streaming-function \
     --runtime nodejs24.x \
     --zip-file fileb://function.zip \
     --handler index.handler \
     --timeout 10 \
     --role arn:aws:iam::123456789012:role/response-streaming-role
   ```

**Pour créer une URL de la fonction**

1. Ajoutez une stratégie basée sur les ressources à votre fonction en accordant les autorisations `lambda:InvokeFunctionUrl` et `lambda:InvokeFunction`. Chaque instruction doit être ajoutée dans une commande distincte. Remplacez la valeur de `--principal` par votre Compte AWS identifiant.

   ```
   aws lambda add-permission \
     --function-name my-streaming-function \
     --action lambda:InvokeFunctionUrl \
     --statement-id UrlPolicyInvokeURL \
     --principal 123456789012 \
     --function-url-auth-type AWS_IAM
   ```

   ```
   aws lambda add-permission \
       --function-name my-streaming-function \
       --action lambda:InvokeFunction \
       --statement-id UrlPolicyInvokeFunction \
       --principal 123456789012
   ```

1. Créez un point de terminaison d’URL pour la fonction avec la commande `create-function-url-config`.

   ```
   aws lambda create-function-url-config \
     --function-name my-streaming-function \
     --auth-type AWS_IAM \
     --invoke-mode RESPONSE_STREAM
   ```
**Note**  
Si un message d’erreur concernant `--invoke-mode` s’affiche, il se peut que vous deviez effectuer une mise à niveau vers une [version plus récente d’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

## Test du point de terminaison d’URL de fonction
<a name="response-streaming-tutorial-test"></a>

Testez votre intégration en invoquant votre fonction. Vous pouvez ouvrir l’URL de votre fonction dans un navigateur ou utiliser curl.

```
curl --request GET "https://abcdefghijklm7nop7qrs740abcd.lambda-url.us-east-1.on.aws/" --user "AKIAIOSFODNN7EXAMPLE" --aws-sigv4 "aws:amz:us-east-1:lambda" --no-buffer
```

Notre URL de la fonction utilise le type d’authentification `IAM_AUTH`. Cela signifie que vous devez signer les demandes à la fois avec [votre clé d’accès AWS et votre clé secrète](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html). Dans la commande précédente, remplacez par `AKIAIOSFODNN7EXAMPLE` l'ID de la clé d' AWS accès. Entrez votre clé AWS secrète lorsque vous y êtes invité. Si vous n'avez pas votre clé AWS secrète, vous pouvez [utiliser des AWS informations d'identification temporaires](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) à la place.

Vous devriez obtenir une réponse comme celle-ci :

```
Streaming with Helper 
Hello 0 
Hello 1
Hello 2
```

## Nettoyage de vos ressources
<a name="cleanup"></a>

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).