Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Integrazioni per API WebSocket APIs Gateway
Dopo aver impostato una route API, devi integrarla con un endpoint nel back-end. Un endpoint di backend viene anche definito endpoint di integrazione e può essere una funzione Lambda, un endpoint HTTP o un'azione di servizio. AWS L'integrazione dell'API dispone di una richiesta e di una risposta di integrazione.
In questa sezione, puoi imparare come configurare le richieste di integrazione e le risposte di integrazione per la tua API. WebSocket
**Topics**
+ [Configurare una richiesta di integrazione WebSocket API in API Gateway](apigateway-websocket-api-integration-requests.md)
+ [Configurare una risposta di integrazione WebSocket API in API Gateway](apigateway-websocket-api-integration-responses.md)
# Configurare una richiesta di integrazione WebSocket API in API Gateway
La configurazione di una richiesta di integrazione comporta le seguenti operazioni:
+ Selezione di una chiave di instradamento da integrare nel back-end.
+ Specificazione dell'endpoint di backend da richiamare. WebSocket APIs supporta i seguenti tipi di integrazione:
+ `AWS_PROXY`
+ `AWS`
+ `HTTP_PROXY`
+ `HTTP`
+ `MOCK`
Per ulteriori informazioni sui tipi di integrazione, consulta [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 di API Gateway V2.
+ Configurazione della modalità di trasformazione dei dati della richiesta di instradamento, se necessario, in dati di richiesta di integrazione specificando uno o più modelli di richiesta.
## Configurare una richiesta di integrazione WebSocket API utilizzando la console API Gateway
**Per aggiungere una richiesta di integrazione a un percorso in un' WebSocket API utilizzando la console API Gateway**
1. Accedere alla console API Gateway, scegliere l'API e selezionare **Routes (Route)**.
1. In **Routes (Route)**, scegliere la route.
1. Scegli la scheda **Richiesta di integrazione**, quindi seleziona **Modifica** nella sezione **Impostazioni della richiesta di integrazione**.
1. Per **Tipo di integrazione** scegli una delle seguenti opzioni:
+ Scegli **la funzione Lambda** solo se la tua API sarà integrata con una AWS Lambda funzione che hai già creato in questo account o in un altro account.
**Per creare una nuova funzione Lambda in AWS Lambda, impostare un'autorizzazione di risorsa sulla funzione Lambda o eseguire qualsiasi altra azione del servizio Lambda, scegli invece Service.AWS **
+ Scegliere **HTTP** se l'API verrà integrata con un endpoint HTTP esistente. Per ulteriori informazioni, consulta [Integrazioni HTTP per REST APIs in API Gateway](setup-http-integrations.md).
+ Scegliere **Mock (Fittizio)** se si desidera generare le risposte API direttamente da API Gateway, senza la necessità di un back-end di integrazione. Per ulteriori informazioni, consulta [Integrazioni fittizie per REST APIs in API Gateway](how-to-mock-integration.md).
+ Scegli **AWS service** se la tua API sarà integrata con un servizio. AWS
+ Scegli **Collegamento VPC** se l'API utilizzerà un `VpcLink` come endpoint di integrazione privato. Per ulteriori informazioni, consulta [Configura un'integrazione privata](set-up-private-integration.md).
1. Se scegli **Funzione Lambda** procedi come segue:
1. Per **Utilizza integrazione proxy Lambda** seleziona la casella di controllo desiderata per utilizzare l'[integrazione proxy Lambda](set-up-lambda-proxy-integrations.md#api-gateway-create-api-as-simple-proxy) o l'[integrazione proxy Lambda tra più account](apigateway-cross-account-lambda-integrations.md).
1. Per **Funzione Lambda** specifica la funzione in uno dei modi seguenti:
+ Se la funzione Lambda si trova nello stesso account, immetti il nome della funzione e quindi seleziona la funzione dall'elenco a discesa.
**Nota**
Il nome della funzione può facoltativamente includere l'alias o la specifica della versione, come in `HelloWorld`, `HelloWorld:1` o `HelloWorld:alpha`.
+ Se la funzione si trova in un account diverso, immettere l'ARN per la funzione.
1. Per utilizzare il valore di timeout predefinito di 29 secondi, mantieni attiva l'opzione **Timeout predefinito**. Per impostare un timeout personalizzato, scegli **Timeout predefinito** e immetti un valore di timeout compreso tra `50` e `29000` millisecondi.
1. Se si sceglie **HTTP**, seguire le istruzioni nella fase 4 di [Configurazione di una richiesta di integrazione API tramite la console API Gateway](how-to-method-settings-console.md).
1. Se si sceglie **Mock (Fittizio)**, andare alla fase **Request Templates (Modelli di richiesta)**.
1. Se scegli **Servizio AWS ** segui le istruzioni della fase 6 in [Configurazione di una richiesta di integrazione API tramite la console API Gateway](how-to-method-settings-console.md).
1. Se scegli **Collegamento VPC** procedi come segue:
1. Per **Integrazione proxy VPC** seleziona la casella di controllo se desideri eseguire il proxy delle richieste sull'endpoint di `VPCLink`.
1. Per **HTTP method (Metodo HTTP)** scegliere il tipo di metodo HTTP che corrisponde maggiormente al metodo nel back-end HTTP.
1. Dall'elenco a discesa **Collegamento VPC** seleziona un collegamento VPC. È possibile selezionare `[Use Stage Variables]` e inserire **\$1\$1stageVariables.vpcLinkId\$1** nella casella di testo sotto l'elenco.
È possibile definire la variabile di fase `vpcLinkId` dopo l'implementazione dell'API in una fase e l'impostazione del suo valore sull'ID del `VpcLink`.
1. In **Endpoint URL (URL endpoint)**, immettere l'URL del back-end HTTP che l'integrazione deve utilizzare.
1. Per utilizzare il valore di timeout predefinito di 29 secondi, mantieni attiva l'opzione **Timeout predefinito**. Per impostare un timeout personalizzato, scegli **Timeout predefinito** e immetti un valore di timeout compreso tra `50` e `29000` millisecondi.
1. Scegli **Save changes** (Salva modifiche).
1. In **Modelli di richiesta** procedi come segue:
1. Per immettere un'**Espressione di selezione del modello** scegli **Modifica** in **Modelli di richiesta**.
1. Immetti un'**Espressione di selezione del modello**. Specifica un'espressione che viene ricercata da Gateway API nel payload del messaggio. Se viene trovata, viene valutata e il risultato è un valore chiave del modello che viene utilizzato per selezionare il modello di mappatura dei dati che deve essere applicato ai dati nel payload del messaggio. Il modello di mappatura dei dati viene creato nel passaggio successivo. Scegli **Modifica** per salvare le modifiche.
1. Scegli **Crea modello** per creare il modello di mappatura dei dati. Per **Chiave del modello** immetti il valore della chiave del modello utilizzato per selezionare il modello di mappatura dei dati da applicare ai dati nel payload del messaggio. Quindi, specifica un modello di mappatura. Scegli **Crea modello**.
Per ulteriori informazioni sulle espressioni di selezione del modello, consulta [Espressioni di selezione del modello](websocket-api-data-transformations.md#apigateway-websocket-api-template-selection-expressions).
## Imposta una richiesta di integrazione utilizzando il AWS CLI
È possibile impostare una richiesta di integrazione per un percorso in un' WebSocket API utilizzando AWS CLI come illustrato nell'esempio seguente, che crea un'integrazione fittizia:
1. Crea un file denominato `integration-params.json`, con i seguenti contenuti:
```
{"PassthroughBehavior": "WHEN_NO_MATCH", "TimeoutInMillis": 29000, "ConnectionType": "INTERNET", "RequestTemplates": {"application/json": "{\"statusCode\":200}"}, "IntegrationType": "MOCK"}
```
1. Utilizza il seguente comando [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html) per creare l’integrazione fittizia.
```
aws apigatewayv2 --region us-east-1 create-integration --api-id aabbccddee --cli-input-json file://integration-params.json
```
L'output sarà simile al seguente:
```
{
"PassthroughBehavior": "WHEN_NO_MATCH",
"TimeoutInMillis": 29000,
"ConnectionType": "INTERNET",
"IntegrationResponseSelectionExpression": "${response.statuscode}",
"RequestTemplates": {
"application/json": "{\"statusCode\":200}"
},
"IntegrationId": "0abcdef",
"IntegrationType": "MOCK"
}
```
In alternativa, è possibile impostare una richiesta di integrazione per un'integrazione proxy utilizzando il AWS CLI.
1. Creare una funzione Lambda nella console Lambda e assegnarle un ruolo di esecuzione Lambda di base.
1. Utilizza il seguente comando [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html) per creare l’integrazione.
```
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
```
L'output sarà simile al seguente:
```
{
"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"
}
```
## Formato di input di una funzione Lambda per l'integrazione del proxy per WebSocket APIs
Con l'integrazione proxy Lambda, API Gateway mappa l'intera richiesta client al parametro di input `event` della funzione Lambda di back-end. Nell'esempio seguente viene illustrata la struttura dell'evento di input dall'instradamento `$connect` e dell'evento di input dall'instradamento `$disconnect` che Gateway API invia a un'integrazione 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
}
```
------
# Configurare una risposta di integrazione WebSocket API in API Gateway
La sezione seguente fornisce una breve panoramica delle risposte di integrazione per l' WebSocket API e su come impostare una risposta di integrazione per un' WebSocket API.
**Topics**
+ [Panoramica delle risposte di integrazione](#apigateway-websocket-api-integration-response-overview)
+ [Risposte di integrazione per la comunicazione bidirezionale](#apigateway-websocket-api-integration-response-for-two-way-communication)
+ [Configurazione di una risposta di integrazione mediante la console API Gateway](#apigateway-websocket-api-integration-response-using-console)
+ [Imposta una risposta di integrazione utilizzando il AWS CLI](#apigateway-websocket-api-integration-response-using-awscli)
## Panoramica delle risposte di integrazione
La risposta di integrazione di API Gateway è un metodo di creazione di modelli e di manipolazione della risposta da un servizio di back-end. Esistono alcune differenze nella configurazione di un'API REST rispetto a una risposta di integrazione WebSocket API, ma concettualmente il comportamento è lo stesso.
WebSocket le rotte possono essere configurate per la comunicazione bidirezionale o unidirezionale.
+ Quando una route è configurata per la comunicazione bidirezionale, una risposta di integrazione consente di configurare le trasformazioni sul payload del messaggio restituito, in modo simile alle risposte di integrazione per REST. APIs
+ Se una route è configurata per la comunicazione unidirezionale, indipendentemente dalla configurazione della risposta di integrazione, non verrà restituita alcuna risposta sul WebSocket canale dopo l'elaborazione del messaggio.
API Gateway non trasferisce la risposta del back-end alla risposta di instradamento, a meno che non venga configurata una risposta di instradamento. Per informazioni sull'impostazione di una risposta di instradamento, consultare [Imposta le risposte di routing per WebSocket APIs in API Gateway](apigateway-websocket-api-route-response.md).
## Risposte di integrazione per la comunicazione bidirezionale
Le integrazioni possono essere divise in integrazioni *proxy* e integrazioni *non proxy*.
**Importante**
Per le *integrazioni proxy*, API Gateway trasferisce automaticamente l'output del back-end all’intermediario come payload completo. Non esiste alcuna risposta di integrazione.
Per *integrazioni non proxy*, è necessario configurare almeno una risposta di integrazione:
+ Idealmente, una delle risposte di integrazione deve agire come un metodo catch-all quando non è possibile effettuare una scelta esplicita. Questo caso predefinito viene rappresentato impostando una chiave di risposta di integrazione di `$default`.
+ In tutti gli altri casi, la chiave di risposta di integrazione funziona come un'espressione regolare. Il formato adottato è `"/expression/"`.
Per integrazioni HTTP non proxy:
+ API Gateway tenterà di trovare una corrispondenza con il codice di stato HTTP della risposta di back-end. In questo caso, la chiave di risposta di integrazione funzionerà come un'espressione regolare. Se non è possibile trovare una corrispondenza, viene scelta `$default` come risposta di integrazione.
+ L'espressione di selezione del modello, come descritto in precedenza, funziona in modo identico. Ad esempio:
+ `/2\d\d/`: ricevi e trasforma risposte andate a buon fine
+ `/4\d\d/`: ricevi e trasforma errori di richiesta non valida
+ `$default`: ricevi e trasforma tutte le risposte impreviste
Per ulteriori informazioni sulle espressioni di selezione del modello, consultare [Espressioni di selezione del modello](websocket-api-data-transformations.md#apigateway-websocket-api-template-selection-expressions).
## Configurazione di una risposta di integrazione mediante la console API Gateway
Per configurare una risposta di integrazione del percorso per un' WebSocket API utilizzando la console API Gateway:
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegli la tua WebSocket API e scegli il tuo percorso.
1. Scegli la scheda **Richiesta di integrazione**, quindi seleziona **Crea risposta di integrazione** nella sezione **Impostazioni della risposta di integrazione**.
1. Per **Chiave della risposta** inserisci un valore che verrà individuato nella chiave della risposta del messaggio in uscita dopo aver valutato l'espressione di selezione di risposta. Ad esempio, puoi inserire **/4\$1d\$1d/** per ricevere e trasformare gli errori di richiesta non valida o **\$1default** per ricevere e trasformare tutte le risposte che corrispondono all'espressione di selezione del modello.
1. Per **Espressione di selezione del modello** immetti un'espressione di selezione per valutare il messaggio in uscita.
1. Scegli **Crea risposta**.
1. È inoltre possibile definire un modello di mappatura per configurare le trasformazioni del payload dei messaggi restituiti. Scegli **Crea modello**.
1. Immettere un nome per la chiave. Se è stata scelta l'espressione di selezione del modello predefinita, immettere**\$1\$1default**.
1. Per **Modello della risposta** immetti il modello di mappatura nell'editor di codice.
1. Scegli **Crea modello**.
1. Scegli **Implementa API** per implementare l'API.
Per connettersi all'API, utilizzare il seguente comando [wscat](https://www.npmjs.com/package/wscat). Per ulteriori informazioni su `wscat`, consultare [Utilizzalo `wscat` per connetterti a un' WebSocket API e inviarle messaggi](apigateway-how-to-call-websocket-api-wscat.md).
```
wscat -c wss://api-id.execute-api.us-east-2.amazonaws.com/test
```
Quando viene richiamato l'instradamento, dovrebbe venire restituito il payload del messaggio restituito.
## Imposta una risposta di integrazione utilizzando il AWS CLI
Il [create-integration-response](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration-response.html)comando seguente crea una risposta di `$default` integrazione:
```
aws apigatewayv2 create-integration-response \
--api-id vaz7da96z6 \
--integration-id a1b2c3 \
--integration-response-key '$default'
```