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à.
# CORS per REST APIs in API Gateway
[CORS (Cross-origin resource sharing)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) è una caratteristica di sicurezza del browser che limita le richieste HTTP multiorigine avviate da script in esecuzione nel browser. Per ulteriori informazioni, consulta [Che cos'è CORS?](https://aws.amazon.com/what-is/cross-origin-resource-sharing/)
## Determinazione della necessità di abilitare il supporto di CORS
Una richiesta HTTP *multiorigine* è una richiesta effettuata a:
+ Un *dominio* diverso (ad esempio da `example.com` a `amazondomains.com`)
+ Un *sottodominio* diverso (ad esempio da `example.com` a `petstore.example.com`)
+ Una *porta* diversa (ad esempio da `example.com` a `example.com:10777`)
+ Un *protocollo* diverso (ad esempio da `https://example.com` a `http://example.com`)
Se non riesci ad accedere all'API e ricevi un messaggio di errore che contiene `Cross-Origin Request Blocked`, potresti dover abilitare CORS.
Le richieste HTTP multiorigine possono essere di due tipi: richieste *semplici* e richieste *non semplici*.
## Abilitazione di CORS per una richiesta semplice
Una richiesta HTTP è *semplice* se si verificano tutte le condizioni seguenti:
+ Viene inviata a una risorsa API che permette solo richieste `GET`, `HEAD` e `POST`.
+ Se si tratta di una richiesta di metodo `POST`, deve includere un'intestazione `Origin`.
+ Il tipo di contenuto del payload della richiesta è `text/plain`, `multipart/form-data` o `application/x-www-form-urlencoded`.
+ La richiesta non contiene intestazioni personalizzate.
+ Eventuali requisiti aggiuntivi elencati nella [documentazione di Mozilla CORS per le richieste semplici](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#Simple_requests).
Per richieste di metodo `POST` multiorigine semplici, la risposta della risorsa deve includere l'intestazione `Access-Control-Allow-Origin: '*'` o `Access-Control-Allow-Origin:'origin'`.
Tutte le altre richieste HTTP multiorigine sono richieste *non semplici*.
## Abilitazione di CORS per una richiesta non semplice
Se le risorse dell'API ricevono richieste non semplici, è necessario abilitare il supporto CORS aggiuntivo a seconda del tipo di integrazione.
### Abilitazione di CORS per integrazioni non proxy
Per questo tipo di integrazioni, il [protocollo CORS](https://fetch.spec.whatwg.org/#http-cors-protocol) richiede al browser di inviare una richiesta preliminare al server e di attendere l'approvazione (o una richiesta di credenziali) del server prima di inviare la richiesta effettiva. È necessario configurare l'API per inviare una risposta appropriata alla richiesta di verifica preliminare.
Creazione di una risposta di verifica preliminare
1. Creare un metodo `OPTIONS` per l'integrazione fittizia.
1. Aggiungere le seguenti intestazioni di risposta alla risposta del metodo 200:
+ `Access-Control-Allow-Headers`
+ `Access-Control-Allow-Methods`
+ `Access-Control-Allow-Origin`
1. Impostare il comportamento passthrough di integrazione su `NEVER`. In questo caso, la richiesta di metodo di un tipo di contenuto non mappato sarà rifiutata con la risposta Tipo di supporto non compatibile HTTP 415. Per ulteriori informazioni, consulta [Comportamento della richiesta del metodo per i payload senza modelli di mappatura per REST APIs in API Gateway](integration-passthrough-behaviors.md).
1. Immettere i valori per le intestazioni delle risposte. Per consentire tutte le origini, tutti i metodi e le intestazioni comuni, usare i seguenti valori di intestazione:
+ `Access-Control-Allow-Headers: 'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token'`
+ `Access-Control-Allow-Methods: 'DELETE,GET,HEAD,OPTIONS,PUT,POST,PATCH'`
+ `Access-Control-Allow-Origin: '*'`
Dopo aver creato la richiesta di verifica preliminare, è necessario restituire l'intestazione `Access-Control-Allow-Origin: '*'` o `Access-Control-Allow-Origin:'origin'` per tutti i metodi abilitati per CORS per almeno tutte le 200 risposte.
### Abilitazione di CORS per integrazioni non proxy utilizzando il Console di gestione AWS
È possibile utilizzare il per abilitare CORS Console di gestione AWS . Gateway Amazon API crea un metodo `OPTIONS` e aggiunge l'intestazione `Access-Control-Allow-Origin` alle risposte di integrazione del metodo esistente. Questo non sempre funziona e talvolta è necessario modificare manualmente la risposta di integrazione per restituire l'intestazione `Access-Control-Allow-Origin` di tutti i metodi abilitati per CORS per almeno tutte le 200 risposte.
Se i tipi di supporti binari sono impostati su `*/*` per l’API, quando Gateway API crea un metodo `OPTIONS`, modificare `contentHandling` in `CONVERT_TO_TEXT`.
Il comando [update-integration](https://docs.aws.amazon.com/cli/latest/reference/apigateway/update-integration.html) seguente modifica `contentHandling` in `CONVERT_TO_TEXT` per una richiesta di integrazione:
```
aws apigateway update-integration \
--rest-api-id abc123 \
--resource-id aaa111 \
--http-method OPTIONS \
--patch-operations op='replace',path='/contentHandling',value='CONVERT_TO_TEXT'
```
Il [update-integration-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/update-integration-response.html)comando seguente modifica il formato `contentHandling` `CONVERT_TO_TEXT` per una risposta di integrazione:
```
aws apigateway update-integration-response \
--rest-api-id abc123 \
--resource-id aaa111 \
--http-method OPTIONS \
--status-code 200 \
--patch-operations op='replace',path='/contentHandling',value='CONVERT_TO_TEXT'
```
## Abilitazione del supporto di CORS per le integrazioni proxy
Per un'integrazione proxy Lambda o un'integrazione con proxy HTTP, il back-end è responsabile della restituzione delle intestazioni `Access-Control-Allow-Origin`, `Access-Control-Allow-Methods` e `Access-Control-Allow-Headers` , perché un'integrazione proxy non restituisce una risposta di integrazione.
Le seguenti funzioni Lambda di esempio restituiscono le intestazioni CORS richieste:
------
#### [ Node.js ]
```
export const handler = async (event) => {
const response = {
statusCode: 200,
headers: {
"Access-Control-Allow-Headers" : "Content-Type",
"Access-Control-Allow-Origin": "https://www.example.com",
"Access-Control-Allow-Methods": "OPTIONS,POST,GET"
},
body: JSON.stringify('Hello from Lambda!'),
};
return response;
};
```
------
#### [ Python 3 ]
```
import json
def lambda_handler(event, context):
return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Headers': 'Content-Type',
'Access-Control-Allow-Origin': 'https://www.example.com',
'Access-Control-Allow-Methods': 'OPTIONS,POST,GET'
},
'body': json.dumps('Hello from Lambda!')
}
```
------
**Topics**
+ [Determinazione della necessità di abilitare il supporto di CORS](#apigateway-cors-request-types)
+ [Abilitazione di CORS per una richiesta semplice](#apigateway-cors-simple-request)
+ [Abilitazione di CORS per una richiesta non semplice](#apigateway-enable-cors-non-simple)
+ [Abilitazione del supporto di CORS per le integrazioni proxy](#apigateway-enable-cors-proxy)
+ [Abilitazione CORS su una risorsa tramite la console API Gateway](how-to-cors-console.md)
+ [Abilitazione di CORS per una risorsa tramite l'API di importazione di API Gateway](enable-cors-for-resource-using-swagger-importer-tool.md)
+ [Test di CORS per un'API di Gateway API](apigateway-test-cors.md)