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.
# Configurer une demande d'intégration d' WebSocket API dans API Gateway
La configuration d’une demande d’intégration comprend les opérations suivantes :
+ La sélection d’une clé de routage à intégrer avec le serveur principal.
+ Spécifier le point de terminaison du backend à appeler. WebSocket APIs prennent en charge les types d'intégration suivants :
+ `AWS_PROXY`
+ `AWS`
+ `HTTP_PROXY`
+ `HTTP`
+ `MOCK`
Pour plus d'informations sur les types d'intégration, consultez [IntegrationType](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-integrations-integrationid.html#apis-apiid-integrations-integrationid-prop-integration-integrationtype)l'API REST API Gateway V2.
+ La configuration de la transformation des données de la demande de routage, si nécessaire, en données de demande d’intégration en spécifiant un ou plusieurs modèles de demande.
## Configuration d'une demande d'intégration d' WebSocket API à l'aide de la console API Gateway
**Pour ajouter une demande d'intégration à un itinéraire dans une WebSocket API à l'aide de la console API Gateway**
1. Connectez-vous à la console API Gateway et choisissez l’API, puis choisissez **Routes**.
1. Sous **Routes**, choisissez la route.
1. Choisissez l’onglet **Demande d’intégration**, puis dans la section **Paramètres de la demande d’intégration**, choisissez **Modifier**.
1. Pour **Type d’intégration**, sélectionnez l’une des valeurs suivantes :
+ Choisissez la **fonction Lambda** uniquement si votre API doit être intégrée à une AWS Lambda fonction que vous avez déjà créée dans ce compte ou dans un autre compte.
**Pour créer une nouvelle fonction Lambda dans AWS Lambda, pour définir une autorisation de ressource sur la fonction Lambda ou pour effectuer toute autre action de service Lambda, choisissez plutôt Service.AWS **
+ Sélectionnez **HTTP** si votre API doit être intégrée avec un point de terminaison HTTP existant. Pour de plus amples informations, veuillez consulter [Intégrations HTTP pour REST APIs dans API Gateway](setup-http-integrations.md).
+ Choisissez **Mock** si vous souhaitez générer des réponses d’API directement depuis API Gateway, sans recourir à un backend d’intégration. Pour de plus amples informations, veuillez consulter [Intégrations fictives pour REST APIs dans API Gateway](how-to-mock-integration.md).
+ Choisissez **AWS un service** si votre API doit être intégrée à un AWS service.
+ Choisissez **Lien VPC** si votre API doit utiliser un `VpcLink` en tant que point de terminaison d’intégration privé. Pour de plus amples informations, veuillez consulter [Configurez une intégration privée](set-up-private-integration.md).
1. Si vous avez sélectionné **Fonction Lambda**, procédez comme suit :
1. Pour **Utiliser une intégration proxy Lambda**, cochez la case si vous avez l’intention d’utiliser [Intégration proxy Lambda](set-up-lambda-proxy-integrations.md#api-gateway-create-api-as-simple-proxy) ou [Intégration proxy Lambda entre comptes](apigateway-cross-account-lambda-integrations.md).
1. Pour **Fonction Lambda**, spécifiez la fonction de l’une des manières suivantes :
+ Si votre Fonction Lambda se trouve dans le même compte, entrez le nom de la fonction, puis sélectionnez la fonction dans la liste déroulante.
**Note**
Le nom de la fonction peut éventuellement inclure son alias ou sa spécification de version, comme dans `HelloWorld`, `HelloWorld:1` ou `HelloWorld:alpha`.
+ Si la fonction se trouve dans un autre compte, tapez l’ARN de la fonction.
1. Pour utiliser la valeur de délai d'expiration par défaut de 29 secondes, gardez **Délai d'expiration** activé. Pour définir un délai d'expiration personnalisé, choisissez **Délai d'expiration** et entrez une valeur de délai d'expiration comprise entre `50` et `29000` millisecondes.
1. Si vous avez sélectionné **HTTP**, suivez les instructions de l’étape 4 de la section [Configuration d’une demande d’intégration d’API à l’aide de la console API Gateway](how-to-method-settings-console.md).
1. Si vous avez sélectionné **Mock (Fictif)**, passez à l’étape **Request Templates (Modèles de demande)**.
1. Si vous avez choisi **Service AWS **, suivez les instructions de l’étape 6 de [Configuration d’une demande d’intégration d’API à l’aide de la console API Gateway](how-to-method-settings-console.md).
1. Si vous avez sélectionné **Lien VPC**, procédez comme suit :
1. Pour **Intégration proxy au VPC**, sélectionnez la case à cocher si vous souhaitez que vos demandes soient traitées par proxy vers le point de terminaison de votre `VPCLink`.
1. Dans le champ **Méthode HTTP**, sélectionnez le type de méthode HTTP qui correspond le mieux au service backend HTTP.
1. Dans la liste déroulante **Lien VPC**, sélectionnez un lien VPC. Vous pouvez sélectionner `[Use Stage Variables]` et entrer **\$1\$1stageVariables.vpcLinkId\$1** dans la zone de texte en dessous de la liste.
Vous pouvez définir la variable d’étape `vpcLinkId` après le déploiement de l’API dans une étape et définir sa valeur sur l’ID du `VpcLink`.
1. Pour **URL du point de terminaison**, entrez l’URL du back-end HTTP que cette intégration doit utiliser.
1. Pour utiliser la valeur de délai d'expiration par défaut de 29 secondes, gardez **Délai d'expiration** activé. Pour définir un délai d'expiration personnalisé, choisissez **Délai d'expiration** et entrez une valeur de délai d'expiration comprise entre `50` et `29000` millisecondes.
1. Sélectionnez **Enregistrer les modifications**.
1. Sous **Modèles de demande**, procédez comme suit :
1. Pour entrer une **Expression de sélection de modèle**, sous **Modèles de demande**, choisissez **Modifier**.
1. Entrez une **Expression de sélection de modèle**. Utilisez une expression qu’API Gateway recherche dans la charge utile du message. S’il la trouve, il l’évalue, et le résultat est une valeur de clé de modèle qui est utilisée pour sélectionner le modèle de mappage de données à appliquer aux données dans la charge utile du message. Vous créez le modèle de mappage de données à la prochaine étape. Choisissez **Modifier** pour enregistrer vos modifications.
1. Choisissez **Créer un modèle** pour créer le modèle de mappage de données. Pour **Clé de modèle**, entrez une valeur de clé de modèle qui est utilisée pour sélectionner le modèle de mappage de données à appliquer aux données dans la charge utile du message. Entrez ensuite un modèle de mappage. Sélectionnez **Create template (Créer un modèle)**.
Pour plus d’informations sur les expressions de sélection du modèle, consultez la section [Expressions de sélection du modèle](websocket-api-data-transformations.md#apigateway-websocket-api-template-selection-expressions).
## Configurez une demande d'intégration à l'aide du AWS CLI
Vous pouvez configurer une demande d'intégration pour un itinéraire dans une WebSocket API en utilisant l' AWS CLI exemple suivant, qui crée une intégration fictive :
1. Créez un fichier nommé `integration-params.json`, avec le contenu suivant :
```
{"PassthroughBehavior": "WHEN_NO_MATCH", "TimeoutInMillis": 29000, "ConnectionType": "INTERNET", "RequestTemplates": {"application/json": "{\"statusCode\":200}"}, "IntegrationType": "MOCK"}
```
1. Utilisez la commande [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html) suivante pour créer l’intégration simulée.
```
aws apigatewayv2 --region us-east-1 create-integration --api-id aabbccddee --cli-input-json file://integration-params.json
```
Le résultat se présente comme suit :
```
{
"PassthroughBehavior": "WHEN_NO_MATCH",
"TimeoutInMillis": 29000,
"ConnectionType": "INTERNET",
"IntegrationResponseSelectionExpression": "${response.statuscode}",
"RequestTemplates": {
"application/json": "{\"statusCode\":200}"
},
"IntegrationId": "0abcdef",
"IntegrationType": "MOCK"
}
```
Vous pouvez également configurer une demande d'intégration pour une intégration par proxy en utilisant le AWS CLI.
1. Créez une fonction Lambda dans la console Lambda et attribuez-lui un rôle d’exécution Lambda de base.
1. Utilisez la commande [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html) suivante pour créer l’intégration.
```
aws apigatewayv2 create-integration --api-id aabbccddee --integration-type AWS_PROXY --integration-method POST --integration-uri arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123412341234:function:simpleproxy-echo-e2e/invocations
```
Le résultat se présente comme suit :
```
{
"PassthroughBehavior": "WHEN_NO_MATCH",
"IntegrationMethod": "POST",
"TimeoutInMillis": 29000,
"ConnectionType": "INTERNET",
"IntegrationUri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123412341234:function:simpleproxy-echo-e2e/invocations",
"IntegrationId": "abcdefg",
"IntegrationType": "AWS_PROXY"
}
```
## Format d'entrée d'une fonction Lambda pour l'intégration de proxy pour WebSocket APIs
Avec l’intégration de proxy Lambda, API Gateway mappe l’intégralité de la demande du client avec le paramètre `event` en entrée de la fonction Lambda du backend. L’exemple suivant montre la structure de l’événement d’entrée de la route `$connect` et de l’événement d’entrée de la route `$disconnect` qu’API Gateway envoie à une intégration de proxy Lambda.
------
#### [ Input from the \$1connect route ]
```
{
headers: {
Host: 'abcd123.execute-api.us-east-1.amazonaws.com',
'Sec-WebSocket-Extensions': 'permessage-deflate; client_max_window_bits',
'Sec-WebSocket-Key': '...',
'Sec-WebSocket-Version': '13',
'X-Amzn-Trace-Id': '...',
'X-Forwarded-For': '192.0.2.1',
'X-Forwarded-Port': '443',
'X-Forwarded-Proto': 'https'
},
multiValueHeaders: {
Host: [ 'abcd123.execute-api.us-east-1.amazonaws.com' ],
'Sec-WebSocket-Extensions': [ 'permessage-deflate; client_max_window_bits' ],
'Sec-WebSocket-Key': [ '...' ],
'Sec-WebSocket-Version': [ '13' ],
'X-Amzn-Trace-Id': [ '...' ],
'X-Forwarded-For': [ '192.0.2.1' ],
'X-Forwarded-Port': [ '443' ],
'X-Forwarded-Proto': [ 'https' ]
},
requestContext: {
routeKey: '$connect',
eventType: 'CONNECT',
extendedRequestId: 'ABCD1234=',
requestTime: '09/Feb/2024:18:11:43 +0000',
messageDirection: 'IN',
stage: 'prod',
connectedAt: 1707502303419,
requestTimeEpoch: 1707502303420,
identity: { sourceIp: '192.0.2.1' },
requestId: 'ABCD1234=',
domainName: 'abcd1234.execute-api.us-east-1.amazonaws.com',
connectionId: 'AAAA1234=',
apiId: 'abcd1234'
},
isBase64Encoded: false
}
```
------
#### [ Input from the \$1disconnect route ]
```
{
headers: {
Host: 'abcd1234.execute-api.us-east-1.amazonaws.com',
'x-api-key': '',
'X-Forwarded-For': '',
'x-restapi': ''
},
multiValueHeaders: {
Host: [ 'abcd1234.execute-api.us-east-1.amazonaws.com' ],
'x-api-key': [ '' ],
'X-Forwarded-For': [ '' ],
'x-restapi': [ '' ]
},
requestContext: {
routeKey: '$disconnect',
disconnectStatusCode: 1005,
eventType: 'DISCONNECT',
extendedRequestId: 'ABCD1234=',
requestTime: '09/Feb/2024:18:23:28 +0000',
messageDirection: 'IN',
disconnectReason: 'Client-side close frame status not set',
stage: 'prod',
connectedAt: 1707503007396,
requestTimeEpoch: 1707503008941,
identity: { sourceIp: '192.0.2.1' },
requestId: 'ABCD1234=',
domainName: 'abcd1234.execute-api.us-east-1.amazonaws.com',
connectionId: 'AAAA1234=',
apiId: 'abcd1234'
},
isBase64Encoded: false
}
```
------