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à.
# Tutorial e workshop di Amazon API Gateway
I seguenti tutorial e workshop forniscono esercizi pratici per aiutarti a usare API Gateway. Per iniziare, è consigliabile completare la sezione [Tutorial: creazione di una REST API con un'integrazione proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md).
**Tutorial sull'API REST**
+ [Scegli un tutorial di integrazione AWS Lambda](getting-started-with-lambda-integration.md)
+ [Tutorial: creazione di un'API REST mediante l'importazione di un esempio](api-gateway-create-api-from-example.md)
+ [Scelta di un tutorial per l'integrazione HTTP](getting-started-http-integrations.md)
+ [Tutorial: creazione di una REST API con un'integrazione privata](getting-started-with-private-integration.md)
+ [Tutorial: creare un'API REST con un' AWS integrazione](getting-started-aws-proxy.md)
+ [Tutorial: crea un'API REST per calcolatrice con due integrazioni AWS di servizi e un'integrazione non proxy Lambda](integrating-api-with-aws-services-lambda.md)
+ [Tutorial: creazione di una REST API come un proxy Amazon S3](integrating-api-with-aws-services-s3.md)
+ [Tutorial: creazione di un'API REST come un proxy Amazon Kinesis](integrating-api-with-aws-services-kinesis.md)
+ [Tutorial: crea un'API REST utilizzando AWS SDKs o AWS CLI](api-gateway-create-api-cli-sdk.md)
+ [Tutorial: creazione di una REST API privata](private-api-tutorial.md)
**Tutorial sull'API HTTP**
+ [Tutorial: creazione di un'API HTTP CRUD con Lambda e DynamoDB](http-api-dynamo-db.md)
+ [Tutorial: creazione di un'API HTTP con un'integrazione privata con un servizio Amazon ECS](http-api-private-integration.md)
**Tutorial sull'API WebSocket**
+ [Tutorial: crea un'app di WebSocket chat con WebSocket API, Lambda e DynamoDB](websocket-api-chat-app.md)
**Workshop**
+ [Creazione di un'applicazione Web serverless](https://webapp.serverlessworkshops.io)
+ [CI/CD per applicazioni serverless](https://cicd.serverlessworkshops.io)
+ [Workshop sulla sicurezza serverless](https://github.com/aws-samples/aws-serverless-security-workshop)
+ [Gestione, autenticazione e autorizzazione delle identità serverless](https://auth.serverlessworkshops.io)
+ [Workshop su Gateway Amazon API](https://catalog.workshops.aws/apigateway/en-US)
# Tutorial sull'API REST di Amazon API Gateway
I seguenti tutorial forniscono esercizi pratici per aiutarti a conoscere API Gateway REST. APIs
**Topics**
+ [Scegli un tutorial di integrazione AWS Lambda](getting-started-with-lambda-integration.md)
+ [Tutorial: creazione di un'API REST mediante l'importazione di un esempio](api-gateway-create-api-from-example.md)
+ [Scelta di un tutorial per l'integrazione HTTP](getting-started-http-integrations.md)
+ [Tutorial: creazione di una REST API con un'integrazione privata](getting-started-with-private-integration.md)
+ [Tutorial: creare un'API REST con un' AWS integrazione](getting-started-aws-proxy.md)
+ [Tutorial: crea un'API REST per calcolatrice con due integrazioni AWS di servizi e un'integrazione non proxy Lambda](integrating-api-with-aws-services-lambda.md)
+ [Tutorial: creazione di una REST API come un proxy Amazon S3](integrating-api-with-aws-services-s3.md)
+ [Tutorial: creazione di un'API REST come un proxy Amazon Kinesis](integrating-api-with-aws-services-kinesis.md)
+ [Tutorial: crea un'API REST utilizzando AWS SDKs o AWS CLI](api-gateway-create-api-cli-sdk.md)
+ [Tutorial: creazione di una REST API privata](private-api-tutorial.md)
# Scegli un tutorial di integrazione AWS Lambda
Per creare un'API tramite integrazioni Lambda, puoi usare l'integrazione proxy Lambda o l'integrazione non proxy Lambda.
Nell'integrazione proxy Lambda, l'input nella funzione Lambda può essere espresso con qualsiasi combinazione di intestazioni di richiesta, variabili di percorso, parametri di stringa di query, corpo e dati di configurazione dell'API. È necessario solo che tu scelga una funzione Lambda. API Gateway configura automaticamente la richiesta e la risposta di integrazione. Una volta configurate, il metodo API può evolvere senza modificare le impostazioni esistenti. Ciò è possibile in quanto la funzione Lambda backend analizza i dati della richiesta in entrata e risponde al client.
Con l'integrazione non proxy Lambda, devi accertarti che l'input della funzione Lambda venga fornito come payload della richiesta di integrazione. È necessario mappare i dati di input forniti dal client come parametri di richiesta nel corpo della richiesta di integrazione appropriato. Potrebbe anche essere necessario convertire il corpo della richiesta fornito dal client in un formato riconosciuto dalla funzione Lambda.
In un proxy Lambda o in un'integrazione non proxy Lambda, è possibile utilizzare una funzione Lambda in un account diverso da quello in cui è stata creata l'API.
**Topics**
+ [Tutorial: creazione di una REST API con un'integrazione proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md)
+ [Tutorial: creazione di una REST API con un'integrazione non proxy Lambda](getting-started-lambda-non-proxy-integration.md)
+ [Tutorial: creazione di una REST API con un'integrazione proxy Lambda multi-account](apigateway-cross-account-lambda-integrations.md)
# Tutorial: creazione di una REST API con un'integrazione proxy Lambda
L'[integrazione proxy Lambda](set-up-lambda-proxy-integrations.md) è un tipo di integrazione API di API Gateway leggero e flessibile che permette di integrare un metodo API, o un'intera API, con una funzione Lambda. La funzione Lambda può essere scritta in [qualsiasi linguaggio supportato da Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). Poiché si tratta di un'integrazione proxy, è possibile modificare l'implementazione della funzione Lambda in qualsiasi momento senza necessità di ridistribuire l'API.
In questo tutorial, esegui quanto indicato di seguito:
+ Creazione di una funzione Lambda "Hello, World\$1" come back-end per l'API.
+ Creazione e test di un'API "Hello World\$1" API con integrazione proxy Lambda.
**Topics**
+ [Creazione di una funzione Lambda "Hello, World\$1" valida e completa](#api-gateway-proxy-integration-create-lambda-backend)
+ [Creazione di una funzione Lambda "Hello, World\$1" API](#api-gateway-create-api-as-simple-proxy-for-lambda-build)
+ [Distribuzione e test dell'API](#api-gateway-create-api-as-simple-proxy-for-lambda-test)
## Creazione di una funzione Lambda "Hello, World\$1" valida e completa
**Per creare una funzione Lambda "Hello, World\$1" Funzione Lambda nella console Lambda**
1. [Accedi alla console Lambda all'indirizzo https://console.aws.amazon.com /lambda.](https://console.aws.amazon.com/lambda)
1. Nella barra di AWS navigazione, scegli un. [Regione AWS](https://docs.aws.amazon.com/general/latest/gr/apigateway.html)
**Nota**
Prendere nota della regione in cui si crea la funzione Lambda. Questa informazione sarà necessaria in fase di creazione dell'API.
1. Nel riquadro di navigazione scegliere **Functions (Funzioni)**.
1. Selezionare **Create function (Crea funzione)**.
1. Scegli **Author from scratch** (Crea da zero).
1. In **Basic information (Informazioni di base)** eseguire queste operazioni:
1. In **Function name (Nome funzione)** immettere **GetStartedLambdaProxyIntegration**.
1. Per **Runtime**, scegli l'ultimo runtime supportato di **Node.js** o di **Python**.
1. Mantieni l'impostazione predefinita per **Architettura**.
1. In **Autorizzazioni** espandere **Modifica ruolo di esecuzione predefinito**. Nell'elenco a discesa **Ruolo di esecuzione**, scegli **Crea nuovo ruolo dai modelli di policy AWS **.
1. In **Role name (Nome ruolo)** immettere **GetStartedLambdaBasicExecutionRole**.
1. Lasciare il campo **Policy templates (Modelli di policy)** vuoto.
1. Selezionare **Create function (Crea funzione)**.
1. In **Codice funzione**, nell'editor di codice in linea, copy/paste il codice seguente:
------
#### [ Node.js ]
```
export const handler = async(event, context) => {
console.log('Received event:', JSON.stringify(event, null, 2));
var res ={
"statusCode": 200,
"headers": {
"Content-Type": "*/*"
}
};
var greeter = 'World';
if (event.greeter && event.greeter!=="") {
greeter = event.greeter;
} else if (event.body && event.body !== "") {
var body = JSON.parse(event.body);
if (body.greeter && body.greeter !== "") {
greeter = body.greeter;
}
} else if (event.queryStringParameters && event.queryStringParameters.greeter && event.queryStringParameters.greeter !== "") {
greeter = event.queryStringParameters.greeter;
} else if (event.multiValueHeaders && event.multiValueHeaders.greeter && event.multiValueHeaders.greeter != "") {
greeter = event.multiValueHeaders.greeter.join(" and ");
} else if (event.headers && event.headers.greeter && event.headers.greeter != "") {
greeter = event.headers.greeter;
}
res.body = "Hello, " + greeter + "!";
return res
};
```
------
#### [ Python ]
```
import json
def lambda_handler(event, context):
print(event)
greeter = 'World'
try:
if (event['queryStringParameters']) and (event['queryStringParameters']['greeter']) and (
event['queryStringParameters']['greeter'] is not None):
greeter = event['queryStringParameters']['greeter']
except KeyError:
print('No greeter')
try:
if (event['multiValueHeaders']) and (event['multiValueHeaders']['greeter']) and (
event['multiValueHeaders']['greeter'] is not None):
greeter = " and ".join(event['multiValueHeaders']['greeter'])
except KeyError:
print('No greeter')
try:
if (event['headers']) and (event['headers']['greeter']) and (
event['headers']['greeter'] is not None):
greeter = event['headers']['greeter']
except KeyError:
print('No greeter')
if (event['body']) and (event['body'] is not None):
body = json.loads(event['body'])
try:
if (body['greeter']) and (body['greeter'] is not None):
greeter = body['greeter']
except KeyError:
print('No greeter')
res = {
"statusCode": 200,
"headers": {
"Content-Type": "*/*"
},
"body": "Hello, " + greeter + "!"
}
return res
```
------
1. Selezionare **Deploy (Distribuisci)**.
## Creazione di una funzione Lambda "Hello, World\$1" API
Viene ora creata un'API per la funzione Lambda "Hello, World\$1" utilizzando la console API Gateway.
**Per creare una funzione Lambda "Hello, World\$1" "Hello, World\$1"**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Se si utilizza API Gateway per la prima volta, verrà visualizzata una pagina che presenta le caratteristiche del servizio. In **API REST**, scegliere **Crea**. Quando appare il popup **Create Example API (Crea API di esempio)**, scegliere **OK**.
Se non è la prima volta che si utilizza API Gateway, scegliere **Create API (Crea API)**. In **API REST**, scegliere **Crea**.
1. Per **API name (Nome API)**, immettere **LambdaProxyAPI**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Lasciare l'opzione **Tipo di endpoint API** impostata su **Regionale**.
1. Per il tipo di **indirizzo IP**, selezionare. **IPv4**
1. Seleziona **Create API** (Crea API).
Dopo l'API, è necessario creare una risorsa. In genere, le risorse API sono organizzate in una struttura di risorse in base alla logica dell'applicazione. In questo esempio crei una risorsa **/helloworld**.
**Come creare una risorsa**
1. Scegli **Crea risorsa**.
1. Mantieni l'opzione **Risorsa proxy** disattivata.
1. Mantieni **Percorso risorsa** impostato su `/`.
1. Per **Resource Name (Nome risorsa)** immetti **helloworld**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
In un'integrazione proxy, l'intera richiesta viene inviata alla funzione Lambda di back-end così com'è, tramite un metodo `ANY` catch-all che rappresenta qualsiasi metodo HTTP. Il metodo HTTP effettivo viene specificato dal client in fase di runtime. Il metodo `ANY` consente di utilizzare la configurazione di un solo metodo API per tutti i metodi HTTP supportati: `DELETE`, `GET`, `HEAD`, `OPTIONS`, `PATCH`, `POST` e `PUT`.
**Per creare un metodo `ANY`**
1. Seleziona la risorsa **/helloworld**, quindi scegli **Crea metodo**.
1. Per **Tipo di metodo** seleziona **ANY**.
1. Per **Tipo di integrazione** seleziona **Funzione Lambda**.
1. Attiva l'opzione **Integrazione proxy Lambda**.
1. Per la **funzione Lambda**, seleziona il Regione AWS luogo in cui hai creato la funzione Lambda, quindi inserisci il nome della 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. Scegli **Crea metodo**.
## Distribuzione e test dell'API
**Per distribuire l'API**
1. Seleziona **Deploy API (Distribuisci API)**.
1. In **Fase**, seleziona **Nuova fase**.
1. In **Stage name (Nome fase)** immettere **test**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Seleziona **Implementa**.
1. In **Dettagli fase**, scegli l'icona Copia per copiare l'URL di richiamo dell'API.
### Uso del browser e di cURL per testare un'API con integrazione proxy Lambda
Puoi utilizzare un browser oppure [cURL](https://curl.se/) per testare l'API.
Per testare le richieste `GET` utilizzando solo parametri della stringa di query, è possibile immettere l'URL per la risorsa `helloworld` dell'API nella barra degli indirizzi di un browser.
Per creare l'URL per la risorsa `helloworld` dell'API, aggiungi la risorsa `helloworld` e il parametro della stringa di query `?greeter=John` all'URL di invocazione. L'URL sarà simile al seguente.
```
https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld?greeter=John
```
Per gli altri metodi, occorre utilizzare utilità di test dell'API REST più avanzate, come [POSTMAN](https://www.postman.com/) o [cURL](https://curl.se/). In questo tutorial viene usato cURL. Gli esempi di comando cURL seguenti presuppongono che cURL sia installato nel computer in uso.
**Per testare l'API implementata tramite cURL:**
1. Apri una finestra del terminale.
1. Copia il comando cURL seguente e incollalo nella finestra del terminale, quindi sostituisci l'URL di richiamata con quello copiato nella fase precedente e aggiungi **/helloworld** alla fine dell'URL.
**Nota**
Se si esegue il comando in Windows, utilizzare questa sintassi:
```
curl -v -X POST "https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld" -H "content-type: application/json" -d "{ \"greeter\": \"John\" }"
```
1. Per chiamare l'API con il parametro della stringa di query `?greeter=John`:
```
curl -X GET 'https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld?greeter=John'
```
1. Per chiamare l'API con un parametro di intestazione `greeter:John`:
```
curl -X GET https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld \
-H 'content-type: application/json' \
-H 'greeter: John'
```
1. Per chiamare l'API con un corpo `{"greeter":"John"}`:
```
curl -X POST https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld \
-H 'content-type: application/json' \
-d '{ "greeter": "John" }'
```
In tutti i casi, l'output è una risposta 200 con il corpo seguente:
```
Hello, John!
```
# Tutorial: creazione di una REST API con un'integrazione non proxy Lambda
In questa procedura guidata viene utilizzata la console API Gateway per creare un'API che permette a un client di chiamare le funzioni Lambda tramite l'integrazione non proxy Lambda (detta anche integrazione personalizzata). Per ulteriori informazioni su AWS Lambda e sulle funzioni Lambda, consulta la [Guida per gli sviluppatori di AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/).
Per semplificare l'apprendimento, scegliamo una funzione Lambda semplice con una configurazione API minima per illustrare le fasi di creazione di un'API di API Gateway con l'integrazione personalizzata Lambda. Laddove necessario, descriveremo la logica. Per un esempio più dettagliato dell'integrazione personalizzata Lambda, consulta [Tutorial: crea un'API REST per calcolatrice con due integrazioni AWS di servizi e un'integrazione non proxy Lambda](integrating-api-with-aws-services-lambda.md).
Prima di creare l'API, configura il back-end Lambda creando una funzione Lambda in AWS Lambda, come descritto di seguito.
**Topics**
+ [Creazione di una funzione Lambda per l'integrazione non proxy Lambda](#getting-started-new-lambda)
+ [Creazione di un'API con l'integrazione non proxy Lambda](#getting-started-new-api)
+ [Test della chiamata del metodo API](#getting-started-new-get)
+ [Distribuzione dell'API](#getting-started-deploy-api)
+ [Test dell'API in una fase di distribuzione](#getting-started-test)
+ [Elimini](#getting-started-clean-up)
## Creazione di una funzione Lambda per l'integrazione non proxy Lambda
**Nota**
La creazione di funzioni Lambda può comportare addebiti sul tuo AWS account.
In questa fase, viene creata una funzione Lambda "Hello, World\$1" per l'integrazione Lambda personalizzata. In tutta la procedura guidata la funzione è denominata `GetStartedLambdaIntegration`.
L'implementazione di questa funzione Lambda `GetStartedLambdaIntegration` è la seguente:
------
#### [ Node.js ]
```
'use strict';
var days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
var times = ['morning', 'afternoon', 'evening', 'night', 'day'];
export const handler = async(event) => {
console.log(event);
// Parse the input for the name, city, time and day property values
let name = event.name === null || event.name === undefined || event.name === "" ? 'you' : event.name;
let city = event.city === undefined ? 'World' : event.city;
let time = times.indexOf(event.time)<0 ? 'day' : event.time;
let day = days.indexOf(event.day)<0 ? null : event.day;
// Generate a greeting
let greeting = 'Good ' + time + ', ' + name + ' of ' + city + '. ';
if (day) greeting += 'Happy ' + day + '!';
// Log the greeting to CloudWatch
console.log('Hello: ', greeting);
// Return a greeting to the caller
return {"greeting": greeting}
};
```
------
#### [ Python ]
```
import json
days = {
'Sunday',
'Monday',
'Tuesday',
'Wednesday',
'Thursday',
'Friday',
'Saturday'}
times = {'morning', 'afternoon', 'evening', 'night', 'day'}
def lambda_handler(event, context):
print(event)
# parse the input for the name, city, time, and day property values
name = event.get("name") or 'you'
city = event.get("city") or 'World'
try:
if event['time'] in times:
time = event['time']
else:
time = 'day'
except KeyError:
time = 'day'
try:
if event['day'] in days:
day = event['day']
else:
day = ''
except KeyError:
day = ''
# Generate a greeting
greeting = 'Good ' + time + ', ' + name + ' of ' + \
city + '.' + ['', ' Happy ' + day + '!'][day != '']
# Log the greeting to CloudWatch
print(greeting)
# Return a greeting to the caller
return {"greeting": greeting}
```
------
Per l'integrazione Lambda personalizzata, API Gateway passa l'input alla funzione Lambda dal client come corpo della richiesta di integrazione. L'oggetto `event` del gestore della funzione Lambda è l'input.
La nostra funzione Lambda è semplice. Analizza l'oggetto `event` di input per le proprietà `name`, `city`, `time` e `day`. Quindi restituisce un saluto, come un oggetto JSON di `{"message":greeting}`, all'intermediario. Il messaggio è nel modello `"Good [morning|afternoon|day], [name|you] in [city|World]. Happy day!"`. Si presume che l'input per la funzione Lambda sia dell'oggetto JSON seguente:
```
{
"city": "...",
"time": "...",
"day": "...",
"name" : "..."
}
```
Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).
Inoltre, la funzione registra la sua esecuzione su Amazon CloudWatch `console.log(...)` chiamando. Questo risulta utile per tracciare le chiamate durante il debug della funzione. Per consentire alla `GetStartedLambdaIntegration` funzione di registrare la chiamata, imposta un ruolo IAM con politiche appropriate per la funzione Lambda per creare gli CloudWatch stream e aggiungere voci di registro agli stream. La console Lambda permette di creare le policy e i ruoli IAM necessari.
Se configuri l'API senza usare la console API Gateway, come nel caso in cui si esegue l'[importazione di un'API da un file OpenAPI](https://github.com/aws-samples/api-gateway-secure-pet-store/blob/master/src/main/resources/swagger.yaml#L39), dovrai creare esplicitamente, se necessario, e configurare una policy e un ruolo di invocazione affinché API Gateway possa invocare le funzioni Lambda. Per ulteriori informazioni su come configurare i ruoli di esecuzione e di invocazione Lambda per un'API di API Gateway, consulta [Controllo degli accessi a una REST API con le autorizzazioni IAM](permissions.md).
A differenza di `GetStartedLambdaProxyIntegration`, la funzione Lambda per l'integrazione proxy Lambda, la funzione Lambda `GetStartedLambdaIntegration` per l'integrazione personalizzata Lambda riceve l'input solo dal corpo della richiesta di integrazione API di API Gateway. La funzione può restituire un output di qualsiasi oggetto JSON, una stringa, un numero, un valore booleano o un BLOB binario. La funzione Lambda per l'integrazione proxy Lambda, al contrario, può ricevere l'input da tutti i dati di richiesta ma deve restituire un output di un oggetto JSON specifico. La funzione `GetStartedLambdaIntegration` per l'integrazione personalizzata Lambda può ricevere come input i parametri di richiesta API, a condizione che API Gateway mappi i parametri di richiesta API necessari al corpo della richiesta di integrazione prima di inoltrare la richiesta client al back-end. Perché ciò accada, lo sviluppatore dell'API deve creare un modello di mappatura e configurarlo nel metodo API durante la creazione dell'API.
Viene ora creata la funzione Lambda `GetStartedLambdaIntegration`.
**Per creare la funzione Lambda `GetStartedLambdaIntegration` per l'integrazione personalizzata Lambda**
1. Apri la console all' AWS Lambda indirizzo. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. Esegui una delle seguenti operazioni:
+ Se viene visualizzata la pagina di benvenuto, scegliere **Get Started Now (Inizia subito)**, quindi **Create a function (Crea una funzione)**.
+ Se viene visualizzata la pagina di elenco **Lambda > Funzioni**, scegliere **Create a function (Crea una funzione)**.
1. Scegli **Author from scratch** (Crea da zero).
1. Nel riquadro **Author from scratch (Crea da zero)** procedere nel seguente modo:
1. In **Nome (Name)**, immettere **GetStartedLambdaIntegration** come nome della funzione Lambda.
1. Per **Runtime**, scegli l'ultimo runtime supportato di **Node.js** o di **Python**.
1. Mantieni l'impostazione predefinita per **Architettura**.
1. In **Autorizzazioni** espandere **Modifica ruolo di esecuzione predefinito**. Nell'elenco a discesa **Ruolo di esecuzione**, scegli **Crea nuovo ruolo dai modelli di policy AWS **.
1. Per **Role name (Nome ruolo)**, digitare un nome per il ruolo, ad esempio **GetStartedLambdaIntegrationRole**.
1. Per **Modelli di policy**, scegliere **Autorizzazioni microservizi semplici**.
1. Selezionare **Create function (Crea funzione)**.
1. Nel riquadro **Configure function (Configura funzione)** effettua quanto segue in **Function code (Codice funzione)**:
1. Copiare il codice di funzione Lambda elencato all'inizio di questa sezione e incollarlo nell'editor di codice inline.
1. Lascia i valori predefiniti negli altri campi di questa sezione.
1. Selezionare **Deploy (Distribuisci)**.
1. Per testare la funzione appena creata, scegli la scheda **Test**.
1. Per **Event name (Nome evento)** immettere **HelloWorldTest**.
1. Per **JSON dell'evento**, sostituisci il codice predefinito con il seguente.
```
{
"name": "Jonny",
"city": "Seattle",
"time": "morning",
"day": "Wednesday"
}
```
1. Scegliere **Test (Testa)** per invocare la funzione. Viene visualizzata la sezione **Execution result: succeeded (Risultato esecuzione: riuscito)**. Espandi **Dettaglio**. Verrà visualizzato l'output seguente.
```
{
"greeting": "Good morning, Jonny of Seattle. Happy Wednesday!"
}
```
L'output viene anche scritto in CloudWatch Logs.
Come esercizio complementare, puoi usare la console IAM per visualizzare il ruolo IAM (`GetStartedLambdaIntegrationRole`) creato insieme alla funzione Lambda. A questo ruolo IAM sono collegate due policy inline. Una stipula le autorizzazioni di base per l'esecuzione Lambda Consente di richiamare qualsiasi CloudWatch risorsa del tuo account nella regione in cui viene creata la funzione Lambda. CloudWatch `CreateLogGroup` Questa politica consente inoltre di creare CloudWatch flussi e registrare gli eventi per la funzione Lambda`GetStartedLambdaIntegration`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "logs:CreateLogGroup",
"Resource": "arn:aws:logs:us-east-1:111111111111:*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111111111111:log-group:/aws/lambda/GetStartedLambdaIntegration:*"
]
}
]
}
```
------
L'altro documento di policy si applica all'invocazione di un altro AWS servizio che non viene utilizzato in questo esempio. Puoi ignorarlo in questa fase.
Al ruolo IAM è associata un'entità attendibile, ovvero `lambda.amazonaws.com`. La relazione di fiducia è la seguente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
La combinazione di questa relazione di fiducia e della politica in linea consente alla funzione Lambda di richiamare `console.log()` una funzione per registrare gli eventi nei registri. CloudWatch
## Creazione di un'API con l'integrazione non proxy Lambda
Con la funzione Lambda (`GetStartedLambdaIntegration`) creata e testata, è possibile esporre la funzione mediante un'API di API Gateway. A scopo illustrativo, viene esposta la funzione Lambda con un metodo HTTP generico. Vengono utilizzati il corpo della richiesta, una variabile di percorso URL, una stringa di query e un'intestazione per ricevere i dati di input necessari dal client. Attiviamo il validatore di richieste API Gateway per l'API per garantire che tutti i dati necessari vengano definiti e specificati in modo appropriato. Configuriamo un modello di mappatura per API Gateway per trasformare i dati della richiesta forniti dal client nel formato valido, come richiesto dalla funzione Lambda di back-end.
**Per creare un'API con un'integrazione non proxy Lambda**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Se si utilizza API Gateway per la prima volta, verrà visualizzata una pagina che presenta le caratteristiche del servizio. In **API REST**, scegliere **Crea**. Quando appare il popup **Create Example API (Crea API di esempio)**, scegliere **OK**.
Se non è la prima volta che si utilizza API Gateway, scegliere **Create API (Crea API)**. In **API REST**, scegliere **Crea**.
1. Per **API name (Nome API)**, immettere **LambdaNonProxyAPI**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Lasciare l'opzione **Tipo di endpoint API** impostata su **Regionale**.
1. Per il tipo di **indirizzo IP**, selezionare. **IPv4**
1. Seleziona **Create API** (Crea API).
Dopo l'API, è necessario creare una risorsa **/\$1city\$1**. Questo è l'esempio di una risorsa con una variabile di percorso che riceve un input dal client. Più avanti mapperai questa variabile nell'input della funzione Lambda utilizzando un modello di mappatura.
**Come creare una risorsa**
1. Scegli **Crea risorsa**.
1. Mantieni l'opzione **Risorsa proxy** disattivata.
1. Mantieni **Percorso risorsa** impostato su `/`.
1. Per **Resource Name (Nome risorsa)** immetti **\$1city\$1**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
Dopo la risorsa **/\$1city\$1**, è necessario creare un metodo `ANY`. Il metodo HTTP `ANY` funge da segnaposto per un metodo HTTP valido inviato da un client al runtime. Questo esempio mostra che il metodo `ANY` può essere utilizzato sia per l'integrazione Lambda personalizzata sia per quella proxy.
**Per creare un metodo `ANY`**
1. Seleziona la risorsa **/\$1city\$1**, quindi scegli **Crea metodo**.
1. Per **Tipo di metodo** seleziona **ANY**.
1. Per **Tipo di integrazione** seleziona **Funzione Lambda**.
1. Mantieni l'opzione **Integrazione proxy Lambda** disattivata.
1. Per la **funzione Lambda**, seleziona il Regione AWS luogo in cui hai creato la funzione Lambda, quindi inserisci il nome della funzione.
1. Scegli **Impostazioni della richiesta del metodo.**
Ora, attivare un validatore richiesta per una variabile di percorso URL, un parametro di stringa di query e un'intestazione per assicurarsi che tutti i dati necessari siano definiti. Per questo esempio, crea un parametro della stringa di query `time` e un'intestazione `day`.
1. Per **Validatore richiesta** seleziona **Convalida parametri di stringa query e intestazioni**.
1. Scegli **Parametri della stringa di query URL** ed effettua le seguenti operazioni:
1. Scegliere **Add query string (Aggiungi stringa di query)**.
1. In **Nome**, inserisci **time**.
1. Attiva **Campo obbligatorio**.
1. Mantieni disattivata l'opzione **Caching**.
1. Scegli **Intestazioni di richiesta HTTP** e procedi come segue:
1. Seleziona **Add header (Aggiungi intestazione)**.
1. In **Nome**, inserisci **day**.
1. Attiva **Campo obbligatorio**.
1. Mantieni disattivata l'opzione **Caching**.
1. Scegli **Crea metodo**.
Dopo aver attivato un validatore della richiesta, configura la richiesta di integrazione per il metodo `ANY` aggiungendo un modello di mappatura del corpo per trasformare la richiesta in ingresso in un payload JSON, come richiesto dalla funzione Lambda di back-end.
**Per configurare la richiesta di integrazione**
1. Nella scheda **Richiesta di integrazione** scegli **Modifica** in **Impostazioni della richiesta di integrazione**.
1. Per **Richiesta corpo passthrough** scegli **Quando non ci sono modelli definiti (consigliato)**.
1. Scegli **Modelli di mappatura**.
1. Scegliere **Add mapping template (Aggiungi modello di mappatura)**.
1. Per **Tipo di contenuto** inserisci **application/json**.
1. Per **Corpo del modello** inserisci il seguente codice:
```
#set($inputRoot = $input.path('$'))
{
"city": "$input.params('city')",
"time": "$input.params('time')",
"day": "$input.params('day')",
"name": "$inputRoot.callerName"
}
```
1. Scegli **Save** (Salva).
## Test della chiamata del metodo API
La console API Gateway offre l'opportunità di testare la chiamata dell'API prima della distribuzione. La caratteristica Test della console consente di testare l'API inviando la richiesta seguente:
```
POST /Seattle?time=morning
day:Wednesday
{
"callerName": "John"
}
```
In questa richiesta di test imposterai `ANY` su `POST` e `{city}` su `Seattle` e assegnerai `Wednesday` come valore di intestazione di `day` e `"John"` come valore di `callerName`.
**Test del metodo `ANY`**
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. In **Tipo di metodo**, seleziona `POST`.
1. In **Percorso** immetti **Seattle** per **city**.
1. In **Stringhe di query** immetti **time=morning**.
1. In **Intestazioni** immetti **day:Wednesday**.
1. In **Corpo della richiesta** immetti **\$1 "callerName": "John" \$1**.
1. Scegli **Test (Esegui test)**.
Verifica che il payload della risposta restituita sia come segue:
```
{
"greeting": "Good morning, John of Seattle. Happy Wednesday!"
}
```
Puoi anche visualizzare i log per analizzare il modo in cui API Gateway elabora la richiesta e la risposta.
```
Execution log for request test-request
Thu Aug 31 01:07:25 UTC 2017 : Starting execution for request: test-invoke-request
Thu Aug 31 01:07:25 UTC 2017 : HTTP Method: POST, Resource Path: /Seattle
Thu Aug 31 01:07:25 UTC 2017 : Method request path: {city=Seattle}
Thu Aug 31 01:07:25 UTC 2017 : Method request query string: {time=morning}
Thu Aug 31 01:07:25 UTC 2017 : Method request headers: {day=Wednesday}
Thu Aug 31 01:07:25 UTC 2017 : Method request body before transformations: { "callerName": "John" }
Thu Aug 31 01:07:25 UTC 2017 : Request validation succeeded for content type application/json
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request URI: https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request headers: {x-amzn-lambda-integration-tag=test-request, Authorization=****************************************************************************************************************************************************************************************************************************************************************************************************************************************338c72, X-Amz-Date=20170831T010725Z, x-amzn-apigateway-api-id=beags1mnid, X-Amz-Source-Arn=arn:aws:execute-api:us-west-2:123456789012:beags1mnid/null/POST/{city}, Accept=application/json, User-Agent=AmazonAPIGateway_beags1mnid, X-Amz-Security-Token=FQoDYXdzELL//////////wEaDMHGzEdEOT/VvGhabiK3AzgKrJw+3zLqJZG4PhOq12K6W21+QotY2rrZyOzqhLoiuRg3CAYNQ2eqgL5D54+63ey9bIdtwHGoyBdq8ecWxJK/YUnT2Rau0L9HCG5p7FC05h3IvwlFfvcidQNXeYvsKJTLXI05/yEnY3ttIAnpNYLOezD9Es8rBfyruHfJfOqextKlsC8DymCcqlGkig8qLKcZ0hWJWVwiPJiFgL7laabXs++ZhCa4hdZo4iqlG729DE4gaV1mJVdoAagIUwLMo+y4NxFDu0r7I0/EO5nYcCrppGVVBYiGk7H4T6sXuhTkbNNqVmXtV3ch5bOlh7 [TRUNCATED]
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request body after transformations: {
"city": "Seattle",
"time": "morning",
"day": "Wednesday",
"name" : "John"
}
Thu Aug 31 01:07:25 UTC 2017 : Sending request to https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Received response. Integration latency: 328 ms
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response body before transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response headers: {x-amzn-Remapped-Content-Length=0, x-amzn-RequestId=c0475a28-8de8-11e7-8d3f-4183da788f0f, Connection=keep-alive, Content-Length=62, Date=Thu, 31 Aug 2017 01:07:25 GMT, X-Amzn-Trace-Id=root=1-59a7614d-373151b01b0713127e646635;sampled=0, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Method response body after transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Method response headers: {X-Amzn-Trace-Id=sampled=0;root=1-59a7614d-373151b01b0713127e646635, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Successfully completed execution
Thu Aug 31 01:07:25 UTC 2017 : Method completed with status: 200
```
I log mostrano la richiesta in ingresso prima della mappatura e la richiesta di integrazione dopo la mappatura. I log risultano utili per valutare, in caso di esito negativo di un test, se l'input originale è corretto o il modello di mappatura funziona correttamente.
## Distribuzione dell'API
La chiamata di test è una simulazione e presenta alcune limitazioni. Ad esempio ignora qualsiasi sistema di autorizzazione attuato per l'API. Per testare l'esecuzione dell'API in tempo reale, è necessario prima distribuire l'API. Per distribuire un'API, crea una fase per creare una snapshot dell'API in quel momento. Il nome della fase definisce inoltre il percorso di base in base al nome host predefinito dell'API. La risorsa radice dell'API viene aggiunta dopo il nome della fase. Quando modifichi l'API, devi ridistribuirla in una fase nuova o esistente per rendere effettive le modifiche.
**Per distribuire l'API in una fase**
1. Seleziona **Deploy API (Distribuisci API)**.
1. In **Fase**, seleziona **Nuova fase**.
1. In **Stage name (Nome fase)** immettere **test**.
**Nota**
L'input deve essere un testo con codifica UTF-8, ovvero non localizzato.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Seleziona **Implementa**.
In **Dettagli fase**, scegli l'icona Copia per copiare l'URL di richiamo dell'API. Il modello generale dell'URL di base dell'API è `https://api-id.region.amazonaws.com/stageName`. Ad esempio, l'URL di base dell'API (`beags1mnid`) creato nella regione `us-west-2` e distribuito nella fase `test` è `https://beags1mnid.execute-api.us-west-2.amazonaws.com/test`.
## Test dell'API in una fase di distribuzione
Sono disponibili diversi modi per testare un'API distribuita. Per le richieste GET che utilizzano solo variabili di percorso URL o parametri di stringa di query, puoi immettere l'URL di risorsa dell'API nel browser. Per gli altri metodi, occorre utilizzare utilità di test dell'API REST più avanzate, come [POSTMAN](https://www.postman.com/) o [cURL](https://curl.se/).
**Per testare l'API tramite cURL**
1. Apri una finestra terminale sul tuo computer locale connesso a Internet.
1. Per testare `POST /Seattle?time=evening`:
Copia il comando cURL seguente e incollalo nella finestra terminale.
```
curl -v -X POST \
'https://beags1mnid.execute-api.us-west-2.amazonaws.com/test/Seattle?time=evening' \
-H 'content-type: application/json' \
-H 'day: Thursday' \
-H 'x-amz-docs-region: us-west-2' \
-d '{
"callerName": "John"
}'
```
Dovresti visualizzare una risposta di operazione riuscita con il payload seguente:
```
{"greeting":"Good evening, John of Seattle. Happy Thursday!"}
```
Se modifichi `POST` in `PUT` in questa richiesta di metodo, otterrai la stessa risposta.
## Elimini
Se non hai più bisogno delle funzioni Lambda create per questa procedura dettagliata, puoi eliminarle in questa fase. Puoi anche eliminare le risorse IAM associate.
**avvertimento**
Se intendi completare le altre procedure guidate di questa serie, non eliminare il ruolo di esecuzione o di invocazione Lambda. Se elimini una funzione Lambda su APIs cui fai affidamento, quella non APIs funzionerà più. L'eliminazione di una funzione Lambda non può essere annullata. Se desideri utilizzare di nuovo la funzione Lambda, dovrai ricrearla.
Se elimini una risorsa IAM su cui si basa una funzione Lambda, quella funzione Lambda non funzionerà più e tutte le risorse APIs che si basano su quella funzione non funzioneranno più. L'eliminazione di una risorsa IAM non può essere annullata. Se desideri utilizzare di nuovo la risorsa IAM, dovrai ricrearla.
**Per eliminare la funzione Lambda**
1. Accedi a Console di gestione AWS e apri la console all' AWS Lambda indirizzo. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. Nell'elenco delle funzioni scegliere **GetStartedLambdaIntegration**, **Actions (Operazioni)**, quindi **Delete function (Elimina funzione)**. Quando viene richiesto, scegliere nuovamente **Delete (Elimina)**.
**Per eliminare le risorse IAM associate**
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. In **Details (Dettagli)** scegliere **Roles (Ruoli)**.
1. Nell'elenco dei ruoli scegliere **GetStartedLambdaIntegrationRole**, **Role Actions (Operazioni ruolo)**, quindi **Delete role (Elimina ruolo)**. Per eliminare il ruolo utilizzando la console, attieniti alla procedura seguente.
# Tutorial: creazione di una REST API con un'integrazione proxy Lambda multi-account
Ora puoi utilizzare una AWS Lambda funzione di un altro AWS account come backend di integrazione delle API. Ogni account può trovarsi in qualsiasi regione in cui è disponibile Amazon API Gateway. Ciò semplifica la gestione e la condivisione centralizzata delle funzioni di backend Lambda tra più utenti. APIs
In questa sezione, viene illustrato come configurare l'integrazione proxy Lambda tra più account utilizzando la console Amazon API Gateway.
## Creazione di un'API per l'integrazione Lambda tra più account API Gateway
**Come creare un’API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Se si utilizza API Gateway per la prima volta, verrà visualizzata una pagina che presenta le caratteristiche del servizio. In **API REST**, scegliere **Crea**. Quando appare il popup **Create Example API (Crea API di esempio)**, scegliere **OK**.
Se non è la prima volta che si utilizza API Gateway, scegliere **Create API (Crea API)**. In **API REST**, scegliere **Crea**.
1. Per **API name (Nome API)**, immettere **CrossAccountLambdaAPI**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Lasciare l'opzione **Tipo di endpoint API** impostata su **Regionale**.
1. Per il tipo di **indirizzo IP**, selezionare. **IPv4**
1. Seleziona **Create API** (Crea API).
## Creazione di una funzione di integrazione Lambda in un altro account
Viene ora creata una funzione Lambda in un account diverso da quello in cui hai creato l'API di esempio.
**Creazione di una funzione Lambda in un altro account**
1. Accedere alla console Lambda in un account diverso da quello in cui è stata creata l'API di API Gateway.
1. Selezionare **Create function (Crea funzione)**.
1. Scegli **Author from scratch** (Crea da zero).
1. In **Author from scratch (Crea da zero)**, effettuare le seguenti operazioni:
1. Per **Function name (Nome funzione)** immettere un nome.
1. Dall'elenco a discesa **Runtime**, scegliere un runtime Node.js supportato.
1. Mantieni l'impostazione predefinita per **Architettura**.
1. In **Autorizzazioni**, espandere **Scegli o crea un ruolo di esecuzione**. È possibile creare un ruolo o scegliere un ruolo esistente.
1. Selezionare **Create function (Crea funzione)** per continuare.
1. Scorrere verso il basso fino al riquadro **Function code (Codice funzione)**.
1. Immetti l'implementazione della funzione Node.js da [Tutorial: creazione di una REST API con un'integrazione proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md).
1. Selezionare **Deploy (Distribuisci)**.
1. Prendere nota dell'ARN completo della funzione (nell'angolo in alto a destra del riquadro della funzione Lambda), in quanto sarà necessario per la creazione dell'integrazione Lambda tra più account.
## Configurazione dell'integrazione Lambda tra più account
Dopo la creazione di una funzione di integrazione Lambda in un altro account, puoi utilizzare la console API Gateway per aggiungerla all'API nel tuo primo account.
**Nota**
Se si sta configurando una regione, un provider di autorizzazioni tra più account, `sourceArn` che viene aggiunto alla funzione di destinazione deve utilizzare la regione della funzione, non la regione dell'API.
Dopo l'API, è necessario creare una risorsa. In genere, le risorse API sono organizzate in una struttura di risorse in base alla logica dell'applicazione. In questo esempio crei una risorsa **/helloworld**.
**Come creare una risorsa**
1. Scegli **Crea risorsa**.
1. Mantieni l'opzione **Risorsa proxy** disattivata.
1. Mantieni **Percorso risorsa** impostato su `/`.
1. Per **Resource Name (Nome risorsa)** immetti **helloworld**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
Dopo la risorsa, è necessario creare un metodo `GET`. Integra il metodo `GET` con una funzione Lambda in un altro account.
**Creazione di un metodo `GET`**
1. Seleziona la risorsa **/helloworld**, quindi scegli **Crea metodo**.
1. Per **Tipo di metodo** seleziona **GET**.
1. Per **Tipo di integrazione** seleziona **Funzione Lambda**.
1. Attiva l'opzione **Integrazione proxy Lambda**.
1. Per **Funzione Lambda** immetti l'ARN completo della funzione Lambda dalla fase 1.
Nella console Lambda, puoi trovare l'ARN della funzione nell'angolo in alto a destra.
1. Quando immetti l'ARN, viene visualizzata una stringa di comando `aws lambda add-permission`. Questa policy fornisce al tuo primo account l'accesso alla funzione Lambda del secondo account. Copia e incolla la stringa di `aws lambda add-permission` comando in una AWS CLI finestra configurata per il secondo account.
1. Scegli **Crea metodo**.
Puoi visualizzare la policy aggiornata per la funzione nella console Lambda.
**(Facoltativo) Per visualizzare la policy aggiornata**
1. Accedi a Console di gestione AWS e apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Seleziona la funzione Lambda.
1. Seleziona **Autorizzazioni**.
Viene visualizzata una policy `Allow` con una clausola `Condition` in cui `AWS:SourceArn` è l'ARN per il metodo `GET` dell'API.
# Tutorial: creazione di un'API REST mediante l'importazione di un esempio
Puoi utilizzare la console Amazon API Gateway per creare e testare una semplice API REST con l'integrazione HTTP per un PetStore sito Web. La definizione dell'API è preconfigurata come file OpenAPI 2.0. Dopo aver caricato la definizione dell'API in API Gateway, puoi usare la console API Gateway per esaminare la struttura di base dell'API o semplicemente distribuire e testare l'API.
L'API di PetStore esempio supporta i seguenti metodi per consentire a un client di accedere al sito Web di backend HTTP di`http://petstore-demo-endpoint.execute-api.com/petstore/pets`.
**Nota**
Questo tutorial utilizza un endpoint HTTP come esempio. Quando ne crei uno tuo APIs, ti consigliamo di utilizzare gli endpoint HTTPS per le tue integrazioni HTTP.
+ `GET /`: per l'accesso in lettura della risorsa radice dell'API non integrata con un endpoint di back-end. API Gateway risponde con una panoramica del PetStore sito Web. Questo è un esempio del tipo di integrazione `MOCK`.
+ `GET /pets`: per l'accesso in lettura alla risorsa `/pets` dell'API integrata con la risorsa `/pets` di back-end omonima. Il backend restituisce una pagina di animali domestici disponibili in. PetStore Questo è un esempio del tipo di integrazione `HTTP`. L'URL dell'endpoint di integrazione è `http://petstore-demo-endpoint.execute-api.com/petstore/pets`.
+ `POST /pets`: per l'accesso in scrittura alla risorsa `/pets` dell'API integrata con la risorsa `/petstore/pets` di back-end. Dopo aver ricevuto una richiesta corretta, il backend aggiunge l'animale domestico specificato a PetStore e restituisce il risultato al chiamante. L'integrazione è anche `HTTP`.
+ `GET /pets/{petId}`: per l'accesso in lettura a un animale domestico identificato da un valore `petId` specificato come variabile di percorso dell'URL di richiesta in entrata. Questo metodo ha anche il tipo di integrazione `HTTP`. Il backend restituisce l'animale domestico specificato trovato in. PetStore L'URL dell'endpoint HTTP di back-end è `http://petstore-demo-endpoint.execute-api.com/petstore/pets/n`, dove `n` è un valore intero come l'identificativo dell'animale domestico su cui è stata eseguita la query.
L'API supporta l'accesso CORS mediante i metodi `OPTIONS` del tipo di integrazione `MOCK`. API Gateway restituisce le intestazioni richieste che supportano l'accesso a CORS.
La procedura seguente descrive le diverse fasi per creare e testare un'API da un esempio mediante la console API Gateway.
**Per importare, creare ed eseguire il test dell'API di esempio**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Esegui una delle seguenti operazioni:
+ Per creare la tua prima API, in **REST API**, scegli **Crea**.
+ Se hai già creato un'API, scegli **Crea API**, quindi scegliere **Crea** per **API REST**.
1. In **Crea REST API** scegli **API di esempio**, quindi seleziona **Crea API** per creare l'API di esempio.
![\[Esempio di REST API nella console Gateway API.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-new-console.png)
È possibile scorrere la definizione OpenAPI per i dettagli relativi a questa API di esempio prima di scegliere **Crea API**.
1. Nel riquadro di navigazione principale scegli **Risorse**. L'API appena creata viene mostrata come segue:
![\[L'API di esempio dopo l'importazione nella console Gateway API.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-result-new-console.png)
Il riquadro **Resources (Risorse)** mostra la struttura dell'API creata come albero di nodi. I metodi API definiti in ogni risorsa sono le estremità dell'albero. Quando una risorsa viene selezionata, tutti i relativi metodi vengono elencati nella tabella **Metodi** a destra. Con ogni metodo vengono visualizzati il tipo di metodo, il tipo di integrazione, il tipo di autorizzazione e il requisito della chiave API.
1. Per visualizzare i dettagli di un metodo, modificarne la configurazione o testarne la chiamata, scegli il nome del metodo nell'elenco o nella struttura di risorse. In questo caso scegliamo il metodo `POST /pets` a scopo illustrativo:
![\[Il metodo POST /pets per l'API di esempio nella console Gateway API.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-post-method-execution-new-console.png)
Il riquadro **Esecuzione metodo** risultante presenta una vista logica della struttura e dei comportamenti del metodo scelto (`POST /pets`).
La **Richiesta metodo** e la **Risposta metodo** rappresentano l'interfaccia dell'API con il front-end, mentre la **Richiesta di integrazione** e la **Risposta di integrazione** rappresentano l'interfaccia dell'API con il back-end.
Un client usa l'API per accedere a una funzionalità di back-end tramite la **Richiesta metodo**. Gateway API converte la richiesta del client, se necessario, nel formato accettabile per il back-end nella **Richiesta di integrazione**, prima di inoltrare la richiesta in entrata al back-end. La richiesta trasformata è nota come richiesta di integrazione. Analogamente, il back-end restituisce la risposta a Gateway API nella **Risposta di integrazione**. API Gateway quindi la instrada a **Method Response (Risposta metodo)** prima di inviarla al client. Anche in questo caso, se necessario, API Gateway può mappare i dati della risposta di back-end a un formato previsto dal client.
Per il metodo `POST` su una risorsa API, il payload della richiesta del metodo può essere passato attraverso la richiesta di integrazione senza alcuna modifica, se il formato del payload della richiesta del metodo è uguale a quello del payload della richiesta di integrazione.
La richiesta del metodo `GET /` usa il tipo di integrazione `MOCK` e non è legata a un endpoint di back-end reale. La **Risposta di integrazione** corrispondente è configurata per restituire una pagina HTML statica. Quando viene chiamato il metodo, Gateway API accetta la richiesta e restituisce immediatamente al client la risposta di integrazione configurata mediante la **Risposta metodo**. Puoi usare l'integrazione fittizia per testare un'API senza richiedere un endpoint di back-end. Puoi usarla anche per fornire una risposta locale, generata da un modello di mappatura del corpo della risposta.
In qualità di sviluppatore dell'API, puoi controllare i comportamenti delle interazioni front-end dell'API mediante la configurazione della richiesta e della risposta di metodo. Puoi inoltre controllare i comportamenti delle interazioni back-end dell'API mediante la configurazione della richiesta e della risposta di integrazione. Ciò prevede le mappature dei dati tra un metodo e l'integrazione corrispondente. Per ora, ci concentriamo sul test dell'API per fornire un'esperienza utente. end-to-end
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. Ad esempio, per testare il metodo `POST /pets`, immetti il payload **\$1"type": "dog","price": 249.99\$1** seguente nel **Corpo della richiesta** prima di selezionare **Test**.
![\[Test del metodo POST nella console Gateway API.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-post-method-test-new-console.png)
L'input specifica gli attributi dell'animale da aggiungere all'elenco degli animali domestici sul PetStore sito web.
1. I risultati visualizzati sono simili ai seguenti:
![\[Il risultato del test del metodo POST nella console Gateway API.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-post-method-test-result-new-console.png)
La voce **Log** dell'output mostra le modifiche dello stato dalla richiesta di metodo alla richiesta di integrazione e dalla risposta di integrazione alla risposta di metodo. Può risultare utile per la risoluzione dei problemi legati agli errori di mappatura che impediscono la riuscita della richiesta. In questo esempio non viene applicata alcuna mappatura: il payload della richiesta di metodo viene passato al back-end attraverso la richiesta di integrazione e, analogamente, la risposta del back-end viene passata alla risposta del metodo attraverso la risposta di integrazione.
Per testare l'API utilizzando un client diverso dalla test-invoke-request funzionalità API Gateway, devi prima implementare l'API in una fase.
1. Seleziona **Implementa API** per implementare l'API di esempio.
![\[Utilizza il pulsante Implementa API per implementare l'API, in modo che i chiamanti possano invocare l'API.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-deploy-api-new-console.png)
1. Per **Fase** seleziona **Nuova fase**, quindi immetti **test**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Seleziona **Implementa**.
1. Nel riquadro **Fasi** risultante, il campo **Richiama URL** in **Dettagli fase** visualizza l'URL per richiamare la richiesta del metodo `GET /` dell'API.
![\[Dopo aver creato la REST API, la console mostra il valore URL di richiamo dell'API.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/getting-started-rest-invoke-url.png)
1. Scegli l'icona Copia per copiare l'URL di richiamo dell'API, quindi immetti l'URL di richiamo dell'API in un browser Web. La risposta con esito positivo restituisce il risultato, generato dal modello di mappatura nella risposta di integrazione.
1. Nel pannello di navigazione **Stages** (Fasi), espandere la fase **test**, selezionare **GET** per `/pets/{petId}`, quindi copiare il valore **Invoke URL** (URL chiamata) di `https://api-id.execute-api.region.amazonaws.com/test/pets/{petId}`. `{petId}` indica una variabile di percorso.
Incollare il valore **Invoke URL (URL chiamata)** ottenuto nella fase precedente nella barra degli indirizzi di un browser, sostituendo `{petId}` con, ad esempio, `1` e premere Invio per inviare la richiesta. Dovrebbe essere restituita una risposta 200 OK con il payload JSON seguente:
```
{
"id": 1,
"type": "dog",
"price": 249.99
}
```
L'invocazione del metodo API nel modo indicato è possibile in quanto il tipo di **Authorization (Autorizzazione)** è impostato su `NONE`. Se venisse utilizzata l’autorizzazione `AWS_IAM`, la richiesta verrebbe firmata con i protocolli [Signature Version 4](https://docs.aws.amazon.com/IAM/latest/UserGuide/create-signed-request.html) (SigV4) o [Signature Version 4a](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html#how-sigv4a-works) (SigV4a). Per un esempio di questo tipo di richiesta, consulta [Tutorial: creazione di una REST API con un'integrazione non proxy HTTP](api-gateway-create-api-step-by-step.md).
# Scelta di un tutorial per l'integrazione HTTP
Per creare un'API con l'integrazione HTTP, è possibile utilizzare l'integrazione proxy HTTP o l'integrazione personalizzata HTTP.
Per l'integrazione proxy HTTP, è necessario solo impostare il metodo HTTP e l'URI dell'endpoint HTTP, in base ai requisiti del backend. Si consiglia, se possibile, di utilizzare l'integrazione proxy HTTP per semplificare la configurazione dell'API.
L'integrazione personalizzata HTTP può risultare utile se è necessario trasformare i dati delle richieste client per il backend o i dati delle risposte del backend per il client.
**Topics**
+ [Tutorial: creazione di una REST API con l'integrazione proxy HTTP](api-gateway-create-api-as-simple-proxy-for-http.md)
+ [Tutorial: creazione di una REST API con un'integrazione non proxy HTTP](api-gateway-create-api-step-by-step.md)
# Tutorial: creazione di una REST API con l'integrazione proxy HTTP
L'integrazione proxy HTTP è un meccanismo semplice, potente e versatile per creare un'API che permetta a un'applicazione Web di accedere a più caratteristiche o risorse dell'endpoint HTTP integrato, ad esempio l'intero sito Web, con una configurazione semplificata di un solo metodo API. In un'integrazione proxy HTTP, API Gateway passa la richiesta di metodo inviata dal client al back-end. I dati di richiesta che vengono passati includono intestazioni di richiesta, parametri delle stringhe di query, variabili di percorso URL e payload. L'endpoint HTTP di back-end o il server Web analizza i dati delle richieste in ingresso per stabilire la risposta da restituire. L'integrazione proxy HTTP consente l'interazione diretta tra client e back-end senza alcun intervento da parte di API Gateway dopo la configurazione del metodo API, tranne nel caso di problemi noti elencati in , ad esempio caratteri non supportat [Note importanti Amazon API Gateway](api-gateway-known-issues.md).
Con la risorsa proxy globale `{proxy+}` e il verbo catch-all `ANY` per il metodo HTTP, puoi usare un'integrazione proxy HTTP per creare un'API di un metodo API singolo. Il metodo espone l'intero set di operazioni e risorse HTTP accessibili pubblicamente di un sito Web. Quando il server Web di back-end apre più risorse per l'accesso pubblico, il client può usare le nuove risorse con la stessa configurazione API. Per consentirlo, lo sviluppatore del sito Web deve comunicare chiaramente con lo sviluppatore del client in merito alla natura delle nuove risorse e alle operazioni applicabili per ciascuna di esse.
Come breve introduzione, il tutorial che segue fornisce un esempio di integrazione proxy HTTP. Nel tutorial, creiamo un'API utilizzando la console API Gateway per l'integrazione con il PetStore sito Web tramite una risorsa `{proxy+}` proxy generica e creiamo il segnaposto del metodo HTTP di. `ANY`
**Topics**
+ [Creazione di un'API con l'integrazione proxy HTTP mediante la console API Gateway](#api-gateway-create-api-as-simple-proxy-for-http-build)
+ [Verifica di un'API con l'integrazione proxy HTTP](#api-gateway-create-api-as-simple-proxy-for-http-test)
## Creazione di un'API con l'integrazione proxy HTTP mediante la console API Gateway
Nella procedura seguente vengono descritte le fasi necessarie per creare e testare un'API con una risorsa proxy per un back-end HTTP mediante la console API Gateway. Il back-end HTTP è il sito Web `PetStore` (`http://petstore-demo-endpoint.execute-api.com/petstore/pets`) da [Tutorial: creazione di una REST API con un'integrazione non proxy HTTP](api-gateway-create-api-step-by-step.md), in cui vengono usati screenshot come supporto visivo per illustrare gli elementi dell'interfaccia utente API Gateway. Se non hai esperienza di utilizzo della console API Gateway per la creazione di un'API, può essere di aiuto seguire prima tale sezione.
**Come creare un’API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Se si utilizza API Gateway per la prima volta, verrà visualizzata una pagina che presenta le caratteristiche del servizio. In **API REST**, scegliere **Crea**. Quando appare il popup **Create Example API (Crea API di esempio)**, scegliere **OK**.
Se non è la prima volta che si utilizza API Gateway, scegliere **Create API (Crea API)**. In **API REST**, scegliere **Crea**.
1. Per **API name (Nome API)**, immettere **HTTPProxyAPI**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Lasciare l'opzione **Tipo di endpoint API** impostata su **Regionale**.
1. Per il tipo di **indirizzo IP**, selezionare. **IPv4**
1. Seleziona **Create API** (Crea API).
In questa fase crei un percorso della risorsa proxy di `{proxy+}`. Questo è il segnaposto di un endpoint di back-end in `http://petstore-demo-endpoint.execute-api.com/`. Ad esempio, può essere `petstore`, `petstore/pets` e `petstore/pets/{petId}`. Quando crei la risorsa `{proxy+}`, Gateway API crea il metodo `ANY` che funge da segnaposto per qualsiasi verbo HTTP supportato al runtime.
**Per creare una risorsa **/\$1proxy\$1\$1****
1. Scegliere l'API.
1. Nel riquadro di navigazione principale scegli **Risorse**.
1. Scegli **Crea risorsa**.
1. Attiva **Risorsa proxy**.
1. Mantieni **Percorso risorsa** impostato su `/`.
1. Per **Resource Name (Nome risorsa)** immetti **\$1proxy\$1\$1**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
![\[Creazione di una risorsa figlio.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/api-gateway-simple-proxy-create-proxy-resource-new-console.png)
In questa fase integri il metodo `ANY` con un endpoint HTTP di back-end, utilizzando un'integrazione proxy. In un'integrazione proxy, Gateway API passa la richiesta del metodo inviata dal client al back-end senza intervento di Gateway API.
**Per creare un metodo `ANY`**
1. Scegli la risorsa **/\$1proxy\$1\$1**.
1. Scegli il metodo **ANY**.
1. Sotto il simbolo di avviso, scegli **Modifica integrazione**. Non puoi implementare un'API con un metodo senza un'integrazione.
1. Per **Tipo di integrazione** seleziona **HTTP**.
1. Attiva l'opzione **Integrazione proxy HTTP**.
1. Per **Metodo HTTP** seleziona **ANY**.
1. Per **URL dell'endpoint** immetti **http://petstore-demo-endpoint.execute-api.com/\$1proxy\$1**.
1. Scegli **Save** (Salva).
## Verifica di un'API con l'integrazione proxy HTTP
L'esito di una richiesta client specifica dipende dagli elementi seguenti:
+ Se il back-end ha reso disponibile l'endpoint di back-end corrispondente e, in caso affermativo, se ha concesso le autorizzazioni di accesso richieste.
+ Se il client fornisce l'input corretto.
Ad esempio, l' PetStore API utilizzata qui non espone la `/petstore` risorsa. In questo modo, ottieni una risposta `404 Resource Not Found` contenente il messaggio di errore `Cannot GET /petstore`.
Inoltre per analizzare correttamente il risultato, il client deve essere in grado di gestire il formato di output del back-end. API Gateway non svolge alcuna mediazione per semplificare le interazioni tra il client e il back-end.
**Per testare un'API integrata con il PetStore sito Web utilizzando l'integrazione del proxy HTTP tramite la risorsa proxy**
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. In **Tipo di metodo**, seleziona `GET`.
1. In **Percorso** immetti **petstore/pets** per **proxy**.
1. In **Stringhe di query** immetti **type=fish**.
1. Scegli **Test (Esegui test)**.
![\[Utilizza la funzionalità Test per eseguire il test del metodo.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/api-gateway-simple-proxy-petstore-call-proxy-resource-new-console.png)
Poiché supporta la richiesta `GET /petstore/pets?type=fish`, il sito Web di back-end restituisce una risposta con esito positivo simile alla seguente:
```
[
{
"id": 1,
"type": "fish",
"price": 249.99
},
{
"id": 2,
"type": "fish",
"price": 124.99
},
{
"id": 3,
"type": "fish",
"price": 0.99
}
]
```
Se provi a chiamare `GET /petstore`, ottieni una risposta `404` con il messaggio di errore `Cannot GET /petstore`. Questo perché il back-end non supporta l'operazione specificata. Se chiami`GET /petstore/pets/1`, riceverai una `200 OK` risposta con il seguente payload, poiché la richiesta è supportata dal PetStore sito Web.
```
{
"id": 1,
"type": "dog",
"price": 249.99
}
```
Puoi anche utilizzare un browser per testare l'API. Implementa l'API e associala a una fase per creare l'URL di richiamata dell'API.
**Per distribuire l'API**
1. Seleziona **Deploy API (Distribuisci API)**.
1. In **Fase**, seleziona **Nuova fase**.
1. In **Stage name (Nome fase)** immettere **test**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Seleziona **Implementa**.
Ora i client possono chiamare la tua API.
**Richiamo dell'API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Nel pannello di navigazione principale scegli **Fase**.
1. In **Dettagli fase**, scegli l'icona Copia per copiare l'URL di richiamo dell'API.
Immetti l'URL di richiamata dell'API in un browser Web.
L'URL completo dovrebbe essere del tipo `https://abcdef123.execute-api.us-east-2.amazonaws.com/test/petstore/pets?type=fish`.
Il tuo browser invia una richiesta `GET` all'API.
1. Il risultato sarà uguale a quello che viene restituito quando si usa **Test** nella console Gateway API.
# Tutorial: creazione di una REST API con un'integrazione non proxy HTTP
In questo tutorial viene creata un'API da zero utilizzando la console Amazon API Gateway. Puoi pensare alla console come a uno studio di progettazione delle API e utilizzarla per analizzare le caratteristiche delle API, sperimentare i loro comportamenti, crearle e poi distribuirle per fasi.
**Topics**
+ [Creazione di un'API con l'integrazione personalizzata HTTP](#api-gateway-create-resource-and-methods)
+ [(Facoltativo) Mappatura dei parametri di richiesta](#api-gateway-create-resources-and-methods-next-steps)
## Creazione di un'API con l'integrazione personalizzata HTTP
Questa sezione illustra per fasi come creare le risorse, esporre i metodi su una risorsa, configurare un metodo per ottenere i comportamenti dell'API desiderati, testar e distribuire le API.
In questa fase si crea un'API vuota. Nelle seguenti fasi crei risorse e metodi per connettere l'API all'endpoint `http://petstore-demo-endpoint.execute-api.com/petstore/pets`, utilizzando un'integrazione HTTP non proxy.
**Come creare un’API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Se si utilizza API Gateway per la prima volta, verrà visualizzata una pagina che presenta le caratteristiche del servizio. In **API REST**, scegliere **Crea**. Quando appare il popup **Create Example API (Crea API di esempio)**, scegliere **OK**.
Se non è la prima volta che si utilizza API Gateway, scegliere **Create API (Crea API)**. In **API REST**, scegliere **Crea**.
1. Per **API name (Nome API)**, immettere **HTTPNonProxyAPI**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Lasciare l'opzione **Tipo di endpoint API** impostata su **Regionale**.
1. Per il tipo di **indirizzo IP**, selezionare. **IPv4**
1. Seleziona **Create API** (Crea API).
L'albero **Resources (Risorse)** mostra la risorsa root (`/`) senza metodi. In questo esercizio, creeremo l'API con l'integrazione personalizzata HTTP del PetStore sito Web (http://petstore-demo-endpoint.execute-api. com/petstore/pets.) A scopo illustrativo, creeremo una `/pets` risorsa come elemento secondario della radice e mostreremo un metodo GET su questa risorsa per consentire a un cliente di recuperare un elenco di articoli Pets disponibili dal sito Web. PetStore
**Per creare una risorsa /pets**
1. Scegli **Crea risorsa**.
1. Mantieni l'opzione **Risorsa proxy** disattivata.
1. Mantieni **Percorso risorsa** impostato su `/`.
1. Per **Resource Name (Nome risorsa)** immetti **pets**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
In questa fase crei un metodo `GET` per la risorsa **/pets**. Il metodo `GET` è integrato con il sito Web `http://petstore-demo-endpoint.execute-api.com/petstore/pets`. Altre opzioni per il metodo API sono:
+ **POST**, usato principalmente per creare risorse figlio.
+ **PUT**, utilizzato principalmente per aggiornare risorse esistenti (e, sebbene non consigliato, può essere usato per creare risorse figlio).
+ **DELETE**, utilizzato per eliminare le risorse.
+ **PATCH**, utilizzato per aggiornare le risorse.
+ **HEAD**, utilizzato principalmente negli scenari di test. È lo stesso di GET ma non restituisce la rappresentazione della risorsa.
+ **OPTIONS**, che può essere utilizzato dagli intermediari per ricevere informazioni sulle opzioni di comunicazione disponibili per il servizio di destinazione.
Per **HTTP method (Metodo HTTP)** della richiesta di integrazione, occorre selezionarne uno supportato dal back-end. Per `HTTP` o `Mock integration`, è opportuno che la richiesta di metodo e la richiesta di integrazione utilizzino lo stesso verbo HTTP. Per altri tipi di integrazione, la richiesta di metodo utilizzerà probabilmente un verbo HTTP diverso da quello della richiesta di integrazione. Ad esempio, per chiamare una funzione Lambda, la richiesta di integrazione deve utilizzare `POST` per invocare la funzione, mentre la richiesta di metodo potrebbe utilizzare qualsiasi verbo HTTP in base alla logica della funzione Lambda.
**Per creare un metodo `GET` nella risorsa **/pets****
1. Seleziona la risorsa **/pets**.
1. Scegli **Crea metodo**.
1. Per **Tipo di metodo** seleziona **GET**.
1. Per **Tipo di integrazione** seleziona **Integrazione HTTP**.
1. Mantieni l'opzione **Integrazione proxy HTTP** disattivata.
1. Per **Metodo HTTP** seleziona **GET**.
1. Per **URL dell'endpoint** immetti **http://petstore-demo-endpoint.execute-api.com/petstore/pets**.
Il PetStore sito Web consente di recuperare un elenco di `Pet` elementi in base al tipo di animale domestico, ad esempio «Cane» o «Gatto», in una determinata pagina.
1. Per **Gestione contenuti** seleziona **Transito**.
1. Scegli **Parametri della stringa di query URL**.
Il PetStore sito Web utilizza `type` i parametri della stringa di `page` interrogazione per accettare un input. Aggiungi i parametri della stringa di query alla richiesta del metodo e mappali nei parametri della stringa di query corrispondenti della richiesta di integrazione.
1. Per aggiungere i parametri della stringa di query, procedi come indicato di seguito:
1. Scegliere **Add query string (Aggiungi stringa di query)**.
1. Per **Nome** immetti **type**.
1. Mantieni **Obbligatorio** e **Caching** disattivati.
Ripeti le fasi precedenti per creare una stringa di query aggiuntiva denominata **page**.
1. Scegli **Crea metodo**.
Se invii una richiesta, ora il client può fornire un tipo di animale e un numero di pagina come parametri della stringa di query. Questi parametri di input devono essere mappati nei parametri della stringa di query dell'integrazione per inoltrare i valori di input al nostro PetStore sito Web nel backend.
**Per mappare i parametri di input alla richiesta di integrazione**
1. Nella scheda **Richiesta di integrazione** scegli **Modifica** in **Impostazioni della richiesta di integrazione**.
1. Scegli **Parametri della stringa di query URL** ed effettua le seguenti operazioni:
1. Scegli **Aggiungi parametro della stringa di query**.
1. In **Nome**, inserisci **type**.
1. Per **Mappato da** immetti **method.request.querystring.type**.
1. Mantieni disattivata l'opzione **Caching**.
1. Scegli **Aggiungi parametro della stringa di query**.
1. In **Nome**, inserisci **page**.
1. Per **Mappato da** immetti **method.request.querystring.page**.
1. Mantieni disattivata l'opzione **Caching**.
1. Scegli **Save** (Salva).
**Per testare l'API**
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. In **Stringhe di query** immetti **type=Dog&page=2**.
1. Scegli **Test (Esegui test)**.
Il risultato è simile al seguente:
![\[Risultato del metodo GET on Pets per la chiamata di test\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/api-gateway-create-api-step-by-step-test-invoke-get-on-pets-result-new-console.png)
Ora che il test è andato a buon fine, puoi distribuire l'API per renderla pubblicamente disponibile.
1. Seleziona **Deploy API (Distribuisci API)**.
1. In **Fase**, seleziona **Nuova fase**.
1. In **Stage name (Nome fase)** immettere **Prod**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Seleziona **Implementa**.
1. (Facoltativo) In **Dettagli fase** puoi scegliere l'icona Copia per copiare l'URL di richiamata dell'API in **Richiama URL**. È possibile usare questo valore con strumenti come [Postman](https://www.postman.com) e [cURL](https://curl.se/) per testare l'API.
Se utilizzi un SDK per creare un client, puoi chiamare i metodi esposti dall'SDK per firmare la richiesta. Per maggiori dettagli sull'implementazione, consulta il kit [SDK AWS](https://aws.amazon.com/developer/tools/) scelto.
**Nota**
Se apporti modifiche alla tua API, devi ridistribuirla per fare in modo che le caratteristiche nuove o aggiornate siano disponibili prima di chiamare di nuovo l'URL di richiesta.
## (Facoltativo) Mappatura dei parametri di richiesta
### Mappatura di parametri di richieste per un'API di API Gateway
Questo tutorial illustra come creare il parametro di percorso `{petId}` nella richiesta del metodo dell'API in modo da specificare un ID elemento, mapparlo al parametro di percorso `{id}` nell'URL della richiesta di integrazione e inviare la richiesta all'endpoint HTTP.
**Nota**
Se immetti una lettera maiuscola o minuscola errata, ad esempio una lettera minuscola anziché maiuscola, verranno restituiti errori più avanti nella procedura dettagliata.
#### Fase 1: Creazione delle risorse
In questa fase crei una risorsa con un parametro di percorso \$1petId\$1.
**Per creare la risorsa \$1petId\$1**
1. Seleziona la risorsa **/pets**, quindi scegli **Crea risorsa**.
1. Mantieni l'opzione **Risorsa proxy** disattivata.
1. Per **Percorso risorsa** seleziona **/pets**.
1. Per **Resource Name (Nome risorsa)** immetti **\$1petId\$1**.
Utilizza le parentesi graffe (`{ }`) per racchiudere `petId`, in modo da visualizzare **/pets/\$1petId\$1**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
#### Fase 2: Creazione e test dei metodi
In questa fase crei un metodo `GET` con un parametro di percorso `{petId}`.
**Per configurare il metodo GET**
1. Seleziona la risorsa **/\$1petId\$1**, quindi scegli **Crea metodo**.
1. Per **Tipo di metodo** seleziona **GET**.
1. Per **Tipo di integrazione** seleziona **Integrazione HTTP**.
1. Mantieni l'opzione **Integrazione proxy HTTP** disattivata.
1. Per **Metodo HTTP** seleziona **GET**.
1. Per **URL dell'endpoint** immetti **http://petstore-demo-endpoint.execute-api.com/petstore/pets/\$1id\$1**.
1. Per **Gestione contenuti** seleziona **Transito**.
1. Mantieni attivata l'opzione **Timeout predefinito**.
1. Scegli **Crea metodo**.
A questo punto mappare il parametro di percorso `{petId}` appena creato al parametro di percorso `{id}` nell'URL dell'endpoint HTTP della richiesta di integrazione. L'URL dell'endpoint HTTP è **http://petstore-demo-endpoint.execute-api.com/petstore/pets/\$1id\$1**.
**Per mappare il parametro di percorso `{petId}`**
1. Nella scheda **Richiesta di integrazione** scegli **Modifica** in **Impostazioni della richiesta di integrazione**.
1. Scegli **Parametri di percorso URL**.
1. Gateway API crea un parametro di percorso per la richiesta di integrazione denominato **petId** che tuttavia non è valido per l'URL dell'endpoint HTTP impostato come integrazione backend. L'endpoint HTTP utilizza `{id}` come parametro di percorso. Per **Nome**, elimina **petId** e inserisci **id**.
In questo modo, verrà mappato il parametro di percorso `petId` della richiesta del metodo al parametro di percorso `id` della richiesta di integrazione.
1. Scegli **Save** (Salva).
Quindi testa il metodo.
**Test del metodo **
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. In **Percorso** immetti **4** per **petId**.
1. Scegli **Test (Esegui test)**.
Se il test ha esito positivo, in **Corpo della risposta** viene visualizzato quanto segue:
```
{
"id": 4,
"type": "bird",
"price": 999.99
}
```
#### Fase 3: Distribuzione dell'API
In questa fase, viene distribuita l'API per poter iniziare a richiamarla esternamente alla console API Gateway.
**Per distribuire l'API**
1. Seleziona **Deploy API (Distribuisci API)**.
1. Per **Fase** seleziona **Produzione**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Selezionare **Deploy (Distribuisci)**.
#### Fase 4: Test dell'API
In questa fase verrà chiusa la console API Gateway e utilizzata l'API per accedere all'endpoint HTTP.
1. Nel pannello di navigazione principale scegli **Fase**.
1. In **Dettagli fase**, scegli l'icona Copia per copiare l'URL di richiamo dell'API.
Dovrebbe essere simile a quanto segue:
```
https://my-api-id.execute-api.region-id.amazonaws.com/prod
```
1. Inserisci questo URL nella casella dell'indirizzo di una nuova scheda del browser e aggiungi `/pets/4` all'URL prima di inviare la richiesta.
1. Il browser restituirà quanto segue:
```
{
"id": 4,
"type": "bird",
"price": 999.99
}
```
#### Fasi successive
Puoi personalizzare ulteriormente la tua API attivando la convalida delle richieste, trasformando i dati o creando risposte del gateway personalizzate.
Per scoprire altri modi per personalizzare l'API, consulta i seguenti tutorial:
+ Per ulteriori informazioni sulla convalida della richiesta, consulta [Configurazione della convalida di base delle richieste in API Gateway](api-gateway-request-validation-set-up.md).
+ Per informazioni su come trasformare i payload di richiesta e risposta, consulta [Tutorial: modifica la richiesta e la risposta di integrazione per le integrazioni ai servizi AWS](set-up-data-transformations-in-api-gateway.md).
+ Per informazioni su come creare risposte del gateway personalizzate, consulta [Impostare una risposta del gateway per un'API REST utilizzando la console API Gateway](set-up-gateway-response-using-the-console.md).
# Tutorial: creazione di una REST API con un'integrazione privata
In questo tutorial, crei un'API REST che si connette a un servizio Amazon ECS eseguito in un Amazon VPC. I clienti al di fuori del tuo Amazon VPC possono utilizzare l'API per accedere al tuo servizio Amazon ECS.
Questo tutorial dura circa un'ora. Innanzitutto, utilizzi un CloudFormation modello per creare un servizio Amazon VPC e Amazon ECS. Quindi utilizzi la console API Gateway per creare un collegamento VPC V2. Il link VPC consente ad API Gateway di accedere al servizio Amazon ECS eseguito nel tuo VPC Amazon. Successivamente, crei un'API REST che utilizza il collegamento VPC V2 per connettersi al tuo servizio Amazon ECS. Infine, si esegue il dell'API.
Quando richiami la tua API REST, API Gateway indirizza la richiesta al tuo servizio Amazon ECS tramite il tuo link VPC V2, quindi restituisce la risposta dal servizio.
**Nota**
Questo tutorial era precedentemente supportato per HTTP APIs e ora è supportato per REST APIs utilizzando VPC link V2.
![\[Panoramica della REST API creata in questo tutorial.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/private-integration-rest.png)
Per completare questo tutorial, sono necessari un AWS account e un AWS Identity and Access Management utente con accesso alla console. Per ulteriori informazioni, consulta [Configurazione per l'utilizzo di Gateway API](setting-up.md).
**Topics**
+ [Fase 1: Creazione di un servizio Amazon ECS](#rest-api-private-integration-create-ecs-service)
+ [Fase 2: Creazione di un link VPC](#http-api-private-integration-vpc-link)
+ [Fase 3: Creare un'API REST](#http-api-private-integration-create-api)
+ [Fase 4: Testa la tua API](#rest-api-private-integration-test-api)
+ [Fase 5: distribuzione dell'API](#rest-api-private-integration-deploy-api)
+ [Fase 6: Chiama la tua API](#rest-api-private-integration-call)
+ [Fase 7: pulire](#rest-api-private-integration-cleanup)
## Fase 1: Creazione di un servizio Amazon ECS
Amazon ECS è un servizio di gestione dei container che facilita l'esecuzione, l'arresto e la gestione di container Docker in un cluster. In questo tutorial eseguirai il cluster su un'infrastruttura serverless gestita da Amazon ECS.
Scarica e decomprimi [questo CloudFormation modello](samples/rest-private-integration-tutorial.zip), che crea tutte le dipendenze per il servizio, incluso un Amazon VPC. Si utilizza il modello per creare un servizio Amazon ECS che utilizza un Application Load Balancer.
**Per creare uno stack CloudFormation**
1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Scegliere **Create stack (Crea stack)**, quindi **With new resources (standard) (Con nuove risorse (standard))**.
1. In **Specificare modello**, scegliere **Carica un file modello**.
1. Selezionare il modello scaricato.
1. Scegli **Next (Successivo)**.
1. Per **Stack name (Nome stack)**, inserire **rest-api-private-integrations-tutorial**, quindi scegliere **Next (Avanti)**.
1. Per **Configure stack options (Configura opzioni di stack)**, scegliere **Next (Successivo)**.
1. Per quanto riguarda **le funzionalità**, riconosci che CloudFormation puoi creare risorse IAM nel tuo account.
1. Scegli **Avanti**, quindi scegli **Invia**.
CloudFormation esegue il provisioning del servizio ECS, operazione che può richiedere alcuni minuti. Quando lo stato del tuo CloudFormation stack è **CREATE\$1COMPLETE**, sei pronto per passare alla fase successiva.
## Fase 2: Creazione di un link VPC
Un link VPC consente ad API Gateway di accedere alle risorse private in un VPC Amazon. Utilizzi un link VPC per consentire ai clienti di accedere al tuo servizio Amazon ECS tramite la tua API REST.
**Per creare un link VPC**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Nel pannello di navigazione principale scegli **Collegamenti VPC** e quindi **Crea**.
È possibile che per aprire il pannello di navigazione principale sia necessario scegliere l'icona del menu.
1. Per **Scegli una versione di collegamento VPC, seleziona VPC link** **V2**.
1. In **Name (Nome)**, immettere **private-integrations-tutorial**.
1. Per **VPC** scegliere il VPC creato nella fase 1. Il nome deve iniziare con **RestApiStack**.
1. Per **Sottoreti**, selezionare le due sottoreti private nel VPC. I nomi finiscono con `PrivateSubnet`.
1. Per **Gruppi di sicurezza** seleziona l'ID gruppo che inizia con `private-integrations-tutorial` e ha la descrizione `RestApiStack/RestApiTutorialService/Service/SecurityGroup`.
1. Scegli **Create** (Crea).
Dopo aver creato il tuo VPC link V2, API Gateway fornisce interfacce di rete elastiche per accedere al tuo VPC. Il processo può richiedere alcuni minuti. Nel frattempo, puoi creare la tua API.
## Fase 3: Creare un'API REST
L'API REST fornisce un endpoint HTTP per il tuo servizio Amazon ECS.
**Creazione di una REST API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegli **Create API (Crea API)**, quindi per **API REST**, scegli **Build (Crea)**.
1. Per **Nome**, immetti **private-integration-api**.
1. Per il tipo di **indirizzo IP**, selezionare. **IPv4**
1. Seleziona **Create API** (Crea API).
Dopo aver creato l'API, crei un metodo.
1. Scegli **Crea metodo** e procedi come descritto di seguito:
1. In **Tipo di metodo**, seleziona `GET`.
1. In **Tipo di integrazione** seleziona **Collegamento VPC**.
1. Attiva l'opzione **Integrazione proxy VPC**.
1. Per **Metodo HTTP** seleziona `GET`.
1. Per il collegamento **VPC, scegli il collegamento** VPC V2 che hai creato nel passaggio precedente.
1. Per **Integration Target**, inserisci il load balancer che hai creato con il CloudFormation modello nel passaggio 1. Il nome dovrebbe iniziare con **rest-.**
1. Per **URL dell'endpoint** immetti `http://private-integrations-tutorial.com`.
L'URL viene utilizzato per impostare l'`Host`intestazione della richiesta di integrazione. In questo caso, l'intestazione dell'host è. **private-integrations-tutorial**
1. Scegli **Crea metodo**.
Con l'integrazione del proxy, l'API è pronta per essere testata.
## Fase 4: Testa la tua API
Successivamente, provi a richiamare il metodo API.
**Per testare l'API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. **Scegli Test**
Verifica che la risposta della tua API sia un messaggio di benvenuto che indica che la tua app è in esecuzione su Amazon ECS.
## Fase 5: distribuzione dell'API
Successivamente, distribuisci la tua API.
**Per distribuire l'API**
1. Seleziona **Deploy API (Distribuisci API)**.
1. In **Fase**, seleziona **Nuova fase**.
1. In **Stage name (Nome fase)** immettere **Prod**.
1. (Facoltativo) In **Description (Descrizione)**, immettere una descrizione.
1. Seleziona **Deploy (Implementa)**.
## Fase 6: Chiama la tua API
Dopo aver distribuito l'API, puoi chiamarla.
**Per chiamare la tua API**
1. Immetti l'URL di richiamo in un browser Web.
L'URL completo dovrebbe essere del tipo `https://abcd123.execute-api.us-east-2.amazonaws.com/Prod`.
Il tuo browser invia una richiesta `GET` all'API.
1. Verifica che la risposta della tua API sia un messaggio di benvenuto che indica che la tua app è in esecuzione su Amazon ECS.
Se vedi il messaggio di benvenuto, significa che hai creato con successo un servizio Amazon ECS che viene eseguito in un Amazon VPC e hai utilizzato un'API API Gateway REST con un collegamento VPC V2 per accedere al servizio Amazon ECS.
## Fase 7: pulire
Per evitare costi non necessari, eliminare le risorse create nell'ambito di questo tutorial. I passaggi seguenti eliminano il collegamento VPC V2, lo CloudFormation stack e l'API REST.
**Per eliminare un'API REST**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Nella **APIs**pagina, seleziona un'API. Scegliere **Azioni**, scegliere **Elimina**, quindi confermare la scelta.
**Per eliminare un link VPC**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere **link VPC**.
1. Selezionare il link VPC, scegliere **Elimina**, quindi confermare la scelta.
**Per eliminare uno stack CloudFormation**
1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Seleziona il tuo stack. CloudFormation
1. Scegli **Elimina** e conferma la tua scelta.
# Tutorial: creare un'API REST con un' AWS integrazione
Gli argomenti [Tutorial: creazione di una REST API con un'integrazione proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md) e [Tutorial: creazione di una REST API con un'integrazione non proxy Lambda](getting-started-lambda-non-proxy-integration.md) descrivono entrambi come creare un'API di API Gateway per esporre la funzione Lambda integrata. Inoltre, puoi creare un'API API Gateway per esporre altri AWS servizi, come Amazon SNS, Amazon S3, Amazon Kinesis e persino. AWS Lambda Questo è possibile grazie all'integrazione di `AWS`. L'integrazione Lambda o l'integrazione proxy Lambda è un caso speciale, in cui la chiamata della funzione Lambda viene esposta tramite l'API di API Gateway.
Tutti i AWS servizi supportano un supporto dedicato per esporre APIs le proprie funzionalità. Tuttavia, è probabile che i protocolli applicativi o le interfacce di programmazione differiscano da servizio a servizio. Un'API API Gateway con `AWS` integrazione ha il vantaggio di fornire un protocollo applicativo coerente per consentire al cliente di accedere a diversi AWS servizi.
In questa procedura guidata creeremo un'API per esporre Amazon SNS. Per altri esempi di integrazione di un'API con altri AWS servizi, consulta[Tutorial e workshop di Amazon API Gateway](api-gateway-tutorials.md).
Diversamente dall'integrazione proxy Lambda, non esiste un'integrazione proxy corrispondente per altri servizi AWS . Pertanto, un metodo API è integrato con una singola AWS azione. Per ottenere maggiore flessibilità, analogamente all'integrazione proxy, puoi configurare l'integrazione proxy Lambda. La funzione Lambda quindi analizza ed elabora le richieste di altre azioni. AWS
API Gateway non esegue un nuovo tentativo quando si verifica il timeout dell'endpoint. La chiamata API deve implementare una logica di ripetizione per gestire i timeout degli endpoint.
Questa procedura dettagliata si basa sulle istruzioni e sui concetti riportati in [Tutorial: creazione di una REST API con un'integrazione non proxy Lambda](getting-started-lambda-non-proxy-integration.md). Se la procedura dettagliata non è ancora stata completata, è consigliabile eseguirla ora prima di proseguire.
**Topics**
+ [Prerequisiti](#getting-started-aws-proxy-prerequisites)
+ [Fase 1: creare il ruolo di esecuzione del proxy del AWS servizio](#getting-started-aws-proxy-add-roles)
+ [Fase 2: creazione della risorsa](#getting-started-aws-proxy-add-resources)
+ [Fase 3: creazione del metodo GET](#getting-started-aws-proxy-add-methods)
+ [Fase 4: specifica delle impostazioni del metodo e test del metodo](#getting-started-aws-proxy-set-methods)
+ [Fase 5: distribuzione dell'API](#getting-started-aws-proxy-deploy)
+ [Fase 6: test dell'API](#getting-started-aws-proxy-test)
+ [Fase 7: pulire](#getting-started-aws-proxy-clean-up)
## Prerequisiti
Prima di iniziare questa procedura guidata, esegui queste operazioni:
1. Completa le fasi descritte in [Configurazione per l'utilizzo di Gateway API](setting-up.md).
1. Crea una nuova API denominata `MyDemoAPI`. Per ulteriori informazioni, consulta [Tutorial: creazione di una REST API con un'integrazione non proxy HTTP](api-gateway-create-api-step-by-step.md).
1. Distribuisci l'API almeno una volta in una fase denominata `test`. Per ulteriori informazioni, consulta la pagina relativa alla [distribuzione dell'API](getting-started-lambda-non-proxy-integration.md#getting-started-deploy-api) in [Scegli un tutorial di integrazione AWS Lambda](getting-started-with-lambda-integration.md).
1. Completa le altre fasi descritte in [Scegli un tutorial di integrazione AWS Lambda](getting-started-with-lambda-integration.md).
1. Crea almeno un argomento in Amazon Simple Notification Service (Amazon SNS). Utilizzerai l'API distribuita per ottenere un elenco di argomenti in Amazon SNS associati AWS al tuo account. Per informazioni su come creare un argomento in Amazon SNS, consulta [Creazione di un argomento](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html). Non devi copiare l'ARN dell'argomento citato nella fase 5.
## Fase 1: creare il ruolo di esecuzione del proxy del AWS servizio
Per permettere all'API di richiamare le operazioni Amazon SNS necessarie, devi aver collegato le policy IAM appropriate a un ruolo IAM. In questo passaggio si crea un nuovo ruolo IAM.
**Per creare il ruolo di esecuzione del proxy di AWS servizio**
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Scegliere **Roles (Ruoli)**.
1. Scegli **Crea ruolo**.
1. Scegli il **AWS servizio** in **Seleziona il tipo di entità affidabile**, quindi seleziona **API Gateway** e seleziona Consenti **a API Gateway di inviare i log ai CloudWatch log**.
1. Scegli **Successivo** e di nuovo **Successivo**.
1. In **Role name (Nome ruolo)** immettere **APIGatewaySNSProxyPolicy** e quindi selezionare **Create role (Crea ruolo)**.
1. Nell'elenco **Roles (Ruoli)** scegliere il ruolo appena creato. Potrebbe essere necessario scorrere o utilizzare la barra di ricerca per trovare il ruolo.
1. Per il ruolo selezionato, seleziona la scheda **Aggiungi autorizzazioni**.
1. Dall'elenco a discesa scegli **Collega policy**.
1. Nella barra di ricerca inserisci **AmazonSNSReadOnlyAccess** e scegli **Aggiungi autorizzazioni**.
**Nota**
Per semplicità, questo tutorial utilizza una policy gestita. Come best practice, dovresti creare la tua policy IAM per concedere le autorizzazioni minime richieste.
1. Annota l'**ARN del ruolo** appena creato, lo utilizzerai in seguito.
## Fase 2: creazione della risorsa
In questo passaggio, crei una risorsa che consente al proxy del AWS servizio di interagire con il AWS servizio.
**Per creare la risorsa**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Seleziona la risorsa root **/**, rappresentata da una singola barra (**/**), quindi scegli **Crea risorsa**.
1. Mantieni l'opzione **Risorsa proxy** disattivata.
1. Mantieni **Percorso risorsa** impostato su `/`.
1. Per **Resource Name (Nome risorsa)** immetti **mydemoawsproxy**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
## Fase 3: creazione del metodo GET
In questo passaggio, si crea un metodo GET che consente al proxy del AWS servizio di interagire con il servizio. AWS
**Per creare il metodo `GET`**
1. Seleziona la risorsa **/mydemoawsproxy**, quindi scegli **Crea metodo**.
1. Per Tipo di metodo seleziona **GET**.
1. Per **Tipo di integrazione** seleziona **Servizio AWS**.
1. Per **Regione AWS**, seleziona l'argomento Regione AWS in cui hai creato il tuo Amazon SNS.
1. Per **Servizio AWS** seleziona **Amazon SNS**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **Metodo HTTP** seleziona **GET**.
1. Per **Tipo di operazione** scegli **Usa nome operazione**.
1. Per **Nome azione** immetti **ListTopics**.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo per **APIGatewaySNSProxyPolicy**.
1. Scegli **Crea metodo**.
## Fase 4: specifica delle impostazioni del metodo e test del metodo
A questo punto puoi testare il metodo `GET` per verificare che sia stato configurato correttamente per elencare gli argomenti Amazon SNS.
**Test del metodo `GET`**
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. Scegli **Test (Esegui test)**.
Il risultato mostra una risposta simile a quella riportata di seguito:
```
{
"ListTopicsResponse": {
"ListTopicsResult": {
"NextToken": null,
"Topics": [
{
"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-1"
},
{
"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-2"
},
...
{
"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-N"
}
]
},
"ResponseMetadata": {
"RequestId": "abc1de23-45fa-6789-b0c1-d2e345fa6b78"
}
}
}
```
## Fase 5: distribuzione dell'API
In questa fase, viene distribuita l'API per poterla chiamare esternamente alla console API Gateway.
**Per distribuire l'API**
1. Seleziona **Deploy API (Distribuisci API)**.
1. In **Fase**, seleziona **Nuova fase**.
1. In **Stage name (Nome fase)** immettere **test**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Selezionare **Deploy (Distribuisci)**.
## Fase 6: test dell'API
In questa fase, esci dalla console API Gateway e utilizzi il proxy del AWS servizio per interagire con il servizio Amazon SNS.
1. Nel pannello di navigazione principale scegli **Fase**.
1. In **Dettagli fase**, scegli l'icona Copia per copiare l'URL di richiamo dell'API.
L'URL dovrebbe essere simile a questo:
```
https://my-api-id.execute-api.region-id.amazonaws.com/test
```
1. Immetti l'URL nella barra degli indirizzi di una nuova scheda del browser.
1. Aggiungi `/mydemoawsproxy` in modo che l'URL sia simile al seguente:
```
https://my-api-id.execute-api.region-id.amazonaws.com/test/mydemoawsproxy
```
Accedi all'URL. Verranno visualizzate informazioni simili alle seguenti:
```
{"ListTopicsResponse":{"ListTopicsResult":{"NextToken": null,"Topics":[{"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-1"},{"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-2"},...{"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-N}]},"ResponseMetadata":{"RequestId":"abc1de23-45fa-6789-b0c1-d2e345fa6b78}}}
```
## Fase 7: pulire
Puoi eliminare le risorse IAM necessarie al proxy del AWS servizio per funzionare.
**avvertimento**
Se elimini una risorsa IAM su cui si basa un proxy di AWS servizio, quel proxy di AWS servizio e tutti quelli APIs che si basano su di essa non funzioneranno più. L'eliminazione di una risorsa IAM non può essere annullata. Per usare di nuovo la risorsa IAM, è necessario ricrearla.
**Per eliminare le risorse IAM associate**
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nell'area **Details (Dettagli)** scegliere **Roles (Ruoli)**.
1. Selezionare **APIGatewayAWSProxyExecRole** e quindi scegliere **Role Actions (Operazioni ruolo)**, **Delete Role (Elimina ruolo)**. Quando viene richiesto, scegliere **Yes, Delete (Sì, elimina)**.
1. Nell'area **Details (Dettagli)** scegliere **Policies (Policy)**.
1. Selezionare **APIGatewayAWSProxyExecPolicy** e quindi scegliere **Policy actions (Operazioni policy)**, **Delete (Elimina)**. Quando viene richiesto, scegliere **Delete (Elimina)**.
Hai completato questa procedura guidata. Per discussioni più dettagliate sulla creazione di API come proxy di AWS servizio, consulta [Tutorial: creazione di una REST API come un proxy Amazon S3](integrating-api-with-aws-services-s3.md)[Tutorial: crea un'API REST per calcolatrice con due integrazioni AWS di servizi e un'integrazione non proxy Lambda](integrating-api-with-aws-services-lambda.md), o[Tutorial: creazione di un'API REST come un proxy Amazon Kinesis](integrating-api-with-aws-services-kinesis.md).
# Tutorial: crea un'API REST per calcolatrice con due integrazioni AWS di servizi e un'integrazione non proxy Lambda
[Tutorial: creazione di una REST API con un'integrazione non proxy Lambda](getting-started-lambda-non-proxy-integration.md) utilizza esclusivamente l'integrazione `Lambda Function`. L'integrazione `Lambda Function` è un caso speciale del tipo di integrazione `AWS Service` in cui gran parte delle operazioni di configurazione dell'integrazione vengono eseguite automaticamente, ad esempio l'aggiunta automatica delle autorizzazioni basate su risorse necessarie per invocare la funzione Lambda. In questo caso, due integrazioni su tre utilizzano l'integrazione `AWS Service`. Questo tipo di integrazione offre un controllo maggiore, ma richiede l'esecuzione manuale di attività come la creazione e la definizione di un ruolo IAM contenente le autorizzazioni appropriate.
In questo tutorial verrà creata una funzione Lambda `Calc` che implementa operazioni aritmetiche di base, accettando e restituendo input e output in formato JSON. Verrà quindi creata un'API REST, che verrà integrata con la funzione Lambda nei modi seguenti:
1. Esponendo un metodo `GET` nella risorsa `/calc` per richiamare la funzione Lambda, fornendo l'input sotto forma di parametri delle stringhe di query (integrazione `AWS Service`).
1. Esponendo un metodo `POST` nella risorsa `/calc` per richiamare la funzione Lambda, fornendo l'input nel payload della richiesta del metodo (integrazione `AWS Service`).
1. Esponendo un metodo `GET` nelle risorse `/calc/{operand1}/{operand2}/{operator}` nidificate per richiamare la funzione Lambda, fornendo l'input sotto forma di parametri di percorso (integrazione `Lambda Function`).
Oltre a provare questo tutorial, puoi esaminare il [file di definizione OpenAPI](api-as-lambda-proxy-export-swagger-with-extensions.md) per l'API `Calc`, che è possibile importare in API Gateway seguendo le istruzioni in [Sviluppa REST APIs utilizzando OpenAPI in API Gateway](api-gateway-import-api.md).
**Topics**
+ [Creazione di un ruolo IAM prevedibile](#api-as-lambda-proxy-setup-iam-role-policies)
+ [Creazione di una funzione Lambda `Calc`](#api-as-lambda-proxy-create-lambda-function)
+ [Test della funzione Lambda `Calc`](#api-as-lambda-proxy-test-lambda-function-)
+ [Creazione di un'API `Calc`](#api-as-lambda-proxy-create-api-resources)
+ [Integrazione 1: creazione di un metodo `GET` con parametri di query per chiamare la funzione Lambda](#api-as-lambda-proxy-expose-get-method-with-query-strings-to-call-lambda-function)
+ [Integrazione 2: creazione di un metodo `POST` con un payload JSON per chiamare la funzione Lambda](#api-as-lambda-proxy-expose-post-method-with-json-body-to-call-lambda-function)
+ [Integrazione 3: creazione di un metodo `GET` con parametri di percorso per chiamare la funzione Lambda](#api-as-lambda-proxy-expose-get-method-with-path-parameters-to-call-lambda-function)
+ [Definizioni OpenAPI di un'API di esempio integrata con una funzione Lambda](api-as-lambda-proxy-export-swagger-with-extensions.md)
## Creazione di un ruolo IAM prevedibile
Affinché l'API possa richiamare la funzione Lambda `Calc`, è necessario un ruolo IAM API Gateway prevedibile, ovvero un ruolo IAM con la relazione di trust seguente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "apigateway.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Il ruolo che crei dovrà avere l'autorizzazione Lambda [InvokeFunction](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html). In caso contrario, il chiamante dell'API riceverà una risposta `500 Internal Server Error`. Per assegnare al ruolo questa autorizzazione, è necessario collegare al ruolo la policy IAM seguente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "*"
}
]
}
```
------
Ecco come procedere:
**Creazione di un ruolo IAM API Gateway prevedibile**
1. Accedi alla console IAM.
1. Scegliere **Roles (Ruoli)**.
1. Seleziona **Create Role (Crea ruolo)**.
1. In **Select type of trusted entity (Seleziona tipo di entità attendibile)**, scegli **AWS Service**.
1. In **Choose the service that will use this role (Scegli il servizio che utilizzerà questo ruolo)**, seleziona **Lambda**.
1. Scegli **Next: Permissions (Successivo: Autorizzazioni)**.
1. Selezionare **Create Policy (Crea policy)**.
Si aprirà una nuova finestra **Create Policy** (Crea policy) della console. Nella finestra procedi nel seguente modo:
1. Nella scheda **JSON**, sostituisci la policy esistente con la seguente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "*"
}
]
}
```
------
1. Scegliere **Review policy (Esamina policy)**.
1. In**Review Policy** (Rivedi policy), effettua le operazioni seguenti:
1. In **Name** (Nome), digita un nome, ad esempio **lambda\$1execute**.
1. Selezionare **Create Policy (Crea policy)**.
1. Nella finestra **Create Role** (Crea ruolo) originaria della console, procedi nel seguente modo:
1. In **Attach permissions policies** (Collega policy delle autorizzazioni), scegli la tua policy **lambda\$1execute** dall'elenco a discesa.
Se la policy non è visualizzata nell'elenco, scegliere il pulsante di aggiornamento in alto. Non aggiornare la pagina del browser.
1. Scegliere **Next: Tags (Successivo: Tag)**.
1. Scegli **Next:Review** (Successivo:Rivedi).
1. Per **Role name** (Nome ruolo), digita un nome, ad esempio **lambda\$1invoke\$1function\$1assume\$1apigw\$1role**.
1. Seleziona **Create role** (Crea ruolo).
1. Seleziona il tuo **lambda\$1invoke\$1function\$1assume\$1apigw\$1role** nell'elenco dei ruoli.
1. Seleziona la scheda **Trust relationships** (Relazioni di trust).
1. Seleziona **Edit trust relationship (Modifica relazione di trust)**.
1. Sostituisci la policy esistente con la seguente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"lambda.amazonaws.com",
"apigateway.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Selezionare **Update Trust Policy (Aggiorna policy di trust)**.
1. Prendi nota dell'ARN per il ruolo appena creato. Sarà necessario in seguito.
## Creazione di una funzione Lambda `Calc`
Verrà quindi creata una funzione Lambda utilizzando la console Lambda.
1. Nella console Lambda, scegliere **Create function (Crea funzione)**.
1. Scegli **Author from Scratch** (Crea da zero).
1. In **Name (Nome)**, immettere **Calc**.
1. Per **Runtime**, scegli l'ultimo runtime supportato di **Node.js** o di **Python**.
1. Utilizza le impostazioni predefinite per tutte le altre opzioni.
1. Scegli **Crea funzione**.
1. Copia la seguente funzione Lambda e incollala nel runtime preferito e nell'editor di codice nella console Lambda.
------
#### [ Node.js ]
```
export const handler = async function (event, context) {
console.log("Received event:", JSON.stringify(event));
if (
event.a === undefined ||
event.b === undefined ||
event.op === undefined
) {
return "400 Invalid Input";
}
const res = {};
res.a = Number(event.a);
res.b = Number(event.b);
res.op = event.op;
if (isNaN(event.a) || isNaN(event.b)) {
return "400 Invalid Operand";
}
switch (event.op) {
case "+":
case "add":
res.c = res.a + res.b;
break;
case "-":
case "sub":
res.c = res.a - res.b;
break;
case "*":
case "mul":
res.c = res.a * res.b;
break;
case "/":
case "div":
if (res.b == 0) {
return "400 Divide by Zero";
} else {
res.c = res.a / res.b;
}
break;
default:
return "400 Invalid Operator";
}
return res;
};
```
------
#### [ Python ]
```
import json
def lambda_handler(event, context):
print(event)
try:
(event['a']) and (event['b']) and (event['op'])
except KeyError:
return '400 Invalid Input'
try:
res = {
"a": float(
event['a']), "b": float(
event['b']), "op": event['op']}
except ValueError:
return '400 Invalid Operand'
if event['op'] == '+':
res['c'] = res['a'] + res['b']
elif event['op'] == '-':
res['c'] = res['a'] - res['b']
elif event['op'] == '*':
res['c'] = res['a'] * res['b']
elif event['op'] == '/':
if res['b'] == 0:
return '400 Divide by Zero'
else:
res['c'] = res['a'] / res['b']
else:
return '400 Invalid Operator'
return res
```
------
1. In Execution role (Ruolo di esecuzione) scegliere **Choose an existing role (Scegli un ruolo esistente)**.
1. Immettere l'ARN per il ruolo **lambda\$1invoke\$1function\$1assume\$1apigw\$1role** creato in precedenza.
1. Selezionare **Deploy (Distribuisci)**.
Questa funzione richiede due operandi (`a` e `b`) e un operatore (`op`) del parametro di input `event`. L'input è un oggetto JSON con il formato seguente:
```
{
"a": "Number" | "String",
"b": "Number" | "String",
"op": "String"
}
```
Questa funzione restituisce il risultato calcolato (`c`) e l'input. Per un input non valido, la funzione restituisce il valore null o la stringa "Invalid op" come risultato. L'output ha il formato JSON seguente:
```
{
"a": "Number",
"b": "Number",
"op": "String",
"c": "Number" | "String"
}
```
Prima dell'integrazione con l'API nella fase successiva, è necessario testare la funzione nella console Lambda.
## Test della funzione Lambda `Calc`
Di seguito viene descritto come testare la funzione `Calc` nella console Lambda:
1. Seleziona la scheda **Test**.
1. Come nome dell'evento di test, immettere **calc2plus5**.
1. Sostituire la definizione dell'evento di test con quanto segue:
```
{
"a": "2",
"b": "5",
"op": "+"
}
```
1. Scegli **Save (Salva)**.
1. Scegli **Test (Esegui test)**.
1. Espandere **Execution result: succeeded (Risultato esecuzione: riuscita)**. Verrà visualizzato un codice analogo al seguente:
```
{
"a": 2,
"b": 5,
"op": "+",
"c": 7
}
```
## Creazione di un'API `Calc`
Nella procedura seguente viene illustrato come creare un'API per la funzione Lambda `Calc` appena creata. Nelle sezioni successive verranno aggiunti metodi e risorse.
**Come creare un’API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Se si utilizza API Gateway per la prima volta, verrà visualizzata una pagina che presenta le caratteristiche del servizio. In **API REST**, scegliere **Crea**. Quando appare il popup **Create Example API (Crea API di esempio)**, scegliere **OK**.
Se non è la prima volta che si utilizza API Gateway, scegliere **Create API (Crea API)**. In **API REST**, scegliere **Crea**.
1. Per **API name (Nome API)**, immettere **LambdaCalc**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Lasciare l'opzione **Tipo di endpoint API** impostata su **Regionale**.
1. Per il tipo di **indirizzo IP**, selezionare. **IPv4**
1. Seleziona **Create API** (Crea API).
## Integrazione 1: creazione di un metodo `GET` con parametri di query per chiamare la funzione Lambda
Creando un metodo `GET` che passa i parametri delle stringhe di query alla funzione Lambda, si permette all'API di essere richiamata da un browser. Questo approccio può essere utile, soprattutto APIs perché consente l'accesso aperto.
Dopo l'API, è necessario creare una risorsa. In genere, le risorse API sono organizzate in una struttura di risorse in base alla logica dell'applicazione. In questa fase crei una risorsa **/calc**.
**Per creare una risorsa **/calc****
1. Scegli **Crea risorsa**.
1. Mantieni l'opzione **Risorsa proxy** disattivata.
1. Mantieni **Percorso risorsa** impostato su `/`.
1. Per **Resource Name (Nome risorsa)** immetti **calc**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
Creando un metodo `GET` che passa i parametri delle stringhe di query alla funzione Lambda, si permette all'API di essere richiamata da un browser. Questo approccio può essere utile, soprattutto APIs perché consente l'accesso aperto.
Con questo metodo, Lambda richiede che venga usata la richiesta `POST` per richiamare qualsiasi funzione Lambda. Questo esempio mostra che il metodo HTTP in una richiesta del metodo di front-end può essere diverso dalla richiesta di integrazione nel back-end.
**Creazione di un metodo `GET`**
1. Seleziona la risorsa **/calc** quindi scegli **Crea metodo**.
1. Per **Tipo di metodo** seleziona **GET**.
1. Per **Tipo di integrazione** seleziona **Servizio AWS**.
1. Per **Regione AWS**, seleziona il Regione AWS luogo in cui hai creato la tua funzione Lambda.
1. Per **Servizio AWS** seleziona **Lambda**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **Metodo HTTP** seleziona **POST**.
1. In **Tipo di operazione** scegli **Utilizza sostituzione percorso**. Questa opzione permette di specificare l'ARN dell'operazione [Invoke (Richiama)](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html) per eseguire la funzione `Calc`.
1. Per **Sostituzione percorso** immetti **2015-03-31/functions/arn:aws:lambda:*us-east-2*:*account-id*:function:Calc/invocations**. Per** *account-id***, inserisci il tuo Account AWS ID. Per***us-east-2***, inserisci Regione AWS dove hai creato la tua funzione Lambda.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo per **lambda\$1invoke\$1function\$1assume\$1apigw\$1role**.
1. Non modificare le impostazioni di **Cache delle credenziali** e **Timeout predefinito**.
1. Scegli **Impostazioni della richiesta del metodo**.
1. Per **Validatore richiesta** seleziona **Convalida parametri di stringa query e intestazioni**.
Questa impostazione restituisce un messaggio di errore se il client non specifica i parametri obbligatori.
1. Scegli **Parametri della stringa di query URL**.
A questo punto si configurano i parametri della stringa di query per il metodo **GET** sulla risorsa **/calc** in modo da poter ricevere l'input per conto della funzione Lambda di backend.
Per creare i parametri della stringa di query, procedi come indicato di seguito:
1. Scegliere **Add query string (Aggiungi stringa di query)**.
1. In **Nome**, inserisci **operand1**.
1. Attiva **Campo obbligatorio**.
1. Mantieni disattivata l'opzione **Caching**.
Ripeti le stesse fasi e crea una stringa di query denominata **operand2** e una stringa di query denominata **operator**.
1. Scegli **Crea metodo**.
A questo punto crea un modello di mappatura per tradurre le stringhe di query fornite dal client in payload di richiesta di integrazione, come richiesto dalla funzione `Calc`. Questo modello mappa i tre parametri della stringa di query dichiarati in **Richiesta metodo** in valori di proprietà designati dell'oggetto JSON come input per la funzione Lambda di back-end. L'oggetto JSON trasformato verrà incluso come payload di richiesta di integrazione.
**Per mappare i parametri di input alla richiesta di integrazione**
1. Nella scheda **Richiesta di integrazione** scegli **Modifica** in **Impostazioni della richiesta di integrazione**.
1. Per **Richiesta corpo passthrough** scegli **Quando non ci sono modelli definiti (consigliato)**.
1. Scegli **Modelli di mappatura**.
1. Scegliere **Add mapping template (Aggiungi modello di mappatura)**.
1. Per **Tipo di contenuto** inserisci **application/json**.
1. Per **Corpo del modello** inserisci il seguente codice:
```
{
"a": "$input.params('operand1')",
"b": "$input.params('operand2')",
"op": "$input.params('operator')"
}
```
1. Scegli **Save** (Salva).
È ora possibile testare il metodo `GET` per verificare che sia stato configurato correttamente per richiamare la funzione Lambda.
**Test del metodo `GET`**
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. In **Stringhe di query** immetti **operand1=2&operand2=3&operator=\$1**.
1. Scegli **Test (Esegui test)**.
I risultati dovrebbero essere simili a quanto segue:
![\[Creazione di un'API in API Gateway come un proxy Lambda\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/aws_proxy_lambda_calc_get_method_test_new_console.png)
## Integrazione 2: creazione di un metodo `POST` con un payload JSON per chiamare la funzione Lambda
Se si crea un metodo `POST` con un payload JSON per chiamare la funzione Lambda, si richiede al client di fornire l'input necessario alla funzione di back-end nel corpo della richiesta. Per garantire che il client carichi i dati di input corretti, verrà abilitata la convalida delle richieste nel payload.
**Per creare un metodo `POST` con un payload JSON**
1. Seleziona la risorsa **/calc** quindi scegli **Crea metodo**.
1. Per **Tipo di metodo** seleziona **POST**.
1. Per **Tipo di integrazione** seleziona **Servizio AWS**.
1. Per **Regione AWS**, seleziona il Regione AWS luogo in cui hai creato la tua funzione Lambda.
1. Per **Servizio AWS** seleziona **Lambda**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **Metodo HTTP** seleziona **POST**.
1. In **Tipo di operazione** scegli **Utilizza sostituzione percorso**. Questa opzione permette di specificare l'ARN dell'operazione [Invoke (Richiama)](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html) per eseguire la funzione `Calc`.
1. Per **Sostituzione percorso** immetti **2015-03-31/functions/arn:aws:lambda:*us-east-2*:*account-id*:function:Calc/invocations**. Per** *account-id***, inserisci il tuo Account AWS ID. Per***us-east-2***, inserisci Regione AWS dove hai creato la tua funzione Lambda.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo per **lambda\$1invoke\$1function\$1assume\$1apigw\$1role**.
1. Non modificare le impostazioni di **Cache delle credenziali** e **Timeout predefinito**.
1. Scegli **Crea metodo**.
A questo punto crea un modello di **input** per descrivere la struttura dei dati di input e convalidare il corpo della richiesta in ingresso.
**Per creare un modello di input**
1. Nel riquadro di navigazione principale seleziona **Modelli**.
1. Scegli **Crea modello**.
1. In **Nome**, inserisci **input**.
1. Per **Tipo di contenuto** inserisci **application/json**.
Se non viene trovato alcun tipo di contenuto corrispondente, la convalida della richiesta non viene eseguita. Per utilizzare lo stesso modello indipendentemente dal tipo di contenuti, inserisci **\$1default**.
1. Per **Schema modello** immetti il seguente modello:
```
{
"type":"object",
"properties":{
"a":{"type":"number"},
"b":{"type":"number"},
"op":{"type":"string"}
},
"title":"input"
}
```
1. Scegli **Crea modello**.
A questo punto crea un modello di **output**. Questo modello descrive la struttura di dati dell'output calcolato del back-end. Può essere usato per mappare i dati della risposta di integrazione a un modello diverso. Questo tutorial è basato sul comportamento di passthrough e non usa questo modello.
**Per creare un modello di output**
1. Scegli **Crea modello**.
1. In **Nome**, inserisci **output**.
1. Per **Tipo di contenuto** inserisci **application/json**.
Se non viene trovato alcun tipo di contenuto corrispondente, la convalida della richiesta non viene eseguita. Per utilizzare lo stesso modello indipendentemente dal tipo di contenuti, inserisci **\$1default**.
1. Per **Schema modello** immetti il seguente modello:
```
{
"type":"object",
"properties":{
"c":{"type":"number"}
},
"title":"output"
}
```
1. Scegli **Crea modello**.
A questo punto crea un modello di **risultato**. Questo modello descrive la struttura dei dati della risposta restituiti. Fa riferimento agli schemi di **input** e **output** definiti nell'API.
**Per creare un modello di risultato**
1. Scegli **Crea modello**.
1. In **Nome**, inserisci **result**.
1. Per **Tipo di contenuto** inserisci **application/json**.
Se non viene trovato alcun tipo di contenuto corrispondente, la convalida della richiesta non viene eseguita. Per utilizzare lo stesso modello indipendentemente dal tipo di contenuti, inserisci **\$1default**.
1. Per **lo schema del modello**, inserisci il seguente modello con il tuo*restapi-id*. Il tuo *restapi-id* è elencato tra parentesi nella parte superiore della console nel seguente flusso: `API Gateway > APIs > LambdaCalc (abc123).`
```
{
"type":"object",
"properties":{
"input":{
"$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/input"
},
"output":{
"$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/output"
}
},
"title":"result"
}
```
1. Scegli **Crea modello**.
A questo punto configura la richiesta del metodo POST per abilitare la convalida della richiesta nel corpo della richiesta in ingresso.
**Abilitazione della convalida della richiesta del metodo POST**
1. Nel pannello di navigazione scegli **Risorse**, quindi seleziona il metodo `POST` nella struttura di risorse.
1. Nella scheda **Richiesta metodo**, in **Impostazioni richiesta metodo**, scegli **Modifica**.
1. Per **Validatore richiesta** seleziona **Convalida corpo**.
1. Scegli **Corpo della richiesta**, quindi seleziona **Aggiungi modello**.
1. Per **Tipo di contenuto** inserisci **application/json**.
Se non viene trovato alcun tipo di contenuto corrispondente, la convalida della richiesta non viene eseguita. Per utilizzare lo stesso modello indipendentemente dal tipo di contenuti, inserisci **\$1default**.
1. Per **Modello** seleziona **input**.
1. Scegli **Save** (Salva).
È ora possibile testare il metodo `POST` per verificare che sia stato configurato correttamente per richiamare la funzione Lambda.
**Test del metodo `POST`**
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. Per **Corpo della richiesta** immetti il payload JSON seguente.
```
{
"a": 1,
"b": 2,
"op": "+"
}
```
1. Scegli **Test (Esegui test)**.
Verrà visualizzato l’output seguente:
```
{
"a": 1,
"b": 2,
"op": "+",
"c": 3
}
```
## Integrazione 3: creazione di un metodo `GET` con parametri di percorso per chiamare la funzione Lambda
Verrà ora creato un metodo `GET` in una risorsa specificata da una sequenza di parametri di percorso per chiamare la funzione Lambda di back-end. I valori dei parametri di percorso specificano i dati di input per la funzione Lambda. Verrà usato un modello di mappatura per mappare i valori dei parametri di percorso in ingresso al payload di richiesta di integrazione necessario.
La struttura della risorsa API risultante sarà la seguente:
![\[Creazione di un'API in API Gateway come un proxy Lambda\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/aws_proxy_lambda_create_api_resources_new_console.png)
**Per creare una risorsa **/\$1operand1\$1/\$1operand2\$1/\$1operator\$1****
1. Scegli **Crea risorsa**.
1. Per **Percorso risorsa** seleziona `/calc`.
1. Per **Resource Name (Nome risorsa)** immetti **\$1operand1\$1**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
1. Per **Percorso risorsa** seleziona `/calc/{operand1}/`.
1. Per **Resource Name (Nome risorsa)** immetti **\$1operand2\$1**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
1. Per **Percorso risorsa** seleziona `/calc/{operand1}/{operand2}/`.
1. Per **Resource Name (Nome risorsa)** immetti **\$1operator\$1**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
Questa volta verrà utilizzata l'integrazione Lambda predefinita nella console Gateway API per configurare l'integrazione del metodo.
**Per configurare l'integrazione di un metodo**
1. Seleziona la risorsa **/\$1operand1\$1/\$1operand2\$1/\$1operator\$1**, quindi scegli **Crea metodo**.
1. Per **Tipo di metodo** seleziona **GET**.
1. In **Tipo di integrazione**, seleziona **Lambda**.
1. Mantieni l'opzione **Integrazione proxy Lambda** disattivata.
1. Per la **funzione Lambda**, seleziona il Regione AWS luogo in cui hai creato la funzione Lambda e inserisci. **Calc**
1. Mantieni attivata l'opzione **Timeout predefinito**.
1. Scegli **Crea metodo**.
A questo punto crea il modello per mappare i tre parametri del percorso URL, dichiarati quando è stata creata la risorsa **/calc/\$1operand1\$1/\$1operand2\$1/\$1operator\$1**, ai valori di proprietà designati nell'oggetto JSON. Poiché i percorsi URL devono essere codificati in formato URL, l'operatore di divisione deve essere specificato come `%2F` invece di `/`. Questo modello traduce `%2F` in `'/'` prima di passarlo alla funzione Lambda.
**Per creare un modello di mappatura**
1. Nella scheda **Richiesta di integrazione** scegli **Modifica** in **Impostazioni della richiesta di integrazione**.
1. Per **Richiesta corpo passthrough** scegli **Quando non ci sono modelli definiti (consigliato)**.
1. Scegli **Modelli di mappatura**.
1. Per **Tipo di contenuto** inserisci **application/json**.
1. Per **Corpo del modello** inserisci il seguente codice:
```
{
"a": "$input.params('operand1')",
"b": "$input.params('operand2')",
"op": #if($input.params('operator')=='%2F')"/"#{else}"$input.params('operator')"#end
}
```
1. Scegli **Save** (Salva).
A questo punto testa il metodo `GET` per verificare che sia stato configurato correttamente per richiamare la funzione Lambda e passare l'output originale con la risposta di integrazione senza mappatura.
**Test del metodo `GET`**
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. Per **Percorso** procedi come segue:
1. Per **operand1** immetti **1**.
1. Per **operand2** immetti **1**.
1. Per **operator** immetti **\$1**.
1. Scegli **Test (Esegui test)**.
1. Il risultato deve essere simile al seguente:
![\[Test del metodo GET nella console Gateway API.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/aws_proxy_lambda_calc_get_method_test_path_parm_new_console.png)
A questo punto modella la struttura di dati del payload di risposta del metodo dopo lo schema `result`.
Per impostazione predefinita, al corpo della risposta del metodo viene assegnato un modello vuoto. Di conseguenza, il corpo della risposta di integrazione viene passato senza mappatura. Tuttavia, quando generi un SDK per uno dei linguaggi fortemente tipizzati, ad esempio Java o Objective-C, gli utenti dell'SDK riceveranno un oggetto vuoto come risultato. Affinché sia il client REST che i client SDK ricevano il risultato desiderato, è necessario modellare i dati della risposta utilizzando uno schema predefinito. Verrà illustrato come definire un modello per il corpo della risposta del metodo e creare un modello di mappatura per convertire il corpo della risposta di integrazione nel corpo della risposta del metodo.
**Per creare una risposta del metodo**
1. Nella scheda **Risposta metodo** scegli **Modifica** in **Risposta 200**.
1. In **Corpo della risposta** scegli **Aggiungi modello**.
1. Per **Tipo di contenuto** inserisci **application/json**.
1. Per **Modello** seleziona **risultato**.
1. Scegli **Save** (Salva).
L'impostazione del modello per il corpo della risposta del metodo assicura che i dati della risposta verranno trasmessi nell'oggetto `result` di un determinato SDK. Per fare in modo che i dati della risposta di integrazione siano mappati di conseguenza, è necessario un modello di mappatura.
**Per creare un modello di mappatura**
1. Nella scheda **Risposta di integrazione** scegli **Modifica** in **Predefinito - Risposta**.
1. Scegli **Modelli di mappatura**.
1. Per **Tipo di contenuto** inserisci **application/json**.
1. Per **Corpo del modello** inserisci il seguente codice:
```
#set($inputRoot = $input.path('$'))
{
"input" : {
"a" : $inputRoot.a,
"b" : $inputRoot.b,
"op" : "$inputRoot.op"
},
"output" : {
"c" : $inputRoot.c
}
}
```
1. Scegli **Save** (Salva).
**Per testare il modello di mappatura**
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. Per **Percorso** procedi come segue:
1. Per **operand1** immetti **1**.
1. Per **operand2** immetti **2**.
1. Per **operator** immetti **\$1**.
1. Scegli **Test (Esegui test)**.
1. Il risultato sarà simile al seguente:
```
{
"input": {
"a": 1,
"b": 2,
"op": "+"
},
"output": {
"c": 3
}
}
```
A questo punto puoi chiamare l'API solo tramite la funzionalità **Test** nella console Gateway API. Per rendere l'API disponibile per i client, è necessario distribuirla. Assicurarsi sempre di ridistribuire l'API ogni volta che si aggiunge, si modifica o si elemina una risorsa o un metodo, si aggiorna una mappatura dei dati o si aggiornano le impostazioni della fase. In caso contrario, le nuove funzionalità o gli aggiornamenti non saranno disponibili per i client dell'API, come indicato di seguito:
**Per distribuire l'API**
1. Seleziona **Deploy API (Distribuisci API)**.
1. In **Fase**, seleziona **Nuova fase**.
1. In **Stage name (Nome fase)** immettere **Prod**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Seleziona **Implementa**.
1. (Facoltativo) In **Dettagli fase** puoi scegliere l'icona Copia per copiare l'URL di richiamata dell'API in **Richiama URL**. È possibile usare questo valore con strumenti come [Postman](https://www.postman.com) e [cURL](https://curl.se/) per testare l'API.
**Nota**
Implementa nuovamente l'API ogni volta che aggiungi, modifichi o elemini una risorsa o un metodo e aggiorni una mappatura dei dati oppure le impostazioni della fase. In caso contrario, le nuove caratteristiche o gli aggiornamenti non saranno disponibili per i client dell'API.
# Definizioni OpenAPI di un'API di esempio integrata con una funzione Lambda
------
#### [ OpenAPI 2.0 ]
```
{
"swagger": "2.0",
"info": {
"version": "2017-04-20T04:08:08Z",
"title": "LambdaCalc"
},
"host": "uojnr9hd57.execute-api.us-east-1.amazonaws.com",
"basePath": "/test",
"schemes": [
"https"
],
"paths": {
"/calc": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "operand2",
"in": "query",
"required": true,
"type": "string"
},
{
"name": "operator",
"in": "query",
"required": true,
"type": "string"
},
{
"name": "operand1",
"in": "query",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
},
"headers": {
"operand_1": {
"type": "string"
},
"operand_2": {
"type": "string"
},
"operator": {
"type": "string"
}
}
}
},
"x-amazon-apigateway-request-validator": "Validate query string parameters and headers",
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.operator": "integration.response.body.op",
"method.response.header.operand_2": "integration.response.body.b",
"method.response.header.operand_1": "integration.response.body.a"
},
"responseTemplates": {
"application/json": "#set($res = $input.path('$'))\n{\n \"result\": \"$res.a, $res.b, $res.op => $res.c\",\n \"a\" : \"$res.a\",\n \"b\" : \"$res.b\",\n \"op\" : \"$res.op\",\n \"c\" : \"$res.c\"\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_match",
"httpMethod": "POST",
"requestTemplates": {
"application/json": "{\n \"a\": \"$input.params('operand1')\",\n \"b\": \"$input.params('operand2')\", \n \"op\": \"$input.params('operator')\" \n}"
},
"type": "aws"
}
},
"post": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"in": "body",
"name": "Input",
"required": true,
"schema": {
"$ref": "#/definitions/Input"
}
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
}
}
},
"x-amazon-apigateway-request-validator": "Validate body",
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseTemplates": {
"application/json": "#set($inputRoot = $input.path('$'))\n{\n \"a\" : $inputRoot.a,\n \"b\" : $inputRoot.b,\n \"op\" : $inputRoot.op,\n \"c\" : $inputRoot.c\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_templates",
"httpMethod": "POST",
"type": "aws"
}
}
},
"/calc/{operand1}/{operand2}/{operator}": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "operand2",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "operator",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "operand1",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
}
}
},
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseTemplates": {
"application/json": "#set($inputRoot = $input.path('$'))\n{\n \"input\" : {\n \"a\" : $inputRoot.a,\n \"b\" : $inputRoot.b,\n \"op\" : \"$inputRoot.op\"\n },\n \"output\" : {\n \"c\" : $inputRoot.c\n }\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_templates",
"httpMethod": "POST",
"requestTemplates": {
"application/json": "{\n \"a\": \"$input.params('operand1')\",\n \"b\": \"$input.params('operand2')\",\n \"op\": #if($input.params('operator')=='%2F')\"/\"#{else}\"$input.params('operator')\"#end\n \n}"
},
"contentHandling": "CONVERT_TO_TEXT",
"type": "aws"
}
}
}
},
"definitions": {
"Input": {
"type": "object",
"required": [
"a",
"b",
"op"
],
"properties": {
"a": {
"type": "number"
},
"b": {
"type": "number"
},
"op": {
"type": "string",
"description": "binary op of ['+', 'add', '-', 'sub', '*', 'mul', '%2F', 'div']"
}
},
"title": "Input"
},
"Output": {
"type": "object",
"properties": {
"c": {
"type": "number"
}
},
"title": "Output"
},
"Result": {
"type": "object",
"properties": {
"input": {
"$ref": "#/definitions/Input"
},
"output": {
"$ref": "#/definitions/Output"
}
},
"title": "Result"
}
},
"x-amazon-apigateway-request-validators": {
"Validate body": {
"validateRequestParameters": false,
"validateRequestBody": true
},
"Validate query string parameters and headers": {
"validateRequestParameters": true,
"validateRequestBody": false
}
}
}
```
------
# Tutorial: creazione di una REST API come un proxy Amazon S3
Per illustrare l'uso di un'API REST in API Gateway come proxy Amazon S3, in questa sezione viene descritto come creare e configurare un'API REST per esporre le operazioni Amazon S3 seguenti:
+ Esponi GET sulla risorsa radice dell'API per [elencare tutti i bucket Amazon S3 di un intermediario](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListBuckets.html).
+ Esponi GET su una risorsa cartella per [visualizzare un elenco di tutti gli oggetti di un bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html).
+ Esponi GET su una Folder/Item risorsa per [visualizzare o scaricare un oggetto da un bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html).
Puoi importare l'API di esempio come proxy Amazon S3, come illustrato in [Definizioni OpenAPI dell'API di esempio come un proxy Amazon S3](api-as-s3-proxy-export-swagger-with-extensions.md). Questo esempio include più metodi esposti. Per istruzioni su come importare l'API tramite la definizione OpenAPI, consulta [Sviluppa REST APIs utilizzando OpenAPI in API Gateway](api-gateway-import-api.md).
**Nota**
Per integrare l'API di API Gateway con Amazon S3, devi scegliere una regione in cui i servizi API Gateway e Amazon S3 siano entrambi disponibili. Per la disponibilità delle regioni, consulta [Endpoint e quote Amazon API Gateway](https://docs.aws.amazon.com/general/latest/gr/apigateway.html).
**Topics**
+ [Configurazione delle autorizzazioni IAM per consentire all'API di invocare operazioni Amazon S3](#api-as-s3-proxy-iam-permissions)
+ [Creazione di risorse API per rappresentare risorse Amazon S3](#api-as-s3-proxy-create-resources)
+ [Esposizione di un metodo API per elencare i bucket Amazon S3 dell'intermediario](#api-root-get-as-s3-get-service)
+ [Esposizione dei metodi API per accedere a un bucket Amazon S3](#api-folder-operations-as-s3-bucket-actions)
+ [Esposizione dei metodi API per accedere a un oggetto Amazon S3 in un bucket](#api-items-in-folder-as-s3-objects-in-bucket)
+ [Definizioni OpenAPI dell'API di esempio come un proxy Amazon S3](api-as-s3-proxy-export-swagger-with-extensions.md)
+ [Chiamata dell'API mediante un client API REST](api-as-s3-proxy-test-using-postman.md)
## Configurazione delle autorizzazioni IAM per consentire all'API di invocare operazioni Amazon S3
Per permettere all'API di richiamare le operazioni Amazon S3, devi aver collegato le policy IAM appropriate a un ruolo IAM. In questo passaggio si crea un nuovo ruolo IAM.
**Per creare il ruolo di esecuzione del proxy del AWS servizio**
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Scegliere **Roles (Ruoli)**.
1. Scegli **Crea ruolo**.
1. Scegli il **AWS servizio** in **Seleziona il tipo di entità affidabile**, quindi seleziona **API Gateway** e seleziona Consenti **a API Gateway di inviare i log ai CloudWatch log**.
1. Scegli **Successivo** e di nuovo **Successivo**.
1. In **Role name (Nome ruolo)** immettere **APIGatewayS3ProxyPolicy** e quindi selezionare **Create role (Crea ruolo)**.
1. Nell'elenco **Roles (Ruoli)** scegliere il ruolo appena creato. Potrebbe essere necessario scorrere o utilizzare la barra di ricerca per trovare il ruolo.
1. Per il ruolo selezionato, seleziona la scheda **Aggiungi autorizzazioni**.
1. Dall'elenco a discesa scegli **Collega policy**.
1. Nella barra di ricerca inserisci **AmazonS3FullAccess** e scegli **Aggiungi autorizzazioni**.
**Nota**
Per semplicità, questo tutorial utilizza una policy gestita. Come best practice, dovresti creare la tua policy IAM per concedere le autorizzazioni minime richieste.
1. Annota l'**ARN del ruolo** appena creato, lo utilizzerai in seguito.
## Creazione di risorse API per rappresentare risorse Amazon S3
Si utilizza la risorsa radice dell'API (`/`) come container dei bucket Amazon S3 di un chiamante autenticato. Inoltre, si dovranno creare le risorse `Folder` e `Item` per rappresentare rispettivamente un bucket Amazon S3 e un oggetto Amazon S3 specifico. Il nome della cartella e la chiave dell'oggetto verranno specificati dall'intermediario nell'ambito di un URL di richiesta nel formato dei parametri di percorso.
**Nota**
Quando accedi a oggetti la cui chiave include `/` o qualsiasi altro carattere speciale, il carattere deve avere la codifica URL. Ad esempio, `test/test.txt` dovrebbe avere la codifica `test%2Ftest.txt`.
**Per creare una risorsa API che espone le caratteristiche del servizio Amazon S3**
1. **Nello stesso modo in Regione AWS cui hai creato il tuo bucket Amazon S3, crea un'API denominata MyS3.** Questa risorsa della radice dell'API (**/**) rappresenta il servizio Amazon S3. In questa fase crei le due risorse aggiuntive **/\$1folder\$1** e **/\$1item\$1**.
1. Scegli **Crea risorsa**.
1. Mantieni l'opzione **Risorsa proxy** disattivata.
1. Per **Percorso risorsa** seleziona `/`.
1. Per **Resource Name (Nome risorsa)** immetti **\$1folder\$1**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** deselezionato.
1. Scegli **Crea risorsa**.
1. Seleziona la risorsa **/\$1folder\$1**, quindi scegli **Crea risorsa**.
1. Ripeti le fasi precedenti per creare una risorsa figlio **/\$1folder\$1** denominata **\$1item\$1**.
L'API finale è simile a quanto riportato di seguito:
![\[Creazione di un'API in API Gateway come un proxy Amazon S3\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/aws_proxy_s3_create_api-resources_new_console.png)
## Esposizione di un metodo API per elencare i bucket Amazon S3 dell'intermediario
Per ottenere l'elenco dei bucket Amazon S3 dell'intermediario, è necessario richiamare l'operazione [GET Service](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListBuckets.html) in Amazon S3. Nella risorsa radice dell'API, (**/**), crea il metodo GET. Configura il metodo GET per l'integrazione con Amazon S3, come indicato di seguito.
**Per creare e inizializzare il metodo `GET /` dell'API**
1. Seleziona la risorsa **/**, quindi scegli **Crea metodo**.
1. Per Tipo di metodo seleziona **GET**.
1. Per **Tipo di integrazione** seleziona **Servizio AWS**.
1. Per **Regione AWS**, seleziona il Regione AWS luogo in cui hai creato il tuo bucket Amazon S3.
1. Per **Servizio AWS** seleziona **Amazon Simple Storage Service**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **Metodo HTTP** seleziona **GET**.
1. In **Tipo di operazione** scegli **Utilizza sostituzione percorso**.
Con la sostituzione del percorso, API Gateway invia la richiesta client ad Amazon S3 come [richiesta in stile percorso dell'API REST Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/RESTAPI.html), in cui la risorsa Amazon S3 viene espressa dal percorso della risorsa del modello `s3-host-name/bucket/key`. API Gateway imposta il valore `s3-host-name` e passa i valori `bucket` e `key` specificati dal client ad Amazon S3.
1. In **Sostituzione percorso** immetti **/**.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo per **APIGatewayS3ProxyPolicy**.
1. Scegli **Impostazioni della richiesta del metodo**.
Si utilizzano le impostazioni della richiesta del metodo per controllare chi può chiamare questo metodo dell'API.
1. Per **Autorizzazioni** seleziona `AWS_IAM` nel menu a discesa.
![\[Dichiarazione dei tipi di risposta di metodo\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/aws_proxy_s3_setup_method_request_authorization_new_console.png)
1. Scegli **Crea metodo**.
Questa configurazione integra la richiesta `GET https://your-api-host/stage/` front-end con il back-end `GET https://your-s3-host/`.
Per consentire all'API di restituire correttamente risposte di esito positivo ed eccezioni al chiamante, si dichiarano le risposte 200, 400 e 500 in **Risposta metodo**. Si utilizza la mappatura predefinita per le risposte 200 in modo che le risposte di backend del codice di stato non dichiarate in questa sede vengano restituite al chiamante come risposte 200.
**Per dichiarare i tipi di risposta del metodo `GET /`**
1. Nella scheda **Risposta metodo** scegli **Modifica** in **Risposta 200**.
1. Scegli **Aggiungi intestazione** e procedi come descritto di seguito:
1. Per **Nome intestazione** immetti **Content-Type**.
1. Seleziona **Add header (Aggiungi intestazione)**.
Ripeti queste fasi per creare un'intestazione **Timestamp** e un'intestazione **Content-Length**.
1. Scegli **Save** (Salva).
1. Nella scheda **Risposta metodo** scegli **Crea risposta** in **Risposte del metodo**.
1. Per **Codice di stato HTTP** immetti **400**.
Non impostare alcuna intestazione per questa risposta.
1. Scegli **Save** (Salva).
1. Ripeti le seguenti fasi per creare la risposta 500.
Non impostare alcuna intestazione per questa risposta.
Poiché la risposta di integrazione con esito positivo da Amazon S3 restituisce l'elenco di bucket come payload XML e la risposta del metodo predefinita di Gateway API restituisce un payload JSON, è necessario mappare il valore del parametro di intestazione Content-Type di backend all'equivalente di frontend. In caso contrario, il client riceverà `application/json` come tipo di contenuto quando il corpo della risposta è effettivamente una stringa XML. La procedura seguente descrive come eseguire questa configurazione. È possibile inoltre visualizzare altri parametri di intestazione per il client, ad esempio Date e Content-Length.
**Per configurare le mappature delle intestazioni di risposta per il metodo GET /.**
1. Nella scheda **Risposta di integrazione** scegli **Modifica** in **Predefinito - Risposta**.
1. Per l'intestazione **Content-Length** immetti **integration.response.header.Content-Length** come valore di mappatura.
1. Per l'intestazione **Content-Type** immetti **integration.response.header.Content-Type** come valore di mappatura.
1. Per l'intestazione **Timestamp** immetti **integration.response.header.Date** come valore di mappatura.
1. Scegli **Save** (Salva). Il risultato sarà essere simile al seguente:
![\[Mappatura delle intestazioni delle risposte di integrazione alle intestazioni delle risposte di metodo\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/aws_proxy_s3_setup_integration_response_headers_new_console.png)
1. Nella scheda **Risposta di integrazione** scegli **Crea risposta** in **Risposte di integrazione**.
1. Per **HTTP status regex (Regex stato HTTP)**, immettere **4\$1d\$12\$1**. Tutti i codici di stato della risposta HTTP 4xx sono così mappati alla risposta del metodo.
1. Per **Codice di stato risposta metodo** seleziona **400**.
1. Scegli **Create** (Crea).
1. Ripeti le seguenti fasi per creare una risposta di integrazione per la risposta del metodo 500. Per **HTTP status regex (Regex stato HTTP)**, immettere **5\$1d\$12\$1**.
Come suggerisce la buona norma, è opportuno testare l'API configurata fino a questo momento.
**Test del metodo `GET /`**
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. Scegli **Test (Esegui test)**. Il risultato sarà simile all'immagine seguente:
![\[Risultato del test del bucket GET nella radice dell'API\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/aws_proxy_s3_test_root_get_result_new_console.png)
## Esposizione dei metodi API per accedere a un bucket Amazon S3
Per utilizzare un bucket Amazon S3, esponi il metodo `GET` nella risorsa /\$1folder\$1 per elencare gli oggetti del bucket. Le istruzioni sono simili a quelle descritte in [Esposizione di un metodo API per elencare i bucket Amazon S3 dell'intermediario](#api-root-get-as-s3-get-service). Per altri metodi, puoi importare l'API di esempio come descritto in [Definizioni OpenAPI dell'API di esempio come un proxy Amazon S3](api-as-s3-proxy-export-swagger-with-extensions.md).
**Per esporre il metodo GET in una risorsa folder**
1. Seleziona la risorsa **/\$1folder\$1**, quindi scegli **Crea metodo**.
1. Per Tipo di metodo seleziona **GET**.
1. Per **Tipo di integrazione** seleziona **Servizio AWS**.
1. Per **Regione AWS**, seleziona il Regione AWS luogo in cui hai creato il tuo bucket Amazon S3.
1. Per **Servizio AWS** seleziona **Amazon Simple Storage Service**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **Metodo HTTP** seleziona **GET**.
1. In **Tipo di operazione** scegli **Utilizza sostituzione percorso**.
1. Per **Sostituzione percorso** immetti **\$1bucket\$1**.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo per **APIGatewayS3ProxyPolicy**.
1. Scegli **Crea metodo**.
Imposta il parametro di percorso `{folder}` nell'URL dell'endpoint Amazon S3. Dovrai mappare il parametro di percorso `{folder}` della richiesta di metodo al parametro di percorso `{bucket}` della richiesta di integrazione.
**Per mappare `{folder}` a `{bucket}`**
1. Nella scheda **Richiesta di integrazione** scegli **Modifica** in **Impostazioni della richiesta di integrazione**.
1. Seleziona **Parametri di percorso URL**, quindi scegli **Aggiungi parametro di percorso**.
1. In **Nome**, inserisci **bucket**.
1. In **Mappato da**, inserire **method.request.path.folder**.
1. Scegli **Save** (Salva).
A questo punto esegui il test dell'API.
**Per testare il metodo `/{folder} GET`**
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. In **Percorso** immetti il nome del tuo bucket per **folder**.
1. Scegli **Test (Esegui test)**.
Il risultato del test conterrà l'elenco degli oggetti presenti nel bucket.
![\[Test del metodo GET per la creazione di un bucket Amazon S3.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/aws_proxy_s3_test_api_folder_get_new_console.png)
## Esposizione dei metodi API per accedere a un oggetto Amazon S3 in un bucket
Amazon S3 supporta le operazioni GET, DELETE, HEAD, OPTIONS, POST e PUT per accedere agli oggetti e gestirli in un bucket specifico. In questo tutorial, esponi un metodo `GET` nella risorsa `{folder}/{item}` per ottenere un'immagine da un bucket. Per ulteriori applicazioni della risorsa `{folder}/{item}`, consulta l'API di esempio in [Definizioni OpenAPI dell'API di esempio come un proxy Amazon S3](api-as-s3-proxy-export-swagger-with-extensions.md).
**Per esporre il metodo GET in un elemento**
1. Seleziona la risorsa **/\$1item\$1**, quindi scegli **Crea metodo**.
1. Per Tipo di metodo seleziona **GET**.
1. Per **Tipo di integrazione** seleziona **Servizio AWS**.
1. Per **Regione AWS**, seleziona il Regione AWS luogo in cui hai creato il tuo bucket Amazon S3.
1. Per **Servizio AWS** seleziona **Amazon Simple Storage Service**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **Metodo HTTP** seleziona **GET**.
1. In **Tipo di operazione** scegli **Utilizza sostituzione percorso**.
1. Per **Sostituzione percorso** immetti **\$1bucket\$1/\$1object\$1**.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo per **APIGatewayS3ProxyPolicy**.
1. Scegli **Crea metodo**.
Imposta i parametri di percorso `{folder}` e `{item}` nell'URL dell'endpoint Amazon S3. Dovrai mappare il parametro di percorso della richiesta di metodo al parametro di percorso della richiesta di integrazione.
In questa fase si effettuano le operazioni seguenti:
+ Mappa il parametro di percorso `{folder}` della richiesta di metodo al parametro di percorso `{bucket}` della richiesta di integrazione.
+ Mappa il parametro di percorso `{item}` della richiesta di metodo al parametro di percorso `{object}` della richiesta di integrazione.
**Per mappare `{folder}` a `{bucket}` e `{item}` a `{object}`**
1. Nella scheda **Richiesta di integrazione** scegli **Modifica** in **Impostazioni della richiesta di integrazione**.
1. Scegli **Parametri di percorso URL**.
1. Scegli **Aggiungi parametro di percorso**.
1. In **Nome**, inserisci **bucket**.
1. In **Mappato da**, inserire **method.request.path.folder**.
1. Scegli **Aggiungi parametro di percorso**.
1. In **Nome**, inserisci **object**.
1. In **Mappato da**, inserire **method.request.path.item**.
1. Scegli **Save** (Salva).
**Per testare il metodo `/{folder}/{object} GET`**
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. In **Percorso** immetti il nome del tuo bucket per **folder**.
1. In **Percorso** immetti il nome di un elemento per **item**.
1. Scegli **Test (Esegui test)**.
Il corpo della risposta conterrà il contenuto dell'elemento.
![\[Test del metodo GET per la creazione di un bucket Amazon S3.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/aws_proxy_s3_test_api_item_get_new_console.png)
La richiesta restituisce correttamente il testo normale ("Hello world") come contenuto del file specificato (test.txt) nel bucket Amazon S3 fornito (amzn-s3-demo-bucket).
Per scaricare o caricare file binari ovvero, in API Gateway, tutti i contenuti JSON che hanno una codifica diversa da UTF-8, sono necessarie impostazioni API aggiuntive, come mostrato di seguito:
**Per scaricare o caricare file binari da S3**
1. Registra i tipi di file multimediali del file interessato nelle API. binaryMediaTypes Questa operazione può essere eseguita nella console:
1. Scegli **Impostazioni API** per l'API.
1. In **Tipi di media binari** scegli **Gestisci tipi di supporti**.
1. Scegli **Aggiungi tipo di supporto binario**, quindi immetti il tipo di supporto richiesto, ad esempio `image/png`.
1. Scegli **Salva modifiche** per salvare l'impostazione.
1. Aggiungi l'intestazione `Content-Type` (for upload) and/or `Accept` (for download) alla richiesta del metodo per richiedere al client di specificare il tipo di supporto binario richiesto e mapparlo alla richiesta di integrazione.
1. Imposta **Content Handling** (Gestione contenuto) su `Passthrough` nella richiesta di integrazione (per il caricamento) e in una risposta di integrazione (per il download). Assicurati che per il tipo di contenuto interessato non sia definito un modello di mappatura. Per ulteriori informazioni, consulta [Trasformazioni dei dati per REST APIs in API Gateway](rest-api-data-transformations.md).
Il limite della dimensione del payload è 10 MB. Consulta [Quote per la configurazione e l’esecuzione di una REST API in Gateway API](api-gateway-execution-service-limits-table.md).
Assicurati che ai file in Amazon S3 vengano aggiunti tipi di contenuto corretti come metadati dei file. Per il contenuto multimediale riproducibile in streaming, potrebbe essere necessario aggiungere anche `Content-Disposition:inline` ai metadati.
Per ulteriori informazioni sul supporto binario in API Gateway, consulta [Conversioni dei tipi di contenuto in API Gateway](api-gateway-payload-encodings-workflow.md).
# Definizioni OpenAPI dell'API di esempio come un proxy Amazon S3
Le definizioni OpenAPI seguenti descrivono un'API che funge da proxy Amazon S3. Questa API contiene più operazioni Amazon S3 rispetto all'API creata nel tutorial. Nelle definizioni OpenAPI sono esposti i seguenti metodi:
+ Esponi GET sulla risorsa radice dell'API per [elencare tutti i bucket Amazon S3 di un intermediario](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListBuckets.html).
+ Esponi GET su una risorsa cartella per [visualizzare un elenco di tutti gli oggetti di un bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html).
+ Esponi PUT su una risorsa cartella per [aggiungere un bucket ad Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucket.html).
+ Esponi DELETE su una risorsa cartella per [rimuovere un bucket da Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucket.html).
+ Esponi GET su una Folder/Item risorsa per [visualizzare o scaricare un oggetto da un bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html).
+ Esponi PUT su una Folder/Item risorsa per [caricare un oggetto in un bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html).
+ Esponi HEAD su una Folder/Item risorsa per [ottenere i metadati degli oggetti in un bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html).
+ Esporre DELETE su una Folder/Item risorsa per [rimuovere un oggetto da un bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObject.html).
Per istruzioni su come importare l'API tramite la definizione OpenAPI, consulta [Sviluppa REST APIs utilizzando OpenAPI in API Gateway](api-gateway-import-api.md).
Per istruzioni su come creare un'API simile, consulta [Tutorial: creazione di una REST API come un proxy Amazon S3](integrating-api-with-aws-services-s3.md).
Per informazioni su come richiamare questa API utilizzando [Postman](https://www.postman.com/), che supporta l'autorizzazione IAM, consulta AWS . [Chiamata dell'API mediante un client API REST](api-as-s3-proxy-test-using-postman.md)
------
#### [ OpenAPI 2.0 ]
```
{
"swagger": "2.0",
"info": {
"version": "2016-10-13T23:04:43Z",
"title": "MyS3"
},
"host": "9gn28ca086.execute-api.{region}.amazonaws.com",
"basePath": "/S3",
"schemes": [
"https"
],
"paths": {
"/": {
"get": {
"produces": [
"application/json"
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Timestamp": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type",
"method.response.header.Content-Length": "integration.response.header.Content-Length",
"method.response.header.Timestamp": "integration.response.header.Date"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"uri": "arn:aws:apigateway:us-west-2:s3:path//",
"passthroughBehavior": "when_no_match",
"httpMethod": "GET",
"type": "aws"
}
}
},
"/{folder}": {
"get": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Date": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type",
"method.response.header.Date": "integration.response.header.Date",
"method.response.header.Content-Length": "integration.response.header.content-length"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"passthroughBehavior": "when_no_match",
"httpMethod": "GET",
"type": "aws"
}
},
"put": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "Content-Type",
"in": "header",
"required": false,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type",
"method.response.header.Content-Length": "integration.response.header.Content-Length"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.bucket": "method.request.path.folder",
"integration.request.header.Content-Type": "method.request.header.Content-Type"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"passthroughBehavior": "when_no_match",
"httpMethod": "PUT",
"type": "aws"
}
},
"delete": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Date": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type",
"method.response.header.Date": "integration.response.header.Date"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"passthroughBehavior": "when_no_match",
"httpMethod": "DELETE",
"type": "aws"
}
}
},
"/{folder}/{item}": {
"get": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "item",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"content-type": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.content-type": "integration.response.header.content-type",
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.object": "method.request.path.item",
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"passthroughBehavior": "when_no_match",
"httpMethod": "GET",
"type": "aws"
}
},
"head": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "item",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type",
"method.response.header.Content-Length": "integration.response.header.Content-Length"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.object": "method.request.path.item",
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"passthroughBehavior": "when_no_match",
"httpMethod": "HEAD",
"type": "aws"
}
},
"put": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "Content-Type",
"in": "header",
"required": false,
"type": "string"
},
{
"name": "item",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type",
"method.response.header.Content-Length": "integration.response.header.Content-Length"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.object": "method.request.path.item",
"integration.request.path.bucket": "method.request.path.folder",
"integration.request.header.Content-Type": "method.request.header.Content-Type"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"passthroughBehavior": "when_no_match",
"httpMethod": "PUT",
"type": "aws"
}
},
"delete": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "item",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200"
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.object": "method.request.path.item",
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"passthroughBehavior": "when_no_match",
"httpMethod": "DELETE",
"type": "aws"
}
}
}
},
"securityDefinitions": {
"sigv4": {
"type": "apiKey",
"name": "Authorization",
"in": "header",
"x-amazon-apigateway-authtype": "awsSigv4"
}
},
"definitions": {
"Empty": {
"type": "object",
"title": "Empty Schema"
}
}
}
```
------
#### [ OpenAPI 3.0 ]
```
{
"openapi" : "3.0.1",
"info" : {
"title" : "MyS3",
"version" : "2016-10-13T23:04:43Z"
},
"servers" : [ {
"url" : "https://9gn28ca086.execute-api.{region}.amazonaws.com/{basePath}",
"variables" : {
"basePath" : {
"default" : "S3"
}
}
} ],
"paths" : {
"/{folder}" : {
"get" : {
"parameters" : [ {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Date" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "GET",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" : "integration.response.header.Content-Type",
"method.response.header.Date" : "integration.response.header.Date",
"method.response.header.Content-Length" : "integration.response.header.content-length"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"put" : {
"parameters" : [ {
"name" : "Content-Type",
"in" : "header",
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "PUT",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" : "integration.response.header.Content-Type",
"method.response.header.Content-Length" : "integration.response.header.Content-Length"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.bucket" : "method.request.path.folder",
"integration.request.header.Content-Type" : "method.request.header.Content-Type"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"delete" : {
"parameters" : [ {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Date" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "DELETE",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" : "integration.response.header.Content-Type",
"method.response.header.Date" : "integration.response.header.Date"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
}
},
"/{folder}/{item}" : {
"get" : {
"parameters" : [ {
"name" : "item",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"content-type" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "GET",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.content-type" : "integration.response.header.content-type",
"method.response.header.Content-Type" : "integration.response.header.Content-Type"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.object" : "method.request.path.item",
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"put" : {
"parameters" : [ {
"name" : "Content-Type",
"in" : "header",
"schema" : {
"type" : "string"
}
}, {
"name" : "item",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "PUT",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" : "integration.response.header.Content-Type",
"method.response.header.Content-Length" : "integration.response.header.Content-Length"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.object" : "method.request.path.item",
"integration.request.path.bucket" : "method.request.path.folder",
"integration.request.header.Content-Type" : "method.request.header.Content-Type"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"delete" : {
"parameters" : [ {
"name" : "item",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "DELETE",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200"
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.object" : "method.request.path.item",
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"head" : {
"parameters" : [ {
"name" : "item",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "HEAD",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" : "integration.response.header.Content-Type",
"method.response.header.Content-Length" : "integration.response.header.Content-Length"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.object" : "method.request.path.item",
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
}
},
"/" : {
"get" : {
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Timestamp" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "GET",
"uri" : "arn:aws:apigateway:us-west-2:s3:path//",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" : "integration.response.header.Content-Type",
"method.response.header.Content-Length" : "integration.response.header.Content-Length",
"method.response.header.Timestamp" : "integration.response.header.Date"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
}
}
},
"components" : {
"schemas" : {
"Empty" : {
"title" : "Empty Schema",
"type" : "object"
}
}
}
}
```
------
# Chiamata dell'API mediante un client API REST
Per fornire un end-to-end tutorial, ora mostriamo come chiamare l'API usando [Postman](https://www.postman.com/), che supporta l' AWS autorizzazione IAM.
**Per chiamare l'API proxy Amazon S3 utilizzando Postman**
1. Distribuisci o ridistribuisci l'API. Annota l'URL di base dell'API visualizzato accanto a **Invoke URL** (URL chiamata) in alto in **Stage Editor** (Editor fasi).
1. Avvia Postman.
1. Seleziona **Authorization** (Autorizzazione), quindi scegli `AWS Signature`. Inserisci l'ID della chiave di accesso e la chiave di accesso segreta del tuo utente IAM rispettivamente nei campi **AccessKey**e **SecretKey**di immissione. Inserisci la destinazione Regione AWS in cui viene distribuita la tua API nella casella di testo **AWS Regione**. Immetti `execute-api` nel campo di input **Nome servizio**.
Puoi creare una coppia di chiavi dalla scheda **Security Credentials (Credenziali di sicurezza)** con il tuo account utente IAM nella console di gestione IAM.
1. Per aggiungere un bucket denominato `amzn-s3-demo-bucket` all'account Amazon S3 nella regione `{region}`:
1. Seleziona **PUT** nell'elenco a discesa dei metodi e digita l'URL del metodo (`https://api-id.execute-api.aws-region.amazonaws.com/stage/folder-name`)
1. Imposta il valore dell'intestazione `Content-Type` come `application/xml`. Potrebbe essere necessario eliminare le intestazioni esistenti prima di impostare il tipo di contenuto.
1. Seleziona la voce di menu **Body** (Corpo) e digita il seguente frammento XML come corpo della richiesta:
```
{region}
```
1. Seleziona **Send** (Invia) per inviare la richiesta. Se l'operazione viene eseguita correttamente, dovresti ricevere una risposta `200 OK` con un payload vuoto.
1. Per aggiungere un file di testo a un bucket, segui le istruzioni riportate sopra. Se specifichi il nome bucket **amzn-s3-demo-bucket** per `{folder}` e il nome file **Readme.txt** per `{item}` nell'URL e fornisci la stringa di testo **Hello, World\$1** come contenuti del file (rendendola così il payload di richiesta), la richiesta diventa
```
PUT /S3/amzn-s3-demo-bucket/Readme.txt HTTP/1.1
Host: 9gn28ca086.execute-api.{region}.amazonaws.com
Content-Type: application/xml
X-Amz-Date: 20161015T062647Z
Authorization: AWS4-HMAC-SHA256 Credential=access-key-id/20161015/{region}/execute-api/aws4_request, SignedHeaders=content-length;content-type;host;x-amz-date, Signature=ccadb877bdb0d395ca38cc47e18a0d76bb5eaf17007d11e40bf6fb63d28c705b
Cache-Control: no-cache
Postman-Token: 6135d315-9cc4-8af8-1757-90871d00847e
Hello, World!
```
Se l'operazione viene eseguita correttamente, dovresti ricevere una risposta `200 OK` con un payload vuoto.
1. Per ottenere il contenuto del file `Readme.txt` appena aggiunto al bucket `amzn-s3-demo-bucket`, esegui una richiesta GET come la seguente:
```
GET /S3/amzn-s3-demo-bucket/Readme.txt HTTP/1.1
Host: 9gn28ca086.execute-api.{region}.amazonaws.com
Content-Type: application/xml
X-Amz-Date: 20161015T063759Z
Authorization: AWS4-HMAC-SHA256 Credential=access-key-id/20161015/{region}/execute-api/aws4_request, SignedHeaders=content-type;host;x-amz-date, Signature=ba09b72b585acf0e578e6ad02555c00e24b420b59025bc7bb8d3f7aed1471339
Cache-Control: no-cache
Postman-Token: d60fcb59-d335-52f7-0025-5bd96928098a
```
Se l'operazione viene eseguita correttamente, dovresti ricevere una risposta `200 OK` con la stringa di testo `Hello, World!` come payload.
1. Per elencare le voci nel bucket `amzn-s3-demo-bucket`, invia la richiesta seguente:
```
GET /S3/amzn-s3-demo-bucket HTTP/1.1
Host: 9gn28ca086.execute-api.{region}.amazonaws.com
Content-Type: application/xml
X-Amz-Date: 20161015T064324Z
Authorization: AWS4-HMAC-SHA256 Credential=access-key-id/20161015/{region}/execute-api/aws4_request, SignedHeaders=content-type;host;x-amz-date, Signature=4ac9bd4574a14e01568134fd16814534d9951649d3a22b3b0db9f1f5cd4dd0ac
Cache-Control: no-cache
Postman-Token: 9c43020a-966f-61e1-81af-4c49ad8d1392
```
Se l'operazione riesce, dovresti ricevere una risposta `200 OK` con un payload XML che mostra una voce singola nel bucket specificato, a meno che tu non abbia aggiunto altri file al bucket prima di inviare questa richiesta.
```
apig-demo-5
1000
false
Readme.txt
2016-10-15T06:26:48.000Z
"65a8e27d8879283831b664bd8b7f0ad4"
13
06e4b09e9d...603addd12ee
user-name
STANDARD
```
**Nota**
Per caricare o scaricare un'immagine, è necessario impostare la gestione del contenuto su CONVERT\$1TO\$1BINARY.
# Tutorial: creazione di un'API REST come un proxy Amazon Kinesis
In questa pagina viene descritto come creare e configurare un'API REST con un'integrazione di tipo `AWS` per accedere a Kinesis.
**Nota**
Per integrare l'API di API Gateway con Kinesis, devi scegliere una regione in cui i servizi API Gateway e Kinesis siano entrambi disponibili. Per la disponibilità della regione, vedere [Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html).
Per scopi illustrativi, creeremo un'API di esempio per permettere a un client di eseguire le operazioni seguenti:
1. Elencare i flussi disponibili dell'utente in Kinesis
1. Creare, descrivere o eliminare un flusso specificato.
1. Leggere o scrivere record di dati nel flusso specificato
Per eseguire le attività precedenti, l'API espone metodi in diverse risorse per richiamare, rispettivamente, gli elementi seguenti:
1. L'operazione `ListStreams` in Kinesis
1. Operazione `CreateStream`, `DescribeStream` o `DeleteStream`
1. Operazione `GetRecords` o `PutRecords` (inclusa `PutRecord`) in Kinesis
In particolare, compileremo l'API in questo modo:
+ Esponi un metodo HTTP GET sulla `/streams` risorsa dell'API e integra il metodo con l'[ListStreams](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListStreams.html)azione in Kinesis per elencare gli stream nell'account del chiamante.
+ Esponi un metodo HTTP POST sulla `/streams/{stream-name}` risorsa dell'API e integra il metodo con l'[CreateStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_CreateStream.html)azione in Kinesis per creare uno stream denominato nell'account del chiamante.
+ Esponi un metodo HTTP GET sulla `/streams/{stream-name}` risorsa dell'API e integra il metodo con l'[DescribeStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DescribeStream.html)azione in Kinesis per descrivere uno stream denominato nell'account del chiamante.
+ Esponi un metodo HTTP DELETE sulla `/streams/{stream-name}` risorsa dell'API e integra il metodo con l'[DeleteStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DeleteStream.html)azione in Kinesis per eliminare uno stream nell'account del chiamante.
+ Esponi un metodo HTTP PUT sulla `/streams/{stream-name}/record` risorsa dell'API e integra il metodo con l'[PutRecord](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html)azione in Kinesis. In questo modo, il client può aggiungere un singolo record di dati al flusso denominato.
+ Esponi un metodo HTTP PUT sulla `/streams/{stream-name}/records` risorsa dell'API e integra il metodo con l'[PutRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html)azione in Kinesis. In questo modo, il client può aggiungere un elenco di record di dati al flusso denominato.
+ Esponi un metodo HTTP GET sulla `/streams/{stream-name}/records` risorsa dell'API e integra il metodo con l'[GetRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetRecords.html)azione in Kinesis. In questo modo, il client può aggiungere un elenco di record di dati nel flusso denominato, con un'iterazione shard specificata. Un'iterazione shard specifica la posizione dello shard da cui iniziare a leggere i record di dati in sequenza.
+ Esponi un metodo HTTP GET sulla `/streams/{stream-name}/sharditerator` risorsa dell'API e integra il metodo con l'[GetShardIterator](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetShardIterator.html)azione in Kinesis. Questo metodo helper deve essere fornito all'operazione `ListStreams` in Kinesis.
Puoi applicare le istruzioni presentate qui ad altre operazioni di Kinesis. Per l'elenco completo delle operazioni di Kinesis, consulta la [documentazione di riferimento delle API di Amazon Kinesis](https://docs.aws.amazon.com/kinesis/latest/APIReference/Welcome.html).
Invece di usare la console API Gateway per creare l'API di esempio, puoi importare l'API di esempio in API Gateway, usando l'API Gateway di [Importa API](https://docs.aws.amazon.com/apigateway/latest/api/API_ImportRestApi.html). Per informazioni su come usare l'API di importazione, consulta [Sviluppa REST APIs utilizzando OpenAPI in API Gateway](api-gateway-import-api.md).
## Creazione di un ruolo e una policy IAM per l'API per accedere a Kinesis
Per permettere all'API di richiamare le operazioni di Kinesis, devi aver collegato le policy IAM appropriate a un ruolo IAM. In questo passaggio si crea un nuovo ruolo IAM.
**Per creare il ruolo di esecuzione del proxy del AWS servizio**
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Scegliere **Roles (Ruoli)**.
1. Scegli **Crea ruolo**.
1. Scegli il **AWS servizio** in **Seleziona il tipo di entità affidabile**, quindi seleziona **API Gateway** e seleziona Consenti **a API Gateway di inviare i log ai CloudWatch log**.
1. Scegli **Successivo** e di nuovo **Successivo**.
1. In **Role name (Nome ruolo)** immettere **APIGatewayKinesisProxyPolicy** e quindi selezionare **Create role (Crea ruolo)**.
1. Nell'elenco **Roles (Ruoli)** scegliere il ruolo appena creato. Potrebbe essere necessario scorrere o utilizzare la barra di ricerca per trovare il ruolo.
1. Per il ruolo selezionato, seleziona la scheda **Aggiungi autorizzazioni**.
1. Dall'elenco a discesa scegli **Collega policy**.
1. Nella barra di ricerca inserisci **AmazonKinesisFullAccess** e scegli **Aggiungi autorizzazioni**.
**Nota**
Per semplicità, questo tutorial utilizza una policy gestita. Come best practice, dovresti creare la tua policy IAM per concedere le autorizzazioni minime richieste.
1. Annota l'**ARN del ruolo** appena creato, lo utilizzerai in seguito.
## Creazione di un'API come un proxy Kinesis
Usa la procedura seguente per creare l'API nella console API Gateway.
**Per creare un'API come proxy AWS di servizio per Kinesis**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Se si utilizza API Gateway per la prima volta, verrà visualizzata una pagina che presenta le caratteristiche del servizio. In **API REST**, scegliere **Crea**. Quando appare il popup **Create Example API (Crea API di esempio)**, scegliere **OK**.
Se non è la prima volta che si utilizza API Gateway, scegliere **Create API (Crea API)**. In **API REST**, scegliere **Crea**.
1. Selezionare **New API (Nuova API)**.
1. Per **API name (Nome API)** immettere **KinesisProxy**. Per tutti gli altri campi mantieni i valori predefiniti.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Per il tipo di **indirizzo IP**, selezionare. **IPv4**
1. Seleziona **Create API** (Crea API).
Dopo la creazione dell'API, la console API Gateway visualizza la pagina **Resources (Risorse)**, che contiene solo la risorsa root (`/`) dell'API.
## Visualizzazione dell'elenco di flussi in Kinesis
Kinesis supporta l'operazione `ListStreams` con la chiamata API REST seguente:
```
POST /?Action=ListStreams HTTP/1.1
Host: kinesis..
Content-Length:
User-Agent:
Content-Type: application/x-amz-json-1.1
Authorization:
X-Amz-Date:
{
...
}
```
Nella richiesta API REST precedente l'operazione è specificata nel parametro di query `Action`. In alternativa, puoi specificare l'operazione in un'intestazione `X-Amz-Target`:
```
POST / HTTP/1.1
Host: kinesis..
Content-Length:
User-Agent:
Content-Type: application/x-amz-json-1.1
Authorization:
X-Amz-Date:
X-Amz-Target: Kinesis_20131202.ListStreams
{
...
}
```
In questo tutorial useremo il parametro di query per specificare l'operazione.
Per esporre un'operazione di Kinesis nell'API, aggiungi una risorsa `/streams` alla root dell'API. Imposta quindi un metodo `GET` nella risorsa e integra il metodo con l'operazione `ListStreams` di Kinesis.
La procedura seguente descrive come elencare flussi Kinesis tramite la console API Gateway.
**Per elencare i flussi Kinesis utilizzando la console API Gateway**
1. Seleziona la risorsa `/`, quindi scegli **Crea risorsa**.
1. Per **Resource Name (Nome risorsa)** immetti **streams**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
1. Scegli la risorsa `/streams` e seleziona **Crea metodo**, quindi procedi come segue:
1. Per **Tipo di metodo** seleziona **GET**.
**Nota**
Il verbo HTTP per un metodo richiamato da un client può differire dal verbo HTTP per un'integrazione richiesta dal back-end. Qui selezioniamo `GET` perché la visualizzazione dell'elenco di flussi è intuitivamente un'operazione READ.
1. Per **Tipo di integrazione** seleziona **Servizio AWS **.
1. Per **Regione AWS**, seleziona il Regione AWS luogo in cui hai creato lo stream Kinesis.
1. Per **Servizio AWS** seleziona **Kinesis**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **HTTP method** (Metodo HTTP) scegli **POST**.
**Nota**
Qui scegliamo `POST` perché Kinesis richiede che con il metodo venga richiamata l'operazione `ListStreams`.
1. Per **Tipo di operazione** scegli **Usa nome operazione**.
1. Per **Nome azione** immetti **ListStreams**.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo di esecuzione.
1. Lascia il valore predefinito **Transito** per **Gestione contenuti**.
1. Scegli **Crea metodo**.
1. Nella scheda **Richiesta di integrazione** scegli **Modifica** in **Impostazioni della richiesta di integrazione**.
1. Per **Richiesta corpo passthrough** scegli **Quando non ci sono modelli definiti (consigliato)**.
1. Scegli **Parametri delle intestazioni delle richieste URL** ed effettua le seguenti operazioni:
1. Scegli **Aggiungi parametro delle intestazioni delle richieste**.
1. In **Nome**, inserisci **Content-Type**.
1. In **Mappato da**, inserire **'application/x-amz-json-1.1'**.
Usiamo la mappatura dei parametri delle richieste per impostare l'intestazione `Content-Type` sul valore statico `'application/x-amz-json-1.1'` per indicare a Kinesis che l'input è una versione specifica di JSON.
1. Scegli **Modelli di mappatura**, quindi seleziona **Aggiungi modello di mappatura** ed effettua le seguenti operazioni:
1. Per **Content-Type** immetti **application/json**.
1. Per **Corpo del modello** immetti **\$1\$1**.
1. Scegli **Save** (Salva).
La [ListStreams](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListStreams.html#API_ListStreams_RequestSyntax)richiesta richiede un payload nel seguente formato JSON:
```
{
"ExclusiveStartStreamName": "string",
"Limit": number
}
```
Tuttavia, le proprietà sono facoltative. Per usare i valori predefiniti, qui abbiamo optato per un payload JSON vuoto.
1. Testa il metodo GET nella risorsa **/streams** per richiamare l'azione `ListStreams` in Kinesis:
Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
Scegli **Esegui test** per testare il metodo.
Se hai già creato due flussi denominati "myStream" e "yourStream" in Kinesis, il test con esito positivo restituisce una risposta 200 OK che contiene il payload seguente:
```
{
"HasMoreStreams": false,
"StreamNames": [
"myStream",
"yourStream"
]
}
```
## Creazione, descrizione ed eliminazione di un flusso in Kinesis
Per creare, descrivere ed eliminare un flusso in Kinesis è necessario effettuare, rispettivamente, le richieste API REST di Kinesis seguenti:
```
POST /?Action=CreateStream HTTP/1.1
Host: kinesis.region.domain
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"ShardCount": number,
"StreamName": "string"
}
```
```
POST /?Action=DescribeStream HTTP/1.1
Host: kinesis.region.domain
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"StreamName": "string"
}
```
```
POST /?Action=DeleteStream HTTP/1.1
Host: kinesis.region.domain
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"StreamName":"string"
}
```
Puoi compilare l'API in modo da accettare l'input richiesto come payload JSON della richiesta del metodo e passare il payload alla richiesta di integrazione. Tuttavia, per fornire più esempi di mappatura dei dati tra richieste di metodi e di integrazione e le rispettive risposte, creeremo l'API in un modo diverso.
Esponiamo i metodi `GET``POST`, e `Delete` HTTP su una risorsa. to-be-named `Stream` Useremo la variabile di percorso `{stream-name}` come segnaposto della risorsa flusso e integreremo questi metodi API rispettivamente con le operazioni `DescribeStream`, `CreateStream` e `DeleteStream` di Kinesis. Richiederemo che il client passi altri dati di input come intestazioni, parametri di query o payload della richiesta di un metodo. Specificheremo modelli di mappatura per trasformare i dati nel payload della richiesta di integrazione necessario.
**Per creare la risorsa \$1stream-name\$1**
1. Scegli la risorsa **/streams**, quindi seleziona **Crea risorsa**.
1. Mantieni l'opzione **Risorsa proxy** disattivata.
1. Per **Percorso risorsa** seleziona `/streams`.
1. Per **Resource Name (Nome risorsa)** immetti **\$1stream-name\$1**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
**Per configurare e testare il metodo GET in una risorsa flusso**
1. Scegli la risorsa **/\$1stream-name\$1**, quindi seleziona **Crea metodo**.
1. Per **Tipo di metodo** seleziona **GET**.
1. Per **Tipo di integrazione** seleziona **Servizio AWS **.
1. Per **Regione AWS**, seleziona il Regione AWS luogo in cui hai creato lo stream Kinesis.
1. Per **Servizio AWS** seleziona **Kinesis**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **HTTP method** (Metodo HTTP) scegli **POST**.
1. Per **Tipo di operazione** scegli **Usa nome operazione**.
1. Per **Nome azione** immetti **DescribeStream**.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo di esecuzione.
1. Lascia il valore predefinito **Transito** per **Gestione contenuti**.
1. Scegli **Crea metodo**.
1. Nella sezione **Richiesta di integrazione** aggiungi i seguenti **parametri delle intestazioni delle richieste URL**:
```
Content-Type: 'x-amz-json-1.1'
```
L'attività segue la stessa procedura usata per configurare la mappatura dei parametri di richiesta per il metodo `GET /streams`.
1. Aggiungi il modello di mappatura del corpo seguente per mappare i dati dalla richiesta del metodo `GET /streams/{stream-name}` alla richiesta di integrazione `POST /?Action=DescribeStream`:
```
{
"StreamName": "$input.params('stream-name')"
}
```
Questo modello di mappatura genera il payload della richiesta di integrazione necessario per l'operazione `DescribeStream` di Kinesis dal valore del parametro di percorso `stream-name` della richiesta del metodo.
1. Per testare il metodo `GET /stream/{stream-name}` per richiamare l'azione `DescribeStream` in Kinesis, scegli la scheda **Test**.
1. Per **Percorso** immetti il nome di un flusso Kinesis esistente in **stream-name**.
1. Scegli **Test (Esegui test)**. Se il test ha esito positivo, viene restituita una risposta 200 OK con un payload simile al seguente:
```
{
"StreamDescription": {
"HasMoreShards": false,
"RetentionPeriodHours": 24,
"Shards": [
{
"HashKeyRange": {
"EndingHashKey": "68056473384187692692674921486353642290",
"StartingHashKey": "0"
},
"SequenceNumberRange": {
"StartingSequenceNumber": "49559266461454070523309915164834022007924120923395850242"
},
"ShardId": "shardId-000000000000"
},
...
{
"HashKeyRange": {
"EndingHashKey": "340282366920938463463374607431768211455",
"StartingHashKey": "272225893536750770770699685945414569164"
},
"SequenceNumberRange": {
"StartingSequenceNumber": "49559266461543273504104037657400164881014714369419771970"
},
"ShardId": "shardId-000000000004"
}
],
"StreamARN": "arn:aws:kinesis:us-east-1:12345678901:stream/myStream",
"StreamName": "myStream",
"StreamStatus": "ACTIVE"
}
}
```
Dopo aver distribuito l'API, puoi effettuare una richiesta REST su questo metodo API:
```
GET https://your-api-id.execute-api.region.amazonaws.com/stage/streams/myStream HTTP/1.1
Host: your-api-id.execute-api.region.amazonaws.com
Content-Type: application/json
Authorization: ...
X-Amz-Date: 20160323T194451Z
```
**Per configurare e testare il metodo POST in una risorsa flusso**
1. Scegli la risorsa **/\$1stream-name\$1**, quindi seleziona **Crea metodo**.
1. Per **Tipo di metodo** seleziona **POST**.
1. Per **Tipo di integrazione** seleziona **Servizio AWS **.
1. Per **Regione AWS**, seleziona il Regione AWS luogo in cui hai creato lo stream Kinesis.
1. Per **Servizio AWS** seleziona **Kinesis**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **HTTP method** (Metodo HTTP) scegli **POST**.
1. Per **Tipo di operazione** scegli **Usa nome operazione**.
1. Per **Nome azione** immetti **CreateStream**.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo di esecuzione.
1. Lascia il valore predefinito **Transito** per **Gestione contenuti**.
1. Scegli **Crea metodo**.
1. Nella sezione **Richiesta di integrazione** aggiungi i seguenti **parametri delle intestazioni delle richieste URL**:
```
Content-Type: 'x-amz-json-1.1'
```
L'attività segue la stessa procedura usata per configurare la mappatura dei parametri di richiesta per il metodo `GET /streams`.
1. Aggiungi il modello di mappatura del corpo seguente per mappare i dati dalla richiesta del metodo `POST /streams/{stream-name}` alla richiesta di integrazione `POST /?Action=CreateStream`:
```
{
"ShardCount": #if($input.path('$.ShardCount') == '') 5 #else $input.path('$.ShardCount') #end,
"StreamName": "$input.params('stream-name')"
}
```
Nel modello di mappatura precedente impostiamo `ShardCount` sul valore fisso 5 se il client non specifica alcun valore nel payload della richiesta del metodo.
1. Per testare il metodo `POST /stream/{stream-name}` per richiamare l'azione `CreateStream` in Kinesis, scegli la scheda **Test**.
1. Per **Percorso** immetti il nome di un nuovo flusso Kinesis in **stream-name**.
1. Scegli **Test (Esegui test)**. Se il test ha esito positivo, viene restituita una risposta 200 OK senza dati.
Dopo aver distribuito l'API, puoi anche effettuare una richiesta API REST sul metodo POST in una risorsa flusso per richiamare l'operazione `CreateStream` in Kinesis:
```
POST https://your-api-id.execute-api.region.amazonaws.com/stage/streams/yourStream HTTP/1.1
Host: your-api-id.execute-api.region.amazonaws.com
Content-Type: application/json
Authorization: ...
X-Amz-Date: 20160323T194451Z
{
"ShardCount": 5
}
```
**Configurazione e test del metodo DELETE in una risorsa flusso**
1. Scegli la risorsa **/\$1stream-name\$1**, quindi seleziona **Crea metodo**.
1. Per **Tipo di metodo** seleziona **DELETE**.
1. Per **Tipo di integrazione** seleziona **Servizio AWS **.
1. Per **Regione AWS**, seleziona il Regione AWS luogo in cui hai creato lo stream Kinesis.
1. Per **Servizio AWS** seleziona **Kinesis**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **HTTP method** (Metodo HTTP) scegli **POST**.
1. Per **Tipo di operazione** scegli **Usa nome operazione**.
1. Per **Nome azione** immetti **DeleteStream**.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo di esecuzione.
1. Lascia il valore predefinito **Transito** per **Gestione contenuti**.
1. Scegli **Crea metodo**.
1. Nella sezione **Richiesta di integrazione** aggiungi i seguenti **parametri delle intestazioni delle richieste URL**:
```
Content-Type: 'x-amz-json-1.1'
```
L'attività segue la stessa procedura usata per configurare la mappatura dei parametri di richiesta per il metodo `GET /streams`.
1. Aggiungi il modello di mappatura del corpo seguente per mappare i dati dalla richiesta del metodo `DELETE /streams/{stream-name}` alla richiesta di integrazione corrispondente di `POST /?Action=DeleteStream`:
```
{
"StreamName": "$input.params('stream-name')"
}
```
Questo modello di mappatura genera l'input richiesto per l'operazione `DELETE /streams/{stream-name}` dal nome di percorso URL fornito dal client `stream-name`.
1. Per testare il metodo `DELETE /stream/{stream-name}` per richiamare l'azione `DeleteStream` in Kinesis, scegli la scheda **Test**.
1. Per **Percorso** immetti il nome di un flusso Kinesis esistente in **stream-name**.
1. Scegli **Test (Esegui test)**. Se il test ha esito positivo, viene restituita una risposta 200 OK senza dati.
Dopo aver distribuito l'API, puoi anche effettuare la richiesta API REST seguente sul metodo DELETE nella risorsa flusso per chiamare l'operazione `DeleteStream` in Kinesis:
```
DELETE https://your-api-id.execute-api.region.amazonaws.com/stage/streams/yourStream HTTP/1.1
Host: your-api-id.execute-api.region.amazonaws.com
Content-Type: application/json
Authorization: ...
X-Amz-Date: 20160323T194451Z
{}
```
## Recupero di record e aggiunta di record in un flusso in Kinesis
Dopo aver creato un flusso in Kinesis, puoi aggiungere record di dati al flusso e leggere i dati dal flusso. L'aggiunta di record di dati implica la chiamata all'[PutRecord](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html#API_PutRecord_Examples)azione [PutRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html#API_PutRecords_Examples)o in Kinesis. La prima operazione aggiunge più record, la seconda aggiunge un singolo record al flusso.
```
POST /?Action=PutRecords HTTP/1.1
Host: kinesis.region.domain
Authorization: AWS4-HMAC-SHA256 Credential=..., ...
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"Records": [
{
"Data": blob,
"ExplicitHashKey": "string",
"PartitionKey": "string"
}
],
"StreamName": "string"
}
```
oppure
```
POST /?Action=PutRecord HTTP/1.1
Host: kinesis.region.domain
Authorization: AWS4-HMAC-SHA256 Credential=..., ...
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"Data": blob,
"ExplicitHashKey": "string",
"PartitionKey": "string",
"SequenceNumberForOrdering": "string",
"StreamName": "string"
}
```
Qui `StreamName` identifica il flusso di destinazione per aggiungere record. `StreamName`, `Data`, e `PartitionKey` sono dati di input obbligatori. Nel nostro esempio useremo i valori predefiniti per tutti i dati di input facoltativi e non ne specificheremo in modo esplicito i valori nell'input per la richiesta del metodo.
Leggere i dati in Kinesis equivale a richiamare l'azione [GetRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetRecords.html#API_GetRecords_Examples):
```
POST /?Action=GetRecords HTTP/1.1
Host: kinesis.region.domain
Authorization: AWS4-HMAC-SHA256 Credential=..., ...
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"ShardIterator": "string",
"Limit": number
}
```
Qui il flusso di origine da cui vogliamo ottenere record è specificato nel valore `ShardIterator` obbligatorio, come mostrato nell'operazione di Kinesis seguente per ottenere un'iterazione shard:
```
POST /?Action=GetShardIterator HTTP/1.1
Host: kinesis.region.domain
Authorization: AWS4-HMAC-SHA256 Credential=..., ...
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"ShardId": "string",
"ShardIteratorType": "string",
"StartingSequenceNumber": "string",
"StreamName": "string"
}
```
Per le operazioni `GetRecords` e `PutRecords`, esponiamo rispettivamente i metodi `GET` e `PUT` in una risorsa `/records` che viene aggiunta a una risorsa flusso denominata (`/{stream-name}`). Analogamente, esponiamo l'operazione `PutRecord` come metodo `PUT` in una risorsa `/record`.
Poiché l'operazione `GetRecords` accetta come input un valore `ShardIterator`, ottenuto chiamando l'operazione helper `GetShardIterator`, esponiamo un metodo helper `GET` in una risorsa `ShardIterator` (`/sharditerator`).
**Per creare le risorse /record, /records e /sharditerator**
1. Scegli la risorsa **/\$1stream-name\$1**, quindi seleziona **Crea risorsa**.
1. Mantieni l'opzione **Risorsa proxy** disattivata.
1. Per **Percorso risorsa** seleziona `/{stream-name}`.
1. Per **Resource Name (Nome risorsa)** immetti **record**.
1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.
1. Scegli **Crea risorsa**.
1. Ripeti le fasi precedenti per creare una risorsa **/records** e una risorsa **/sharditerator**. L'API finale sarà simile alla seguente:
![\[Creazione del metodo Records:GET|PUT|PUT|GET per l'API.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/api-gateway-kinesis-proxy-setup-streams-stream-record-method-new-console.png)
Le quattro procedure seguenti descrivono come configurare ognuno dei metodi, come mappare i dati dalle richieste dei metodi alle richieste di integrazione e come testare i metodi.
**Per configurare e testare il metodo `PUT /streams/{stream-name}/record` per richiamare `PutRecord` in Kinesis:**
1. Scegli la risorsa **/record**, quindi seleziona **Crea metodo**.
1. Per **Tipo di metodo** seleziona **PUT**.
1. Per **Tipo di integrazione** seleziona **Servizio AWS **.
1. Per **Regione AWS**, seleziona il Regione AWS luogo in cui hai creato lo stream Kinesis.
1. Per **Servizio AWS** seleziona **Kinesis**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **HTTP method** (Metodo HTTP) scegli **POST**.
1. Per **Tipo di operazione** scegli **Usa nome operazione**.
1. Per **Nome azione** immetti **PutRecord**.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo di esecuzione.
1. Lascia il valore predefinito **Transito** per **Gestione contenuti**.
1. Scegli **Crea metodo**.
1. Nella sezione **Richiesta di integrazione** aggiungi i seguenti **parametri delle intestazioni delle richieste URL**:
```
Content-Type: 'x-amz-json-1.1'
```
L'attività segue la stessa procedura usata per configurare la mappatura dei parametri di richiesta per il metodo `GET /streams`.
1. Aggiungi il modello di mappatura del corpo seguente per mappare i dati dalla richiesta del metodo `PUT /streams/{stream-name}/record` alla richiesta di integrazione corrispondente di `POST /?Action=PutRecord`:
```
{
"StreamName": "$input.params('stream-name')",
"Data": "$util.base64Encode($input.json('$.Data'))",
"PartitionKey": "$input.path('$.PartitionKey')"
}
```
Questo modello di mappatura presuppone che il payload della richiesta del metodo abbia il formato seguente:
```
{
"Data": "some data",
"PartitionKey": "some key"
}
```
Questi dati possono essere modellati tramite lo schema JSON seguente:
```
{
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "PutRecord proxy single-record payload",
"type": "object",
"properties": {
"Data": { "type": "string" },
"PartitionKey": { "type": "string" }
}
}
```
Puoi creare un modello per includere questo schema e usare il modello per semplificare la generazione del modello di mappatura. Tuttavia, puoi generare un modello di mappatura senza usare alcun modello.
1. Per testare il metodo `PUT /streams/{stream-name}/record`, imposta la variabile di percorso `stream-name` sul nome di un flusso esistente, fornisci un payload con il formato richiesto e quindi invia la richiesta del metodo. Il risultato con esito positivo è una risposta `200 OK `con un payload nel formato seguente:
```
{
"SequenceNumber": "49559409944537880850133345460169886593573102115167928386",
"ShardId": "shardId-000000000004"
}
```
**Per configurare e testare il metodo `PUT /streams/{stream-name}/records` per richiamare `PutRecords` in Kinesis**
1. Scegli la risorsa **/records**, quindi seleziona **Crea metodo**.
1. Per **Tipo di metodo** seleziona **PUT**.
1. Per **Tipo di integrazione** seleziona **Servizio AWS **.
1. Per **Regione AWS**, seleziona il Regione AWS luogo in cui hai creato lo stream Kinesis.
1. Per **Servizio AWS** seleziona **Kinesis**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **HTTP method** (Metodo HTTP) scegli **POST**.
1. Per **Tipo di operazione** scegli **Usa nome operazione**.
1. Per **Nome azione** immetti **PutRecords**.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo di esecuzione.
1. Lascia il valore predefinito **Transito** per **Gestione contenuti**.
1. Scegli **Crea metodo**.
1. Nella sezione **Richiesta di integrazione** aggiungi i seguenti **parametri delle intestazioni delle richieste URL**:
```
Content-Type: 'x-amz-json-1.1'
```
L'attività segue la stessa procedura usata per configurare la mappatura dei parametri di richiesta per il metodo `GET /streams`.
1. Aggiungi il modello di mappatura seguente per mappare i dati dalla richiesta del metodo `PUT /streams/{stream-name}/records` alla richiesta di integrazione corrispondente di `POST /?Action=PutRecords`:
```
{
"StreamName": "$input.params('stream-name')",
"Records": [
#foreach($elem in $input.path('$.records'))
{
"Data": "$util.base64Encode($elem.data)",
"PartitionKey": "$elem.partition-key"
}#if($foreach.hasNext),#end
#end
]
}
```
Questo modello di mappatura presuppone che il payload della richiesta del metodo possa essere modellato tramite lo schema JSON seguente:
```
{
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "PutRecords proxy payload data",
"type": "object",
"properties": {
"records": {
"type": "array",
"items": {
"type": "object",
"properties": {
"data": { "type": "string" },
"partition-key": { "type": "string" }
}
}
}
}
}
```
Puoi creare un modello per includere questo schema e usare il modello per semplificare la generazione del modello di mappatura. Tuttavia, puoi generare un modello di mappatura senza usare alcun modello.
In questo tutorial abbiamo usato due formati di payload leggermente diversi per mostrare come uno sviluppatore di API possa scegliere di esporre il formato di dati di back-end al client o nasconderlo dal client. Un formato è per il metodo `PUT /streams/{stream-name}/records` (sopra). Un altro formato viene usato per il metodo `PUT /streams/{stream-name}/record` (nella procedura precedente). Nell'ambiente di produzione devi mantenere i due formati coerenti.
1.
Per testare il metodo `PUT /streams/{stream-name}/records`, imposta la variabile di percorso `stream-name` su un flusso esistente, fornisci il payload seguente e invia la richiesta del metodo.
```
{
"records": [
{
"data": "some data",
"partition-key": "some key"
},
{
"data": "some other data",
"partition-key": "some key"
}
]
}
```
Il risultato con esito positivo è una risposta 200 OK con un payload simile all'output seguente:
```
{
"FailedRecordCount": 0,
"Records": [
{
"SequenceNumber": "49559409944537880850133345460167468741933742152373764162",
"ShardId": "shardId-000000000004"
},
{
"SequenceNumber": "49559409944537880850133345460168677667753356781548470338",
"ShardId": "shardId-000000000004"
}
]
}
```
**Per configurare e testare il metodo `GET /streams/{stream-name}/sharditerator` per richiamare `GetShardIterator` in Kinesis**
Il metodo `GET /streams/{stream-name}/sharditerator` è un metodo helper per acquisire un'iterazione shard necessaria prima di chiamare il metodo `GET /streams/{stream-name}/records`.
1. Scegli la risorsa **/sharditerator**, quindi seleziona **Crea metodo**.
1. Per **Tipo di metodo** seleziona **GET**.
1. Per **Tipo di integrazione** seleziona **Servizio AWS **.
1. Per **Regione AWS**, seleziona il Regione AWS luogo in cui hai creato lo stream Kinesis.
1. Per **Servizio AWS** seleziona **Kinesis**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **HTTP method** (Metodo HTTP) scegli **POST**.
1. Per **Tipo di operazione** scegli **Usa nome operazione**.
1. Per **Nome azione** immetti **GetShardIterator**.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo di esecuzione.
1. Lascia il valore predefinito **Transito** per **Gestione contenuti**.
1. Scegli **Parametri della stringa di query URL**.
L'operazione `GetShardIterator` richiede l'immissione di un valore ShardId. Per passare un valore `ShardId` fornito dal client, aggiungiamo un parametro di query `shard-id` alla richiesta del metodo, come mostrato nella seguente fase.
1. Scegliere **Add query string (Aggiungi stringa di query)**.
1. In **Nome**, inserisci **shard-id**.
1. Mantieni **Obbligatorio** e **Caching** disattivati.
1. Scegli **Crea metodo**.
1. Nella sezione **Richiesta di integrazione** aggiungi il seguente modello di mappatura per generare l'input richiesto (`ShardId` e `StreamName`) per l'azione `GetShardIterator` dei parametri `shard-id` e `stream-name` della richiesta del metodo. Inoltre, il modello di mappatura imposta anche `ShardIteratorType` su `TRIM_HORIZON` come comportamento predefinito.
```
{
"ShardId": "$input.params('shard-id')",
"ShardIteratorType": "TRIM_HORIZON",
"StreamName": "$input.params('stream-name')"
}
```
1. Usando l'opzione **Test** nella console API Gateway, immetti il nome di un flusso esistente come valore della variabile `stream-name`**Path (Percorso)**, imposta `shard-id`**Query string (Stringa di query)** su un valore `ShardId` esistente, ad esempio `shard-000000000004`, e seleziona **Test**.
Il payload di risposta di esito positivo è simile all'output seguente:
```
{
"ShardIterator": "AAAAAAAAAAFYVN3VlFy..."
}
```
Annota il valore di `ShardIterator`. Ti servirà per ottenere record da un flusso.
**Per configurare e testare il metodo `GET /streams/{stream-name}/records` per richiamare l'operazione `GetRecords` in Kinesis**
1. Scegli la risorsa **/records**, quindi seleziona **Crea metodo**.
1. Per **Tipo di metodo** seleziona **GET**.
1. Per **Tipo di integrazione** seleziona **Servizio AWS **.
1. Per **Regione AWS**, seleziona il Regione AWS luogo in cui hai creato lo stream Kinesis.
1. Per **Servizio AWS** seleziona **Kinesis**.
1. Lascia vuoto **Sottodominio AWS **.
1. Per **HTTP method** (Metodo HTTP) scegli **POST**.
1. Per **Tipo di operazione** scegli **Usa nome operazione**.
1. Per **Nome azione** immetti **GetRecords**.
1. Per **Ruolo di esecuzione** immetti l'ARN del ruolo di esecuzione.
1. Lascia il valore predefinito **Transito** per **Gestione contenuti**.
1. Scegli **Intestazioni di richiesta HTTP**.
L'operazione `GetRecords` richiede l'immissione di un valore `ShardIterator`. Per passare un valore `ShardIterator` fornito dal client, si aggiunge un parametro di intestazione `Shard-Iterator` alla richiesta del metodo.
1. Seleziona **Add header (Aggiungi intestazione)**.
1. In **Nome**, inserisci **Shard-Iterator**.
1. Mantieni **Obbligatorio** e **Caching** disattivati.
1. Scegli **Crea metodo**.
1. Nella sezione **Richiesta di integrazione** aggiungi il seguente modello di mappatura del corpo per mappare il valore del parametro di intestazione `Shard-Iterator` al valore della proprietà `ShardIterator` del payload JSON per l'azione `GetRecords` in Kinesis.
```
{
"ShardIterator": "$input.params('Shard-Iterator')"
}
```
1. Usando l'opzione **Test** nella console Gateway API, immetti il nome di un flusso esistente come valore della variabile **Percorso** `stream-name`, imposta **Intestazione** `Shard-Iterator` sul valore `ShardIterator` ottenuto dall'esecuzione del test del metodo `GET /streams/{stream-name}/sharditerator` (precedente) e scegli **Test**.
Il payload di risposta di esito positivo è simile all'output seguente:
```
{
"MillisBehindLatest": 0,
"NextShardIterator": "AAAAAAAAAAF...",
"Records": [ ... ]
}
```
# Definizioni OpenAPI di un'API di esempio come un proxy Kinesis
Di seguito sono riportate le definizioni OpenAPI per l'API di esempio come proxy Kinesis utilizzate in questo tutorial.
------
#### [ OpenAPI 3.0 ]
```
{
"openapi": "3.0.0",
"info": {
"title": "KinesisProxy",
"version": "2016-03-31T18:25:32Z"
},
"paths": {
"/streams/{stream-name}/sharditerator": {
"get": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
},
{
"name": "shard-id",
"in": "query",
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/GetShardIterator",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardId\": \"$input.params('shard-id')\",\n \"ShardIteratorType\": \"TRIM_HORIZON\",\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/records": {
"get": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
},
{
"name": "Shard-Iterator",
"in": "header",
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/GetRecords",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardIterator\": \"$input.params('Shard-Iterator')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"put": {
"parameters": [
{
"name": "Content-Type",
"in": "header",
"schema": {
"type": "string"
}
},
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/PutRecordsMethodRequestPayload"
}
},
"application/x-amz-json-1.1": {
"schema": {
"$ref": "#/components/schemas/PutRecordsMethodRequestPayload"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/PutRecords",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\",\n \"Records\": [\n {\n \"Data\": \"$util.base64Encode($elem.data)\",\n \"PartitionKey\": \"$elem.partition-key\"\n }#if($foreach.hasNext),#end\n ]\n}",
"application/x-amz-json-1.1": "{\n \"StreamName\": \"$input.params('stream-name')\",\n \"records\" : [\n {\n \"Data\" : \"$elem.data\",\n \"PartitionKey\" : \"$elem.partition-key\"\n }#if($foreach.hasNext),#end\n ]\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}": {
"get": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/DescribeStream",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"post": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/CreateStream",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardCount\": 5,\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"delete": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"headers": {
"Content-Type": {
"schema": {
"type": "string"
}
}
},
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
},
"400": {
"description": "400 response",
"headers": {
"Content-Type": {
"schema": {
"type": "string"
}
}
},
"content": {}
},
"500": {
"description": "500 response",
"headers": {
"Content-Type": {
"schema": {
"type": "string"
}
}
},
"content": {}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/DeleteStream",
"responses": {
"4\\d{2}": {
"statusCode": "400",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
},
"5\\d{2}": {
"statusCode": "500",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/record": {
"put": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/PutRecord",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\",\n \"Data\": \"$util.base64Encode($input.json('$.Data'))\",\n \"PartitionKey\": \"$input.path('$.PartitionKey')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams": {
"get": {
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/ListStreams",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
}
},
"components": {
"schemas": {
"Empty": {
"type": "object"
},
"PutRecordsMethodRequestPayload": {
"type": "object",
"properties": {
"records": {
"type": "array",
"items": {
"type": "object",
"properties": {
"data": {
"type": "string"
},
"partition-key": {
"type": "string"
}
}
}
}
}
}
}
}
}
```
------
#### [ OpenAPI 2.0 ]
```
{
"swagger": "2.0",
"info": {
"version": "2016-03-31T18:25:32Z",
"title": "KinesisProxy"
},
"basePath": "/test",
"schemes": [
"https"
],
"paths": {
"/streams": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/ListStreams",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/DescribeStream",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"post": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/CreateStream",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardCount\": 5,\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"delete": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response",
"headers": {
"Content-Type": {
"type": "string"
}
}
},
"500": {
"description": "500 response",
"headers": {
"Content-Type": {
"type": "string"
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/DeleteStream",
"responses": {
"4\\d{2}": {
"statusCode": "400",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
},
"5\\d{2}": {
"statusCode": "500",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/record": {
"put": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/PutRecord",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\",\n \"Data\": \"$util.base64Encode($input.json('$.Data'))\",\n \"PartitionKey\": \"$input.path('$.PartitionKey')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/records": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "Shard-Iterator",
"in": "header",
"required": false,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/GetRecords",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardIterator\": \"$input.params('Shard-Iterator')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"put": {
"consumes": [
"application/json",
"application/x-amz-json-1.1"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "Content-Type",
"in": "header",
"required": false,
"type": "string"
},
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
},
{
"in": "body",
"name": "PutRecordsMethodRequestPayload",
"required": true,
"schema": {
"$ref": "#/definitions/PutRecordsMethodRequestPayload"
}
},
{
"in": "body",
"name": "PutRecordsMethodRequestPayload",
"required": true,
"schema": {
"$ref": "#/definitions/PutRecordsMethodRequestPayload"
}
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/PutRecords",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\",\n \"Records\": [\n {\n \"Data\": \"$util.base64Encode($elem.data)\",\n \"PartitionKey\": \"$elem.partition-key\"\n }#if($foreach.hasNext),#end\n ]\n}",
"application/x-amz-json-1.1": "{\n \"StreamName\": \"$input.params('stream-name')\",\n \"records\" : [\n {\n \"Data\" : \"$elem.data\",\n \"PartitionKey\" : \"$elem.partition-key\"\n }#if($foreach.hasNext),#end\n ]\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/sharditerator": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "shard-id",
"in": "query",
"required": false,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/GetShardIterator",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardId\": \"$input.params('shard-id')\",\n \"ShardIteratorType\": \"TRIM_HORIZON\",\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
}
},
"definitions": {
"Empty": {
"type": "object"
},
"PutRecordsMethodRequestPayload": {
"type": "object",
"properties": {
"records": {
"type": "array",
"items": {
"type": "object",
"properties": {
"data": {
"type": "string"
},
"partition-key": {
"type": "string"
}
}
}
}
}
}
}
}
```
------
# Tutorial: crea un'API REST utilizzando AWS SDKs o AWS CLI
Usa il seguente tutorial per creare un' PetStore API che supporti i `GET /pets/{petId}` metodi `GET /pets` and. I metodi sono integrati con un endpoint HTTP. Puoi seguire questo tutorial usando l' AWS SDK for JavaScript, l'SDK for Python (Boto3) o il. AWS CLI Per configurare l'API vengono utilizzati i seguenti comandi o funzioni:
------
#### [ JavaScript v3 ]
+ [ CreateRestApiCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/CreateRestApiCommand/)
+ [ CreateResourceCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/CreateResourceCommand/)
+ [ PutMethodCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/PutMethodCommand/)
+ [ PutMethodResponseCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/PutMethodResponseCommand/)
+ [ PutIntegrationCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/PutIntegrationCommand/)
+ [ PutIntegrationResponseCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/PutIntegrationResponseCommand/)
+ [ CreateDeploymentCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/CreateDeploymentCommand/)
------
#### [ Python ]
+ [ create\$1rest\$1api](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/create_rest_api.html)
+ [ create\$1resource](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/create_resource.html)
+ [ put\$1method](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/put_method.html)
+ [ put\$1method\$1response](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/put_method_response.html)
+ [ put\$1integration](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/put_integration.html)
+ [ put\$1integration\$1response](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/put_integration_response.html)
+ [ create\$1deployment](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/create_deployment.html)
------
#### [ AWS CLI ]
+ [create-rest-api](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-rest-api.html)
+ [create-resource](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-resource.html)
+ [put-method](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method.html)
+ [put-method-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method-response.html)
+ [put-integration](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration.html)
+ [put-integration-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration-response.html)
+ [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-deployment.html)
------
[Per ulteriori informazioni sull' AWS SDK per la versione JavaScript 3, vedi A cosa serve l'SDK? AWS JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/welcome.html) . Per ulteriori informazioni sull'SDK per Python (Boto3), consulta [AWS SDK per Python (Boto3)](https://docs.aws.amazon.com/pythonsdk). Per ulteriori informazioni su AWS CLI, vedi [Cos'è il AWS CLI?](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) .
## Configura un'API ottimizzata per l'edge PetStore
In questo tutorial, i comandi di esempio utilizzano valori segnaposto per valori IDs come l'ID API e l'ID della risorsa. Una volta completato il tutorial, sostituisci questi valori con valori personalizzati.
**Per configurare un'API ottimizzata per i bordi utilizzando PetStore AWS SDKs**
1. Utilizza il seguente esempio per creare un'entità `RestApi`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, CreateRestApiCommand} from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new CreateRestApiCommand({
name: "Simple PetStore (JavaScript v3 SDK)",
description: "Demo API created using the AWS SDK for JavaScript v3",
version: "0.00.001",
binaryMediaTypes: [
'*']
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.error(Couldn't create API:\n", err)
}
})();
```
Una chiamata riuscita restituisce l'ID API e l'ID risorsa root dell'API in un output simile al seguente:
```
{
id: 'abc1234',
name: 'PetStore (JavaScript v3 SDK)',
description: 'Demo API created using the AWS SDK for node.js',
createdDate: 2017-09-05T19:32:35.000Z,
version: '0.00.001',
rootResourceId: 'efg567'
binaryMediaTypes: [ '*' ]
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.create_rest_api(
name='Simple PetStore (Python SDK)',
description='Demo API created using the AWS SDK for Python',
version='0.00.001',
binaryMediaTypes=[
'*'
]
)
except botocore.exceptions.ClientError as error:
logger.exception("Couldn't create REST API %s.", error)
raise
attribute=["id","name","description","createdDate","version","binaryMediaTypes","apiKeySource","endpointConfiguration","disableExecuteApiEndpoint","rootResourceId"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Una chiamata riuscita restituisce l'ID API e l'ID risorsa root dell'API in un output simile al seguente:
```
{'id': 'abc1234', 'name': 'Simple PetStore (Python SDK)', 'description': 'Demo API created using the AWS SDK for Python', 'createdDate': datetime.datetime(2024, 4, 3, 14, 31, 39, tzinfo=tzlocal()), 'version': '0.00.001', 'binaryMediaTypes': ['*'], 'apiKeySource': 'HEADER', 'endpointConfiguration': {'types': ['EDGE']}, 'disableExecuteApiEndpoint': False, 'rootResourceId': 'efg567'}
```
------
#### [ AWS CLI ]
```
aws apigateway create-rest-api --name 'Simple PetStore (AWS CLI)' --region us-west-2
```
L'output di questo comando è il seguente:
```
{
"id": "abcd1234",
"name": "Simple PetStore (AWS CLI)",
"createdDate": "2022-12-15T08:07:04-08:00",
"apiKeySource": "HEADER",
"endpointConfiguration": {
"types": [
"EDGE"
]
},
"disableExecuteApiEndpoint": false,
"rootResourceId": "efg567"
}
```
------
L'API creata ha un ID API che corrisponde a `abcd1234` e un ID risorsa root che corrisponde a `efg567`. Questi valori vengono utilizzati nella configurazione dell'API.
1. Quindi, viene aggiunta una risorsa figlio sotto la risorsa root e specificato il valore `RootResourceId` come valore della proprietà `parentId`. Nel seguente esempio si crea una risorsa `/pets` per l’API:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, CreateResourceCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new CreateResourceCommand({
restApiId: 'abcd1234',
parentId: 'efg567',
pathPart: 'pets'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The '/pets' resource setup failed:\n", err)
}
})();
```
Una chiamata riuscita restituisce informazioni sulla risorsa in un output simile al seguente:
```
{
"path": "/pets",
"pathPart": "pets",
"id": "aaa111",
"parentId": "efg567'"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.create_resource(
restApiId='abcd1234',
parentId='efg567',
pathPart='pets'
)
except botocore.exceptions.ClientError as error:
logger.exception("The '/pets' resource setup failed: %s.", error)
raise
attribute=["id","parentId", "pathPart", "path",]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Una chiamata riuscita restituisce informazioni sulla risorsa in un output simile al seguente:
```
{'id': 'aaa111', 'parentId': 'efg567', 'pathPart': 'pets', 'path': '/pets'}
```
------
#### [ AWS CLI ]
```
aws apigateway create-resource --rest-api-id abcd1234 \
--region us-west-2 \
--parent-id efg567 \
--path-part pets
```
L'output di questo comando è il seguente:
```
{
"id": "aaa111",
"parentId": "efg567",
"pathPart": "pets",
"path": "/pets"
}
```
------
La risorsa `/pets` creata ha un ID risorsa che corrisponde a `aaa111`. Questo valore viene utilizzato nella configurazione dell'API.
1. Quindi, viene aggiunta una risorsa figlio sotto la risorsa `/pets`. Questa risorsa `/{petId}` ha un parametro di percorso per `{petId}`. Per fare di una parte di percorso un parametro di percorso, racchiudila tra parentesi graffe, `{ }`. Nel seguente esempio si crea una risorsa `/pets/{petId}` per l’API:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, CreateResourceCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new CreateResourceCommand({
restApiId: 'abcd1234',
parentId: 'aaa111',
pathPart: '{petId}'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The '/pets/{petId}' resource setup failed:\n", err)
}
})();
```
Una chiamata riuscita restituisce informazioni sulla risorsa in un output simile al seguente:
```
{
"path": "/pets/{petId}",
"pathPart": "{petId}",
"id": "bbb222",
"parentId": "aaa111'"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.create_resource(
restApiId='abcd1234',
parentId='aaa111',
pathPart='{petId}'
)
except botocore.exceptions.ClientError as error:
logger.exception("The '/pets/{petId}' resource setup failed: %s.", error)
raise
attribute=["id","parentId", "pathPart", "path",]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Una chiamata riuscita restituisce informazioni sulla risorsa in un output simile al seguente:
```
{'id': 'bbb222', 'parentId': 'aaa111', 'pathPart': '{petId}', 'path': '/pets/{petId}'}
```
------
#### [ AWS CLI ]
```
aws apigateway create-resource --rest-api-id abcd1234 \
--region us-west-2 \
--parent-id aaa111 \
--path-part '{petId}'
```
L'output di questo comando è il seguente:
```
{
"id": "bbb222",
"parentId": "aaa111",
"path": "/pets/{petId}",
"pathPart": "{petId}"
}
```
------
La risorsa `/pets/{petId}` creata ha un ID risorsa che corrisponde a `bbb222`. Questo valore viene utilizzato nella configurazione dell'API.
1. Nei due passaggi seguenti, vengono aggiunti metodi HTTP alle risorse. In questo tutorial, vengono impostati i metodi per avere accesso aperto impostando `authorization-type` su `NONE`. Per consentire solo agli utenti autenticati di chiamare il metodo, puoi utilizzare i ruoli e le policy IAM, un'autorizzazione Lambda (nota in precedenza come autorizzazioni ad hoc) o un pool di utenti di Amazon Cognito. Per ulteriori informazioni, consulta [Controlla e gestisci l'accesso a REST APIs in API Gateway](apigateway-control-access-to-api.md).
Nel seguente esempio si aggiunge il metodo HTTP `GET` per la risorsa `/pets`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutMethodCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutMethodCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
authorizationType: 'NONE'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The 'GET /pets' method setup failed:\n", err)
}
})();
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{
"apiKeyRequired": false,
"httpMethod": "GET",
"authorizationType": "NONE"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_method(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
authorizationType='NONE'
)
except botocore.exceptions.ClientError as error:
logger.exception("The 'GET /pets' method setup failed: %s", error)
raise
attribute=["httpMethod","authorizationType","apiKeyRequired"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{'httpMethod': 'GET', 'authorizationType': 'NONE', 'apiKeyRequired': False}
```
------
#### [ AWS CLI ]
```
aws apigateway put-method --rest-api-id abcd1234 \
--resource-id aaa111 \
--http-method GET \
--authorization-type "NONE" \
--region us-west-2
```
L'output di questo comando è il seguente:
```
{
"httpMethod": "GET",
"authorizationType": "NONE",
"apiKeyRequired": false
}
```
------
1. Nel seguente esempio si aggiunge il metodo HTTP `GET` alla risorsa `/pets/{petId}` e si imposta la proprietà `requestParameters` per passare il valore `petId` fornito dal client al backend:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutMethodCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutMethodCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
authorizationType: 'NONE'
requestParameters: {
"method.request.path.petId" : true
}
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The 'GET /pets/{petId}' method setup failed:\n", err)
}
})();
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{
"apiKeyRequired": false,
"httpMethod": "GET",
"authorizationType": "NONE",
"requestParameters": {
"method.request.path.petId": true
}
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_method(
restApiId='abcd1234',
resourceId='bbb222',
httpMethod='GET',
authorizationType='NONE',
requestParameters={
"method.request.path.petId": True
}
)
except botocore.exceptions.ClientError as error:
logger.exception("The 'GET /pets/{petId}' method setup failed: %s", error)
raise
attribute=["httpMethod","authorizationType","apiKeyRequired", "requestParameters" ]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{'httpMethod': 'GET', 'authorizationType': 'NONE', 'apiKeyRequired': False, 'requestParameters': {'method.request.path.petId': True}}
```
------
#### [ AWS CLI ]
```
aws apigateway put-method --rest-api-id abcd1234 \
--resource-id bbb222 --http-method GET \
--authorization-type "NONE" \
--region us-west-2 \
--request-parameters method.request.path.petId=true
```
L'output di questo comando è il seguente:
```
{
"httpMethod": "GET",
"authorizationType": "NONE",
"apiKeyRequired": false,
"requestParameters": {
"method.request.path.petId": true
}
}
```
------
1. Utilizza l'esempio seguente per aggiungere la risposta del metodo 200 OK per il metodo `GET /pets`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutMethodResponseCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutMethodResponseCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
statusCode: '200'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("Set up the 200 OK response for the 'GET /pets' method failed:\n", err)
}
})();
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{
"statusCode": "200"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_method_response(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
statusCode='200'
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the 200 OK response for the 'GET /pets' method failed %s.", error)
raise
attribute=["statusCode"]
filtered_result ={key:result[key] for key in attribute}
logger.info(filtered_result)
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{'statusCode': '200'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-method-response --rest-api-id abcd1234 \
--resource-id aaa111 --http-method GET \
--status-code 200 --region us-west-2
```
L'output di questo comando è il seguente:
```
{
"statusCode": "200"
}
```
------
1. Utilizza l'esempio seguente per aggiungere la risposta del metodo 200 OK per il metodo `GET /pets/{petId}`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutMethodResponseCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutMethodResponseCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
statusCode: '200'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("Set up the 200 OK response for the 'GET /pets/{petId}' method failed:\n", err)
}
})();
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{
"statusCode": "200"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_method_response(
restApiId='abcd1234',
resourceId='bbb222',
httpMethod='GET',
statusCode='200'
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the 200 OK response for the 'GET /pets/{petId}' method failed %s.", error)
raise
attribute=["statusCode"]
filtered_result ={key:result[key] for key in attribute}
logger.info(filtered_result)
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{'statusCode': '200'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-method-response --rest-api-id abcd1234 \
--resource-id bbb222 --http-method GET \
--status-code 200 --region us-west-2
```
L'output di questo comando è il seguente:
```
{
"statusCode": "200"
}
```
------
1. Nel seguente esempio si configura un’integrazione per il metodo `GET /pets` con un endpoint HTTP. L'endpoint HTTP è `http://petstore-demo-endpoint.execute-api.com/petstore/pets`.
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutIntegrationCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutIntegrationCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
type: 'HTTP',
integrationHttpMethod: 'GET',
uri: 'http://petstore-demo-endpoint.execute-api.com/petstore/pets'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("Set up the integration of the 'GET /pets' method of the API failed:\n", err)
}
})();
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{
"httpMethod": "GET",
"passthroughBehavior": "WHEN_NO_MATCH",
"cacheKeyParameters": [],
"type": "HTTP",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"cacheNamespace": "ccc333"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_integration(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
type='HTTP',
integrationHttpMethod='GET',
uri='http://petstore-demo-endpoint.execute-api.com/petstore/pets'
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the integration of the 'GET /' method of the API failed %s.", error)
raise
attribute=["httpMethod","passthroughBehavior","cacheKeyParameters", "type", "uri", "cacheNamespace"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{'httpMethod': 'GET', 'passthroughBehavior': 'WHEN_NO_MATCH', 'cacheKeyParameters': [], 'type': 'HTTP', 'uri': 'http://petstore-demo-endpoint.execute-api.com/petstore/pets', 'cacheNamespace': 'ccc333'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-integration --rest-api-id abcd1234 \
--resource-id aaa111 --http-method GET --type HTTP \
--integration-http-method GET \
--uri 'http://petstore-demo-endpoint.execute-api.com/petstore/pets' \
--region us-west-2
```
L'output di questo comando è il seguente:
```
{
"type": "HTTP",
"httpMethod": "GET",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"connectionType": "INTERNET",
"passthroughBehavior": "WHEN_NO_MATCH",
"timeoutInMillis": 29000,
"cacheNamespace": "6sxz2j",
"cacheKeyParameters": []
}
```
------
1. Nel seguente esempio si configura un’integrazione per il metodo `GET /pets/{petId}` con un endpoint HTTP. L'endpoint HTTP è `http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}`. In questa fase viene mappato il parametro di percorso `petId` al parametro di percorso dell'endpoint di integrazione `id`.
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutIntegrationCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutIntegrationCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
type: 'HTTP',
integrationHttpMethod: 'GET',
uri: 'http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}'
requestParameters: {
"integration.request.path.id": "method.request.path.petId"
}
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("Set up the integration of the 'GET /pets/{petId}' method of the API failed:\n", err)
}
})();
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{
"httpMethod": "GET",
"passthroughBehavior": "WHEN_NO_MATCH",
"cacheKeyParameters": [],
"type": "HTTP",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}",
"cacheNamespace": "ddd444",
"requestParameters": {
"integration.request.path.id": "method.request.path.petId"
}
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_integration(
restApiId='ieps9b05sf',
resourceId='t8zeb4',
httpMethod='GET',
type='HTTP',
integrationHttpMethod='GET',
uri='http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}',
requestParameters={
"integration.request.path.id": "method.request.path.petId"
}
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the integration of the 'GET /pets/{petId}' method of the API failed %s.", error)
raise
attribute=["httpMethod","passthroughBehavior","cacheKeyParameters", "type", "uri", "cacheNamespace", "requestParameters"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{'httpMethod': 'GET', 'passthroughBehavior': 'WHEN_NO_MATCH', 'cacheKeyParameters': [], 'type': 'HTTP', 'uri': 'http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}', 'cacheNamespace': 'ddd444', 'requestParameters': {'integration.request.path.id': 'method.request.path.petId'}}}
```
------
#### [ AWS CLI ]
```
aws apigateway put-integration --rest-api-id abcd1234 \
--resource-id bbb222 --http-method GET --type HTTP \
--integration-http-method GET \
--uri 'http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}' \
--request-parameters '{"integration.request.path.id":"method.request.path.petId"}' \
--region us-west-2
```
L'output di questo comando è il seguente:
```
{
"type": "HTTP",
"httpMethod": "GET",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}",
"connectionType": "INTERNET",
"requestParameters": {
"integration.request.path.id": "method.request.path.petId"
},
"passthroughBehavior": "WHEN_NO_MATCH",
"timeoutInMillis": 29000,
"cacheNamespace": "rjkmth",
"cacheKeyParameters": []
}
```
------
1. Nel seguente esempio si aggiunge la risposta di integrazione per l’integrazione `GET /pets`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutIntegrationResponseCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutIntegrationResponseCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
statusCode: '200',
selectionPattern: ''
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The 'GET /pets' method integration response setup failed:\n", err)
}
})();
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{
"selectionPattern": "",
"statusCode": "200"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_integration_response(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
statusCode='200',
selectionPattern='',
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the integration response of the 'GET /pets' method of the API failed: %s", error)
raise
attribute=["selectionPattern","statusCode"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{'selectionPattern': "", 'statusCode': '200'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-integration-response --rest-api-id abcd1234 \
--resource-id aaa111 --http-method GET \
--status-code 200 --selection-pattern "" \
--region us-west-2
```
L'output di questo comando è il seguente:
```
{
"statusCode": "200",
"selectionPattern": ""
}
```
------
1. Nel seguente esempio si aggiunge la risposta di integrazione per l’integrazione `GET /pets/{petId}`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutIntegrationResponseCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutIntegrationResponseCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
statusCode: '200',
selectionPattern: ''
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The 'GET /pets/{petId}' method integration response setup failed:\n", err)
}
})();
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{
"selectionPattern": "",
"statusCode": "200"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_integration_response(
restApiId='abcd1234',
resourceId='bbb222',
httpMethod='GET',
statusCode='200',
selectionPattern='',
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the integration response of the 'GET /pets/{petId}' method of the API failed: %s", error)
raise
attribute=["selectionPattern","statusCode"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
In caso di esito positivo, la chiamata restituisce il seguente output:
```
{'selectionPattern': "", 'statusCode': '200'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-integration-response --rest-api-id abcd1234 \
--resource-id bbb222 --http-method GET
--status-code 200 --selection-pattern ""
--region us-west-2
```
L'output di questo comando è il seguente:
```
{
"statusCode": "200",
"selectionPattern": ""
}
```
------
Dopo aver creato la risposta di integrazione, l'API può interrogare gli animali domestici disponibili sul PetStore sito Web e visualizzare un singolo animale domestico con un identificatore specificato. Affinché l'API possa essere chiamata dai clienti, devi implementarla. Ti consigliamo di testare l'API prima di implementarla.
1. Nel seguente esempio si testa il metodo `GET /pets`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, TestInvokeMethodCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new TestInvokeMethodCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
pathWithQueryString: '/',
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The test on 'GET /pets' method failed:\n", err)
}
})();
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.test_invoke_method(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
pathWithQueryString='/',
)
except botocore.exceptions.ClientError as error:
logger.exception("Test invoke method on 'GET /pets' failed: %s", error)
raise
print(result)
```
------
#### [ AWS CLI ]
```
aws apigateway test-invoke-method --rest-api-id abcd1234 /
--resource-id aaa111 /
--http-method GET /
--path-with-query-string '/'
```
------
1. Nel seguente esempio si testa il metodo `GET /pets/{petId}` con un valore `petId` che corrisponde a 3:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, TestInvokeMethodCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new TestInvokeMethodCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
pathWithQueryString: '/pets/3',
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The test on 'GET /pets/{petId}' method failed:\n", err)
}
})();
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.test_invoke_method(
restApiId='abcd1234',
resourceId='bbb222',
httpMethod='GET',
pathWithQueryString='/pets/3',
)
except botocore.exceptions.ClientError as error:
logger.exception("Test invoke method on 'GET /pets/{petId}' failed: %s", error)
raise
print(result)
```
------
#### [ AWS CLI ]
```
aws apigateway test-invoke-method --rest-api-id abcd1234 /
--resource-id bbb222 /
--http-method GET /
--path-with-query-string '/pets/3'
```
------
Dopo aver testato l'API correttamente, puoi implementarla in una fase.
1. Nel seguente esempio si implementa l’API in una fase denominata `test`. Quando implementi l'API in una fase, i chiamanti dell'API possono invocare l'API.
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, CreateDeploymentCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new CreateDeploymentCommand({
restApiId: 'abcd1234',
stageName: 'test',
stageDescription: 'test deployment'
});
try {
const results = await apig.send(command)
console.log("Deploying API succeeded\n", results)
} catch (err) {
console.log("Deploying API failed:\n", err)
}
})();
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.create_deployment(
restApiId='ieps9b05sf',
stageName='test',
stageDescription='my test stage',
)
except botocore.exceptions.ClientError as error:
logger.exception("Error deploying stage %s.", error)
raise
print('Deploying API succeeded')
print(result)
```
------
#### [ AWS CLI ]
```
aws apigateway create-deployment --rest-api-id abcd1234 \
--region us-west-2 \
--stage-name test \
--stage-description 'Test stage' \
--description 'First deployment'
```
L'output di questo comando è il seguente:
```
{
"id": "ab1c1d",
"description": "First deployment",
"createdDate": "2022-12-15T08:44:13-08:00"
}
```
------
L'API può ora essere chiamata dai clienti. Puoi testare l'API inserendo l'URL `https://abcd1234.execute-api.us-west-2.amazonaws.com/test/pets` in un browser e sostituendo `abcd1234` con l'identificativo dell'API.
Per altri esempi su come creare o aggiornare un'API utilizzando AWS SDKs o AWS CLI, consulta [Azioni per l'utilizzo di API Gateway AWS SDKs](https://docs.aws.amazon.com/code-library/latest/ug/api-gateway_code_examples_actions.html).
## Automatizzazione della configurazione di un'API
Invece di creare la tua API step-by-step, puoi automatizzare la creazione e la pulizia delle AWS risorse utilizzando OpenAPI o Terraform per creare CloudFormation la tua API.
### Definizione di OpenAPI 3.0
Puoi importare una definizione OpenAPI in Gateway API. Per ulteriori informazioni, consulta [Sviluppa REST APIs utilizzando OpenAPI in API Gateway](api-gateway-import-api.md).
```
{
"openapi" : "3.0.1",
"info" : {
"title" : "Simple PetStore (OpenAPI)",
"description" : "Demo API created using OpenAPI",
"version" : "2024-05-24T20:39:34Z"
},
"servers" : [ {
"url" : "{basePath}",
"variables" : {
"basePath" : {
"default" : "Prod"
}
}
} ],
"paths" : {
"/pets" : {
"get" : {
"responses" : {
"200" : {
"description" : "200 response",
"content" : { }
}
},
"x-amazon-apigateway-integration" : {
"type" : "http",
"httpMethod" : "GET",
"uri" : "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"responses" : {
"default" : {
"statusCode" : "200"
}
},
"passthroughBehavior" : "when_no_match",
"timeoutInMillis" : 29000
}
}
},
"/pets/{petId}" : {
"get" : {
"parameters" : [ {
"name" : "petId",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"200" : {
"description" : "200 response",
"content" : { }
}
},
"x-amazon-apigateway-integration" : {
"type" : "http",
"httpMethod" : "GET",
"uri" : "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}",
"responses" : {
"default" : {
"statusCode" : "200"
}
},
"requestParameters" : {
"integration.request.path.id" : "method.request.path.petId"
},
"passthroughBehavior" : "when_no_match",
"timeoutInMillis" : 29000
}
}
}
},
"components" : { }
}
```
### AWS CloudFormation modello
Per distribuire il CloudFormation modello, consulta [Creazione di uno stack sulla AWS CloudFormation console](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-create-stack.html).
```
AWSTemplateFormatVersion: 2010-09-09
Resources:
Api:
Type: 'AWS::ApiGateway::RestApi'
Properties:
Name: Simple PetStore (AWS CloudFormation)
PetsResource:
Type: 'AWS::ApiGateway::Resource'
Properties:
RestApiId: !Ref Api
ParentId: !GetAtt Api.RootResourceId
PathPart: 'pets'
PetIdResource:
Type: 'AWS::ApiGateway::Resource'
Properties:
RestApiId: !Ref Api
ParentId: !Ref PetsResource
PathPart: '{petId}'
PetsMethodGet:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref PetsResource
HttpMethod: GET
AuthorizationType: NONE
Integration:
Type: HTTP
IntegrationHttpMethod: GET
Uri: http://petstore-demo-endpoint.execute-api.com/petstore/pets/
IntegrationResponses:
- StatusCode: '200'
MethodResponses:
- StatusCode: '200'
PetIdMethodGet:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref PetIdResource
HttpMethod: GET
AuthorizationType: NONE
RequestParameters:
method.request.path.petId: true
Integration:
Type: HTTP
IntegrationHttpMethod: GET
Uri: http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}
RequestParameters:
integration.request.path.id: method.request.path.petId
IntegrationResponses:
- StatusCode: '200'
MethodResponses:
- StatusCode: '200'
ApiDeployment:
Type: 'AWS::ApiGateway::Deployment'
DependsOn:
- PetsMethodGet
Properties:
RestApiId: !Ref Api
StageName: Prod
Outputs:
ApiRootUrl:
Description: Root Url of the API
Value: !Sub 'https://${Api}.execute-api.${AWS::Region}.amazonaws.com/Prod'
```
### Configurazione Terraform
Per ulteriori informazioni su Terraform, consulta [Terraform](https://developer.hashicorp.com/terraform/intro).
```
provider "aws" {
region = "us-east-1" # Update with your desired region
}
resource "aws_api_gateway_rest_api" "Api" {
name = "Simple PetStore (Terraform)"
description = "Demo API created using Terraform"
}
resource "aws_api_gateway_resource" "petsResource"{
rest_api_id = aws_api_gateway_rest_api.Api.id
parent_id = aws_api_gateway_rest_api.Api.root_resource_id
path_part = "pets"
}
resource "aws_api_gateway_resource" "petIdResource"{
rest_api_id = aws_api_gateway_rest_api.Api.id
parent_id = aws_api_gateway_resource.petsResource.id
path_part = "{petId}"
}
resource "aws_api_gateway_method" "petsMethodGet" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petsResource.id
http_method = "GET"
authorization = "NONE"
}
resource "aws_api_gateway_method_response" "petsMethodResponseGet" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petsResource.id
http_method = aws_api_gateway_method.petsMethodGet.http_method
status_code ="200"
}
resource "aws_api_gateway_integration" "petsIntegration" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petsResource.id
http_method = aws_api_gateway_method.petsMethodGet.http_method
type = "HTTP"
uri = "http://petstore-demo-endpoint.execute-api.com/petstore/pets"
integration_http_method = "GET"
depends_on = [aws_api_gateway_method.petsMethodGet]
}
resource "aws_api_gateway_integration_response" "petsIntegrationResponse" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petsResource.id
http_method = aws_api_gateway_method.petsMethodGet.http_method
status_code = aws_api_gateway_method_response.petsMethodResponseGet.status_code
}
resource "aws_api_gateway_method" "petIdMethodGet" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petIdResource.id
http_method = "GET"
authorization = "NONE"
request_parameters = {"method.request.path.petId" = true}
}
resource "aws_api_gateway_method_response" "petIdMethodResponseGet" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petIdResource.id
http_method = aws_api_gateway_method.petIdMethodGet.http_method
status_code ="200"
}
resource "aws_api_gateway_integration" "petIdIntegration" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petIdResource.id
http_method = aws_api_gateway_method.petIdMethodGet.http_method
type = "HTTP"
uri = "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}"
integration_http_method = "GET"
request_parameters = {"integration.request.path.id" = "method.request.path.petId"}
depends_on = [aws_api_gateway_method.petIdMethodGet]
}
resource "aws_api_gateway_integration_response" "petIdIntegrationResponse" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petIdResource.id
http_method = aws_api_gateway_method.petIdMethodGet.http_method
status_code = aws_api_gateway_method_response.petIdMethodResponseGet.status_code
}
resource "aws_api_gateway_deployment" "Deployment" {
rest_api_id = aws_api_gateway_rest_api.Api.id
depends_on = [aws_api_gateway_integration.petsIntegration,aws_api_gateway_integration.petIdIntegration ]
}
resource "aws_api_gateway_stage" "Stage" {
stage_name = "Prod"
rest_api_id = aws_api_gateway_rest_api.Api.id
deployment_id = aws_api_gateway_deployment.Deployment.id
}
```
# Tutorial: creazione di una REST API privata
In questo tutorial è possibile creare un'API REST privata. I client possono accedere all'API solo dall'interno del tuo Amazon VPC. L'API è isolata dall'internet pubblico: si tratta di un requisito di sicurezza comune.
Il completamento di questa esercitazione richiede circa 30 minuti. Innanzitutto, utilizzi un CloudFormation modello per creare un Amazon VPC, un endpoint VPC, una AWS Lambda funzione e avvia un'istanza Amazon EC2 che utilizzerai per testare la tua API. Successivamente, si utilizza Console di gestione AWS per creare un'API privata e allegare una politica delle risorse che consenta l'accesso solo dall'endpoint VPC. Infine, si esegue il dell'API.
![\[Panoramica dell'API privata creata in questo tutorial.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/private-api-tutorial-diagram.png)
Per completare questo tutorial, sono necessari un AWS account e un AWS Identity and Access Management utente con accesso alla console. Per ulteriori informazioni, consulta [Configurazione per l'utilizzo di Gateway API](setting-up.md).
In questo tutorial utilizzerai Console di gestione AWS. Per un CloudFormation modello che crea questa API e tutte le risorse correlate, vedi [template.yaml](samples/private-api-full-template.zip).
**Topics**
+ [Fase 1: Creare dipendenze](#private-api-tutorial-create-dependencies)
+ [Fase 2: creare un'API privata](#private-api-tutorial-create-api)
+ [Fase 3: Creare un metodo e un'integrazione](#private-api-tutorial-create-method)
+ [Fase 4: Allegare una policy sulle risorse](#private-api-tutorial-attach-resource-policy)
+ [Fase 5: distribuzione dell'API](#private-api-tutorial-deploy-api)
+ [Fase 6: verificare che l'API non sia accessibile pubblicamente](#private-api-tutorial-test-private-api)
+ [Fase 7: connettersi a un'istanza nel VPC e richiamare l'API](#private-api-tutorial-connect-to-instance)
+ [Fase 8: Pulizia](#private-api-tutorial-cleanup)
+ [Passaggi successivi: automatizza con CloudFormation](#private-api-tutorial-next-steps)
## Fase 1: Creare dipendenze
[Scarica e decomprimi questo modello. CloudFormation](samples/private-api-starter-template.zip) Utilizza il modello per creare tutte le dipendenze per la tua API privata, tra cui un Amazon VPC, un endpoint VPC e una funzione Lambda utilizzata come back-end della tua API. È possibile creare l'API privata in un secondo momento.
**Per creare una pila CloudFormation**
1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Scegliere **Create stack (Crea stack)**, quindi **With new resources (standard) (Con nuove risorse (standard))**.
1. In **Specificare modello**, scegliere **Carica un file modello**.
1. Selezionare il modello scaricato.
1. Scegli **Next (Successivo)**.
1. Per **Stack name (Nome stack)**, inserire **private-api-tutorial**, quindi scegliere **Next (Avanti)**.
1. Per **Configure stack options (Configura opzioni di stack)**, scegliere **Next (Successivo)**.
1. Per quanto riguarda **le funzionalità**, riconosci che CloudFormation puoi creare risorse IAM nel tuo account.
1. Scegli **Avanti**, quindi scegli **Invia**.
CloudFormation esegue il provisioning delle dipendenze per l'API, operazione che può richiedere alcuni minuti. **Quando lo stato del tuo CloudFormation stack è **CREATE\$1COMPLETE**, scegli Outputs.** Annotare l'ID endpoint VPC. È necessario per le fasi successive di questo tutorial.
## Fase 2: creare un'API privata
Si crea un'API privata per consentire solo ai client all'interno del VPC di accedervi.
**Per creare un'API privata**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegli **Create API (Crea API)**, quindi per **API REST**, scegli **Build (Crea)**.
1. Per **API name (Nome API)**, immettere **private-api-tutorial**.
1. Per **Tipo di endpoint API** scegli **Privato**.
1. **Per l'**endpoint VPC IDs, inserisci** l'ID dell'endpoint VPC dagli output del tuo stack.** CloudFormation
1. Per **Tipo di indirizzo IP**, scegli **Dualstack**.
1. Seleziona **Create API** (Crea API).
## Fase 3: Creare un metodo e un'integrazione
Si crea un metodo `GET` e un'integrazione Lambda per gestire le richieste `GET` all'API. Quando un client chiama l'API, API Gateway invia la richiesta alla funzione Lambda creata nella fase 1 e restituisce una risposta al client.
**Per creare un metodo e un'integrazione**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Scegli **Crea metodo**.
1. Per **Tipo di metodo** seleziona `GET`.
1. Per **Tipo di integrazione** seleziona **Funzione Lambda**.
1. Attiva l'opzione **Integrazione proxy Lambda**. Con un'integrazione proxy Lambda, API Gateway invia un evento a Lambda con una struttura definita e trasforma la risposta dalla funzione Lambda in una risposta HTTP.
1. Per la **funzione Lambda**, scegli la funzione che hai creato con il CloudFormation modello nel passaggio 1. Il nome della funzione inizia con **private-api-tutorial**.
1. Scegli **Crea metodo**.
## Fase 4: Allegare una policy sulle risorse
Si allega una [policy delle risorse](apigateway-resource-policies.md) all'API che consente ai client di richiamare l'API solo tramite l'endpoint VPC. Per limitare ulteriormente l'accesso all'API, è inoltre possibile configurare una [policy degli endpoint VPC](apigateway-vpc-endpoint-policies.md) per l'endpoint VPC, ma per questo tutorial non è necessario.
**Per allegare una policy sulle risorse**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Scegli **Policy delle risorse**, quindi seleziona **Crea policy**.
1. Immetti la seguente policy. Sostituiscilo *vpceID* con l'ID dell'endpoint VPC dagli **output** del tuo stack. CloudFormation
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": "execute-api:/*",
"Condition": {
"StringNotEquals": {
"aws:sourceVpce": "vpce-abcd1234"
}
}
},
{
"Effect": "Allow",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": "execute-api:/*"
}
]
}
```
------
1. Scegli **Save changes** (Salva modifiche).
## Fase 5: distribuzione dell'API
Successivamente, distribuisci l'API per renderla disponibile ai client nel tuo Amazon VPC.
**Per distribuire un'API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Seleziona **Deploy API (Distribuisci API)**.
1. In **Fase**, seleziona **Nuova fase**.
1. In **Stage name (Nome fase)** immettere **test**.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Selezionare **Deploy (Distribuisci)**.
Ora siamo pronti per testare l'API.
## Fase 6: verificare che l'API non sia accessibile pubblicamente
Utilizzare `curl` per verificare che non sia possibile richiamare l'API dall'esterno dell'Amazon VPC.
**Per testare l'API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Nel pannello di navigazione principale scegli **Fasi**, quindi seleziona la fase **test**.
1. In **Dettagli fase**, scegli l'icona Copia per copiare l'URL di richiamo dell'API. L'URL è simile a `https://abcdef123.execute-api.us-west-2.amazonaws.com/test`. L'endpoint VPC creato nella fase 1 ha il DNS privato abilitato, quindi è possibile utilizzare l'URL fornito per richiamare l'API.
1. Usa curl per tentare di richiamare l'API dall'esterno del VPC.
```
curl https://abcdef123.execute-api.us-west-2.amazonaws.com/test
```
Curl indica che l'endpoint dell'API non può essere risolto. Se ricevi una risposta diversa, torna alla fase 2 e assicurati di scegliere **Private (Privato)** per il tipo di endpoint dell'API.
```
curl: (6) Could not resolve host: abcdef123.execute-api.us-west-2.amazonaws.com/test
```
Successivamente, connettiti a un'istanza Amazon EC2 nel VPC per richiamare l'API.
## Fase 7: connettersi a un'istanza nel VPC e richiamare l'API
Successivamente, testa l'API dall'interno del VPC Amazon. Per accedere alla tua API privata, connettiti a un'istanza Amazon EC2 nel tuo VPC e poi usa curl per richiamare l'API. Per connettersi all'istanza nel browser, si utilizza Systems Manager Session Manger.
**Per testare l'API**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Seleziona **Instances (Istanze)**.
1. Scegli l'istanza denominata **private-api-tutorial**che hai creato con il CloudFormation modello nel passaggio 1.
1. Scegliere **Connect (Connetti)**, quindi **Session Manager (Gestore di sessione)**.
1. Scegliere **Connect** per avviare una sessione basata su browser nell'istanza.
1. Nella sessione di Session Manager, usa curl per richiamare l'API. Puoi richiamare l'API perché stai utilizzando un'istanza nel tuo Amazon VPC.
```
curl https://abcdef123.execute-api.us-west-2.amazonaws.com/test
```
Verificare di ottenere la risposta `Hello from Lambda!`.
![\[Utilizza Session Manager per richiamare l'API dall'interno del tuo VPC Amazon.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/private-api-tutorial-invoke.png)
Hai creato un'API accessibile solo dall'interno del tuo VPC Amazon e hai verificato che funzioni.
## Fase 8: Pulizia
Per evitare costi non necessari, eliminare le risorse create nell'ambito di questo tutorial. I seguenti passaggi eliminano l'API REST e lo CloudFormation stack.
**Per eliminare un'API REST**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Nella **APIs**pagina, seleziona un'API. Scegli **Azioni API**, seleziona **Elimina** e quindi conferma la scelta.
**Per eliminare una CloudFormation pila**
1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Seleziona il tuo stack. CloudFormation
1. Scegli **Elimina** e conferma la tua scelta.
## Passaggi successivi: automatizza con CloudFormation
Puoi automatizzare la creazione e la pulizia di tutte le AWS risorse coinvolte in questo tutorial. Per un modello CloudFormation di esempio completo, consulta [template.yaml](samples/private-api-full-template.zip).
# Tutorial sull'API HTTP di Amazon API Gateway
I seguenti tutorial forniscono esercizi pratici per aiutarti a usare le API HTTP di API Gateway.
**Topics**
+ [Tutorial: creazione di un'API HTTP CRUD con Lambda e DynamoDB](http-api-dynamo-db.md)
+ [Tutorial: creazione di un'API HTTP con un'integrazione privata con un servizio Amazon ECS](http-api-private-integration.md)
# Tutorial: creazione di un'API HTTP CRUD con Lambda e DynamoDB
In questo tutorial crei un'API serverless che crea, legge, aggiorna ed elimina voci da una tabella DynamoDB. DynamoDB è un servizio di database NoSQL interamente gestito che combina prestazioni elevate e prevedibili con una scalabilità continua. Questo tutorial richiede circa 30 minuti e può essere eseguito all'interno del [piano gratuito di AWS](https://aws.amazon.com/free/).
Innanzitutto, si crea una tabella [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) utilizzando la console DynamoDB. Quindi crei una funzione [Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) utilizzando la AWS Lambda console. Successivamente, è possibile creare un'API HTTP utilizzando la console API Gateway. Infine, si esegue il dell'API.
Quando si richiama l'API HTTP, API Gateway instrada la richiesta alla funzione Lambda. La funzione Lambda interagisce con DynamoDB e restituisce una risposta ad API Gateway. La console API Gateway restituisce quindi una risposta all'utente.
![\[Panoramica dell'API HTTP creata in questo tutorial.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/ddb-crud.png)
Per completare questo esercizio, sono necessari un AWS account e un AWS Identity and Access Management utente con accesso alla console. Per ulteriori informazioni, consulta [Configurazione per l'utilizzo di Gateway API](setting-up.md).
In questo tutorial utilizzerai Console di gestione AWS. Per un AWS SAM modello che crea questa API e tutte le risorse correlate, vedi [samples/http-dynamo-tutorial.zip](samples/http-dynamo-tutorial.zip).
**Topics**
+ [Fase 1: creazione di una tabella DynamoDB](#http-api-dynamo-db-create-table)
+ [Fase 2: creazione di una funzione Lambda](#http-api-dynamo-db-create-function)
+ [Fase 3: creazione un'API HTTP](#http-api-dynamo-db-create-api)
+ [Fase 4: creazione di route](#http-api-dynamo-db-create-routes)
+ [Fase 5: creazione di un'integrazione](#http-api-dynamo-db-create-integration)
+ [Fase 6: collega la tua integrazione alle route](#http-api-dynamo-db-attach-integrations)
+ [Fase 7: test dell'API](#http-api-dynamo-db-invoke-api)
+ [Fase 8: Pulizia](#http-api-dynamo-db-cleanup)
+ [Passaggi successivi: automatizza con AWS SAM o CloudFormation](#http-api-dynamo-db-next-steps)
## Fase 1: creazione di una tabella DynamoDB
Si utilizza una tabella [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) per memorizzare i dati per l'API.
Ogni voce ha un ID univoco, che usiamo come [chiave di partizione](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey) per la tabella.
**Per creare una tabella DynamoDB**
1. Apri la console DynamoDB all'indirizzo. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Seleziona **Create table (Crea tabella)**.
1. Nel campo **Table name (Nome tabella)** immetti **http-crud-tutorial-items**.
1. In **Partition key** (Chiave di partizione), inserisci **id**.
1. Scegliere **Create table (Crea tabella)**.
## Fase 2: creazione di una funzione Lambda
Crei una funzione [Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) per il back-end della tua API. Questa funzione Lambda crea, legge, aggiorna ed elimina voci da DynamoDB. La funzione utilizza [gli eventi da API Gateway](http-api-develop-integrations-lambda.md#http-api-develop-integrations-lambda.proxy-format) per determinare come interagire con DynamoDB. Per semplicità questo tutorial utilizza una singola funzione Lambda. Come best practice, dovresti creare funzioni separate per ogni route. Per ulteriori informazioni, consulta [Il monolite Lambda](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/monolith).
**Come creare una funzione Lambda**
1. [Accedi alla console Lambda all'indirizzo https://console.aws.amazon.com /lambda.](https://console.aws.amazon.com/lambda)
1. Selezionare **Create function (Crea funzione)**.
1. Nel campo **Function name (Nome funzione)**, immettere **http-crud-tutorial-function**.
1. Per **Runtime**, scegli l'ultimo runtime supportato di **Node.js** o di **Python**.
1. In **Permissions (Autorizzazioni)** scegli **Change default execution role (Cambia ruolo di esecuzione predefinito)**.
1. Seleziona **Crea un nuovo ruolo dai AWS ** modelli di policy.
1. In **Role name (Nome ruolo)**, immettere **http-crud-tutorial-role**.
1. In **Policy templates (Modelli di policy)** scegli **Simple microservice permissions**. Questa policy concede alla funzione Lambda l'autorizzazione per interagire con DynamoDB.
**Nota**
Per semplicità, questo tutorial utilizza una policy gestita. Come best practice, dovresti creare la tua policy IAM per concedere le autorizzazioni minime richieste.
1. Selezionare **Create function (Crea funzione)**.
1. Aprire la funzione Lambda nell'editor di codice della console e sostituirne il contenuto con il codice seguente. Scegli **Deploy (Distribuisci)** per aggiornare la funzione.
------
#### [ Node.js ]
```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
DynamoDBDocumentClient,
ScanCommand,
PutCommand,
GetCommand,
DeleteCommand,
} from "@aws-sdk/lib-dynamodb";
const client = new DynamoDBClient({});
const dynamo = DynamoDBDocumentClient.from(client);
const tableName = "http-crud-tutorial-items";
export const handler = async (event, context) => {
let body;
let statusCode = 200;
const headers = {
"Content-Type": "application/json",
};
try {
switch (event.routeKey) {
case "DELETE /items/{id}":
await dynamo.send(
new DeleteCommand({
TableName: tableName,
Key: {
id: event.pathParameters.id,
},
})
);
body = `Deleted item ${event.pathParameters.id}`;
break;
case "GET /items/{id}":
body = await dynamo.send(
new GetCommand({
TableName: tableName,
Key: {
id: event.pathParameters.id,
},
})
);
body = body.Item;
break;
case "GET /items":
body = await dynamo.send(
new ScanCommand({ TableName: tableName })
);
body = body.Items;
break;
case "PUT /items":
let requestJSON = JSON.parse(event.body);
await dynamo.send(
new PutCommand({
TableName: tableName,
Item: {
id: requestJSON.id,
price: requestJSON.price,
name: requestJSON.name,
},
})
);
body = `Put item ${requestJSON.id}`;
break;
default:
throw new Error(`Unsupported route: "${event.routeKey}"`);
}
} catch (err) {
statusCode = 400;
body = err.message;
} finally {
body = JSON.stringify(body);
}
return {
statusCode,
body,
headers,
};
};
```
------
#### [ Python ]
```
import json
import boto3
from decimal import Decimal
client = boto3.client('dynamodb')
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table('http-crud-tutorial-items')
tableName = 'http-crud-tutorial-items'
def lambda_handler(event, context):
print(event)
body = {}
statusCode = 200
headers = {
"Content-Type": "application/json"
}
try:
if event['routeKey'] == "DELETE /items/{id}":
table.delete_item(
Key={'id': event['pathParameters']['id']})
body = 'Deleted item ' + event['pathParameters']['id']
elif event['routeKey'] == "GET /items/{id}":
body = table.get_item(
Key={'id': event['pathParameters']['id']})
body = body["Item"]
responseBody = [
{'price': float(body['price']), 'id': body['id'], 'name': body['name']}]
body = responseBody
elif event['routeKey'] == "GET /items":
body = table.scan()
body = body["Items"]
print("ITEMS----")
print(body)
responseBody = []
for items in body:
responseItems = [
{'price': float(items['price']), 'id': items['id'], 'name': items['name']}]
responseBody.append(responseItems)
body = responseBody
elif event['routeKey'] == "PUT /items":
requestJSON = json.loads(event['body'])
table.put_item(
Item={
'id': requestJSON['id'],
'price': Decimal(str(requestJSON['price'])),
'name': requestJSON['name']
})
body = 'Put item ' + requestJSON['id']
except KeyError:
statusCode = 400
body = 'Unsupported route: ' + event['routeKey']
body = json.dumps(body)
res = {
"statusCode": statusCode,
"headers": {
"Content-Type": "application/json"
},
"body": body
}
return res
```
------
## Fase 3: creazione un'API HTTP
L'API HTTP fornisce un endpoint HTTP per la funzione Lambda. In questa fase si crea un'API vuota. Nelle fasi seguenti si configurano route e integrazioni per connettere l'API e la funzione Lambda.
**Per creare un'API HTTP**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegli **Create API (Crea API)**, quindi per **API HTTP**, scegli **Build (Crea)**.
1. Per **API name (Nome API)**, immettere **http-crud-tutorial-api**.
1. Per il tipo di **indirizzo IP**, selezionare. **IPv4**
1. Scegli **Next (Successivo)**.
1. Per **Configura route**, scegli **Avanti** per ignorare la creazione della route. È possibile creare route in un secondo momento.
1. Esamina la fase creata da API Gateway e quindi scegli **Next (Avanti)**.
1. Seleziona **Crea**.
## Fase 4: creazione di route
Le route inviano le richieste API in entrata alle risorse di back-end. Le route sono costituite da due parti: un metodo HTTP e un percorso della risorsa, ad esempi, `GET /items`. Per questa API di esempio, creiamo quattro route:
+ `GET /items/{id}`
+ `GET /items`
+ `PUT /items`
+ `DELETE /items/{id}`
**Per creare route**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Scegliere **Percorsi**.
1. Seleziona **Crea**.
1. Per **Method (Metodo)** seleziona **GET**.
1. Per il percorso, immetti **/items/\$1id\$1**. Il `{id}` alla fine del percorso è un parametro che API Gateway recupera dal percorso della richiesta quando essa viene effettuata da un client.
1. Seleziona **Crea**.
1. Ripeti le fasi da 4 a 7 per `GET /items`, `DELETE /items/{id}` e `PUT /items`.
![\[La tua API dispone di route per GET /items, GET /items/{id}, DELETE /items/{id} e PUT /items.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/ddb-create-routes.png)
## Fase 5: creazione di un'integrazione
Si crea un'integrazione per connettere una route alle risorse di back-end. Per questa API di esempio, si crea un'integrazione Lambda che si utilizza per tutte le route.
**Per creare un'integrazione**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Scegli **Integrations (Integrazioni)**.
1. Scegli **Manage integrations (Gestisci integrazioni)**, quindi scegli **Create (Crea)**.
1. Salta il passaggio **Collega questa integrazione a una route**. Lo completerai in una fase successiva.
1. Per **Integration type (Tipo di integrazione)**, scegli **Lambda Function (Funzione Lambda)**.
1. Per **Lambda function (Funzione Lambda)**, immetti **http-crud-tutorial-function**.
1. Seleziona **Crea**.
## Fase 6: collega la tua integrazione alle route
Per questa API di esempio, si utilizza la stessa integrazione Lambda per tutte le route. Dopo aver collegato l'integrazione a tutte le route dell'API, la funzione Lambda viene richiamata quando un client chiama una delle route.
**Per collegare integrazioni alle route**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Scegli **Integrations (Integrazioni)**.
1. Scegli una route.
1. Nel campo **Choose an existing integration (Scegli un'integrazione esistente)**, scegli **http-crud-tutorial-function**.
1. Scegli **Collega integrazione**.
1. Ripeti le fasi 4-6 per tutte le route.
Tutti i percorsi mostrano che è associata un' AWS Lambda integrazione.
![\[La console viene visualizzata AWS Lambda su tutti i percorsi per indicare che l'integrazione è collegata.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/ddb-attach-integrations.png)
Ora che hai un'API HTTP con route e integrazioni, puoi testare la tua API.
## Fase 7: test dell'API
Per assicurarti che la tua API funzioni, usa [curl](https://curl.se).
**Per ottenere l'URL per richiamare la tua API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Prendere nota del valore URL di chiamata per l'API. Viene visualizzato in **Invoke URL (Richiama URL)** nella pagina **Details (Dettagli)**.
![\[Dopo aver creato l'API, la console mostra il valore URL di chiamata per l'API.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/ddb-invoke-url.png)
1. Copia l'URL di chiamata per l'API.
L'URL completo è simile a `https://abcdef123.execute-api.us-west-2.amazonaws.com`.
**Per creare o aggiornare una voce**
+ Utilizza il comando seguente per creare o aggiornare una voce. Il comando include un corpo della richiesta con l'ID, il prezzo e il nome della voce.
```
curl -X "PUT" -H "Content-Type: application/json" -d "{\"id\": \"123\", \"price\": 12345, \"name\": \"myitem\"}" https://abcdef123.execute-api.us-west-2.amazonaws.com/items
```
**Per ottenere tutte le voci**
+ Utilizza il seguente comando per elencare tutte le voci.
```
curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items
```
**Per ottenere una voce**
+ Utilizza il seguente comando per ottenere una voce in base al relativo ID.
```
curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items/123
```
**Per eliminare una voce**
1. Utilizza il comando seguente per eliminare una voce.
```
curl -X "DELETE" https://abcdef123.execute-api.us-west-2.amazonaws.com/items/123
```
1. Ottieni tutte le voci per verificare che la voce sia stata eliminata.
```
curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items
```
## Fase 8: Pulizia
Per evitare costi non necessari, eliminare le risorse create nell'ambito di questo esercizio di nozioni di base. La procedura seguente elimina l'API HTTP, la funzione Lambda e le risorse associate.
**Per eliminare una tabella DynamoDB**
1. Apri la console DynamoDB all'indirizzo. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Seleziona la tabella.
1. Seleziona **Delete Table (Elimina tabella)**.
1. Conferma la scelta e seleziona **Delete (Elimina)**.
**Per eliminare un'API HTTP**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Nella **APIs**pagina, seleziona un'API. Scegli **Azioni**, quindi **Elimina**.
1. Scegliere **Delete (Elimina)**.
**Per eliminare una funzione Lambda**
1. [Accedi alla console Lambda all'indirizzo https://console.aws.amazon.com /lambda.](https://console.aws.amazon.com/lambda)
1. Nella pagina **Funzioni**, selezionare una funzione. Scegli **Azioni**, quindi **Elimina**.
1. Scegliere **Delete (Elimina)**.
**Per eliminare il gruppo di log di una funzione Lambda**
1. Nella CloudWatch console Amazon, apri la [pagina Log groups](https://console.aws.amazon.com/cloudwatch/home#logs:).
1. Nella pagina **Log Groups (Gruppi di log)**, seleziona il gruppo di log della funzione (`/aws/lambda/http-crud-tutorial-function`). Scegliere **Actions (Operazioni)**, quindi selezionare **Delete log group (Elimina gruppo di log)**.
1. Scegliere **Delete (Elimina)**.
**Per eliminare il ruolo di esecuzione di una funzione Lambda**
1. Nella AWS Identity and Access Management console, apri la [pagina Ruoli](https://console.aws.amazon.com/iam/home?#/roles).
1. Seleziona il ruolo della funzione, ad esempi, `http-crud-tutorial-role`.
1. Scegliere **Delete role (Elimina ruolo)**.
1. Scegliere **Yes, delete (Sì, elimina)**.
## Passaggi successivi: automatizza con AWS SAM o CloudFormation
È possibile automatizzare la creazione e la pulizia delle AWS risorse utilizzando o. CloudFormation AWS SAM Per un esempio di modello AWS SAM per questo tutorial, consulta [samples/http-dynamo-tutorial.zip](samples/http-dynamo-tutorial.zip).
Per esempio CloudFormation modelli, vedi modelli di [esempio CloudFormation](https://github.com/awsdocs/amazon-api-gateway-developer-guide/tree/main/cloudformation-templates).
# Tutorial: creazione di un'API HTTP con un'integrazione privata con un servizio Amazon ECS
In questo tutorial, si crea un'API serverless che si connette a un servizio Amazon ECS eseguito in un VPC Amazon. I clienti al di fuori del tuo Amazon VPC possono utilizzare l'API per accedere al tuo servizio Amazon ECS.
Questo tutorial dura circa un'ora. Innanzitutto, utilizzi un CloudFormation modello per creare un servizio Amazon VPC e Amazon ECS. Usa la console API Gateway per creare un link VPC. Il link VPC consente ad API Gateway di accedere al servizio Amazon ECS eseguito nel tuo VPC Amazon. Successivamente, si crea un'API HTTP che utilizza il link VPC per connettersi al servizio Amazon ECS. Infine, si esegue il dell'API.
Quando si richiama l'API HTTP, API Gateway invia la richiesta al tuo servizio Amazon ECS tramite il link VPC e poi restituisce la risposta dal servizio.
![\[Panoramica dell'API HTTP creata in questo tutorial.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/private-integration.png)
Per completare questo tutorial, sono necessari un AWS account e un AWS Identity and Access Management utente con accesso alla console. Per ulteriori informazioni, consulta [Configurazione per l'utilizzo di Gateway API](setting-up.md).
In questo tutorial utilizzerai Console di gestione AWS. Per un CloudFormation modello che crea questa API e tutte le risorse correlate, vedi [template.yaml](samples/private-integration-full-template.zip).
**Topics**
+ [Fase 1: Creazione di un servizio Amazon ECS](#http-api-private-integration-create-ecs-service)
+ [Fase 2: Creazione di un link VPC](#http-api-private-integration-vpc-link)
+ [Fase 3: creazione un'API HTTP](#http-api-private-integration-create-api)
+ [Fase 4: Creazione di una route](#http-api-private-integration-create-routes)
+ [Fase 5: creazione di un'integrazione](#http-api-private-integration-create-integration)
+ [Fase 6: Test dell'API](#http-api-private-integration-invoke-api)
+ [Fase 7: pulizia](#http-api-private-integration-cleanup)
+ [Passaggi successivi: automatizza con CloudFormation](#http-api-private-integration-next-steps)
## Fase 1: Creazione di un servizio Amazon ECS
Amazon ECS è un servizio di gestione dei container che facilita l'esecuzione, l'arresto e la gestione di container Docker in un cluster. In questo tutorial eseguirai il cluster su un'infrastruttura serverless gestita da Amazon ECS.
Scarica e decomprimi [questo CloudFormation modello](samples/private-integration-cfn.zip), che crea tutte le dipendenze per il servizio, incluso un Amazon VPC. Si utilizza il modello per creare un servizio Amazon ECS che utilizza un Application Load Balancer.
**Per creare uno stack CloudFormation**
1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Scegliere **Create stack (Crea stack)**, quindi **With new resources (standard) (Con nuove risorse (standard))**.
1. In **Specificare modello**, scegliere **Carica un file modello**.
1. Selezionare il modello scaricato.
1. Scegli **Next (Successivo)**.
1. Per **Stack name (Nome stack)**, inserire **http-api-private-integrations-tutorial**, quindi scegliere **Next (Avanti)**.
1. Per **Configure stack options (Configura opzioni di stack)**, scegliere **Next (Successivo)**.
1. Per quanto riguarda **le funzionalità**, riconosci che CloudFormation puoi creare risorse IAM nel tuo account.
1. Scegli **Avanti**, quindi scegli **Invia**.
CloudFormation esegue il provisioning del servizio ECS, operazione che può richiedere alcuni minuti. Quando lo stato del tuo CloudFormation stack è **CREATE\$1COMPLETE**, sei pronto per passare alla fase successiva.
## Fase 2: Creazione di un link VPC
Un link VPC consente ad API Gateway di accedere alle risorse private in un VPC Amazon. Si utilizza un link VPC per consentire ai client di accedere al tuo servizio Amazon ECS tramite l'API HTTP.
**Per creare un link VPC**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Nel pannello di navigazione principale scegli **Collegamenti VPC** e quindi **Crea**.
È possibile che per aprire il pannello di navigazione principale sia necessario scegliere l'icona del menu.
1. Per **Scegli una versione di collegamento VPC, seleziona Link** **VPC** per HTTP. APIs
1. In **Name (Nome)**, immettere **private-integrations-tutorial**.
1. Per **VPC** scegliere il VPC creato nella fase 1. Il nome deve iniziare con **PrivateIntegrationsStack**.
1. Per **Sottoreti**, selezionare le due sottoreti private nel VPC. I nomi finiscono con `PrivateSubnet`.
1. Per **Gruppi di sicurezza** seleziona l'ID gruppo che inizia con `private-integrations-tutorial` e ha la descrizione `PrivateIntegrationsStack/PrivateIntegrationsTutorialService/Service/SecurityGroup`.
1. Scegli **Create** (Crea).
Dopo aver creato il link VPC, API Gateway consente alle interfacce di rete elastiche di accedere al VPC. Il processo può richiedere alcuni minuti. Nel frattempo, puoi creare la tua API.
## Fase 3: creazione un'API HTTP
L'API HTTP fornisce un endpoint HTTP per il Servizio Amazon ECS. In questa fase si crea un'API vuota. Nelle fasi 4 e 5, si configura un percorso e un'integrazione per connettere l'API e il servizio Amazon ECS.
**Come creare un’API HTTP**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegli **Create API (Crea API)**, quindi per **API HTTP**, scegli **Build (Crea)**.
1. Per **API name (Nome API)**, immettere **http-private-integrations-tutorial**.
1. Per il tipo di **indirizzo IP**, selezionare. **IPv4**
1. Scegli **Next (Successivo)**.
1. Per **Configura route**, scegli **Avanti** per ignorare la creazione della route. È possibile creare route in un secondo momento.
1. Esamina la fase creata da API Gateway. API Gateway crea una `$default` fase con distribuzioni automatiche abilitate, che è la scelta migliore per questo tutorial. Scegli **Next (Successivo)**.
1. Seleziona **Crea**.
## Fase 4: Creazione di una route
Le route inviano le richieste API in entrata alle risorse di back-end. Le route sono costituite da due parti: un metodo HTTP e un percorso della risorsa, ad esempi, `GET /items`. Per questa API di esempio, creiamo una route.
**Per creare una route**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Scegliere **Percorsi**.
1. Seleziona **Crea**.
1. Per **Method (Metodo)** seleziona **ANY**.
1. Per il percorso, immetti **/\$1proxy\$1\$1**. Il`{proxy+}` alla fine del percorso è una variabile di percorso greedy. API Gateway invia tutte le richieste per l'API a questa route.
1. Seleziona **Crea**.
## Fase 5: creazione di un'integrazione
Si crea un'integrazione per connettere una route alle risorse di back-end.
**Per creare un'integrazione**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Scegli **Integrations (Integrazioni)**.
1. Scegli **Manage integrations (Gestisci integrazioni)**, quindi scegli **Create (Crea)**.
1. Per **Allega questa integrazione a una route**, selezionare la route **ANY/\$1proxy\$1\$1** creata in precedenza.
1. Per **Tipo di integrazione**scegliere **Risorsa privata**.
1. Per **Dettagli sull'integrazione**, scegliere **Seleziona manualmente**.
1. Per **Servizio Target**, scegliere **ALB/NLB**.
1. Per **load balancer**, scegliere il load balancer creato con il modello CloudFormation nella fase 1. Il suo nome dovrebbe iniziare con **HTTP-Priva**.
1. Per **Listener**, scegliere **HTTP 80**.
1. Per **Link VPC**, scegliere il link VPC creato nella fase 2. Dovrebbe chiamarsi `private-integrations-tutorial`.
1. Seleziona **Crea**.
Per verificare che il percorso e l'integrazione siano configurati correttamente, selezionare **Allega integrazioni alle route**. La console mostra che si dispone di una route `ANY /{proxy+}` con un'integrazione a un load balancer VPC.
![\[La console mostra che si dispone di una route /{proxy+} con un'integrazione a un load balancer in un VPC.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/private-integration-tutorial-route.png)
Ora siamo pronti per testare l'API.
## Fase 6: Test dell'API
Successivamente, viene verificata l'API per assicurarsi che funzioni. Per semplicità, usa un browser Web per richiamare l'API.
**Per testare l'API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Prendere nota del valore URL di chiamata per l'API.
![\[Dopo aver creato l'API, la console mostra il valore URL di chiamata per l'API.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/getting-started-invoke-url.png)
1. In un browser web, vai all'URL di chiamata dell'API.
L'URL completo dovrebbe essere del tipo `https://abcdef123.execute-api.us-east-2.amazonaws.com`.
Il tuo browser invia una richiesta `GET` all'API.
1. Verifica che la risposta della tua API sia un messaggio di benvenuto che indica che la tua app è in esecuzione su Amazon ECS.
Se visualizzi il messaggio di benvenuto, hai creato correttamente un servizio Amazon ECS eseguito in un VPC Amazon e hai utilizzato un'API HTTP di API Gateway con un link VPC per accedere al servizio Amazon ECS.
## Fase 7: pulizia
Per evitare costi non necessari, eliminare le risorse create nell'ambito di questo tutorial. I seguenti passaggi eliminano il link VPC, lo CloudFormation stack e l'API HTTP.
**Per eliminare un'API HTTP**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Nella **APIs**pagina, seleziona un'API. Scegliere **Azioni**, scegliere **Elimina**, quindi confermare la scelta.
**Per eliminare un link VPC**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere **link VPC**.
1. Selezionare il link VPC, scegliere **Elimina**, quindi confermare la scelta.
**Per eliminare uno stack CloudFormation**
1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Seleziona il tuo stack. CloudFormation
1. Scegli **Elimina** e conferma la tua scelta.
## Passaggi successivi: automatizza con CloudFormation
Puoi automatizzare la creazione e la pulizia di tutte le AWS risorse coinvolte in questo tutorial. Per un modello CloudFormation di esempio completo, consulta [template.yaml](samples/private-integration-full-template.zip).
# Tutorial sull'API WebSocket di Amazon API Gateway
I seguenti tutorial offrono esercizi pratici per aiutare a utilizzare le API WebSocket di Gateway API.
**Topics**
+ [Tutorial: crea un'app di WebSocket chat con WebSocket API, Lambda e DynamoDB](websocket-api-chat-app.md)
+ [Tutorial: creare un' WebSocket API con un' AWS integrazione](websocket-api-step-functions-tutorial.md)
# Tutorial: crea un'app di WebSocket chat con WebSocket API, Lambda e DynamoDB
In questo tutorial, creerai un'applicazione di chat senza server con un' WebSocket API. Con un' WebSocket API, puoi supportare la comunicazione bidirezionale tra i client. I client possono ricevere messaggi senza dover eseguire il polling per gli aggiornamenti.
Il completamento di questa esercitazione richiede circa 30 minuti. Innanzitutto, utilizzerai un CloudFormation modello per creare funzioni Lambda che gestiranno le richieste API, oltre a una tabella DynamoDB che memorizza il tuo client. IDs Quindi, utilizzerai la console API Gateway per creare un' WebSocket API che si integri con le tue funzioni Lambda. Infine, eseguirai il test dell'API per verificare che i messaggi siano inviati e ricevuti.
![\[Panoramica dell'architettura dell'API creata in questo tutorial.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/ws-chat-app.png)
Per completare questo tutorial, sono necessari un AWS account e un AWS Identity and Access Management utente con accesso alla console. Per ulteriori informazioni, consulta [Configurazione per l'utilizzo di Gateway API](setting-up.md).
Per la connessione all'API è inoltre necessario `wscat`. Per ulteriori informazioni, consulta [Utilizzalo `wscat` per connetterti a un' WebSocket API e inviarle messaggi](apigateway-how-to-call-websocket-api-wscat.md).
**Topics**
+ [Fase 1: creazione di funzioni Lambda e di una tabella DynamoDB](#websocket-api-chat-app-create-dependencies)
+ [Fase 2: Creare un'API WebSocket](#websocket-api-chat-app-create-api)
+ [Fase 3: test dell'API](#websocket-api-chat-app-invoke-api)
+ [Fase 4: pulizia](#websocket-api-chat-app-cleanup)
+ [Passaggi successivi: automatizza con CloudFormation](#websocket-api-chat-app-next-steps)
## Fase 1: creazione di funzioni Lambda e di una tabella DynamoDB
Scarica e decomprimi [il modello di creazione dell'app per CloudFormation](samples/ws-chat-app-starter.zip). Utilizzerai questo modello per creare una tabella Amazon DynamoDB per archiviare il client della tua app. IDs Ogni client connesso ha un ID univoco che utilizzeremo come chiave di partizione della tabella. Questo modello crea anche funzioni Lambda che aggiornano le connessioni client in DynamoDB e gestiscono l'invio di messaggi ai client connessi.
**Per creare uno stack CloudFormation**
1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Scegliere **Create stack (Crea stack)**, quindi **With new resources (standard) (Con nuove risorse (standard))**.
1. In **Specificare modello**, scegliere **Carica un file modello**.
1. Selezionare il modello scaricato.
1. Scegli **Next (Successivo)**.
1. Per **Stack name (Nome stack)**, inserire **websocket-api-chat-app-tutorial**, quindi scegliere **Next (Avanti)**.
1. Per **Configure stack options (Configura opzioni di stack)**, scegliere **Next (Successivo)**.
1. Per quanto riguarda **le funzionalità**, riconosci che CloudFormation puoi creare risorse IAM nel tuo account.
1. Scegli **Avanti**, quindi scegli **Invia**.
CloudFormation fornisce le risorse specificate nel modello. Per completare il provisioning delle risorse, potrebbero essere necessari alcuni minuti. Quando lo stato del tuo CloudFormation stack è **CREATE\$1COMPLETE**, sei pronto per passare alla fase successiva.
## Fase 2: Creare un'API WebSocket
Creerai un' WebSocket API per gestire le connessioni dei client e indirizzare le richieste alle funzioni Lambda che hai creato nel passaggio 1.
**Per creare un'API WebSocket**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Seleziona **Create API** (Crea API). **Quindi, per **WebSocket API**, scegli Build.**
1. Per **API name (Nome API)**, immettere **websocket-chat-app-tutorial**.
1. Per il **tipo di indirizzo IP**, seleziona **IPv4**.
1. Per **Route selection expression** (Espressione di selezione routing), inserire **request.body.action**. L'espressione di selezione del routing determina quale routing viene richiamato da API Gateway quando un client invia un messaggio.
1. Scegli **Next (Successivo)**.
1. Per **Predefined routes** (Routing predefiniti), scegliere **Add \$1connect** (Aggiungi \$1connect), **Add \$1disconnect** (Aggiungi \$1disconnect) e **Add \$1default** (Aggiungi \$1default). I routing **\$1connect** e **\$1disconnect** sono routing speciali che API Gateway richiama automaticamente quando un client si connette o si disconnette da un'API. API Gateway richiama il routing `$default` quando nessun altro routing corrisponde a una richiesta.
1. Per **Custom routes** (Routing personalizzati), scegli **Add custom route** (Aggiungi routing personalizzato). Per **Route key** (Chiave routing), inserire **sendmessage**. Questo routing personalizzato gestisce i messaggi inviati ai client connessi.
1. Scegli **Next (Successivo)**.
1. In **Attach integrations** (Collega integrazioni), per ogni routing e**Integration type** (Tipo di integrazione), scegliere Lambda.
Per **Lambda**, scegli la funzione Lambda corrispondente che hai creato nel passaggio 1. CloudFormation Il nome di ciascuna funzione corrisponde a un routing. Ad esempio, per il routing **\$1connect**, scegliere la funzione denominata **websocket-chat-app-tutorial-ConnectHandler**.
1. Esamina la fase creata da API Gateway. Di default, API Gateway crea un nome di fase `production` e implementa automaticamente l'API in quella fase. Scegli **Next (Successivo)**.
1. Scegliere **Create and deploy** (Crea e implementa).
## Fase 3: test dell'API
Successivamente, eseguirai il test dell'API per assicurarti che funzioni correttamente. Per connetterti all'API, utilizza il comando `wscat`.
**Per ottenere l'URL di richiamo dell'API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegliere l'API.
1. Scegli **Stages** (Fasi), quindi scegli **production** (produzione).
1. **Annota l'URL della tua API. WebSocket ** L'URL dovrebbe essere del tipo `wss://abcdef123.execute-api.us-east-2.amazonaws.com/production`.
**Per connetterti all'API**
1. Per connetterti all'API, utilizza il seguente comando. Quando ti connetti all'API, API Gateway richiama il routing `$connect`. Quando si richiama il routing, esso richiama una funzione Lambda che archivia l'ID di connessione in DynamoDB.
```
wscat -c wss://abcdef123.execute-api.us-west-2.amazonaws.com/production
```
```
Connected (press CTRL+C to quit)
```
1. Apri un nuovo terminale ed esegui nuovamente il comando **wscat** con i parametri seguenti.
```
wscat -c wss://abcdef123.execute-api.us-west-2.amazonaws.com/production
```
```
Connected (press CTRL+C to quit)
```
Ciò fornisce due client connessi in grado di scambiare messaggi.
**Come inviare un messaggio**
+ API Gateway determina quale routing richiamare in base all'espressione di selezione del routing dell'API. L'espressione di selezione del routing dell'API è `$request.body.action`. Di conseguenza, API Gateway richiama il routing `sendmessage` quando si invia il seguente messaggio:
```
{"action": "sendmessage", "message": "hello, everyone!"}
```
La funzione Lambda associata alla route richiamata raccoglie il client da DynamoDB. IDs Quindi, la funzione chiama l'API Gateway Management API e invia il messaggio a tali client. Tutti i client connessi ricevono il seguente messaggio:
```
< hello, everyone!
```
**Per richiamare il routing \$1default dell'API**
+ API Gateway richiama il routing di default dell'API quando un client invia un messaggio che non corrisponde ai routing definiti. La funzione Lambda associata al routing `$default` utilizza l'API di API Gateway Management per inviare al client informazioni relative alla connessione.
```
test
```
```
Use the sendmessage route to send a message. Your info: {"ConnectedAt":"2022-01-25T18:50:04.673Z","Identity":{"SourceIp":"192.0.2.1","UserAgent":null},"LastActiveAt":"2022-01-25T18:50:07.642Z","connectionID":"Mg_ugfpqPHcCIVA="}
```
**Per disconnetterti dall'API**
+ Per disconnetterti dall'API, premi **CTRL\$1C**. Quando un client si disconnette dall'API, API Gateway richiama il routing `$disconnect` dell'API. L'integrazione Lambda per il routing `$disconnect` dell'API rimuove l'ID di connessione da DynamoDB.
## Fase 4: pulizia
Per evitare costi non necessari, eliminare le risorse create nell'ambito di questo tutorial. I passaggi seguenti eliminano lo stack e l'API. CloudFormation WebSocket
**Per eliminare un'API WebSocket**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Nella **APIs**pagina, seleziona la tua API. `websocket-chat-app-tutorial` Scegliere **Azioni**, scegliere **Elimina**, quindi confermare la scelta.
**Per eliminare uno CloudFormation stack**
1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Seleziona il tuo stack. CloudFormation
1. Scegli **Elimina** e conferma la tua scelta.
## Passaggi successivi: automatizza con CloudFormation
Puoi automatizzare la creazione e la pulizia di tutte le AWS risorse coinvolte in questo tutorial. [Per un CloudFormation modello che crea questa API e tutte le risorse correlate, consulta ws-chat-app .yaml.](samples/ws-chat-app.zip)
# Tutorial: creare un' WebSocket API con un' AWS integrazione
In questo tutorial, crei un'applicazione di trasmissione serverless con un' WebSocket API. I client possono ricevere messaggi senza dover eseguire il polling per gli aggiornamenti.
Questo tutorial mostra come trasmettere messaggi ai client connessi e include un esempio di sistema di autorizzazione Lambda, un'integrazione fittizia e un'integrazione non proxy con Step Functions.
![\[Panoramica dell'architettura dell'API creata in questo tutorial.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/ws-sfn-app.png)
Dopo aver creato le risorse utilizzando un CloudFormation modello, utilizzerai la console API Gateway per creare un' WebSocket API che si integri con AWS le tue risorse. Allegherai un autorizzatore Lambda alla tua API e creerai un'integrazione di AWS servizi con Step Functions per avviare l'esecuzione di una macchina a stati. La macchina a stati Step Functions invocherà una funzione Lambda che invia un messaggio a tutti i client connessi.
Dopo aver creato l'API, testerai la connessione all'API e verificherai che i messaggi vengano inviati e ricevuti. Il completamento di questo tutorial richiede circa 45 minuti.
**Topics**
+ [Prerequisiti](#websocket-api-step-functions-prerequisites)
+ [Fase 1: Creazione delle risorse](#websocket-api-step-functions-create-dependencies)
+ [Fase 2: Creare un'API WebSocket](#websocket-api-step-functions-create-api)
+ [Passaggio 3: creare un sistema di autorizzazione Lambda](#websocket-api-step-functions-create-authorizer)
+ [Passaggio 4: creare un'integrazione bidirezionale fittizia](#websocket-api-step-functions-create-mock-integration)
+ [Passaggio 5: creare un'integrazione non proxy con Step Functions](#websocket-api-step-functions-create-step-function-integration)
+ [Fase 6: Test dell'API](#websocket-api-step-functions-test-api)
+ [Fase 7: pulire](#websocket-api-step-functions-cleanup)
+ [Passaggi successivi](#websocket-api-step-functions-next-steps)
## Prerequisiti
Sono necessari i seguenti prerequisiti:
+ Un AWS account e un AWS Identity and Access Management utente con accesso alla console. Per ulteriori informazioni, consulta [Configurazione per l'utilizzo di Gateway API](setting-up.md).
+ `wscat` per la connessione all'API. Per ulteriori informazioni, consulta [Utilizzalo `wscat` per connetterti a un' WebSocket API e inviarle messaggi](apigateway-how-to-call-websocket-api-wscat.md).
Ti consigliamo di completare il tutorial dell'app di WebSocket chat prima di iniziare questo tutorial. Per completare il tutorial sull'app di WebSocket chat, consulta[Tutorial: crea un'app di WebSocket chat con WebSocket API, Lambda e DynamoDB](websocket-api-chat-app.md).
## Fase 1: Creazione delle risorse
Scarica e decomprimi [il modello di creazione dell'app per CloudFormation](samples/ws-sfn-starter.zip). Userai questo modello per creare quanto segue:
+ Funzioni Lambda che gestiscono le richieste API e autorizzano l'accesso alla tua API.
+ Una tabella DynamoDB per memorizzare l'identificazione IDs del client e dell'utente principale restituita dall'autorizzatore Lambda.
+ Una macchina a stati Step Functions per inviare messaggi ai client connessi.
**Per creare uno stack CloudFormation**
1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Scegliere **Create stack (Crea stack)**, quindi **With new resources (standard) (Con nuove risorse (standard))**.
1. In **Specificare modello**, scegliere **Carica un file modello**.
1. Selezionare il modello scaricato.
1. Scegli **Next (Successivo)**.
1. Per **Stack name (Nome stack)**, inserire **websocket-step-functions-tutorial**, quindi scegliere **Next (Avanti)**.
1. Per **Configure stack options (Configura opzioni di stack)**, scegliere **Next (Successivo)**.
1. Per quanto riguarda **le funzionalità**, riconosci che CloudFormation puoi creare risorse IAM nel tuo account.
1. Scegli **Avanti**, quindi scegli **Invia**.
CloudFormation fornisce le risorse specificate nel modello. Per completare il provisioning delle risorse, potrebbero essere necessari alcuni minuti. Scegli la scheda **Output** per vedere le risorse create e le relative. ARNs Quando lo stato del tuo CloudFormation stack è **CREATE\$1COMPLETE**, sei pronto per passare alla fase successiva.
## Fase 2: Creare un'API WebSocket
Creerai un' WebSocket API per gestire le connessioni dei client e indirizzare le richieste verso le risorse che hai creato nel passaggio 1.
**Per creare un' WebSocket API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Seleziona **Create API** (Crea API). **Quindi, per **WebSocket API**, scegli Build.**
1. Per **API name (Nome API)**, immettere **websocket-step-functions-tutorial**.
1. Per il **tipo di indirizzo IP**, seleziona **IPv4**.
1. Per **Route selection expression** (Espressione di selezione routing), inserire **request.body.action**.
L'espressione di selezione del routing determina quale routing viene richiamato da API Gateway quando un client invia un messaggio.
1. Scegli **Next (Successivo)**.
1. Per **Instradamenti predefiniti**, scegli **Aggiungi \$1connect**, **Aggiungi \$1disconnect** e **Aggiungi \$1default**.
Gli instradamenti **\$1connect** e **\$1disconnect** sono instradamenti speciali che Gateway API richiama automaticamente quando un client si connette o si disconnette da un'API. Gateway API invoca l'instradamento **\$1default** quando non ci sono altri instradamenti corrispondenti a una richiesta. Creerai un percorso personalizzato per connetterti a Step Functions dopo aver creato l'API.
1. Seleziona **Successivo**.
1. Per **Integrazione per \$1connect**, procedi come segue:
1. Per **Tipo di integrazione**, scegli **Lambda**.
1. Per la **funzione Lambda**, scegli la funzione **\$1connect** Lambda corrispondente che hai creato CloudFormation nel passaggio 1. Il nome della funzione Lambda deve iniziare con **websocket-step**.
1. Per **Integrazione per \$1disconnect**, procedi come segue:
1. Per **Tipo di integrazione**, scegli **Lambda**.
1. Per la funzione **Lambda, scegli la funzione** Lambda **\$1disconnect** corrispondente che hai creato nel passaggio 1. CloudFormation Il nome della funzione Lambda deve iniziare con **websocket-step**.
1. Per **Integrazione per \$1default**, scegli **mock**.
In un'integrazione fittizia, Gateway API gestisce la risposta di instradamento senza un backend di integrazione.
1. Scegli **Next (Successivo)**.
1. Esamina la fase creata da API Gateway. Di default, Gateway API crea una fase denominata **production** e implementa automaticamente l'API in quella fase. Scegli **Next (Successivo)**.
1. Scegliere **Create and deploy** (Crea e implementa).
## Passaggio 3: creare un sistema di autorizzazione Lambda
Per controllare l'accesso alla tua WebSocket API, crei un autorizzatore Lambda. Il CloudFormation modello ha creato la funzione di autorizzazione Lambda per te. La funzione Lambda è visibile nella console Lambda. Il nome deve iniziare con **websocket-step-functions-tutorial-AuthorizerHandler**. Questa funzione Lambda nega tutte le chiamate all' WebSocket API a meno che l'intestazione non lo `Authorization` sia. `Allow` La funzione Lambda passa anche la variabile `$context.authorizer.principalId` all'API, che viene utilizzata successivamente nella tabella DynamoDB per identificare i chiamanti dell'API.
In questo passaggio configurerai l'instradamento **\$1connect** per utilizzare il sistema di autorizzazione Lambda.
**Per creare un sistema di autorizzazione Lambda**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Nel riquadro di navigazione principale, scegli **Autorizzazioni**.
1. Scegli **Crea provider di autorizzazioni**.
1. Per **Nome del provider di autorizzazioni**, inserisci **LambdaAuthorizer**.
1. Per **Authorizer ARN**, immettere il nome dell'autorizzatore creato dal modello. CloudFormation Il nome deve iniziare con **websocket-step-functions-tutorial-AuthorizerHandler**.
**Nota**
Ti consigliamo di non utilizzare questo autorizzatore di esempio per la tua produzione. APIs
1. Per **Tipo di origine identità**, scegli **Intestazione**. In **Chiave**, inserire **Authorization**.
1. Scegli **Crea autorizzazioni**.
Dopo aver creato il sistema di autorizzazione, collegalo all'instradamento **\$1connect** della tua API.
**Per collegare un sistema di autorizzazione all'instradamento \$1connect**
1. Nel pannello di navigazione principale scegli **Instradamenti**.
1. Scegli l'instradamento **\$1connect**.
1. Nella sezione **Impostazioni della richiesta di instradamento** scegli **Modifica**.
1. Per **Autorizzazione**, scegli il menu a discesa, quindi seleziona il sistema di autorizzazione della richiesta.
1. Scegli **Save changes** (Salva modifiche).
## Passaggio 4: creare un'integrazione bidirezionale fittizia
A questo punto creerai l'integrazione bidirezionale fittizia per l'instradamento **\$1default**. Un'integrazione fittizia consente di inviare una risposta al client senza utilizzare un backend. Quando crei un'integrazione per l'instradamento **\$1default**, puoi mostrare ai client come interagire con la tua API.
Configura l'instradamento **\$1default** per indicare ai client di utilizzare l'instradamento **sendmessage**.
**Per creare un'integrazione fittizia**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Scegli l'instradamento **\$1default**, quindi scegli la scheda **Richiesta di integrazione**.
1. Per **Modelli di richiesta**, scegli **Modifica**.
1. Per **Espressione di selezione del modello**, inserisci **200**, quindi scegli **Modifica**.
1. Nella scheda **Richiesta di integrazione**, in **Modelli di richiesta**, scegli **Crea modello**.
1. Per **Chiave del modello**, inserisci **200**.
1. Per **Genera modello**, inserisci il seguente modello di mappatura:
```
{"statusCode": 200}
```
Scegli **Crea modello**.
Il risultato sarà simile al seguente:
![\[Configurazione della richiesta di integrazione per l'integrazione fittizia per l'instradamento $default.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/ws-sfn-mock-integration-request.png)
1. Nel riquadro **Instradamento \$1default**, scegli **Abilita la comunicazione bidirezionale**.
1. Scegli la scheda **Risposta di integrazione**, quindi scegli **Crea risposta di integrazione**.
1. Per **Chiave della risposta**, inserisci **\$1default**.
1. Per **Espressione di selezione del modello**, inserisci **200**.
1. Scegli **Crea risposta**.
1. Per **Modelli di risposta**, scegli **Crea modello**.
1. Per **Chiave del modello**, inserisci **200**.
1. Per **Modello di risposta**, inserisci il seguente modello di mappatura:
```
{"Use the sendmessage route to send a message. Connection ID: $context.connectionId"}
```
1. Scegli **Crea modello**.
Il risultato sarà simile al seguente:
![\[Configurazione della risposta di integrazione per l'integrazione fittizia per l'instradamento $default.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/ws-sfn-mock-integration-response.png)
## Passaggio 5: creare un'integrazione non proxy con Step Functions
A questo punto creerai un instradamento **sendmessage**. I client possono invocare l'instradamento **sendmessage** per trasmettere un messaggio a tutti i client connessi. Il percorso **sendmessage** ha un'integrazione del servizio non proxy con. AWS AWS Step Functions L'integrazione richiama il [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)comando per la macchina a stati Step Functions che il CloudFormation modello ha creato per te.
**Per creare un'integrazione non proxy**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Selezionare **Create Route (Crea route)**.
1. Per **Chiave instradamento**, inserisci **sendmessage**.
1. Per **Tipo di integrazione** scegli **Servizio AWS **.
1. Per **AWS Regione**, inserisci la regione in cui hai distribuito il modello. CloudFormation
1. Per **Servizio AWS **, scegli **Step Functions**.
1. Per **Metodo HTTP**, scegli **POST**.
1. Per **Nome azione** immetti **StartExecution**.
1. Per **Ruolo di esecuzione**, inserisci il ruolo di esecuzione creato dal CloudFormation modello. Il nome deve essere **WebsocketTutorialApiRole**.
1. Selezionare **Create Route (Crea route)**.
A questo punto creerai un modello di mappatura per inviare i parametri di richiesta alla macchina a stati Step Functions.
**Per creare un modello di mappatura**
1. Scegli l'instradamento **sendmessage**, quindi scegli la scheda **Richiesta di integrazione**.
1. Nella sezione **Modelli di richiesta**, scegli **Modifica**.
1. Per **Espressione di selezione del modello**, inserisci **\$1\$1default**.
1. Scegli **Modifica**.
1. Nella sezione **Modelli di richiesta**, scegli **Crea modello**.
1. Per **Chiave del modello**, inserisci **\$1\$1default**.
1. Per **Genera modello**, inserisci il seguente modello di mappatura:
```
#set($domain = "$context.domainName")
#set($stage = "$context.stage")
#set($body = $input.json('$'))
#set($getMessage = $util.parseJson($body))
#set($mymessage = $getMessage.message)
{
"input": "{\"domain\": \"$domain\", \"stage\": \"$stage\", \"message\": \"$mymessage\"}",
"stateMachineArn": "arn:aws:states:us-east-2:123456789012:stateMachine:WebSocket-Tutorial-StateMachine"
}
```
Sostituire *stateMachineArn* con l'ARN della macchina a stati creata da. CloudFormation
Questo modello di mappatura esegue queste operazioni:
+ Crea la variabile `$domain` utilizzando la variabile di contesto `domainName`.
+ Crea la variabile `$stage` utilizzando la variabile di contesto `stage`.
Le variabili `$domain` e `$stage` sono necessarie per creare un URL di callback.
+ Riceve il messaggio JSON `sendmessage` in arrivo ed estrae la proprietà `message`.
+ Crea l'input per la macchina a stati. L'input è il dominio e lo stadio dell' WebSocket API e il messaggio proveniente dalla `sendmessage` route.
1. Scegli **Crea modello**.
![\[Configurazione dell'instradamento sendmessage.\]](http://docs.aws.amazon.com/it_it/apigateway/latest/developerguide/images/ws-sfn-integration-request.png)
È possibile creare un'integrazione non proxy sugli instradamenti **\$1connect** o **\$1disconnect** per aggiungere o rimuovere direttamente un ID di connessione dalla tabella DynamoDB, senza invocare una funzione Lambda.
## Fase 6: Test dell'API
A questo punto distribuirai e testerai l'API per assicurarti che funzioni correttamente. Utilizzerai il `wscat` comando per connetterti all'API e poi utilizzerai un comando slash per inviare un frame ping per verificare la connessione all' WebSocket API.
**Per distribuire l'API**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Nel pannello di navigazione principale scegli **Instradamenti**.
1. Seleziona **Deploy API (Distribuisci API)**.
1. Per **Fase**, scegli **produzione**.
1. (Facoltativo) Inserisci una descrizione in **Descrizione distribuzione**.
1. Seleziona **Deploy (Implementa)**.
Dopo aver distribuito l'API, puoi invocarla. Utilizza l'URL di richiamo per chiamare la tua API.
**Per ottenere l'URL di richiamo dell'API**
1. Scegliere l'API.
1. Scegli **Stages** (Fasi), quindi scegli **production** (produzione).
1. **Annota l'URL della tua API. WebSocket ** L'URL dovrebbe essere del tipo `wss://abcdef123.execute-api.us-east-2.amazonaws.com/production`.
Ora che hai l'URL di invoke, puoi testare la connessione alla tua WebSocket API.
**Per testare la connessione all'API**
1. Per connetterti all'API, utilizza il seguente comando. Innanzitutto, testa la connessione invocando il percorso `/ping`.
```
wscat -c wss://abcdef123.execute-api.us-east-2.amazonaws.com/production -H "Authorization: Allow" --slash -P
```
```
Connected (press CTRL+C to quit)
```
1. Immetti i seguenti comandi per eseguire il ping del frame di controllo. Puoi utilizzare un frame di controllo per il keepalive dal lato client.
```
/ping
```
Il risultato sarà simile al seguente:
```
< Received pong (data: "")
```
Ora che hai testato la connessione, puoi verificare che la tua API funzioni correttamente. In questo passaggio, apri una nuova finestra di terminale in modo che l' WebSocket API possa inviare un messaggio a tutti i client connessi.
**Per testare l'API**
1. Apri un nuovo terminale ed esegui nuovamente il comando `wscat` con i parametri seguenti.
```
wscat -c wss://abcdef123.execute-api.us-east-2.amazonaws.com/production -H "Authorization: Allow"
```
```
Connected (press CTRL+C to quit)
```
1. Gateway API determina quale instradamento invocare in base all'espressione di selezione della richiesta di instradamento dell'API. L'espressione di selezione dell'instradamento dell'API è `$request.body.action`. Di conseguenza, API Gateway richiama il routing `sendmessage` quando si invia il seguente messaggio:
```
{"action": "sendmessage", "message": "hello, from Step Functions!"}
```
La macchina a stati Step Functions associata all'instradamento invoca una funzione Lambda con il messaggio e l'URL di callback. La funzione Lambda chiama l'API di gestione di Gateway API e invia il messaggio a tutti i client connessi. Tutti i client connessi ricevono il seguente messaggio:
```
< hello, from Step Functions!
```
Ora che hai testato la tua WebSocket API, puoi disconnetterti dalla tua API.
**Per disconnetterti dall'API**
+ Per disconnetterti dall'API, premi `CTRL+C`.
Quando un client si disconnette dall'API, Gateway API invoca l'instradamento **\$1disconnect** dell'API. L'integrazione Lambda per l'instradamento **\$1disconnect** dell'API rimuove l'ID di connessione da DynamoDB.
## Fase 7: pulire
Per evitare costi non necessari, eliminare le risorse create nell'ambito di questo tutorial. I passaggi seguenti eliminano lo CloudFormation stack e WebSocket l'API.
**Per eliminare un'API WebSocket**
1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. **Nella **APIs**pagina, seleziona il tuo websocket-api.**
1. Scegliere **Azioni**, scegliere **Elimina**, quindi confermare la scelta.
**Per eliminare uno stack CloudFormation**
1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Seleziona il tuo stack. CloudFormation
1. Scegli **Elimina** e conferma la tua scelta.
## Passaggi successivi
Puoi automatizzare la creazione e la pulizia di tutte le AWS risorse coinvolte in questo tutorial. [Per un esempio di CloudFormation modello che automatizza queste azioni per questo tutorial, vedi ws-sfn.zip.](samples/ws-sfn-complete.zip)