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à.
# Limita l'accesso all'origine dell'URL di una AWS Lambda funzione
CloudFront fornisce *il controllo dell'accesso all'origine* (OAC) per limitare l'accesso all'origine dell'URL di una funzione Lambda.
**Topics**
+ [Creazione di un nuovo OAC](#create-oac-overview-lambda)
+ [Impostazioni avanzate per il controllo dell’accesso all’origine](#oac-advanced-settings-lambda)
+ [Esempio di codice modello](#example-template-code-lambda-oac)
## Creazione di un nuovo OAC
Completa i passaggi descritti nei seguenti argomenti per configurare un nuovo OAC in. CloudFront
**Importante**
Se utilizzi `PUT` o `POST` metodi con l'URL della funzione Lambda, gli utenti devono calcolare il corpo SHA256 del corpo e includere il valore hash del payload del corpo della richiesta nell'`x-amz-content-sha256`intestazione quando inviano la richiesta a. CloudFront Lambda non supporta i payload non firmati.
**Topics**
+ [Prerequisiti](#oac-prerequisites-lambda)
+ [Concedi CloudFront l'autorizzazione per accedere all'URL della funzione Lambda](#oac-permission-to-access-lambda)
+ [Creazione dell’OAC](#create-oac-lambda)
### Prerequisiti
Prima di creare e configurare OAC, è necessario disporre di una CloudFront distribuzione con un URL della funzione Lambda come origine. Per utilizzare OAC, deve specificare `AWS_IAM` come il valore per il parametro `AuthType`. Per ulteriori informazioni, consulta [Utilizzo dell’URL di una funzione Lambda](DownloadDistS3AndCustomOrigins.md#concept_lambda_function_url).
### Concedi CloudFront l'autorizzazione per accedere all'URL della funzione Lambda
Prima di creare un OAC o configurarlo in una CloudFront distribuzione, assicurati che CloudFront disponga dell'autorizzazione per accedere all'URL della funzione Lambda. Esegui questa operazione dopo aver creato una CloudFront distribuzione, ma prima di aggiungere l'OAC all'URL della funzione Lambda nella configurazione di distribuzione.
**Nota**
Per aggiornare la policy IAM per l’URL della funzione Lambda, devi usare AWS Command Line Interface (AWS CLI). La modifica della policy IAM nella console Lambda non è attualmente supportata.
Il AWS CLI comando seguente concede al CloudFront service principal (`cloudfront.amazonaws.com`) l'accesso all'URL della funzione Lambda. L'`Condition`elemento della policy consente di accedere CloudFront a Lambda *solo* quando la richiesta è per conto della CloudFront distribuzione che contiene l'URL della funzione Lambda. Questa è la distribuzione con l’origine dell’URL della funzione Lambda a cui desideri aggiungere l’OAC.
**Example : AWS CLI comando per aggiornare una policy per consentire l'accesso in sola lettura a una CloudFront distribuzione con OAC abilitato**
I seguenti AWS CLI comandi consentono alla CloudFront distribuzione (`E1PDK09ESKHJWT`) di accedere alla tua *`FUNCTION_URL_NAME`* Lambda.
```
aws lambda add-permission \
--statement-id "AllowCloudFrontServicePrincipal" \
--action "lambda:InvokeFunctionUrl" \
--principal "cloudfront.amazonaws.com" \
--source-arn "arn:aws:cloudfront::123456789012:distribution/E1PDK09ESKHJWT" \
--function-name FUNCTION_URL_NAME
```
```
aws lambda add-permission \
--statement-id "AllowCloudFrontServicePrincipalInvokeFunction" \
--action "lambda:InvokeFunction" \
--principal "cloudfront.amazonaws.com" \
--source-arn "arn:aws:cloudfront::123456789012:distribution/E1PDK09ESKHJWT" \
--function-name FUNCTION_URL_NAME
```
**Nota**
Se crei una distribuzione e questa non dispone dell'autorizzazione per l'URL della funzione Lambda, puoi scegliere Copia il comando **CLI dalla CloudFront console e quindi immettere questo comando** dal tuo terminale a riga di comando. Per ulteriori informazioni, consulta [Concedere alla funzione l’accesso a Servizi AWS](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html#permissions-resource-serviceinvoke) nella *Guida per gli sviluppatori di AWS Lambda *.
### Creazione dell’OAC
Per creare un OAC, puoi usare l' Console di gestione AWS, CloudFormation AWS CLI, o l'API. CloudFront
------
#### [ Console ]
**Come creare un OAC**
1. Accedi Console di gestione AWS e apri la CloudFront console all'indirizzo[https://console.aws.amazon.com/cloudfront/v4/home](https://console.aws.amazon.com/cloudfront/v4/home).
1. Nel pannello di navigazione a sinistra, scegli **Accesso origine**.
1. Scegli **Crea un'impostazione di controllo**.
1. Nel modulo **Crea nuovo OAC**, procedi come indicato di seguito:
1. Immetti un **Nome** e (facoltativamente) una **Descrizione** per l’OAC.
1. Per **Comportamento di firma**, si consiglia di lasciare l’impostazione predefinita (**Richieste di firma (consigliato)**). Per ulteriori informazioni, consulta [Impostazioni avanzate per il controllo dell’accesso all’origine](#oac-advanced-settings-lambda).
1. Per **Tipo di origine**, scegli **Lambda**.
1. Scegli **Create** (Crea).
**Suggerimento**
Dopo aver creato l’OAC, prendi nota del **Nome**. In questa procedura, eseguire le seguenti operazioni:
**Come aggiungere un controllo di accesso origine all’URL di una funzione Lambda in una distribuzione**
1. Apri la CloudFront console all'indirizzo[https://console.aws.amazon.com/cloudfront/v4/home](https://console.aws.amazon.com/cloudfront/v4/home).
1. Scegli una distribuzione con un’URL della funzione Lambda a cui desideri aggiungere l’OAC, quindi scegli la scheda **Origini**.
1. Seleziona l’URL della funzione Lambda a cui desideri aggiungere l’OAC, quindi scegli **Modifica**.
1. Seleziona **HTTPS solo** per il **protocollo** di origine.
1. Nel menu a discesa **Controllo di accesso origine**, scegli il nome OAC che desideri utilizzare.
1. Scegli **Save changes** (Salva modifiche).
La distribuzione inizia a essere distribuita in tutte le CloudFront edge location. Quando una posizione edge riceve la nuova configurazione, firma tutte le richieste che invia all’URL della funzione Lambda.
------
#### [ CloudFormation ]
Per creare un OAC con CloudFormation, usa il tipo di `AWS::CloudFront::OriginAccessControl` risorsa. L'esempio seguente mostra la sintassi del CloudFormation modello, in formato YAML, per la creazione di un OAC.
```
Type: AWS::CloudFront::OriginAccessControl
Properties:
OriginAccessControlConfig:
Description: An optional description for the origin access control
Name: ExampleOAC
OriginAccessControlOriginType: lambda
SigningBehavior: always
SigningProtocol: sigv4
```
*Per ulteriori informazioni, vedere [AWS::CloudFront::OriginAccessControl](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudfront-originaccesscontrol.html) nella Guida per l'utente.AWS CloudFormation *
------
#### [ CLI ]
Per creare un controllo di accesso all'origine con AWS Command Line Interface (AWS CLI), utilizzate il **aws cloudfront create-origin-access-control** comando. È possibile utilizzare un file di input per fornire i parametri di input del comando, anziché specificare ogni singolo parametro come input della riga di comando.
**Per creare un controllo di accesso all'origine (CLI con file di input)**
1. Per creare un file denominato `origin-access-control.yaml`, utilizza il comando seguente. Tale file contiene tutti i parametri di input per il comando **create-origin-access-control**.
```
aws cloudfront create-origin-access-control --generate-cli-skeleton yaml-input > origin-access-control.yaml
```
1. Aprire il file `origin-access-control.yaml` appena creato. Modifica il file per aggiungere un nome per l'OAC, una descrizione (opzionale) e modificare `SigningBehavior` in `always`. Quindi salvare il file.
Per ulteriori informazioni sulle impostazioni OAC, consultare [Impostazioni avanzate per il controllo dell’accesso all’origine](#oac-advanced-settings-lambda).
1. Utilizzare il comando seguente per creare il controllo di accesso origine utilizzando i parametri di input dal file `origin-access-control.yaml`.
```
aws cloudfront create-origin-access-control --cli-input-yaml file://origin-access-control.yaml
```
Prendere nota del valore `Id` nell'output del comando. È necessario per aggiungere l'OAC all'URL di una funzione Lambda in CloudFront una distribuzione.
**Come collegare un OAC all’URL di una funzione Lambda in una distribuzione esistente (CLI con file di input)**
1. Usa il comando seguente per salvare la configurazione di distribuzione per la CloudFront distribuzione a cui desideri aggiungere l'OAC. La distribuzione deve avere come origine l’URL di una funzione Lambda.
```
aws cloudfront get-distribution-config --id --output yaml > dist-config.yaml
```
1. Aprire il file denominato `dist-config.yaml` appena creato. Modifica il file apportando le seguenti modifiche:
+ Nell'oggetto `Origins`, aggiungi l'ID dell'OAC al campo a cui è stato assegnato il nome `OriginAccessControlId`.
+ Rimuovi il valore dal campo denominato `OriginAccessIdentity`, se esiste.
+ Rinominare il campo `ETag` in `IfMatch`, ma non modificare il valore del campo.
Salvare il file al termine.
1. Utilizzare il comando seguente per aggiornare la distribuzione e utilizzare il controllo di accesso origine.
```
aws cloudfront update-distribution --id --cli-input-yaml file://dist-config.yaml
```
La distribuzione inizia a essere distribuita in tutte le CloudFront edge location. Quando una posizione edge riceve la nuova configurazione, firma tutte le richieste che invia all’URL della funzione Lambda.
------
#### [ API ]
Per creare un OAC con l' CloudFront API, usa. [CreateOriginAccessControl](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_CreateOriginAccessControl.html) Per ulteriori informazioni sui campi specificati in questa chiamata API, consulta la documentazione di riferimento sull'API per il tuo AWS SDK o altro client API.
Dopo aver creato un OAC, puoi collegarlo all’URL di una funzione Lambda in una distribuzione, utilizzando una delle seguenti chiamate API:
+ Per collegarlo a una distribuzione esistente, usa [UpdateDistribution](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateDistribution.html).
+ Per collegarlo a una nuova distribuzione, usa [CreateDistribution](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_CreateDistribution.html).
Per entrambe queste chiamate API, fornire l’ID di OAC nel campo `OriginAccessControlId`, all’interno di un’origine. Per ulteriori informazioni sugli altri campi specificati in queste chiamate API, consulta la documentazione di riferimento sull'API per il tuo AWS SDK o altro client API.
------
## Impostazioni avanzate per il controllo dell’accesso all’origine
La funzionalità CloudFront OAC include impostazioni avanzate destinate solo a casi d'uso specifici. Usa le impostazioni consigliate a meno che tu non abbia una necessità specifica per le impostazioni avanzate.
OAC contiene un'impostazione denominata **Signing behavior** (nella console) o `SigningBehavior` (nell'API, nella CLI e). CloudFormation Questa impostazione offre le seguenti opzioni:
**Firma sempre le richieste di origine (impostazione consigliata)**
Si consiglia di utilizzare questa impostazione, denominata **Richieste di firma (consigliata)** nella console, oppure `always` nell'API, nell'interfaccia a riga di comando e CloudFormation. Con questa impostazione, firma CloudFront sempre tutte le richieste inviate all'URL della funzione Lambda.
**Non firmare le richieste di origine**
Questa impostazione è denominata **Non firmare le richieste** nella console, oppure `never`nell'API, nell'interfaccia a riga di comando e CloudFormation. Usa questa impostazione per disattivare OAC per tutte le origini in tutte le distribuzioni che utilizzano questo OAC. Ciò consente di risparmiare tempo e fatica rispetto alla rimozione di un OAC da tutte le origini e le distribuzioni che lo utilizzano, uno per uno. Con questa impostazione, CloudFront non firma alcuna richiesta inviata all'URL della funzione Lambda.
Per utilizzare questa impostazione, l’URL della funzione Lambda deve essere accessibile pubblicamente. Se usi questa impostazione con un URL della funzione Lambda non accessibile pubblicamente, non CloudFront puoi accedere all'origine. L'URL della funzione Lambda restituisce gli errori CloudFront e li CloudFront trasmette ai visualizzatori. Per ulteriori informazioni, consulta il [modello di sicurezza e autenticazione per la URLs funzione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/urls-auth.html) nella Guida per *AWS Lambda l'*utente.
**Non ignorare l'intestazione del visualizzatore (client) `Authorization`**
Questa impostazione è denominata **Non sovrascrivere l'intestazione di autorizzazione**nella console, oppure `no-override` nell'API, nell'interfaccia a riga di comando e CloudFormation. Utilizzate questa impostazione quando desiderate firmare CloudFront le richieste di origine solo quando la richiesta del visualizzatore corrispondente non include un'`Authorization`intestazione. Con questa impostazione, CloudFront trasmette l'`Authorization`intestazione della richiesta del visualizzatore quando ne è presente una, ma firma la richiesta di origine (aggiungendo la propria `Authorization` intestazione) quando la richiesta del visualizzatore non include un'intestazione. `Authorization`
+ Se utilizzi questa impostazione, devi specificare la firma Signature Version 4 per l'URL della funzione Lambda anziché il nome o il CNAME della CloudFront distribuzione. Quando CloudFront inoltra l'`Authorization`intestazione dalla richiesta del visualizzatore all'URL della funzione Lambda, Lambda convalida la firma rispetto all'host del dominio URL Lambda. Se la firma non è basata sul dominio URL Lambda, l’host nella firma non corrisponderà all’host utilizzato dall’origine dell’URL Lambda. Ciò significa che la richiesta non andrà a buon fine, causando un errore di convalida della firma.
+ Per trasmettere l'`Authorization`intestazione dalla richiesta del visualizzatore, è *necessario* aggiungere l'`Authorization`intestazione a una [politica di cache per tutti i comportamenti della cache](controlling-the-cache-key.md) che utilizzano la funzione Lambda URLs associata a questo controllo di accesso all'origine.
## Esempio di codice modello
Se la tua CloudFront origine è l'URL di una funzione Lambda associata a un OAC, puoi usare il seguente script Python per caricare file nella funzione Lambda con il metodo. `POST`
Questo codice presuppone che l’OAC sia stato configurato con il comportamento di firma predefinito impostato su **Firma sempre le richieste di origine** e che non sia stata selezionata l’impostazione **Non sovrascrivere l’intestazione di autorizzazione**.
Questa configurazione consente all’OAC di gestire correttamente l’autorizzazione SigV4 con Lambda utilizzando il nome host Lambda. Il payload viene firmato utilizzando SigV4 dall’identità IAM autorizzata per l’URL della funzione Lambda, che è designato come tipo `IAM_AUTH`.
Il modello mostra come gestire i valori hash del payload firmato nell’intestazione x-amz-content-sha256 per le richieste `POST` dal lato client. Nello specifico, questo modello è progettato per gestire i payload dei dati dei moduli. Il modello consente il caricamento sicuro dei file su un URL CloudFront della funzione Lambda e AWS utilizza meccanismi di autenticazione per garantire che solo le richieste autorizzate possano accedere alla funzione Lambda.
**Il codice include la seguente funzionalità:**
Soddisfa il requisito di includere l’hash del payload nell’intestazione x-amz-content-sha256
Utilizza l'autenticazione SigV4 per un accesso sicuro Servizio AWS
Supporta caricamenti di file utilizzando dati di moduli multiparte
Include la gestione degli errori per le eccezioni richiesta
```
import boto3
from botocore.auth import SigV4Auth
from botocore.awsrequest import AWSRequest
import requests
import hashlib
import os
def calculate_body_hash(body):
return hashlib.sha256(body).hexdigest()
def sign_request(request, credentials, region, service):
sigv4 = SigV4Auth(credentials, service, region)
sigv4.add_auth(request)
def upload_file_to_lambda(cloudfront_url, file_path, region):
# AWS credentials
session = boto3.Session()
credentials = session.get_credentials()
# Prepare the multipart form-data
boundary = "------------------------boundary"
# Read file content
with open(file_path, 'rb') as file:
file_content = file.read()
# Get the filename from the path
filename = os.path.basename(file_path)
# Prepare the multipart body
body = (
f'--{boundary}\r\n'
f'Content-Disposition: form-data; name="file"; filename="{filename}"\r\n'
f'Content-Type: application/octet-stream\r\n\r\n'
).encode('utf-8')
body += file_content
body += f'\r\n--{boundary}--\r\n'.encode('utf-8')
# Calculate SHA256 hash of the entire body
body_hash = calculate_body_hash(body)
# Prepare headers
headers = {
'Content-Type': f'multipart/form-data; boundary={boundary}',
'x-amz-content-sha256': body_hash
}
# Create the request
request = AWSRequest(
method='POST',
url=cloudfront_url,
data=body,
headers=headers
)
# Sign the request
sign_request(request, credentials, region, 'lambda')
# Get the signed headers
signed_headers = dict(request.headers)
# Print request headers before sending
print("Request Headers:")
for header, value in signed_headers.items():
print(f"{header}: {value}")
try:
# Send POST request with signed headers
response = requests.post(
cloudfront_url,
data=body,
headers=signed_headers
)
# Print response status and content
print(f"\nStatus code: {response.status_code}")
print("Response:", response.text)
# Print response headers
print("\nResponse Headers:")
for header, value in response.headers.items():
print(f"{header}: {value}")
except requests.exceptions.RequestException as e:
print(f"An error occurred: {e}")
# Usage
cloudfront_url = "https://d111111abcdef8.cloudfront.net"
file_path = r"filepath"
region = "us-east-1" # example: "us-west-2"
upload_file_to_lambda(cloudfront_url, file_path, region)
```