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à.

# Scrittura del codice della funzione
<a name="writing-function-code"></a>

Puoi usare CloudFront Functions per scrivere funzioni leggere JavaScript per personalizzazioni CDN su larga scala e sensibili alla latenza. Il codice funzionale può manipolare le richieste e le risposte che fluiscono CloudFront, eseguire l'autenticazione e l'autorizzazione di base, generare risposte HTTP all'edge e altro ancora.

Per aiutarti a scrivere il codice funzionale per CloudFront Functions, consulta i seguenti argomenti. Per esempi di codice, consulta [CloudFront Esempi di funzioni per CloudFront](service_code_examples_cloudfront_functions_examples.md) e il [amazon-cloudfront-functions repository](https://github.com/aws-samples/amazon-cloudfront-functions) on GitHub.

**Topics**
+ [

# Scelta dello scopo della funzione
](function-code-choose-purpose.md)
+ [Struttura degli eventi](functions-event-structure.md)
+ [JavaScript funzionalità di runtime](functions-javascript-runtime-features.md)
+ [

# Metodi helper per archivi di valori delle chiavi
](functions-custom-methods.md)
+ [

# Metodi di assistente di gestione per la modifica dell’origine
](helper-functions-origin-modification.md)
+ [

# Metodi di supporto per le proprietà di CloudFront SaaS Manager
](saas-specific-logic-function-code.md)
+ [

# Uso di async e await
](async-await-syntax.md)
+ [

# Supporto CWT per le funzioni CloudFront
](cwt-support-cloudfront-functions.md)
+ [

# Metodi generali di supporto
](general-helper-methods.md)

# Scelta dello scopo della funzione
<a name="function-code-choose-purpose"></a>

Prima di scrivere il codice funzione, è necessario determinare lo scopo della funzione. La maggior parte CloudFront delle funzioni di Functions ha uno dei seguenti scopi.

**Topics**
+ [

## Modifica della richiesta HTTP in un tipo di evento di richiesta visualizzatore
](#function-code-modify-request)
+ [

## Generazione di una risposta HTTP in un tipo di evento di richiesta visualizzatore
](#function-code-generate-response)
+ [

## Modifica della risposta HTTP in un tipo di evento di risposta visualizzatore
](#function-code-modify-response)
+ [

## Convalida le connessioni MTL in un tipo di evento di richiesta di connessione
](#function-code-connection-request)
+ [

## Informazioni correlate
](#related-information-cloudfront-functions-purpose)

Indipendentemente dallo scopo della funzione, `handler` è il punto di ingresso per qualsiasi funzione. Richiede un solo argomento chiamato`event`, che viene passato alla funzione da CloudFront. `event` è un oggetto JSON che contiene una rappresentazione della richiesta HTTP (e la risposta, se la funzione modifica la risposta HTTP). 

## Modifica della richiesta HTTP in un tipo di evento di richiesta visualizzatore
<a name="function-code-modify-request"></a>

La funzione può modificare la richiesta HTTP CloudFront ricevuta dal visualizzatore (client) e restituire la richiesta modificata a CloudFront per continuare l'elaborazione. Ad esempio, il codice funzione potrebbe normalizzare la [chiave cache](understanding-the-cache-key.md) o modificare le intestazioni delle richieste.

Dopo aver creato e pubblicato una funzione che modifica la richiesta HTTP, assicurati di aggiungere un’associazione per il tipo di evento *richiesta visualizzatore*. Per ulteriori informazioni, consulta [Creazione della funzione](functions-tutorial.md#functions-tutorial-create). In questo modo la funzione viene eseguita ogni volta che CloudFront riceve una richiesta da un visualizzatore, prima di verificare se l'oggetto richiesto è nella CloudFront cache.

**Example Esempio**  
Il seguente pseudocodice mostra la struttura di una funzione che modifica la richiesta HTTP.  

```
function handler(event) {
    var request = event.request;

    // Modify the request object here.

    return request;
}
```
La funzione restituisce l'`request`oggetto modificato a CloudFront. CloudFrontcontinua a elaborare la richiesta restituita controllando la CloudFront presenza di un hit nella cache e inviando la richiesta all'origine, se necessario.

## Generazione di una risposta HTTP in un tipo di evento di richiesta visualizzatore
<a name="function-code-generate-response"></a>

La funzione può generare una risposta HTTP all'edge e restituirla direttamente al visualizzatore (client) senza verificare la presenza di una risposta memorizzata nella cache o ulteriori elaborazioni da parte CloudFront di. Ad esempio, il codice funzione potrebbe reindirizzare la richiesta a un nuovo URL oppure verificare l'autorizzazione e restituire una risposta `401` o `403` a richieste non autorizzate.

Quando crei una funzione che genera una risposta HTTP, assicurati di scegliere il tipo di evento *richiesta del visualizzatore*. Ciò significa che la funzione viene eseguita ogni volta che CloudFront riceve una richiesta da un visualizzatore, prima CloudFront di eseguire qualsiasi ulteriore elaborazione della richiesta.

**Example Esempio**  
Il seguente pseudocodice mostra la struttura di una funzione che genera una risposta HTTP.  

```
function handler(event) {
    var request = event.request;

    var response = ...; // Create the response object here,
                        // using the request properties if needed.

    return response;
}
```
La funzione restituisce un `response` oggetto a CloudFront, che ritorna CloudFront immediatamente al visualizzatore senza controllare la CloudFront cache o inviare una richiesta all'origine.

## Modifica della risposta HTTP in un tipo di evento di risposta visualizzatore
<a name="function-code-modify-response"></a>

La funzione può modificare la risposta HTTP prima di CloudFront inviarla al visualizzatore (client), indipendentemente dal fatto che la risposta provenga dalla CloudFront cache o dall'origine. Ad esempio, il codice funzione potrebbe aggiungere o modificare le intestazioni, i codici di stato e i contenuti del corpo della risposta.

Quando crei una funzione che modifica la risposta HTTP, assicurati di scegliere il tipo di evento *risposta del visualizzatore* . Ciò significa che la funzione viene eseguita prima di CloudFront restituire una risposta al visualizzatore, indipendentemente dal fatto che la risposta provenga dalla CloudFront cache o dall'origine.

**Example Esempio**  
Il seguente pseudocodice mostra la struttura di una funzione che modifica la risposta HTTP.  

```
function handler(event) {
    var request = event.request;
    var response = event.response;

    // Modify the response object here,
    // using the request properties if needed.

    return response;
}
```
La funzione restituisce l'`response`oggetto modificato a CloudFront, che ritorna CloudFront immediatamente al visualizzatore.

## Convalida le connessioni MTL in un tipo di evento di richiesta di connessione
<a name="function-code-connection-request"></a>

Le funzioni di connessione sono un tipo di CloudFront funzioni che vengono eseguite durante le connessioni TLS per fornire una logica di convalida e autenticazione personalizzata. Le funzioni di connessione sono attualmente disponibili per le connessioni TLS reciproche (MTLS), in cui è possibile convalidare i certificati client e implementare una logica di autenticazione personalizzata oltre alla convalida dei certificati standard. Le funzioni di connessione vengono eseguite durante il processo di handshake TLS e possono consentire o negare le connessioni in base alle proprietà del certificato, agli indirizzi IP dei client o ad altri criteri.

Dopo aver creato e pubblicato una funzione di connessione, assicuratevi di aggiungere un'associazione per il tipo di evento di *richiesta di connessione* con una distribuzione abilitata per MTLS. In questo modo la funzione viene eseguita ogni volta che un client tenta di stabilire una connessione MTLS con. CloudFront

**Example**  
Il seguente pseudocodice mostra la struttura di una funzione di connessione:  

```
function connectionHandler(connection) {
    // Validate certificate and connection properties here.
    
    if (/* validation passes */) {
        connection.allow();
    } else {
        connection.deny();
    }
}
```
La funzione utilizza metodi di supporto per determinare se consentire o negare la connessione. A differenza delle funzioni di richiesta e risposta del visualizzatore, le funzioni di connessione non possono modificare le richieste o le risposte HTTP.

## Informazioni correlate
<a name="related-information-cloudfront-functions-purpose"></a>

Per ulteriori informazioni sull'utilizzo CloudFront delle funzioni, consultate i seguenti argomenti:
+ [Struttura degli eventi](functions-event-structure.md)
+ [JavaScript funzionalità di runtime](functions-javascript-runtime-features.md)
+ [CloudFront Esempi di funzioni ](service_code_examples_cloudfront_functions_examples.md)
+ [Restrizioni sulle funzioni edge](edge-functions-restrictions.md)

# CloudFront Funzioni, struttura degli eventi
<a name="functions-event-structure"></a>

CloudFront Functions passa un `event` oggetto al codice della funzione come input quando esegue la funzione. Quando si [testa una funzione](test-function.md), si crea l'oggetto `event` e lo si passa alla funzione. Quando si crea un oggetto `event` per testare una funzione, puoi omettere i campi `distributionDomainName`, `distributionId` e `requestId` nell'oggetto `context`. Assicuratevi che i nomi delle intestazioni siano in minuscolo, come accade sempre nell'`event`oggetto che CloudFront Functions passa alla funzione in produzione.

Di seguito viene illustrata una panoramica della struttura di questo oggetto evento. 

```
{
    "version": "1.0",
    "context": {
        <context object>
    },
    "viewer": {
        <viewer object>
    },
    "request": {
        <request object>
    },
    "response": {
        <response object>
    }
}
```

Per ulteriori informazioni, consulta i seguenti argomenti:

**Topics**
+ [

## Campo Versione
](#functions-event-structure-version)
+ [

## Oggetto Context
](#functions-event-structure-context)
+ [

## Struttura degli eventi di connessione
](#functions-event-structure-connection)
+ [

## Oggetto Viewer
](#functions-event-structure-viewer)
+ [

## Oggetto Request
](#functions-event-structure-request)
+ [

## Oggetto Response
](#functions-event-structure-response)
+ [

## Codice di stato e corpo
](#functions-event-structure-status-body)
+ [

## Struttura di una stringa di query, un'intestazione o cookie
](#functions-event-structure-query-header-cookie)
+ [

## Oggetto risposta di esempio
](#functions-response-structure-example)
+ [

## Oggetto evento di esempio
](#functions-event-structure-example)

## Campo Versione
<a name="functions-event-structure-version"></a>

Il `version` campo contiene una stringa che specifica la versione dell'oggetto evento Functions. CloudFront La versione corrente è `1.0`.

## Oggetto Context
<a name="functions-event-structure-context"></a>

L'oggetto `context` contiene informazioni contestuali sull'evento. Include i seguenti campi:

**`distributionDomainName`**  
Il nome di CloudFront dominio (ad esempio, d111111abcdef8.cloudfront.net) della distribuzione standard associata all'evento.  
Il campo `distributionDomainName` viene visualizzato solo quando la funzione viene invocata per le distribuzioni standard.

**`endpoint`**  
Il nome di CloudFront dominio (ad esempio, d111111abcdef8.cloudfront.net) del gruppo di connessione associato all'evento.  
Il campo `endpoint` viene visualizzato solo quando la funzione viene invocata per le distribuzioni multi-tenant.

**`distributionId`**  
L'ID della distribuzione (ad esempio, EXAMPLE) associata all'evento. EDFDVBD6

**`eventType`**  
Il tipo di evento, `viewer-request` o `viewer-response`.

**`requestId`**  
Una stringa che identifica in modo univoco una CloudFront richiesta (e la risposta associata).

## Struttura degli eventi di connessione
<a name="functions-event-structure-connection"></a>

Le funzioni di connessione ricevono una struttura degli eventi diversa rispetto alle funzioni di visualizzazione. Per informazioni dettagliate sulla struttura degli eventi di connessione e sul formato di risposta, vedere[Associare una funzione di CloudFront connessione](connection-functions.md).

## Oggetto Viewer
<a name="functions-event-structure-viewer"></a>

L'oggetto `viewer` contiene un campo `ip` il cui valore è l'indirizzo IP del visualizzatore (client) che ha inviato la richiesta. Se il visualizzatore ha utilizzato un proxy HTTP o un sistema di bilanciamento del carico per inviare la richiesta, il valore è l'indirizzo IP del proxy o del sistema di bilanciamento del carico.

## Oggetto Request
<a name="functions-event-structure-request"></a>

L'`request`oggetto contiene una rappresentazione di una richiesta viewer-to-CloudFront HTTP. Nell'`event`oggetto passato alla funzione, l'`request`oggetto rappresenta la richiesta effettiva CloudFront ricevuta dal visualizzatore.

Se il codice della funzione restituisce un `request` oggetto a CloudFront, deve utilizzare la stessa struttura.

L'oggetto `request` include i seguenti campi:

**`method`**  
Metodo HTTP nella richiesta. Se il codice funzione restituisce `request`, non può modificare questo campo. Questo è l'unico campo di sola lettura nell'oggetto `request`.

**`uri`**  
Il percorso relativo dell'oggetto richiesto.   
Se la funzione Lambda modifica il valore `uri`, si applica quanto segue:  
+ Il nuovo valore `uri` deve iniziare con una barra (`/`).
+ Se una funzione modifica il valore di `uri`, l'oggetto richiesto dal visualizzatore viene modificato.
+ Se una funzione modifica il valore di `uri`, il comportamento della cache per la richiesta o l'origine a cui la richiesta viene inoltrata *non* viene modificato.

**`querystring`**  
Un oggetto che rappresenta la stringa di query nella richiesta. Se la richiesta non include una stringa di query, l’oggetto `request` include comunque un oggetto `querystring` vuoto.  
L'oggetto `querystring` contiene un campo per ogni parametro della stringa di query nella richiesta.

**`headers`**  
Un oggetto che rappresenta le intestazioni HTTP nella richiesta. Se la richiesta contiene intestazioni `Cookie`, queste non faranno parte dell'oggetto `headers`. I cookie sono rappresentati separatamente nell'oggetto `cookies`.  
L'oggetto `headers` contiene un campo per ogni intestazione della richiesta. I nomi delle intestazioni vengono convertiti in caratteri minuscoli ASCII nell’oggetto evento e i nomi delle intestazioni devono essere caratteri minuscoli ASCII quando vengono aggiunti dal codice della funzione. Quando CloudFront Functions riconverte l'oggetto evento in una richiesta HTTP, la prima lettera di ogni parola nei nomi delle intestazioni è in maiuscolo, se si tratta di una lettera ASCII. CloudFront Functions non applica alcuna modifica ai simboli non ASCII nei nomi delle intestazioni. Ad esempio, `TÈst-header` diventerà `tÈst-header` all’interno della funzione. Il simbolo non ASCII `È` rimane invariato.  
Le parole sono separate da un trattino (`-`). Ad esempio, se il codice della funzione aggiunge un'intestazione denominata`example-header-name`, la CloudFront converte in nella richiesta HTTP. `Example-Header-Name`

**`cookies`**  
Un oggetto che rappresenta i cookie nella richiesta (intestazioni `Cookie`).  
L'oggetto `cookies` contiene un campo per ogni cookie nella richiesta.

Per ulteriori informazioni sulla struttura delle stringhe di query, delle intestazioni e dei cookie, consulta [Struttura di una stringa di query, un'intestazione o cookie](#functions-event-structure-query-header-cookie).

Per un oggetto `event` di esempio, consulta [Oggetto evento di esempio](#functions-event-structure-example).

## Oggetto Response
<a name="functions-event-structure-response"></a>

L'`response`oggetto contiene una rappresentazione di una risposta CloudFront-to-viewer HTTP. Nell'`event`oggetto passato alla funzione, l'`response`oggetto rappresenta la risposta effettiva CloudFront di un utente a una richiesta del visualizzatore.

Se il codice funzione restituisce un oggetto `response`, deve utilizzare la stessa struttura.

L'oggetto `response` include i seguenti campi:

**`statusCode`**  
Il codice di stato HTTP per la risposta. Questo valore è un numero intero, non una stringa.  
La funzione può generare o modificare il `statusCode`.

**`statusDescription`**  
Descrizione dello stato HTTP della risposta. Se il codice funzione genera una risposta, questo campo è facoltativo.

**`headers`**  
Un oggetto che rappresenta le intestazioni HTTP nella risposta. Se la risposta contiene intestazioni `Set-Cookie`, queste non faranno parte dell'oggetto `headers`. I cookie sono rappresentati separatamente nell'oggetto `cookies`.  
L'oggetto `headers` contiene un campo per ogni intestazione della risposta. I nomi delle intestazioni vengono convertiti in minuscolo nell'oggetto evento e i nomi delle intestazioni devono essere in minuscolo quando vengono aggiunti dal codice della funzione. Quando CloudFront Functions riconverte l'oggetto evento in una risposta HTTP, la prima lettera di ogni parola nei nomi delle intestazioni viene scritta in maiuscolo. Le parole sono separate da un trattino (`-`). Ad esempio, se il codice della funzione aggiunge un'intestazione denominata`example-header-name`, la CloudFront converte in nella risposta HTTP. `Example-Header-Name`

**`cookies`**  
Un oggetto che rappresenta i cookie nella risposta (intestazioni `Set-Cookie`).  
L'oggetto `cookies` contiene un campo per ogni cookie nella risposta.

**`body`**  
L'aggiunta del campo `body` è facoltativa e non sarà presente nell'oggetto`response` a meno che non venga specificato nella funzione. La funzione non ha accesso al corpo originale restituito dalla CloudFront cache o dall'origine. Se non specificate il `body` campo nella funzione di risposta del visualizzatore, il corpo originale restituito dalla CloudFront cache o dall'origine viene restituito al visualizzatore.  
Se desideri CloudFront restituire un corpo personalizzato al visualizzatore, specifica il contenuto del corpo nel `data` campo e la codifica del corpo nel `encoding` campo. Puoi specificare la codifica come testo normale (`"encoding": "text"`) o come contenuto con codifica Base64 (`"encoding": "base64"`).  
Come scelta rapida, puoi anche specificare il contenuto del corpo direttamente nel campo `body` (`"body": "<specify the body content here>"`). Quando esegui questa operazione, ometti i campi `data` e`encoding`. CloudFront in questo caso tratta il corpo come testo semplice.    
`encoding`  
La codifica del contenuto `body` (campo `data`). Le uniche codifiche valide sono `text` e `base64`.  
Se si specifica `encoding` come `base64` ma il corpo non è valido base64, CloudFront restituisce un errore.  
`data`  
Il contenuto `body`.

Per ulteriori informazioni sui codici di stato modificati e sul contenuto del corpo, consultare [Codice di stato e corpo](#functions-event-structure-status-body).

Per ulteriori informazioni sulla struttura delle intestazioni e dei cookie, consulta [Struttura di una stringa di query, un'intestazione o cookie](#functions-event-structure-query-header-cookie).

Per un oggetto `response` di esempio, consulta [Oggetto risposta di esempio](#functions-response-structure-example).

## Codice di stato e corpo
<a name="functions-event-structure-status-body"></a>

Con CloudFront Functions, puoi aggiornare il codice di stato della risposta del visualizzatore, sostituire l'intero corpo della risposta con uno nuovo o rimuovere il corpo della risposta. Alcuni scenari comuni per l'aggiornamento della risposta del visualizzatore dopo aver valutato alcuni aspetti della risposta dalla CloudFront cache o dall'origine includono quanto segue:
+ Modifica dello stato per impostare un codice di stato HTTP 200 e creazione di contenuto di corpo statico da restituire al visualizzatore.
+ Modifica dello stato per impostare un codice di stato HTTP 301 o 302 per reindirizzare l’utente a un altro sito Web.
+ Decidere se fornire o eliminare il corpo della risposta visualizzatore.

**Nota**  
Se l'origine restituisce un errore HTTP pari o superiore a 400, la CloudFront funzione non verrà eseguita. Per ulteriori informazioni, consulta [Restrizioni su tutte le funzioni edge](edge-function-restrictions-all.md).

Quando lavori con la risposta HTTP, CloudFront Functions non ha accesso al corpo della risposta. Puoi sostituire un contenuto del corpo impostandolo sul valore desiderato oppure puoi rimuovere il corpo impostando il valore in modo da essere vuoto. Se non aggiorni il campo body della tua funzione, il corpo originale restituito dalla CloudFront cache o dall'origine viene restituito al visualizzatore.

**Suggerimento**  
Quando usi CloudFront Functions per sostituire un corpo, assicurati di allineare le intestazioni corrispondenti, ad esempio`content-encoding`, or `content-type``content-length`, al nuovo contenuto del corpo.   
Ad esempio, se l' CloudFront origine o la cache restituiscono `content-encoding: gzip` ma la funzione di risposta del visualizzatore imposta un corpo in testo semplice, la funzione deve anche modificare le `content-type` intestazioni `content-encoding` e di conseguenza.

Se la CloudFront funzione è configurata per restituire un errore HTTP pari o superiore a 400, il visualizzatore non visualizzerà una [pagina di errore personalizzata](creating-custom-error-pages.md) specificata per lo stesso codice di stato.

## Struttura di una stringa di query, un'intestazione o cookie
<a name="functions-event-structure-query-header-cookie"></a>

Le stringhe di query, le intestazioni e i cookie condividono la stessa struttura. Le stringhe di query possono apparire nelle richieste. Le intestazioni vengono visualizzate nelle richieste e nelle risposte. I cookie vengono visualizzati nelle richieste e nelle risposte.

Ogni stringa di query, intestazione o cookie è un campo univoco all'interno dell'oggetto padre `querystring`, `headers` o `cookies`. Il nome del campo è il nome della stringa di query, dell'intestazione o del cookie. Ogni campo contiene una proprietà `value` con il valore della stringa di query, dell'intestazione o del cookie.

**Contents**
+ [

### Valori stringa di query od oggetti stringa di query
](#functions-event-structure-query)
+ [

### Considerazioni speciali per le intestazioni
](#functions-event-structure-headers)
+ [

### Stringhe di query, intestazioni e cookie duplicati (array `multiValue`)
](#functions-event-structure-multivalue)
+ [

### Attributi cookie
](#functions-event-structure-cookie-attributes)

### Valori stringa di query od oggetti stringa di query
<a name="functions-event-structure-query"></a>

Oltre a un oggetto, una funzione può restituire un valore stringa di query. È possibile utilizzare il valore stringa di query per disporre i parametri della stringa di query in qualsiasi ordine personalizzato. 

**Example Esempio**  
Per modificare una stringa di query nel codice funzione, utilizza un codice come il seguente.  

```
var request = event.request; 
request.querystring = 'ID=42&Exp=1619740800&TTL=1440&NoValue=&querymv=val1&querymv=val2,val3';
```

### Considerazioni speciali per le intestazioni
<a name="functions-event-structure-headers"></a>

Solo per le intestazioni, i nomi delle intestazioni vengono convertiti in minuscolo nell'oggetto evento e i nomi delle intestazioni devono essere in minuscolo quando vengono aggiunti dal codice della funzione. Quando CloudFront Functions riconverte l'oggetto evento in una richiesta o risposta HTTP, la prima lettera di ogni parola nei nomi delle intestazioni viene scritta in maiuscolo. Le parole sono separate da un trattino (`-`). Ad esempio, se il codice della funzione aggiunge un'intestazione denominata`example-header-name`, la CloudFront converte nella richiesta o `Example-Header-Name` nella risposta HTTP.

**Example Esempio**  
Considera la seguente intestazione `Host` in una richiesta HTTP:  

```
Host: video.example.com
```
Questa intestazione è rappresentata come segue nell'oggetto `request`:  

```
"headers": {
    "host": {
        "value": "video.example.com"
    }
}
```
Per accedere all'intestazione `Host` nel codice funzione, utilizza un codice come il seguente:  

```
var request = event.request;
var host = request.headers.host.value;
```
Per aggiungere o modificare un'intestazione nel codice funzione, utilizza un codice come il seguente (questo codice aggiunge un'intestazione denominata `X-Custom-Header` con il valore `example value`):  

```
var request = event.request;
request.headers['x-custom-header'] = {value: 'example value'};
```

### Stringhe di query, intestazioni e cookie duplicati (array `multiValue`)
<a name="functions-event-structure-multivalue"></a>

Una richiesta o una risposta HTTP può contenere più di una stringa di query, intestazione o cookie con lo stesso nome. In questo caso, le stringhe di query, le intestazioni o i cookie duplicati vengono compressi in un campo nell'oggetto `request` o `response`, ma questo campo conterrà una proprietà aggiuntiva denominata `multiValue`. La proprietà `multiValue` contiene un array con i valori di ciascuna delle stringhe di query, intestazioni o cookie duplicati.

**Example Esempio**  
Considera una richiesta HTTP con le intestazioni `Accept` seguenti:  

```
Accept: application/json
Accept: application/xml
Accept: text/html
```
Queste intestazioni sono rappresentate come segue nell’oggetto `request`.  

```
"headers": {
    "accept": {
        "value": "application/json",
        "multiValue": [
            {
                "value": "application/json"
            },
            {
                "value": "application/xml"
            },
            {
                "value": "text/html"
            }
        ]
    }
}
```

**Nota**  
Il valore della prima intestazione (in questo caso, `application/json`) viene ripetuto in entrambe le proprietà `value` e `multiValue`. Ciò consente di accedere a *tutti* i valori di passare attraverso l'array `multiValue`.

Se il codice della funzione modifica una stringa di query, un'intestazione o un cookie con un `multiValue` array, CloudFront Functions utilizza le seguenti regole per applicare le modifiche:

1. Se l'array `multiValue` esiste e ha una qualsiasi modifica, allora tale modifica viene applicata. Il primo elemento della proprietà `value` viene ignorato.

1. In caso contrario, viene applicata qualsiasi modifica alla proprietà `value` e i valori successivi (se presenti) rimangono invariati.

La proprietà `multiValue` viene utilizzata solo quando la richiesta HTTP o la risposta contiene stringhe di query duplicate, intestazioni o cookie con lo stesso nome, come illustrato nell'esempio precedente. Tuttavia, se sono presenti più valori in una singola stringa di query, intestazione o cookie, la proprietà `multiValue` non viene utilizzata.

**Example Esempio**  
Considera una richiesta con un’intestazione `Accept` che contiene tre valori.  

```
Accept: application/json, application/xml, text/html
```
Questa intestazione è rappresentata come segue nell’oggetto `request`.  

```
"headers": {
    "accept": {
        "value": "application/json, application/xml, text/html"
    }
}
```

### Attributi cookie
<a name="functions-event-structure-cookie-attributes"></a>

In una intestazione `Set-Cookie` in una risposta HTTP, l'intestazione contiene la coppia nome-valore per il cookie e facoltativamente un insieme di attributi separati da punto e virgola. 

**Example Esempio**  

```
Set-Cookie: cookie1=val1; Secure; Path=/; Domain=example.com; Expires=Wed, 05 Apr 2021 07:28:00 GMT
```
Nell'oggetto `response`, questi attributi sono rappresentati nella proprietà `attributes` del campo cookie. Ad esempio, l'intestazione `Set-Cookie` precedente è rappresentata come segue:  

```
"cookie1": {
    "value": "val1",
    "attributes": "Secure; Path=/; Domain=example.com; Expires=Wed, 05 Apr 2021 07:28:00 GMT"
}
```

## Oggetto risposta di esempio
<a name="functions-response-structure-example"></a>

L'esempio seguente mostra un oggetto `response`, l'output di una funzione di risposta del visualizzatore, in cui il corpo è stato sostituito da una funzione di risposta del visualizzatore.

```
{
  "response": {
    "statusCode": 200,
    "statusDescription": "OK",
    "headers": {
      "date": {
        "value": "Mon, 04 Apr 2021 18:57:56 GMT"
      },
      "server": {
        "value": "gunicorn/19.9.0"
      },
      "access-control-allow-origin": {
        "value": "*"
      },
      "access-control-allow-credentials": {
        "value": "true"
      },
      "content-type": {
        "value": "text/html"
      },
      "content-length": {
        "value": "86"
      }
    },
    "cookies": {
      "ID": {
        "value": "id1234",
        "attributes": "Expires=Wed, 05 Apr 2021 07:28:00 GMT"
      },
      "Cookie1": {
        "value": "val1",
        "attributes": "Secure; Path=/; Domain=example.com; Expires=Wed, 05 Apr 2021 07:28:00 GMT",
        "multiValue": [
          {
            "value": "val1",
            "attributes": "Secure; Path=/; Domain=example.com; Expires=Wed, 05 Apr 2021 07:28:00 GMT"
          },
          {
            "value": "val2",
            "attributes": "Path=/cat; Domain=example.com; Expires=Wed, 10 Jan 2021 07:28:00 GMT"
          }
        ]
      }
    },
    
    // Adding the body field is optional and it will not be present in the response object
    // unless you specify it in your function.
    // Your function does not have access to the original body returned by the CloudFront
    // cache or origin.
    // If you don't specify the body field in your viewer response function, the original
    // body returned by the CloudFront cache or origin is returned to viewer.

     "body": {
      "encoding": "text",
      "data": "<!DOCTYPE html><html><body><p>Here is your custom content.</p></body></html>"
    }
  }
}
```

## Oggetto evento di esempio
<a name="functions-event-structure-example"></a>

Di seguito viene illustrato un esempio di oggetto `event` completo. Questo è un esempio di invocazione per una distribuzione standard, non per una distribuzione multi-tenant. Per le distribuzioni multi-tenant, il `endpoint` campo viene utilizzato al posto di The value of è `distributionDomainName` il nome di `endpoint` CloudFront dominio (ad esempio, d111111abcdef8.cloudfront.net) del gruppo di connessione associato all'evento.

**Nota**  
L'oggetto `event` è l'input per la tua funzione. La funzione restituisce solo l'oggetto `request` o `response`, non l'oggetto `event` completo.

```
{
    "version": "1.0",
    "context": {
        "distributionDomainName": "d111111abcdef8.cloudfront.net",
        "distributionId": "EDFDVBD6EXAMPLE",
        "eventType": "viewer-response",
        "requestId": "EXAMPLEntjQpEXAMPLE_SG5Z-EXAMPLEPmPfEXAMPLEu3EqEXAMPLE=="
    },
    "viewer": {"ip": "198.51.100.11"},
    "request": {
        "method": "GET",
        "uri": "/media/index.mpd",
        "querystring": {
            "ID": {"value": "42"},
            "Exp": {"value": "1619740800"},
            "TTL": {"value": "1440"},
            "NoValue": {"value": ""},
            "querymv": {
                "value": "val1",
                "multiValue": [
                    {"value": "val1"},
                    {"value": "val2,val3"}
                ]
            }
        },
        "headers": {
            "host": {"value": "video.example.com"},
            "user-agent": {"value": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0"},
            "accept": {
                "value": "application/json",
                "multiValue": [
                    {"value": "application/json"},
                    {"value": "application/xml"},
                    {"value": "text/html"}
                ]
            },
            "accept-language": {"value": "en-GB,en;q=0.5"},
            "accept-encoding": {"value": "gzip, deflate, br"},
            "origin": {"value": "https://website.example.com"},
            "referer": {"value": "https://website.example.com/videos/12345678?action=play"},
            "cloudfront-viewer-country": {"value": "GB"}
        },
        "cookies": {
            "Cookie1": {"value": "value1"},
            "Cookie2": {"value": "value2"},
            "cookie_consent": {"value": "true"},
            "cookiemv": {
                "value": "value3",
                "multiValue": [
                    {"value": "value3"},
                    {"value": "value4"}
                ]
            }
        }
    },
    "response": {
        "statusCode": 200,
        "statusDescription": "OK",
        "headers": {
            "date": {"value": "Mon, 04 Apr 2021 18:57:56 GMT"},
            "server": {"value": "gunicorn/19.9.0"},
            "access-control-allow-origin": {"value": "*"},
            "access-control-allow-credentials": {"value": "true"},
            "content-type": {"value": "application/json"},
            "content-length": {"value": "701"}
        },
        "cookies": {
            "ID": {
                "value": "id1234",
                "attributes": "Expires=Wed, 05 Apr 2021 07:28:00 GMT"
            },
            "Cookie1": {
                "value": "val1",
                "attributes": "Secure; Path=/; Domain=example.com; Expires=Wed, 05 Apr 2021 07:28:00 GMT",
                "multiValue": [
                    {
                        "value": "val1",
                        "attributes": "Secure; Path=/; Domain=example.com; Expires=Wed, 05 Apr 2021 07:28:00 GMT"
                    },
                    {
                        "value": "val2",
                        "attributes": "Path=/cat; Domain=example.com; Expires=Wed, 10 Jan 2021 07:28:00 GMT"
                    }
                ]
            }
        }
    }
}
```

# JavaScript funzionalità di runtime per CloudFront Functions
<a name="functions-javascript-runtime-features"></a>

L'ambiente JavaScript di runtime CloudFront Functions è conforme alla [versione 5.1 ECMAScript (ES)](https://www.ecma-international.org/ecma-262/5.1/) e supporta anche alcune funzionalità delle versioni ES da 6 a 12.

Per la maggior parte delle up-to-date funzionalità, si consiglia di utilizzare JavaScript runtime 2.0. 

Le funzionalità JavaScript di runtime 2.0 presentano le seguenti modifiche rispetto alla versione 1.0:
+ Sono disponibili metodi del modulo Buffer
+ Non sono disponibili i seguenti metodi di prototipo per stringhe non standard:
  + `String.prototype.bytesFrom()`
  + `String.prototype.fromBytes()`
  + `String.prototype.fromUTF8()`
  + `String.prototype.toBytes()`
  + `String.prototype.toUTF8()`
+ Il modulo crittografico presenta le seguenti modifiche:
  + `hash.digest()`: il tipo di restituzione viene modificato in `Buffer` se non viene fornita alcuna codifica
  + `hmac.digest()`: il tipo di restituzione viene modificato in `Buffer` se non viene fornita alcuna codifica
+ Per ulteriori informazioni sulle nuove funzionalità aggiuntive, consulta [JavaScript funzionalità di runtime 2.0 per CloudFront Functions](functions-javascript-runtime-20.md).

**Topics**
+ [JavaScript funzionalità di runtime 1.0](functions-javascript-runtime-10.md)
+ [JavaScript funzionalità di runtime 2.0](functions-javascript-runtime-20.md)

# JavaScript Funzionalità di runtime 1.0 per CloudFront Functions
<a name="functions-javascript-runtime-10"></a>

L'ambiente JavaScript di runtime di CloudFront Functions è conforme alla [versione 5.1 ECMAScript (ES)](https://262.ecma-international.org/5.1/) e supporta anche alcune funzionalità delle versioni ES da 6 a 9. Fornisce anche alcuni metodi non standard che non fanno parte delle specifiche ES. 

Negli argomenti seguenti sono elencate tutte le funzionalità linguistiche supportate.

**Topics**
+ [

## Caratteristiche principali
](#writing-functions-javascript-features-core)
+ [

## Oggetti primitivi
](#writing-functions-javascript-features-primitive-objects)
+ [

## Oggetti incorporati
](#writing-functions-javascript-features-builtin-objects)
+ [

## Tipi di errore
](#writing-functions-javascript-features-error-types)
+ [

## Elementi globali
](#writing-functions-javascript-features-globals)
+ [

## Moduli incorporati
](#writing-functions-javascript-features-builtin-modules)
+ [

## Funzionalità con restrizioni
](#writing-functions-javascript-features-restricted-features)

## Caratteristiche principali
<a name="writing-functions-javascript-features-core"></a>

Sono supportate le seguenti caratteristiche principali di ES.

**Tipi**  
Sono supportati tutti i tipi ES 5.1. Tra questi vi sono valori booleani, numeri, stringhe, oggetti, matrici, funzioni, costruttori di funzioni ed espressioni regolari.

**Operatori**  
Sono supportati tutti gli operatori ES 5.1.  
È supportato l'operatore esponenziale ES 7 (`**`).

**Dichiarazioni**  
Le istruzioni `const` e `let` non sono supportate.
Sono supportate le seguenti istruzioni ES 5.1:  
+ `break`
+ `catch`
+ `continue`
+ `do-while`
+ `else`
+ `finally`
+ `for`
+ `for-in`
+ `if`
+ `return`
+ `switch`
+ `throw`
+ `try`
+ `var`
+ `while`
+ Istruzioni etichettate

**Valori letterali**  
Sono supportati i valori letterali modello ES 6: stringhe multilinea, interpolazione di espressioni e modelli di nidificazione.

**Funzioni**  
Sono supportate tutte le funzioni ES 5.1.  
Sono supportate le funzioni freccia ES 6 ed è supportata la sintassi del parametro rest ES 6.

**Unicode**  
Il testo di origine e i valori letterali stringa possono contenere caratteri codificati in Unicode. Sono supportate anche sequenze di escape dei punti di codice Unicode di sei caratteri (ad esempio, `\uXXXX`).

**Modalità rigorosa**  
Le funzioni funzionano in modalità rigorosa per impostazione predefinita, quindi non è necessario aggiungere una istruzione `use strict` nel codice funzione. Non possono essere modificate.

## Oggetti primitivi
<a name="writing-functions-javascript-features-primitive-objects"></a>

Sono supportati i seguenti oggetti primitivi di ES.

**Oggetto**  
Sono supportati i seguenti metodi ES 5.1 sugli oggetti:  
+ `create` (senza elenco delle proprietà)
+ `defineProperties`
+ `defineProperty`
+ `freeze`
+ `getOwnPropertyDescriptor`
+ `getOwnPropertyNames`
+ `getPrototypeOf`
+ `hasOwnProperty`
+ `isExtensible`
+ `isFrozen`
+ `prototype.isPrototypeOf`
+ `isSealed`
+ `keys`
+ `preventExtensions`
+ `prototype.propertyIsEnumerable`
+ `seal`
+ `prototype.toString`
+ `prototype.valueOf`
Sono supportati i seguenti metodi ES 6 sugli oggetti:  
+ `assign`
+ `is`
+ `prototype.setPrototypeOf`
Sono supportati i seguenti metodi ES 8 sugli oggetti:  
+ `entries`
+ `values`

**Stringa**  
Sono supportati i seguenti metodi ES 5.1 sulle stringhe:  
+ `fromCharCode`
+ `prototype.charAt`
+ `prototype.concat`
+ `prototype.indexOf`
+ `prototype.lastIndexOf`
+ `prototype.match`
+ `prototype.replace`
+ `prototype.search`
+ `prototype.slice`
+ `prototype.split`
+ `prototype.substr`
+ `prototype.substring`
+ `prototype.toLowerCase`
+ `prototype.trim`
+ `prototype.toUpperCase`
Sono supportati i seguenti metodi ES 6 sulle stringhe:  
+ `fromCodePoint`
+ `prototype.codePointAt`
+ `prototype.endsWith`
+ `prototype.includes`
+ `prototype.repeat`
+ `prototype.startsWith`
Sono supportati i seguenti metodi ES 8 sulle stringhe:  
+ `prototype.padStart`
+ `prototype.padEnd`
Sono supportati i seguenti metodi ES 9 sulle stringhe:  
+ `prototype.trimStart`
+ `prototype.trimEnd`
Sono supportati i seguenti metodi non standard sulle stringhe:  
+ `prototype.bytesFrom(array | string, encoding)`

  Crea una stringa di byte da un array di ottetti o da una stringa codificata. Le opzioni di codifica delle stringhe sono `hex`, `base64` e `base64url`.
+ `prototype.fromBytes(start[, end])`

  Crea una stringa Unicode da una stringa di byte in cui ogni byte viene sostituito con il corrispondente punto di codice Unicode.
+ `prototype.fromUTF8(start[, end])`

  Crea una stringa Unicode da una stringa di byte codificata UTF-8. Se la codifica non è corretta, viene restituito `null`.
+ `prototype.toBytes(start[, end])`

  Crea una stringa di byte da una stringa Unicode. Tutti i caratteri devono essere compresi nell'intervallo [0,255]. In caso contrario, restituisce `null`.
+ `prototype.toUTF8(start[, end])`

  Crea una stringa di byte codificata UTF-8 da una stringa Unicode.

**Numero**  
Sono supportati tutti i metodi ES 5.1 sui numeri.  
Sono supportati i seguenti metodi ES 6 sui numeri:  
+ `isFinite`
+ `isInteger`
+ `isNaN`
+ `isSafeInteger`
+ `parseFloat`
+ `parseInt`
+ `prototype.toExponential`
+ `prototype.toFixed`
+ `prototype.toPrecision`
+ `EPSILON`
+ `MAX_SAFE_INTEGER`
+ `MAX_VALUE`
+ `MIN_SAFE_INTEGER`
+ `MIN_VALUE`
+ `NEGATIVE_INFINITY`
+ `NaN`
+ `POSITIVE_INFINITY`

## Oggetti incorporati
<a name="writing-functions-javascript-features-builtin-objects"></a>

Sono supportati i seguenti oggetti incorporati di ES.

**Math**  
Sono supportati tutti i metodi matematici ES 5.1.  
Nell'ambiente di runtime di CloudFront Functions, l'`Math.random()`implementazione utilizza `arc4random` OpenBSD con il timestamp di quando la funzione viene eseguita.
Sono supportati i seguenti metodi matematici ES 6:  
+ `acosh`
+ `asinh`
+ `atanh`
+ `cbrt`
+ `clz32`
+ `cosh`
+ `expm1`
+ `fround`
+ `hypot`
+ `imul`
+ `log10`
+ `log1p`
+ `log2`
+ `sign`
+ `sinh`
+ `tanh`
+ `trunc`
+ `E`
+ `LN10`
+ `LN2`
+ `LOG10E`
+ `LOG2E`
+ `PI`
+ `SQRT1_2`
+ `SQRT2`

**Data**  
Sono supportate tutte le funzioni `Date` ES 5.1.  
Per motivi di sicurezza, restituisce `Date` sempre lo stesso valore, ovvero l'ora di inizio della funzione, durante la durata di una singola esecuzione di una funzione. Per ulteriori informazioni, consulta [Funzionalità con restrizioni](#writing-functions-javascript-features-restricted-features).

**Funzione**  
Sono supportati i metodi `apply`, `bind` e `call`.  
I costruttori di funzioni non sono supportati.

**Espressioni regolari**  
Sono supportate tutte le funzioni di espressione regolare ES 5.1. Il linguaggio delle espressioni regolari è compatibile con Perl. Sono supportati i gruppi di acquisizione denominati di ES 9.

**JSON**  
Sono supportate tutte le funzionalità JSON di ES 5.1, incluso `parse` e `stringify`.

**Array**  
Sono supportati i seguenti metodi ES 5.1 sugli array:  
+ `isArray`
+ `prototype.concat`
+ `prototype.every`
+ `prototype.filter`
+ `prototype.forEach`
+ `prototype.indexOf`
+ `prototype.join`
+ `prototype.lastIndexOf`
+ `prototype.map`
+ `prototype.pop`
+ `prototype.push`
+ `prototype.reduce`
+ `prototype.reduceRight`
+ `prototype.reverse`
+ `prototype.shift`
+ `prototype.slice`
+ `prototype.some`
+ `prototype.sort`
+ `prototype.splice`
+ `prototype.unshift`
Sono supportati i seguenti metodi ES 6 sugli array:  
+ `of`
+ `prototype.copyWithin`
+ `prototype.fill`
+ `prototype.find`
+ `prototype.findIndex`
Sono supportati i seguenti metodi ES 7 sugli array:  
+ `prototype.includes`

**Array tipizzati**  
Sono supportati i seguenti array tipizzati ES 6:  
+ `Int8Array`
+ `Uint8Array`
+ `Uint8ClampedArray`
+ `Int16Array`
+ `Uint16Array`
+ `Int32Array`
+ `Uint32Array`
+ `Float32Array`
+ `Float64Array`
+ `prototype.copyWithin`
+ `prototype.fill`
+ `prototype.join`
+ `prototype.set`
+ `prototype.slice`
+ `prototype.subarray`
+ `prototype.toString`

**ArrayBuffer**  
Sono supportati i seguenti metodi su `ArrayBuffer`:  
+ `prototype.isView`
+ `prototype.slice`

**Promessa**  
Sono supportati i seguenti metodi sulle promesse:  
+ `reject`
+ `resolve`
+ `prototype.catch`
+ `prototype.finally`
+ `prototype.then`

**Crittografia**  
Il modulo di crittografia fornisce helper standard hash e HMAC (Hash Message Authentication Code). È possibile caricare il modulo usando `require('crypto')`. Il modulo espone i seguenti metodi che si comportano esattamente come le loro controparti Node.js:  
+ `createHash(algorithm)`
+ `hash.update(data)`
+ `hash.digest([encoding])`
+ `createHmac(algorithm, secret key)`
+ `hmac.update(data)`
+ `hmac.digest([encoding])`
Per ulteriori informazioni, consulta [Crittografia (hash e HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) nella sezione dei moduli incorporati.

**Console**  
Questo è un oggetto helper per il debug. Supporta solo il metodo `log()` per registrare i messaggi di log.  
CloudFront Le funzioni non supportano la sintassi delle virgole, ad esempio. `console.log('a', 'b')` Utilizzare invece il formato `console.log('a' + ' ' + 'b')`.

## Tipi di errore
<a name="writing-functions-javascript-features-error-types"></a>

Sono supportati i seguenti oggetti di errore:
+ `Error`
+ `EvalError`
+ `InternalError`
+ `MemoryError`
+ `RangeError`
+ `ReferenceError`
+ `SyntaxError`
+ `TypeError`
+ `URIError`

## Elementi globali
<a name="writing-functions-javascript-features-globals"></a>

L'oggetto `globalThis` è supportato.

Sono supportate le seguenti funzioni globali ES 5.1:
+ `decodeURI`
+ `decodeURIComponent`
+ `encodeURI`
+ `encodeURIComponent`
+ `isFinite`
+ `isNaN`
+ `parseFloat`
+ `parseInt`

Sono supportate le seguenti costanti globali:
+ `NaN`
+ `Infinity`
+ `undefined`

## Moduli incorporati
<a name="writing-functions-javascript-features-builtin-modules"></a>

Sono supportati i seguenti moduli incorporati:

**Topics**
+ [

### Crittografia (hash e HMAC)
](#writing-functions-javascript-features-builtin-modules-crypto)
+ [

### Stringa di query
](#writing-functions-javascript-features-builtin-modules-query-string)

### Crittografia (hash e HMAC)
<a name="writing-functions-javascript-features-builtin-modules-crypto"></a>

Il modulo di crittografia (`crypto`) fornisce helper di hashing standard e HMAC (Hash Message Authentication Code). È possibile caricare il modulo usando `require('crypto')`. Il modulo fornisce i seguenti metodi che si comportano esattamente come le controparti Node.js.

**Metodi di hashing**

`crypto.createHash(algorithm)`  
Crea e restituisce un oggetto hash che è possibile utilizzare per generare digest hash utilizzando il dato algoritmo: `md5`, `sha1`, o `sha256`.

`hash.update(data)`  
Aggiorna il contenuto hash con il dato `data`.

`hash.digest([encoding])`  
Calcola il digest di tutti i dati passati tramite `hash.update()`. La codifica può essere `hex`, `base64` o `base64url`.

**Metodi HMAC**

`crypto.createHmac(algorithm, secret key)`  
Crea e restituisce un oggetto HMAC che utilizza il dato `algorithm` e `secret key`. L'algoritmo può essere `md5`, `sha1` o `sha256`.

`hmac.update(data)`  
Aggiorna il contenuto HMAC con il dato `data`.

`hmac.digest([encoding])`  
Calcola il digest di tutti i dati passati tramite `hmac.update()`. La codifica può essere `hex`, `base64` o `base64url`.

### Stringa di query
<a name="writing-functions-javascript-features-builtin-modules-query-string"></a>

**Nota**  
L'[oggetto evento CloudFront Functions](functions-event-structure.md) analizza automaticamente le stringhe di query URL per voi. Ciò significa che nella maggior parte dei casi non è necessario utilizzare questo modulo.

Il modulo stringa di query (`querystring`) fornisce metodi per l'analisi e la formattazione delle stringhe di query URL. È possibile caricare il modulo usando `require('querystring')`. Il modulo fornisce i metodi seguenti:

`querystring.escape(string)`  
URL che codifica il dato `string`, restituendo una stringa di query con escape. Il metodo viene utilizzato da `querystring.stringify()` e non deve essere utilizzato direttamente.

`querystring.parse(string[, separator[, equal[, options]]])`  
Analizza una stringa di query (`string`) e restituisce un oggetto.  
Il parametro `separator` è una sottostringa per delimitare coppie chiave e valore nella stringa di query. Per impostazione predefinita, tale valore è `&`.  
Il parametro `equal` è una sottostringa per la delimitazione di chiavi e valori nella stringa di query. Per impostazione predefinita, tale valore è `=`.  
Il parametro `options` è un oggetto con le seguenti chiavi:    
`decodeURIComponent function`  
Un funzione per decodificare i caratteri codificati in percentuale nella stringa di query. Per impostazione predefinita, tale valore è `querystring.unescape()`.  
`maxKeys number`  
Il numero massimo di chiavi da analizzare. Per impostazione predefinita, tale valore è `1000`. Utilizza un valore `0` per rimuovere le limitazioni per il conteggio delle chiavi.
Per impostazione predefinita, si presuppone che i caratteri con codifica in percentuale all'interno della stringa di query utilizzino la codifica UTF-8. Le sequenze UTF-8 non valide vengono sostituite con il carattere sostitutivo `U+FFFD`.  
Ad esempio, per la seguente stringa di query:  

```
'name=value&abc=xyz&abc=123'
```
Il valore restituito di `querystring.parse()` è:  

```
{
name: 'value',
abc: ['xyz', '123']
}
```
`querystring.decode()` è un alias per `querystring.parse()`.

`querystring.stringify(object[, separator[, equal[, options]]])`  
Serializza un `object` e restituisce una stringa di query.  
Il parametro `separator` è una sottostringa per delimitare coppie chiave e valore nella stringa di query. Per impostazione predefinita, tale valore è `&`.  
Il parametro `equal` è una sottostringa per la delimitazione di chiavi e valori nella stringa di query. Per impostazione predefinita, tale valore è `=`.  
Il parametro `options` è un oggetto con le seguenti chiavi:    
`encodeURIComponent function`  
La funzione da utilizzare per convertire caratteri non sicuri dell’URL in codifica percentuale nella stringa di query. Per impostazione predefinita, tale valore è `querystring.escape()`.
Per impostazione predefinita, i caratteri che richiedono la codifica percentuale all'interno della stringa di query sono codificati come UTF-8. Per utilizzare una codifica diversa, specifica l'opzione `encodeURIComponent`.  
Ad esempio, per il seguente codice:  

```
querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' });
```
Il valore restituito è:  

```
'name=value&abc=xyz&abc=123&anotherName='
```
`querystring.encode()` è un alias per `querystring.stringify()`.

`querystring.unescape(string)`  
Decodifica i caratteri codificati in percentuale URL nel dato `string`, restituendo una stringa di query senza escape. Questo metodo viene utilizzato da `querystring.parse()` e non deve essere utilizzato direttamente.

## Funzionalità con restrizioni
<a name="writing-functions-javascript-features-restricted-features"></a>

Le seguenti funzionalità JavaScript linguistiche non sono supportate o sono limitate a causa di problemi di sicurezza.

**Valutazione dinamica del codice**  
La valutazione dinamica del codice non è supportata. Entrambi i costruttori `eval()` e `Function` generano un errore se tentato. Ad esempio, `const sum = new Function('a', 'b', 'return a + b')` genera un errore.

**Timer**  
Le funzioni `setTimeout()`, `setImmediate()` e `clearTimeout()` non sono supportate. Non vi è alcuna disposizione per differire o cedere all'interno di un'esecuzione di funzione. La funzione deve essere eseguita in modo sincrono fino al completamento.

**Data e timestamp**  
Per motivi di sicurezza, non è possibile accedere ai timer ad alta risoluzione. Tutti i metodi `Date` per interrogare l'ora corrente restituiscono sempre lo stesso valore durante la durata di una singola esecuzione di funzione. Il timestamp restituito è il momento in cui la funzione ha iniziato l'esecuzione. Di conseguenza, non è possibile misurare il tempo trascorso nella vostra funzione.

**Accesso al file system**  
Nessun accesso al file system. Ad esempio, non esiste un modulo `fs` per l'accesso al file system come invece è presente in Node.js.

**Accesso al processo**  
Non è possibile accedere al processo. Ad esempio, non esiste un oggetto globale `process` per l’elaborazione dell’accesso alle informazioni come in Node.js.

**Variabili di ambiente**  
Non è possibile accedere alle variabili d’ambiente.   
Puoi invece utilizzarlo CloudFront KeyValueStore per creare un datastore centralizzato di coppie chiave-valore per le tue Funzioni. CloudFront CloudFront KeyValueStore consente aggiornamenti dinamici ai dati di configurazione senza dover implementare modifiche al codice. È necessario utilizzare [JavaScript runtime 2.0](functions-javascript-runtime-20.md) per utilizzare. CloudFront KeyValueStore Per ulteriori informazioni, consulta [Amazon CloudFront KeyValueStore](kvs-with-functions.md).

**Accesso alla rete**  
Non è disponibile alcun supporto per le chiamate di rete. Ad esempio, XHR, HTTP(S) e socket non sono supportati.

# JavaScript funzionalità di runtime 2.0 per CloudFront Functions
<a name="functions-javascript-runtime-20"></a>

L'ambiente JavaScript di runtime di CloudFront Functions è conforme alla [versione 5.1 ECMAScript (ES)](https://262.ecma-international.org/5.1/) e supporta anche alcune funzionalità delle versioni ES da 6 a 12. Fornisce anche alcuni metodi non standard che non fanno parte delle specifiche ES. Negli argomenti seguenti sono elencate tutte le funzionalità supportate in questo runtime.

**Topics**
+ [

## Caratteristiche principali
](#writing-functions-javascript-features-core-20)
+ [

## Oggetti primitivi
](#writing-functions-javascript-features-primitive-objects-20)
+ [

## Oggetti incorporati
](#writing-functions-javascript-features-builtin-objects-20)
+ [

## Tipi di errore
](#writing-functions-javascript-features-error-types-20)
+ [

## Elementi globali
](#writing-functions-javascript-features-globals-20)
+ [

## Moduli incorporati
](#writing-functions-javascript-features-builtin-modules-20)
+ [

## Funzionalità con restrizioni
](#writing-functions-javascript-features-restricted-features-20)

## Caratteristiche principali
<a name="writing-functions-javascript-features-core-20"></a>

Sono supportate le seguenti caratteristiche principali di ES.

**Tipi**  
Sono supportati tutti i tipi ES 5.1. Tra questi vi sono valori booleani, numeri, stringhe, oggetti, matrici, funzioni ed espressioni regolari.

**Operatori**  
Sono supportati tutti gli operatori ES 5.1.  
È supportato l'operatore esponenziale ES 7 (`**`).

**Dichiarazioni**  
Sono supportate le seguenti istruzioni ES 5.1:  
+ `break`
+ `catch`
+ `continue`
+ `do-while`
+ `else`
+ `finally`
+ `for`
+ `for-in`
+ `if`
+ `label`
+ `return`
+ `switch`
+ `throw`
+ `try`
+ `var`
+ `while`
Sono supportate le seguenti istruzioni ES 6:  
+ `const`
+ `let`
Sono supportate le seguenti istruzioni ES 8:  
+ `async`
+ `await`
`async`, `await``const`, e `let` sono supportati nel JavaScript runtime 2.0.  
`await` può essere utilizzato solo all’interno delle funzioni `async`. Argomenti e chiusure `async` non sono supportati.

**Valori letterali**  
Sono supportati i valori letterali modello ES 6: stringhe multilinea, interpolazione di espressioni e modelli di nidificazione.

**Funzioni**  
Sono supportate tutte le funzioni ES 5.1.  
Sono supportate le funzioni freccia ES 6 ed è supportata la sintassi del parametro rest ES 6.

**Unicode**  
Il testo di origine e i valori letterali stringa possono contenere caratteri codificati in Unicode. Sono supportate anche sequenze di escape dei punti di codice Unicode di sei caratteri (ad esempio, `\uXXXX`).

**Modalità rigorosa**  
Le funzioni funzionano in modalità rigorosa per impostazione predefinita, quindi non è necessario aggiungere una istruzione `use strict` nel codice funzione. Non possono essere modificate.

## Oggetti primitivi
<a name="writing-functions-javascript-features-primitive-objects-20"></a>

Sono supportati i seguenti oggetti primitivi di ES.

**Oggetto**  
Sono supportati i seguenti metodi ES 5.1 sugli oggetti:  
+ `Object.create()` (senza elenco delle proprietà)
+ `Object.defineProperties()`
+ `Object.defineProperty()`
+ `Object.freeze()`
+ `Object.getOwnPropertyDescriptor()`
+ `Object.getOwnPropertyDescriptors()`
+ `Object.getOwnPropertyNames()`
+ `Object.getPrototypeOf()`
+ `Object.isExtensible()`
+ `Object.isFrozen()`
+ `Object.isSealed()`
+ `Object.keys()`
+ `Object.preventExtensions()`
+ `Object.seal()`
Sono supportati i seguenti metodi ES 6 sugli oggetti:  
+ `Object.assign()`
Sono supportati i seguenti metodi ES 8 sugli oggetti:  
+ `Object.entries()`
+ `Object.values()`
Sono supportati i seguenti metodi di prototipo ES 5.1 sugli oggetti:  
+ `Object.prototype.hasOwnProperty()`
+ `Object.prototype.isPrototypeOf()`
+ `Object.prototype.propertyIsEnumerable()`
+ `Object.prototype.toString()`
+ `Object.prototype.valueOf()`
Sono supportati i seguenti metodi di prototipo ES 6 sugli oggetti:  
+ `Object.prototype.is()`
+ `Object.prototype.setPrototypeOf()`

**Stringa**  
Sono supportati i seguenti metodi ES 5.1 sulle stringhe:  
+ `String.fromCharCode()`
Sono supportati i seguenti metodi ES 6 sulle stringhe:  
+ `String.fromCodePoint()`
Sono supportati i seguenti metodi di prototipo ES 5.1 sulle stringhe:  
+ `String.prototype.charAt()`
+ `String.prototype.concat()`
+ `String.prototype.indexOf()`
+ `String.prototype.lastIndexOf()`
+ `String.prototype.match()`
+ `String.prototype.replace()`
+ `String.prototype.search()`
+ `String.prototype.slice()`
+ `String.prototype.split()`
+ `String.prototype.substr()`
+ `String.prototype.substring()`
+ `String.prototype.toLowerCase()`
+ `String.prototype.trim()`
+ `String.prototype.toUpperCase()`
Sono supportati i seguenti metodi di prototipo ES 6 sulle stringhe:  
+ `String.prototype.codePointAt()`
+ `String.prototype.endsWith()`
+ `String.prototype.includes()`
+ `String.prototype.repeat()`
+ `String.prototype.startsWith()`
Sono supportati i seguenti metodi di prototipo ES 8 sulle stringhe:  
+ `String.prototype.padStart()`
+ `String.prototype.padEnd()`
Sono supportati i seguenti metodi di prototipo ES 9 sulle stringhe:  
+ `String.prototype.trimStart()`
+ `String.prototype.trimEnd()`
Sono supportati i seguenti metodi di prototipo ES 12 sulle stringhe:  
+ `String.prototype.replaceAll()`
**Nota**  
`String.prototype.replaceAll()`è nuovo nel JavaScript runtime 2.0.

**Numero**  
Sono supportati TUTTI i numeri ES 5.  
Sono supportate le seguenti proprietà ES 6 sui numeri:  
+ `Number.EPSILON`
+ `Number.MAX_SAFE_INTEGER`
+ `Number.MIN_SAFE_INTEGER`
+ `Number.MAX_VALUE`
+ `Number.MIN_VALUE`
+ `Number.NaN`
+ `Number.NEGATIVE_INFINITY`
+ `Number.POSITIVE_INFINITY`
Sono supportati i seguenti metodi ES 6 sui numeri:  
+ `Number.isFinite()`
+ `Number.isInteger()`
+ `Number.isNaN()`
+ `Number.isSafeInteger()`
+ `Number.parseInt()`
+ `Number.parseFloat()`
Sono supportati i seguenti metodi di prototipo ES 5.1 sui numeri:  
+ `Number.prototype.toExponential()`
+ `Number.prototype.toFixed()`
+ `Number.prototype.toPrecision()`
Sono supportati i separatori numerici ES 12.  
I separatori numerici ES 12 sono nuovi nel JavaScript runtime 2.0.

## Oggetti incorporati
<a name="writing-functions-javascript-features-builtin-objects-20"></a>

Sono supportati i seguenti oggetti incorporati di ES.

**Math**  
Sono supportati tutti i metodi matematici ES 5.1.  
Nell'ambiente di runtime di CloudFront Functions, l'`Math.random()`implementazione utilizza `arc4random` OpenBSD con il timestamp di quando la funzione viene eseguita.
Sono supportate le seguenti proprietà matematiche ES 6:  
+ `Math.E`
+ `Math.LN10`
+ `Math.LN2`
+ `Math.LOG10E`
+ `Math.LOG2E`
+ `Math.PI`
+ `Math.SQRT1_2`
+ `Math.SQRT2`
Sono supportati i seguenti metodi matematici ES 6:  
+ `Math.abs()`
+ `Math.acos()`
+ `Math.acosh()`
+ `Math.asin()`
+ `Math.asinh()`
+ `Math.atan()`
+ `Math.atan2()`
+ `Math.atanh()`
+ `Math.cbrt()`
+ `Math.ceil()`
+ `Math.clz32()`
+ `Math.cos()`
+ `Math.cosh()`
+ `Math.exp()`
+ `Math.expm1()`
+ `Math.floor()`
+ `Math.fround()`
+ `Math.hypot()`
+ `Math.imul()`
+ `Math.log()`
+ `Math.log1p()`
+ `Math.log2()`
+ `Math.log10()`
+ `Math.max()`
+ `Math.min()`
+ `Math.pow()`
+ `Math.random()`
+ `Math.round()`
+ `Math.sign()`
+ `Math.sinh()`
+ `Math.sin()`
+ `Math.sqrt()`
+ `Math.tan()`
+ `Math.tanh()`
+ `Math.trunc()`

**Data**  
Sono supportate tutte le funzioni `Date` ES 5.1.  
Per motivi di sicurezza, restituisce `Date` sempre lo stesso valore, ovvero l'ora di inizio della funzione, durante la durata di una singola esecuzione di una funzione. Per ulteriori informazioni, consulta [Funzionalità con restrizioni](functions-javascript-runtime-10.md#writing-functions-javascript-features-restricted-features).

**Funzione**  
Sono supportati i seguenti metodi di prototipo ES 5.1:  
+ `Function.prototype.apply()`
+ `Function.prototype.bind()`
+ `Function.prototype.call()`
I costruttori di funzioni non sono supportati.

**Espressioni regolari**  
Sono supportate tutte le funzioni di espressione regolare ES 5.1. Il linguaggio delle espressioni regolari è compatibile con Perl.  
Sono supportate le seguenti proprietà di accessor per prototipo ES 5.1:  
+ `RegExp.prototype.global`
+ `RegExp.prototype.ignoreCase`
+ `RegExp.protoype.multiline`
+ `RegExp.protoype.source`
+ `RegExp.prototype.sticky`
+ `RegExp.prototype.flags`
**Nota**  
`RegExp.prototype.sticky`e `RegExp.prototype.flags` sono nuove in runtime 2.0. JavaScript
Sono supportati i seguenti metodi di prototipo ES 5.1:  
+ `RegExp.prototype.exec()`
+ `RegExp.prototype.test()`
+ `RegExp.prototype.toString()`
+ `RegExp.prototype[@@replace]()`
+ `RegExp.prototype[@@split]()`
**Nota**  
`RegExp.prototype[@@split]()`sono nuove nel JavaScript runtime 2.0.
Sono supportate le seguenti proprietà di istanza ES 5.1:  
+ `lastIndex`
Sono supportati i gruppi di acquisizione denominati di ES 9.

**JSON**  
Sono supportati i seguenti metodi ES 5.1:  
+ `JSON.parse()`
+ `JSON.stringify()`

**Array**  
Sono supportati i seguenti metodi ES 5.1 sugli array:  
+ `Array.isArray()`
Sono supportati i seguenti metodi ES 6 sugli array:  
+ `Array.of()`
Sono supportati i seguenti metodi di prototipo ES 5.1:  
+ `Array.prototype.concat()`
+ `Array.prototype.every()`
+ `Array.prototype.filter()`
+ `Array.prototype.forEach()`
+ `Array.prototype.indexOf()`
+ `Array.prototype.join()`
+ `Array.prototype.lastIndexOf()`
+ `Array.prototype.map()`
+ `Array.prototype.pop()`
+ `Array.prototype.push()`
+ `Array.prototype.reduce()`
+ `Array.prototype.reduceRight()`
+ `Array.prototype.reverse()`
+ `Array.prototype.shift()`
+ `Array.prototype.slice()`
+ `Array.prototype.some()`
+ `Array.prototype.sort()`
+ `Array.prototype.splice()`
+ `Array.prototype.unshift()`
Sono supportati i seguenti metodi di prototipo ES 6:  
+ `Array.prototype.copyWithin()`
+ `Array.prototype.fill()`
+ `Array.prototype.find()`
+ `Array.prototype.findIndex()`
Sono supportati i seguenti metodi di prototipo ES 7:  
+ `Array.prototype.includes()`

**Array tipizzati**  
Sono supportati i seguenti costruttori di array tipizzati ES 6:  
+ `Float32Array`
+ `Float64Array`
+ `Int8Array`
+ `Int16Array`
+ `Int32Array`
+ `Uint8Array`
+ `Uint8ClampedArray`
+ `Uint16Array`
+ `Uint32Array`
Sono supportati i seguenti metodi ES 6:  
+ `TypedArray.from()`
+ `TypedArray.of()`
**Nota**  
`TypedArray.from()`e `TypedArray.of()` sono nuove nel JavaScript runtime 2.0.
Sono supportati i seguenti metodi di prototipo ES 6:  
+ `TypedArray.prototype.copyWithin()`
+ `TypedArray.prototype.every()`
+ `TypedArray.prototype.fill()`
+ `TypedArray.prototype.filter()`
+ `TypedArray.prototype.find()`
+ `TypedArray.prototype.findIndex()`
+ `TypedArray.prototype.forEach()`
+ `TypedArray.prototype.includes()`
+ `TypedArray.prototype.indexOf()`
+ `TypedArray.prototype.join()`
+ `TypedArray.prototype.lastIndexOf()`
+ `TypedArray.prototype.map()`
+ `TypedArray.prototype.reduce()`
+ `TypedArray.prototype.reduceRight()`
+ `TypedArray.prototype.reverse()`
+ `TypedArray.prototype.some()`
+ `TypedArray.prototype.set()`
+ `TypedArray.prototype.slice()`
+ `TypedArray.prototype.sort()`
+ `TypedArray.prototype.subarray()`
+ `TypedArray.prototype.toString()`
**Nota**  
`TypedArray.prototype.every()`,`TypedArray.prototype.fill()`,`TypedArray.prototype.filter()`,`TypedArray.prototype.find()`, `TypedArray.prototype.findIndex()``TypedArray.prototype.forEach()`,`TypedArray.prototype.includes()`,`TypedArray.prototype.indexOf()`,`TypedArray.prototype.join()`,`TypedArray.prototype.lastIndexOf()`,`TypedArray.prototype.map()`,`TypedArray.prototype.reduce()`, `TypedArray.prototype.reduceRight()``TypedArray.prototype.reverse()`, e `TypedArray.prototype.some()` sono nuovi nel JavaScript runtime 2.0.

**ArrayBuffer**  
Sono supportati i seguenti metodi ES 6 su ArrayBuffer :  
+ `isView()`
Sono supportati i seguenti metodi prototipali ES 6 su ArrayBuffer :  
+ `ArrayBuffer.prototype.slice()`

**Promessa**  
Sono supportati i seguenti metodi ES 6 sulle promesse:  
+ `Promise.all()`
+ `Promise.allSettled()`
+ `Promise.any()`
+ `Promise.reject()`
+ `Promise.resolve()`
+ `Promise.race()`
**Nota**  
`Promise.all()`, `Promise.allSettled()``Promise.any()`, e `Promise.race()` sono nuovi nel JavaScript runtime 2.0.
Sono supportati i seguenti metodi di prototipo ES 6 sulle promesse:  
+ `Promise.prototype.catch()`
+ `Promise.prototype.finally()`
+ `Promise.prototype.then()`

**DataView**  
Sono supportati i seguenti metodi di prototipo ES 6:  
+ `DataView.prototype.getFloat32()`
+ `DataView.prototype.getFloat64()`
+ `DataView.prototype.getInt16()`
+ `DataView.prototype.getInt32()`
+ `DataView.prototype.getInt8()`
+ `DataView.prototype.getUint16()`
+ `DataView.prototype.getUint32()`
+ `DataView.prototype.getUint8()`
+ `DataView.prototype.setFloat32()`
+ `DataView.prototype.setFloat64()`
+ `DataView.prototype.setInt16()`
+ `DataView.prototype.setInt32()`
+ `DataView.prototype.setInt8()`
+ `DataView.prototype.setUint16()`
+ `DataView.prototype.setUint32()`
+ `DataView.prototype.setUint8()`
**Nota**  
Tutti i metodi prototipali di Dataview ES 6 sono nuovi in JavaScript runtime 2.0.

**Symbol**  
Sono supportati i seguenti metodi ES 6:  
+ `Symbol.for()`
+ `Symbol.keyfor()`
**Nota**  
Tutti i metodi Symbol ES 6 sono nuovi nel JavaScript runtime 2.0.

**TextDecoder**  
Sono supportati i seguenti metodi di prototipo:  
+ `TextDecoder.prototype.decode()`
Sono supportate le seguenti proprietà di accessor per prototipo:  
+ `TextDecoder.prototype.encoding`
+ `TextDecoder.prototype.fatal`
+ `TextDecoder.prototype.ignoreBOM`

**TextEncoder**  
Sono supportati i seguenti metodi di prototipo:  
+ `TextEncoder.prototype.encode()`
+ `TextEncoder.prototype.encodeInto()`

**Console**  
Questo è un oggetto helper per il debug. Supporta solo il metodo `log()` per registrare i messaggi di log.  
CloudFront Le funzioni non supportano la sintassi delle virgole, ad esempio`console.log('a', 'b')`. Utilizzare invece il formato `console.log('a' + ' ' + 'b')`.

## Tipi di errore
<a name="writing-functions-javascript-features-error-types-20"></a>

Sono supportati i seguenti oggetti di errore:
+ `Error`
+ `EvalError`
+ `InternalError`
+ `RangeError`
+ `ReferenceError`
+ `SyntaxError`
+ `TypeError`
+ `URIError`

## Elementi globali
<a name="writing-functions-javascript-features-globals-20"></a>

L'oggetto `globalThis` è supportato.

Sono supportate le seguenti funzioni globali ES 5.1:
+ `decodeURI()`
+ `decodeURIComponent()`
+ `encodeURI()`
+ `encodeURIComponent()`
+ `isFinite()`
+ `isNaN()`
+ `parseFloat()`
+ `parseInt()`

Sono supportate le seguenti funzioni globali ES 6:
+ `atob()`
+ `btoa()`
**Nota**  
`atob()`e `btoa()` sono nuovi in JavaScript runtime 2.0.

Sono supportate le seguenti costanti globali:
+ `NaN`
+ `Infinity`
+ `undefined`
+ `arguments`

## Moduli incorporati
<a name="writing-functions-javascript-features-builtin-modules-20"></a>

Sono supportati i seguenti moduli incorporati:

**Topics**
+ [

### Buffer
](#writing-functions-javascript-features-builtin-modules-buffer-20)
+ [

### Stringa di query
](#writing-functions-javascript-features-builtin-modules-query-string-20)
+ [

### Crittografia
](#writing-functions-javascript-features-builtin-modules-crypto-20)

### Buffer
<a name="writing-functions-javascript-features-builtin-modules-buffer-20"></a>

Il modulo fornisce i metodi seguenti:
+ `Buffer.alloc(size[, fill[, encoding]])`

  Alloca un `Buffer`.
  + `size`: dimensione del buffer. Immetti un numero intero.
  + `fill`: facoltativo. Immetti una stringa, `Buffer`, Uint8Array o un numero intero. Il valore predefinito è “`0`”. 
  + `encoding`: facoltativo. Quando `fill` è una stringa, immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”.
+ `Buffer.allocUnsafe(size)`

  Alloca un `Buffer` non inizializzato.
  + `size`: immetti un numero intero.
+ `Buffer.byteLength(value[, encoding])`

  Restituisce la lunghezza di un valore, in byte.
  + `value`: Una stringa, `Buffer` TypedArray, Dataview o Arraybuffer.
  + `encoding`: facoltativo. Quando `value` è una stringa, immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”.
+ `Buffer.compare(buffer1, buffer2)`

  Confronta due `Buffer` per semplificare l'ordinamento degli array. Restituisce `0` se sono uguali, `-1` se viene prima `buffer1` o `1` se viene prima `buffer2`.
  + `buffer1`: immetti un `Buffer`.
  + `buffer2`: immetti un altro `Buffer`.
+ `Buffer.concat(list[, totalLength])`

  Concatena più `Buffer`. Restituisce `0` se non ce ne sono. Restituisce fino a `totalLength`.
  + `list`: immetti un elenco di `Buffer`. Tieni presente che verrà troncato a `totalLength`.
  + `totalLength`: facoltativo. Inserisci un numero intero senza segno. Usa la somma delle istanze `Buffer` nell'elenco se vuoto.
+ `Buffer.from(array)`

  Crea un `Buffer` da un array.
  + `array`: immetti un array di byte da `0` a `255`. 
+ `Buffer.from(arrayBuffer, byteOffset[, length]))`

  Crea una vista da `arrayBuffer`, partendo dall'offset `byteOffset` con lunghezza `length`.
  + `arrayBuffer`: immetti una matrice `Buffer`.
  + `byteOffset`: immetti un numero intero.
  + `length`: facoltativo. Immetti un numero intero.
+ `Buffer.from(buffer)`

  Crea una copia del `Buffer`.
  + `buffer`: immetti un `Buffer`.
+ `Buffer.from(object[, offsetOrEncoding[, length]])`

  Crea un `Buffer` da un oggetto. Restituisce `Buffer.from(object.valueOf(), offsetOrEncoding, length)` se `valueOf()` non è uguale all'oggetto.
  + `object`: immetti un oggetto.
  + `offsetOrEncoding`: facoltativo. Immetti un numero intero o una stringa di codifica.
  + `length`: facoltativo. Immetti un numero intero.
+ `Buffer.from(string[, encoding])`

  Crea un `Buffer` da una stringa.
  + `string`: immetti una stringa.
  + `encoding`: facoltativo. Immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”.
+ `Buffer.isBuffer(object)`

  Controlla se `object` è un buffer. Restituisce `true` o `false`.
  + `object`: immetti un oggetto.
+ `Buffer.isEncoding(encoding)`

  Verifica se `encoding` è supportato. Restituisce `true` o `false`.
  + `encoding`: facoltativo. Immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”.

Il modulo fornisce i seguenti metodi di prototipo del buffer:
+ `Buffer.prototype.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])`

  Confronta `Buffer` con l'obiettivo. Restituisce `0` se sono uguali, `1` se viene prima `buffer` o `-1` se viene prima `target`.
  + `target`: immetti un `Buffer`.
  + `targetStart`: facoltativo. Immetti un numero intero. Il valore predefinito è 0.
  + `targetEnd`: facoltativo. Immetti un numero intero. Il valore predefinito è la lunghezza di `target`.
  + `sourceStart`: facoltativo. Immetti un numero intero. Il valore predefinito è 0.
  + `sourceEnd`: facoltativo. Immetti un numero intero. Il valore predefinito è la lunghezza di `Buffer`.
+ `Buffer.prototype.copy(target[, targetStart[, sourceStart[, sourceEnd]]])`

  Copia il buffer su `target`.
  + `target`: immetti un `Buffer` o `Uint8Array`.
  + `targetStart`: facoltativo. Immetti un numero intero. Il valore predefinito è 0.
  + `sourceStart`: facoltativo. Immetti un numero intero. Il valore predefinito è 0.
  + `sourceEnd`: facoltativo. Immetti un numero intero. Il valore predefinito è la lunghezza di `Buffer`.
+ `Buffer.prototype.equals(otherBuffer)`

  Confronta `Buffer` con `otherBuffer`. Restituisce `true` o `false`.
  + `otherBuffer`: immetti una stringa.
+ `Buffer.prototype.fill(value[, offset[, end][, encoding])`

  Compila `Buffer` con `value`.
  + `value`: immetti una stringa, `Buffer` o un numero intero.
  + `offset`: facoltativo. Immetti un numero intero.
  + `end`: facoltativo. Immetti un numero intero.
  + `encoding`: facoltativo. Immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”.
+ `Buffer.prototype.includes(value[, byteOffset][, encoding])`

  Cerca `value` in `Buffer`. Restituisce `true` o `false`.
  + `value`: immetti una stringa, `Buffer`, `Uint8Array` o un numero intero.
  + `byteOffset`: facoltativo. Immetti un numero intero.
  + `encoding`: facoltativo. Immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”.
+ `Buffer.prototype.indexOf(value[, byteOffset][, encoding])`

  Cerca il primo `value` in `Buffer`. Restituisce `index` se trovato e `-1` se non trovato.
  + `value`: immetti una stringa, `Buffer`, Unit8Array o un numero intero compreso tra 0 e 255. 
  + `byteOffset`: facoltativo. Immetti un numero intero.
  + `encoding`: facoltativo. Se `value` è una stringa, immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”.
+ `Buffer.prototype.lastIndexOf(value[, byteOffset][, encoding])`

  Cerca l'ultimo `value` in `Buffer`. Restituisce `index` se trovato e `-1` se non trovato.
  + `value`: immetti una stringa, `Buffer`, Unit8Array o un numero intero compreso tra 0 e 255. 
  + `byteOffset`: facoltativo. Immetti un numero intero.
  + `encoding`: facoltativo. Se `value` è una stringa, immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”.
+ `Buffer.prototype.readInt8(offset)`

  Leggi `Int8` in `offset` a partire da `Buffer`.
  + `offset`: immetti un numero intero.
+ `Buffer.prototype.readIntBE(offset, byteLength)`

  Leggi `Int` come big-endian in `offset` da `Buffer`.
  + `offset`: immetti un numero intero.
  + `byteLength`: facoltativo. Immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.readInt16BE(offset)`

  Leggi `Int16` come big-endian in `offset` da `Buffer`.
  + `offset`: immetti un numero intero.
+ `Buffer.prototype.readInt32BE(offset)`

  Leggi `Int32` come big-endian in `offset` da `Buffer`.
  + `offset`: immetti un numero intero.
+ `Buffer.prototype.readIntLE(offset, byteLength)`

  Leggi `Int` come little-endian in `offset` da `Buffer`.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.readInt16LE(offset)`

  Leggi `Int16` come little-endian in `offset` da `Buffer`.
  + `offset`: immetti un numero intero.
+ `Buffer.prototype.readInt32LE(offset)`

  Leggi `Int32` come little-endian in `offset` da `Buffer`.
  + `offset`: immetti un numero intero.
+ `Buffer.prototype.readUInt8(offset)`

  Leggi `UInt8` in `offset` a partire da `Buffer`.
  + `offset`: immetti un numero intero.
+ `Buffer.prototype.readUIntBE(offset, byteLength)`

  Leggi `UInt` come big-endian in `offset` da `Buffer`.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.readUInt16BE(offset)`

  Leggi `UInt16` come big-endian in `offset` da `Buffer`.
+ 
  + `offset`: immetti un numero intero.
+ `Buffer.prototype.readUInt32BE(offset)`

  Leggi `UInt32` come big-endian in `offset` da `Buffer`.
  + `offset`: immetti un numero intero.
+ `Buffer.prototype.readUIntLE(offset, byteLength)`

  Leggi `UInt` come little-endian in `offset` da `Buffer`.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.readUInt16LE(offset)`

  Leggi `UInt16` come little-endian in `offset` da `Buffer`.
  + `offset`: immetti un numero intero.
+ `Buffer.prototype.readUInt32LE(offset)`

  Leggi `UInt32` come little-endian in `offset` da `Buffer`.
  + `offset`: immetti un numero intero.
+ `Buffer.prototype.readDoubleBE([offset])`

  Leggi un file a doppia precisione a 64 bit come big-endian in `offset` da `Buffer`.
  + `offset`: facoltativo. Immetti un numero intero.
+ `Buffer.prototype.readDoubleLE([offset])`

  Leggi un file a doppia precisione a 64 bit come little-endian in `offset` da `Buffer`.
  + `offset`: facoltativo. Immetti un numero intero.
+ `Buffer.prototype.readFloatBE([offset])`

  Leggi un file a virgola mobile a 32 bit come big-endian in `offset` da `Buffer`.
  + `offset`: facoltativo. Immetti un numero intero.
+ `Buffer.prototype.readFloatLE([offset])`

  Leggi un file a virgola mobile a 32 bit come little-endian in `offset` da `Buffer`.
  + `offset`: facoltativo. Immetti un numero intero.
+ `Buffer.prototype.subarray([start[, end]])`

  Restituisce una copia di `Buffer` con offset e ritaglio con nuovi valori per `start` e `end`.
  + `start`: facoltativo. Immetti un numero intero. Il valore predefinito è 0.
  + `end`: facoltativo. Immetti un numero intero. Il valore predefinito è la lunghezza del buffer.
+ `Buffer.prototype.swap16()`

  Scambia l'ordine dei byte dell'array `Buffer`, trattandolo come un array di numeri a 16 bit. La lunghezza di `Buffer` deve essere divisibile per 2, altrimenti riceverai un errore.
+ `Buffer.prototype.swap32()`

  Scambia l'ordine dei byte dell'array `Buffer`, trattandolo come un array di numeri a 32 bit. La lunghezza di `Buffer` deve essere divisibile per 4, altrimenti riceverai un errore.
+ `Buffer.prototype.swap64()`

  Scambia l'ordine dei byte dell'array `Buffer`, trattandolo come un array di numeri a 64 bit. La lunghezza di `Buffer` deve essere divisibile per 8, altrimenti riceverai un errore.
+ `Buffer.prototype.toJSON()`

  Restituisce `Buffer` come file JSON. 
+ `Buffer.prototype.toString([encoding[, start[, end]]])`

  Converti `Buffer`, da `start` a `end`, in una stringa codificata.
  + `encoding`: facoltativo. Immetti uno dei seguenti valori: `utf8`, `hex`, `base64` o `base64url`. Il valore predefinito è “`utf8`”.
  + `start`: facoltativo. Immetti un numero intero. Il valore predefinito è 0.
  + `end`: facoltativo. Immetti un numero intero. Il valore predefinito è la lunghezza del buffer.
+ `Buffer.prototype.write(string[, offset[, length]][, encoding])`

  Scrivi il valore `string` codificato su `Buffer` se c'è spazio a sufficienza o un valore `string` troncato se non c'è abbastanza spazio.
  + `string`: immetti una stringa.
  + `offset`: facoltativo. Immetti un numero intero. Il valore predefinito è 0.
  + `length`: facoltativo. Immetti un numero intero. Il valore predefinito è la lunghezza della stringa.
  + `encoding`: facoltativo. Facoltativamente, immetti uno dei seguenti valori: `utf8`, `hex`, `base64` o `base64url`. Il valore predefinito è “`utf8`”.
+ `Buffer.prototype.writeInt8(value, offset, byteLength)`

  Scrivi `Int8` `value` di `byteLength` a `offset` su `Buffer`.
  + `value`: immetti un numero intero.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeIntBE(value, offset, byteLength)`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian.
  + `value`: immetti un numero intero.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeInt16BE(value, offset, byteLength)`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian.
  + `value`: immetti un numero intero.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeInt32BE(value, offset, byteLength)`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian.
  + `value`: immetti un numero intero.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeIntLE(offset, byteLength)`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeInt16LE(offset, byteLength)`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeInt32LE(offset, byteLength)`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeUInt8(value, offset, byteLength)`

  Scrivi `UInt8` `value` di `byteLength` a `offset` su `Buffer`.
  + `value`: immetti un numero intero.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeUIntBE(value, offset, byteLength)`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian.
  + `value`: immetti un numero intero.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeUInt16BE(value, offset, byteLength)`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian.
  + `value`: immetti un numero intero.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeUInt32BE(value, offset, byteLength)`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian.
  + `value`: immetti un numero intero.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeUIntLE(value, offset, byteLength)`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian.
  + `value`: immetti un numero intero.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeUInt16LE(value, offset, byteLength)`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian.
  + `value`: immetti un numero intero.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeUInt32LE(value, offset, byteLength)`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian.
  + `value`: immetti un numero intero.
  + `offset`: immetti un numero intero.
  + `byteLength`: immetti un numero intero compreso tra `1` e `6`.
+ `Buffer.prototype.writeDoubleBE(value, [offset])`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian.
  + `value`: immetti un numero intero.
  + `offset`: facoltativo. Immetti un numero intero. Il valore predefinito è 0.
+ `Buffer.prototype.writeDoubleLE(value, [offset])`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian.
  + `value`: immetti un numero intero.
  + `offset`: facoltativo. Immetti un numero intero. Il valore predefinito è 0.
+ `Buffer.prototype.writeFloatBE(value, [offset])`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian.
  + `value`: immetti un numero intero.
  + `offset`: facoltativo. Immetti un numero intero. Il valore predefinito è 0.
+ `Buffer.prototype.writeFloatLE(value, [offset])`

  Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian.
  + `value`: immetti un numero intero.
  + `offset`: facoltativo. Immetti un numero intero. Il valore predefinito è 0.

Sono supportati i seguenti metodi di istanza:
+ `buffer[index]`

  Ottieni e imposta l'ottetto (byte) a `index` in `Buffer`. 
  + Ottieni un numero da `0` a `255`. In alternativa, imposta un numero da `0` a `255`.

Sono supportate le seguenti proprietà di istanza:
+ `buffer`

  Ottieni l'oggetto `ArrayBuffer` per il buffer. 
+ `byteOffset`

  Ottieni il valore `byteOffset` per l'oggetto `Arraybuffer` del buffer.
+ `length`

  Ottieni il conteggio dei byte del buffer.

**Nota**  
Tutti i metodi del modulo Buffer sono nuovi in runtime 2.0. JavaScript 

### Stringa di query
<a name="writing-functions-javascript-features-builtin-modules-query-string-20"></a>

**Nota**  
L'[oggetto evento CloudFront Functions](functions-event-structure.md) analizza automaticamente le stringhe di query URL per voi. Ciò significa che nella maggior parte dei casi non è necessario utilizzare questo modulo.

Il modulo stringa di query (`querystring`) fornisce metodi per l'analisi e la formattazione delle stringhe di query URL. È possibile caricare il modulo usando `require('querystring')`. Il modulo fornisce i metodi seguenti:

`querystring.escape(string)`  
URL che codifica il dato `string`, restituendo una stringa di query con escape. Il metodo viene utilizzato da `querystring.stringify()` e non deve essere utilizzato direttamente.

`querystring.parse(string[, separator[, equal[, options]]])`  
Analizza una stringa di query (`string`) e restituisce un oggetto.  
Il parametro `separator` è una sottostringa per delimitare coppie chiave e valore nella stringa di query. Per impostazione predefinita, tale valore è `&`.  
Il parametro `equal` è una sottostringa per la delimitazione di chiavi e valori nella stringa di query. Per impostazione predefinita, tale valore è `=`.  
Il parametro `options` è un oggetto con le seguenti chiavi:    
`decodeURIComponent function`  
Un funzione per decodificare i caratteri codificati in percentuale nella stringa di query. Per impostazione predefinita, tale valore è `querystring.unescape()`.  
`maxKeys number`  
Il numero massimo di chiavi da analizzare. Per impostazione predefinita, tale valore è `1000`. Utilizza un valore `0` per rimuovere le limitazioni per il conteggio delle chiavi.
Per impostazione predefinita, si presuppone che i caratteri con codifica in percentuale all'interno della stringa di query utilizzino la codifica UTF-8. Le sequenze UTF-8 non valide vengono sostituite con il carattere sostitutivo `U+FFFD`.  
Ad esempio, per la seguente stringa di query:  

```
'name=value&abc=xyz&abc=123'
```
Il valore restituito di `querystring.parse()` è:  

```
{
name: 'value',
abc: ['xyz', '123']
}
```
`querystring.decode()` è un alias per `querystring.parse()`.

`querystring.stringify(object[, separator[, equal[, options]]])`  
Serializza un `object` e restituisce una stringa di query.  
Il parametro `separator` è una sottostringa per delimitare coppie chiave e valore nella stringa di query. Per impostazione predefinita, tale valore è `&`.  
Il parametro `equal` è una sottostringa per la delimitazione di chiavi e valori nella stringa di query. Per impostazione predefinita, tale valore è `=`.  
Il parametro `options` è un oggetto con le seguenti chiavi:    
`encodeURIComponent function`  
La funzione da utilizzare per convertire caratteri non sicuri dell’URL in codifica percentuale nella stringa di query. Per impostazione predefinita, tale valore è `querystring.escape()`.
Per impostazione predefinita, i caratteri che richiedono la codifica percentuale all'interno della stringa di query sono codificati come UTF-8. Per utilizzare una codifica diversa, specifica l'opzione `encodeURIComponent`.  
Ad esempio, per il seguente codice:  

```
querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' });
```
Il valore restituito è:  

```
'name=value&abc=xyz&abc=123&anotherName='
```
`querystring.encode()` è un alias per `querystring.stringify()`.

`querystring.unescape(string)`  
Decodifica i caratteri codificati in percentuale URL nel dato `string`, restituendo una stringa di query senza escape. Questo metodo viene utilizzato da `querystring.parse()` e non deve essere utilizzato direttamente.

### Crittografia
<a name="writing-functions-javascript-features-builtin-modules-crypto-20"></a>

Il modulo di crittografia (`crypto`) fornisce helper di hashing standard e HMAC (Hash Message Authentication Code). È possibile caricare il modulo usando `require('crypto')`.

**Metodi di hashing**

`crypto.createHash(algorithm)`  
Crea e restituisce un oggetto hash che è possibile utilizzare per generare digest hash utilizzando il dato algoritmo: `md5`, `sha1`, o `sha256`.

`hash.update(data)`  
Aggiorna il contenuto hash con il dato `data`.

`hash.digest([encoding])`  
Calcola il digest di tutti i dati passati tramite `hash.update()`. La codifica può essere `hex`, `base64` o `base64url`.

**Metodi HMAC**

`crypto.createHmac(algorithm, secret key)`  
Crea e restituisce un oggetto HMAC che utilizza il dato `algorithm` e `secret key`. L'algoritmo può essere `md5`, `sha1` o `sha256`.

`hmac.update(data)`  
Aggiorna il contenuto HMAC con il dato `data`.

`hmac.digest([encoding])`  
Calcola il digest di tutti i dati passati tramite `hmac.update()`. La codifica può essere `hex`, `base64` o `base64url`.

## Funzionalità con restrizioni
<a name="writing-functions-javascript-features-restricted-features-20"></a>

Le seguenti funzionalità JavaScript linguistiche non sono supportate o sono limitate a causa di problemi di sicurezza.

**Valutazione dinamica del codice**  
La valutazione dinamica del codice non è supportata. Entrambi i costruttori `eval()` e `Function` generano un errore se tentato. Ad esempio, `const sum = new Function('a', 'b', 'return a + b')` genera un errore.

**Timer**  
Le funzioni `setTimeout()`, `setImmediate()` e `clearTimeout()` non sono supportate. Non vi è alcuna disposizione per differire o cedere all'interno di un'esecuzione di funzione. La funzione deve essere eseguita in modo sincrono fino al completamento.

**Data e timestamp**  
Per motivi di sicurezza, non è possibile accedere ai timer ad alta risoluzione. Tutti i metodi `Date` per interrogare l'ora corrente restituiscono sempre lo stesso valore durante la durata di una singola esecuzione di funzione. Il timestamp restituito è il momento in cui la funzione ha iniziato l'esecuzione. Di conseguenza, non è possibile misurare il tempo trascorso nella vostra funzione.

**Accesso al file system**  
Nessun accesso al file system. Ad esempio, non esiste un modulo `fs` per l'accesso al file system come invece è presente in Node.js.

**Accesso al processo**  
Non è possibile accedere al processo. Ad esempio, non esiste un oggetto globale `process` per l’elaborazione dell’accesso alle informazioni come in Node.js.

**Variabili di ambiente**  
Non è possibile accedere alle variabili d’ambiente. Puoi invece utilizzarlo CloudFront KeyValueStore per creare un datastore centralizzato di coppie chiave-valore per le tue Funzioni. CloudFront CloudFront KeyValueStore consente aggiornamenti dinamici ai dati di configurazione senza dover implementare modifiche al codice. Per ulteriori informazioni, consulta [Amazon CloudFront KeyValueStore](kvs-with-functions.md).

**Accesso alla rete**  
Non è disponibile alcun supporto per le chiamate di rete. Ad esempio, XHR, HTTP(S) e socket non sono supportati.

# Metodi helper per archivi di valori delle chiavi
<a name="functions-custom-methods"></a>

**Nota**  
Le chiamate al metodo di supporto Key Value Store da CloudFront Functions non attivano un evento di AWS CloudTrail dati. Questi eventi non vengono registrati nella cronologia degli CloudTrail eventi. Per ulteriori informazioni, consulta [Registrazione delle chiamate CloudFront API Amazon tramite AWS CloudTrail](logging_using_cloudtrail.md).

Questa sezione si applica se utilizzi [CloudFront Key Value Store](kvs-with-functions.md) per includere valori chiave nella funzione che crei. CloudFront Functions ha un modulo che fornisce tre metodi di supporto per leggere i valori dall'archivio di valori chiave.

Per utilizzare questo modulo nel codice della funzione, assicurati di aver [associato un archivio di valori delle chiavi](kvs-with-functions-associate.md) alla funzione. 

Quindi, includi le seguenti istruzioni nelle prime righe del codice della funzione:

```
import cf from 'cloudfront';
const kvsHandle = cf.kvs();
```



## Metodo `get()`
<a name="functions-custom-methods-get"></a>

Utilizza questo metodo per restituire il valore della chiave per il nome chiave specificato. 

**Richiesta**

```
get("key", options);
```
+ `key`: il nome della chiave di cui è necessario recuperare il valore
+ `options`: è presente un’opzione, `format`. Assicura che la funzione analizzi correttamente i dati. Valori possibili:
  + `string`: (Predefinito) UTF8 codificato
  + `json` 
  + `bytes`: buffer di dati binari non elaborati

**Esempio di richiesta**

```
const value = await kvsHandle.get("myFunctionKey", { format: "string"});
```

**Risposta**

La risposta è una `promise` che si risolve in un valore nel formato richiesto utilizzando `options`. Per impostazione predefinita, il valore viene restituito come stringa.

### Gestione degli errori
<a name="error-handling-exists-method"></a>

Il metodo `get()` restituirà un errore quando la chiave richiesta non esiste nell’archivio di valori delle chiavi associato. Per gestire questo caso d’uso, puoi aggiungere un blocco `catch` e `try` al codice.

**avvertimento**  
L’uso dei combinatori di promesse (ad esempio, `Promise.all`, `Promise.any`) e dei metodi di catena di promesse (ad esempio, `then` e `catch`) può richiedere un elevato utilizzo della memoria delle funzioni. Se la funzione supera la quota [massima di memoria delle funzioni](cloudfront-limits.md#limits-functions), non verrà eseguita. Per evitare questo errore, ti consigliamo di utilizzare la sintassi `await` in modo sequenziale o in loop per richiedere più valori.  
**Esempio**  

```
var value1 = await kvs.get('key1');
var value2 = await kvs.get('key2');
```
Attualmente, l’uso dei combinatori di promesse per ottenere più valori non migliora le prestazioni, come nell’esempio seguente.  

```
var values = await Promise.all([kvs.get('key1'), kvs.get('key2'),]);
```

## Metodo `exists()`
<a name="functions-custom-methods-exists"></a>

Utilizza questo metodo per verificare se la chiave è presente o meno nell’archivio di valori delle chiavi.

**Richiesta**

```
exists("key");
```

**Esempio di richiesta**

```
const exist = await kvsHandle.exists("myFunctionkey");
```

**Risposta**

La risposta è un `promise` che restituisce un valore booleano (`true` o `false`). Questo valore specifica se la chiave esiste o meno nell’archivio di valori delle chiavi.

## Metodo `meta()`
<a name="functions-custom-methods-meta"></a>

Utilizza questo metodo per restituire i metadati relativi all’archivio di valori delle chiavi.

**Richiesta**

```
meta();
```

**Esempio di richiesta**

```
const meta = await kvsHandle.meta();
```

**Risposta**

La risposta è un valore `promise` che si risolve in un oggetto con le seguenti proprietà:
+ `creationDateTime`: la data e l'ora di creazione dell'archivio di valori delle chiavi, nel formato ISO 8601.
+ `lastUpdatedDateTime`: la data e l'ora dell'ultima sincronizzazione dell'archivio di valori delle chiavi, nel formato ISO 8601. Il valore non include il tempo di propagazione verso l'edge.
+ `keyCount`: il numero totale di chiavi in KVS dopo l'ultima sincronizzazione dalla sorgente.

**Esempio di risposta**

```
{keyCount:3,creationDateTime:2023-11-30T23:07:55.765Z,lastUpdatedDateTime:2023-12-15T03:57:52.411Z}
```

# Metodi di assistente di gestione per la modifica dell’origine
<a name="helper-functions-origin-modification"></a>

Questa sezione si applica se aggiorni o modifichi dinamicamente l'origine utilizzata nella richiesta all'interno del codice CloudFront Functions. Puoi aggiornare l'origine solo su *richiesta del visualizzatore* CloudFront Functions. CloudFront Functions dispone di un modulo che fornisce metodi di supporto per aggiornare o modificare dinamicamente l'origine.

Per utilizzare questo modulo, create una CloudFront funzione utilizzando JavaScript runtime 2.0 e includete la seguente dichiarazione nella prima riga del codice della funzione:

```
import cf from 'cloudfront';
```

Per ulteriori informazioni, consulta [JavaScript funzionalità di runtime 2.0 per CloudFront Functions](functions-javascript-runtime-20.md).

**Nota**  
Le pagine della console Esegui test API ed Esegui test non controllano se si è verificata una modifica dell’origine. Tuttavia, il test garantisce che il codice della funzione venga eseguito senza errori.

## Scegli tra CloudFront Functions e Lambda @Edge
<a name="origin-modification-considerations"></a>

Puoi aggiornare le tue origini utilizzando CloudFront Functions o Lambda @Edge.

Quando si utilizza CloudFront Functions per aggiornare le origini, si utilizza il trigger dell'evento *Viewer Request*, il che significa che questa logica verrà eseguita su ogni richiesta quando viene utilizzata questa funzione. Quando si utilizza Lambda@Edge, le funzionalità di aggiornamento dell’origine si trovano nel trigger dell’evento di *richiesta origine*, il che significa che questa logica viene eseguita solo in caso di perdita della cache.

La scelta dipende in gran parte dal carico di lavoro e dall'eventuale utilizzo esistente di CloudFront Functions e Lambda @Edge nelle distribuzioni. Le seguenti considerazioni possono aiutarti a decidere se utilizzare CloudFront Functions o Lambda @Edge per aggiornare le tue origini.

CloudFront Functions è particolarmente utile nelle seguenti situazioni:
+ Quando le tue richieste sono dinamiche (il che significa che non possono essere memorizzate nella cache) e andranno sempre all'origine. CloudFront Functions offre prestazioni migliori e costi complessivi inferiori.
+ Se disponi già di una CloudFront funzione di richiesta del visualizzatore che verrà eseguita su ogni richiesta, puoi aggiungere la logica di aggiornamento dell'origine alla funzione esistente.

Per utilizzare CloudFront Functions per aggiornare le origini, consultate i metodi di supporto nei seguenti argomenti.

Lambda@Edge è particolarmente utile nelle seguenti situazioni:
+ Quando si dispone di contenuti altamente memorizzabili nella cache, Lambda @Edge può essere più efficiente in termini di costi perché viene eseguito solo in caso di errori di cache, mentre Functions viene eseguito su ogni richiesta. CloudFront 
+ Se disponi già di una funzione Lambda@Edge per le richieste origine, puoi aggiungere la logica di aggiornamento dell’origine alla funzione esistente.
+ Quando la logica di aggiornamento dell’origine richiede il recupero di dati da origini dati di terze parti, come Amazon DynamoDB o Amazon S3.

Per ulteriori informazioni su Lambda@Edge, consulta [Personalizzazione al livello di edge con Lambda@Edge](lambda-at-the-edge.md).

## updateRequestOriginmetodo ()
<a name="update-request-origin-helper-function"></a>

Utilizza il metodo `updateRequestOrigin()` per aggiornare le impostazioni di origine per una richiesta. Puoi utilizzare questo metodo per aggiornare le proprietà di origine esistenti per le origini già definite nella distribuzione o per definire una nuova origine per la richiesta. A tale scopo, specifica le proprietà che desideri modificare.

**Importante**  
Tutte le impostazioni non specificate in `updateRequestOrigin()` erediteranno le *stesse impostazioni* dalla configurazione dell’origine esistente.

L'origine impostata dal `updateRequestOrigin()` metodo può essere qualsiasi endpoint HTTP e non è necessario che sia un'origine esistente all'interno della CloudFront distribuzione.

**Note**  
Se stai aggiornando un’origine che fa parte di un gruppo di origine, viene aggiornata solo l’*origine principale* del gruppo di origine. L’origine secondaria rimane invariata. Qualsiasi codice di risposta proveniente dall’origine modificata che soddisfi i criteri di failover attiverà un failover all’origine secondaria.
Se stai modificando il tipo di origine e hai abilitato l’OAC, assicurati che il tipo di origine in `originAccessControlConfig` corrisponda al nuovo tipo di origine.
Non puoi utilizzare il metodo `updateRequestOrigin()` per aggiornare [VPC Origins](private-content-vpc-origins.md). La richiesta non andrà a buon fine.

**Richiesta**

```
updateRequestOrigin({origin properties})
```

Le `origin properties` possono contenere i seguenti valori:

**domainName (facoltativo)**  
Il nome di dominio dell'origine. Se non è fornito, viene utilizzato il nome di dominio dell’origine assegnata.    
**Per origini personalizzate**  
Specifica un nome di dominio DNS, ad esempio `www.example.com`. Il nome di dominio non può includere i due punti (`:`) e non può essere un indirizzo IP. Il nome di dominio può contenere fino a 253 caratteri.  
**Per origini S3**  
Specifica il nome di dominio DNS del bucket Amazon S3, ad esempio `amzn-s3-demo-bucket.s3.eu-west-1.amazonaws.com`. Il nome può contenere fino a 128 caratteri e deve essere tutto in minuscolo.

**HostHeader (opzionale, per origini personalizzate non S3)**  
L'intestazione host da utilizzare quando si effettua la richiesta all'origine. Se questo non viene fornito, viene utilizzato il valore del parametro DomainName. Se non vengono forniti né l'intestazione host né il parametro del nome di dominio, viene utilizzato il nome di dominio dell'origine assegnata o l'intestazione host della richiesta in entrata se la politica di inoltro all'origine (FTO) include l'host. L'intestazione host non può includere i due punti (`:`) e non può essere un indirizzo IP. L'intestazione host può contenere fino a 253 caratteri.

**originPath (facoltativo)**  
Il percorso di directory sul server di origine in cui la richiesta deve trovare il contenuto. Il percorso può iniziare, ma non deve terminare, con una barra (/). Ad esempio, non deve terminare con `example-path/`. Se questo non è fornito, viene utilizzato il percorso di origine dall’origine assegnata.    
**Per origini personalizzate**  
Il percorso deve essere codificato URL e avere una lunghezza massima di 255 caratteri.

**customHeaders (facoltativo)**  
Puoi includere intestazioni personalizzate con la richiesta specificando un nome di intestazione e una coppia di valori per ogni intestazione personalizzata. Il formato è diverso da quello delle intestazioni di richiesta e risposta nella struttura dell’evento. Utilizza la seguente sintassi della coppia chiave-valore:  

```
{"key1": "value1", "key2": "value2", ...}
```
Non è possibile aggiungere intestazioni non consentite e un’intestazione con lo stesso nome non può essere presente anche nelle `headers` della richiesta in entrata. Il nome dell’intestazione deve essere in minuscolo nel codice della funzione. Quando CloudFront Functions riconverte l'oggetto evento in una richiesta HTTP, la prima lettera di ogni parola nei nomi delle intestazioni viene scritta in maiuscolo e le parole sono separate da un trattino.  
Ad esempio, se il codice di funzione aggiunge un'intestazione denominata`example-header-name`, la CloudFront converte in nella richiesta HTTP. `Example-Header-Name` Per ulteriori informazioni, consultare [Intestazioni personalizzate che CloudFront non possono essere aggiunte alle richieste di origine](add-origin-custom-headers.md#add-origin-custom-headers-denylist) e [Restrizioni sulle funzioni edge](edge-functions-restrictions.md).  
Se questo non viene fornito, vengono utilizzate le intestazioni personalizzate dell’origine assegnata.

**connectionAttempts (facoltativo)**  
Il numero di volte che CloudFront tenta di connettersi all'origine. Il valore minimo è 1 e il valore massimo è 3. Se questo non viene fornito, vengono utilizzati i tentativi di connessione dall’origine assegnata.

**originShield (facoltativo)**  
Ciò abilita o aggiorna CloudFront Origin Shield. L'utilizzo di Origin Shield può contribuire a ridurre il carico sulla tua origine. Per ulteriori informazioni, consulta [Usa Amazon CloudFront Origin Shield](origin-shield.md). Se questo non è fornito, vengono utilizzate le impostazioni Origin Shield dall’origine assegnata.    
**enabled (obbligatorio)**  
Espressione booleana per abilitare o disabilitare Origin Shield. Accetta un valore `true` o `false`.  
**region (obbligatorio se abilitato)**  
The Regione AWS for Origin Shield. Specifica la Regione AWS con la latenza più bassa all'origine. Utilizza il codice della Regione, non il nome della Regione. Ad esempio, utilizza `us-east-2` per specificare la Regione Stati Uniti orientali (Ohio).  
Quando abiliti CloudFront Origin Shield, devi specificare Regione AWS il nome. Per un elenco delle Regioni AWS disponibili e informazioni sulla scelta della Regione migliore per l’origine, consulta [Scegli la AWS regione per Origin Shield](origin-shield.md#choose-origin-shield-region).

**originAccessControlConfig (opzionale)**  
L’identificativo univoco di un controllo di accesso origine (OAC) per tale origine. Viene utilizzato solo quando l'origine supporta un CloudFront OAC, come Amazon S3, la URLs funzione MediaStore Lambda e V2. MediaPackage Se questo non viene fornito, vengono utilizzate le impostazioni OAC dell’origine assegnata.  
Questo non supporta l’identità di accesso origine (OAI) legacy. Per ulteriori informazioni, consulta [Limita l'accesso a un' AWS origine](private-content-restricting-access-to-origin.md).    
**enabled (obbligatorio)**  
Espressione booleana per abilitare o disabilitare OAC. Accetta un valore `true` o `false`.  
**signingBehavior (obbligatorio se abilitato)**  
Speciifica a quali richieste si riferisce (aggiunge le CloudFront informazioni di autenticazione). Specifica `always` per il caso d'uso più comune. Per ulteriori informazioni, consulta [Impostazioni avanzate per il controllo dell'accesso all'origine](private-content-restricting-access-to-s3.md#oac-advanced-settings-s3).   
Questo campo può avere uno dei seguenti valori:  
+ `always`— CloudFront firma tutte le richieste di origine, sovrascrivendo l'`Authorization`intestazione della richiesta del visualizzatore, se ne esiste una.
+ `never`— CloudFront non firma alcuna richiesta di origine. Questo valore disattiva il controllo di accesso origine per l’origine.
+ `no-override`— Se la richiesta del visualizzatore non contiene l'`Authorization`intestazione, CloudFront firma la richiesta di origine. Se la richiesta del visualizzatore contiene l'`Authorization`intestazione, CloudFront non firma la richiesta di origine e trasmette invece l'`Authorization`intestazione della richiesta del visualizzatore.
**avvertimento**  
Per trasmettere l’intestazione `Authorization` dalla richiesta visualizzatore, è necessario aggiungerla a una policy di richiesta origine per tutti i comportamenti cache che utilizzano origini associate a questo controllo di accesso origine. Per ulteriori informazioni, consulta [Controllo delle richieste di origine con una policy](controlling-origin-requests.md).  
**signingProtocol (richiesto se abilitato)**  
Il protocollo di firma dell'OAC, che determina il modo in cui CloudFront firma (autentica) le richieste. L’unico valore valido è `sigv4`.  
**originType (richiesto se abilitato)**  
Il tipo di origine per questo OAC. I valori validi includono `s3`, `mediapackagev2`, `mediastore` e `lambda`. 

**timeout (facoltativo)**  
I timeout che puoi specificare per quanto tempo CloudFront devono cercare di attendere che le origini rispondano o inviino dati. Se questo non viene fornito, vengono utilizzate le impostazioni di timeout dell’origine assegnata.   
Se non diversamente specificato, questi timeout supportano sia origini personalizzate che origini Amazon S3.   
**readTimeout (facoltativo)**  
`readTimeout` si applica a entrambi i seguenti valori:  
+ Quanto tempo (in secondi) CloudFront attende una risposta dopo l'inoltro di una richiesta all'origine.
+ Quanto tempo (in secondi) CloudFront attende dopo aver ricevuto un pacchetto di risposta dall'origine e prima di ricevere il pacchetto successivo. 
Il timeout minimo è di 1 secondo e quello massimo è di 120 secondi. Per ulteriori informazioni, consulta [Timeout di risposta](DownloadDistValuesOrigin.md#DownloadDistValuesOriginResponseTimeout).  
**responseCompletionTimeout (facoltativo)**  
Il tempo (in secondi) durante il quale una richiesta dall' CloudFront origine può rimanere aperta e attendere una risposta. Se la risposta completa non viene ricevuta dall'origine entro quest'ora, CloudFront termina la connessione.  
Il valore per `responseCompletionTimeout` deve essere maggiore o uguale al valore per `readTimeout`. Per ulteriori informazioni, consulta [Timeout completamento risposta](DownloadDistValuesOrigin.md#response-completion-timeout).  
**keepAliveTimeout (facoltativo)**  
Questo timeout si applica solo alle origini personalizzate, non alle origini Amazon S3. Le configurazioni di origine S3 ignoreranno queste impostazioni.   
`keepAliveTimeout`Indica per quanto tempo CloudFront deve cercare di mantenere la connessione all'origine dopo aver ricevuto l'ultimo pacchetto della risposta. Il timeout minimo è di 1 secondo e quello massimo è di 120 secondi. Per ulteriori informazioni, consulta [Timeout keep-alive (solo origini personalizzate e VPC)](DownloadDistValuesOrigin.md#DownloadDistValuesOriginKeepaliveTimeout).  
**connectionTimeout (facoltativo)**  
Il numero di secondi che CloudFront attendono quando si tenta di stabilire una connessione all'origine. Il timeout minimo è di 1 secondo e quello massimo è di 10 secondi. Per ulteriori informazioni, consulta [Timeout di connessione](DownloadDistValuesOrigin.md#origin-connection-timeout).

**customOriginConfig (facoltativo)**  
Utilizza `customOriginConfig` per specificare le impostazioni di connessione per origini che *non* sono un bucket Amazon S3. C’è un’eccezione: puoi specificare queste impostazioni se il bucket S3 è configurato con hosting di siti web statici. Altri tipi di configurazioni di bucket S3 ignoreranno queste impostazioni. Se `customOriginConfig` non viene fornito, vengono utilizzate le impostazioni dell’origine assegnata.    
**port (obbligatorio)**  
La porta HTTP CloudFront utilizzata per connettersi all'origine. La porta HTTP sulla quale l'origine è in ascolto.   
**protocol (obbligatorio)**  
Speciifica il protocollo (HTTP o HTTPS) CloudFront utilizzato per connettersi all'origine. I valori validi sono:  
+ `http`— utilizza CloudFront sempre HTTP per connettersi all'origine
+ `https`— utilizza CloudFront sempre HTTPS per connettersi all'origine  
**sslProtocols (obbligatorio)**  
Un elenco che specifica il SSL/TLS protocollo minimo da CloudFront utilizzare per la connessione all'origine tramite HTTPS. I valori validi includono `SSLv3`, `TLSv1`, `TLSv1.1` e `TLSv1.2`. Per ulteriori informazioni, consulta [Protocollo SSL di origine minimo](DownloadDistValuesOrigin.md#DownloadDistValuesOriginSSLProtocols).  
**ipAddressType (facoltativo)**  
Speciifica il tipo di indirizzo IP CloudFront utilizzato per la connessione all'origine. I valori validi includono `ipv4`, `ipv6` e `dualstack`. La modifica di `ipAddressType` è supportata solo quando viene modificata anche la proprietà `domainName`.

**sni (opzionale, per origini personalizzate non S3)**  
La Server Name Indication (SNI) è un'estensione del protocollo Transport Layer Security (TLS) con cui un client indica a quale nome host sta tentando di connettersi all'inizio del processo di handshake TLS. Questo valore deve corrispondere a un nome comune su un certificato TLS sul server di origine. In caso contrario, il server di origine potrebbe generare un errore.   
Se questo non viene fornito, viene utilizzato il valore del `hostHeader` parametro. Se l'intestazione dell'host non viene fornita, viene utilizzato il valore del `domainName` parametro.  
Se non vengono forniti né l'intestazione host né il parametro del nome di dominio, viene utilizzato il nome di dominio dell'origine assegnata o l'intestazione host della richiesta in entrata se la politica di inoltro all'origine (FTO) include l'host. L'SNI non può includere i due punti (`:`) e non può essere un indirizzo IP. Il codice SNI può contenere fino a 253 caratteri.

**allowedCertificateNames (opzionale, per origini personalizzate non S3)**  
È possibile includere un elenco di nomi di certificati validi da utilizzare per CloudFront convalidare la corrispondenza del dominio con il certificato TLS del server di origine durante l'handshake TLS con il server di origine. Questo campo prevede una matrice di nomi di dominio validi e può includere domini wildcard, come. `*.example.com`   
È possibile specificare fino a 20 nomi di certificato consentiti. Ogni nome di certificato può contenere fino a 64 caratteri.

**Example — Aggiornamento dell’origine richiesta Amazon S3**  
Nell’esempio seguente viene modificata l’origine della richiesta visualizzatore in un bucket S3, abilitato OAC e ripristinate le intestazioni personalizzate inviate all’origine.  

```
cf.updateRequestOrigin({
    "domainName" : "amzn-s3-demo-bucket-in-us-east-1.s3.us-east-1.amazonaws.com",
    "originAccessControlConfig": {
        "enabled": true,
        "signingBehavior": "always",
        "signingProtocol": "sigv4",
        "originType": "s3"
    },
    // Empty object resets any header configured on the assigned origin
    "customHeaders": {}
});
```

**Example — Aggiornamento dell’origine richiesta di Application Load Balancer**  
Nell’esempio seguente viene modificata l’origine della richiesta visualizzatore in un’origine Application Load Balancer e impostata un’intestazione e timeout personalizzati.  

```
cf.updateRequestOrigin({
    "domainName" : "example-1234567890.us-east-1.elb.amazonaws.com",
    "timeouts": {
        "readTimeout": 30,
        "connectionTimeout": 5
    },
    "customHeaders": {
        "x-stage": "production",
        "x-region": "us-east-1"
    }
});
```

**Example — Aggiornamento dell’origine con Origin Shield abilitato**  
Nell’esempio seguente, Origin Shield è abilitato nell’origine della distribuzione. Il codice funzione aggiorna solo il nome di dominio utilizzato per l’origine e omette tutti gli altri parametri opzionali. In questo caso, Origin Shield continuerà a essere utilizzato con il nome di dominio di origine modificato poiché i parametri di Origin Shield non sono stati aggiornati.  

```
cf.updateRequestOrigin({
    "domainName" : "www.example.com"
});
```

**Example — Aggiorna l'intestazione dell'host, l'SNI e i nomi dei certificati consentiti**  
Nella maggior parte dei casi d'uso, non è necessario utilizzare questo tipo di modifica per le richieste che arrivano all'origine. Questi parametri non devono essere utilizzati a meno che non si comprenda l'impatto della modifica di questi valori. 
L'esempio seguente modifica il nome di dominio, l'intestazione dell'host, l'SNI e i certificati consentiti dalla richiesta all'origine.   

```
cf.updateRequestOrigin({ 
    "domainName": "www.example.com", 
    "hostHeader": "test.example.com", 
    "sni": "test.example.net", 
    "allowedCertificateNames": ["*.example.com", "*.example.net"],
});
```

## selectRequestOriginByIdmetodo ()
<a name="select-request-origin-id-helper-function"></a>

Utilizza `selectRequestOriginById()` per aggiornare un’origine esistente selezionando un’origine diversa già configurata nella distribuzione. Questo metodo utilizza tutte le stesse impostazioni definite dall’origine aggiornata.

Questo metodo accetta solo origini già definite nella stessa distribuzione utilizzata durante l’esecuzione della funzione. Le origini sono identificate dall’ID origine, ovvero il nome origine definito durante la configurazione dell’origine.

Se nella distribuzione è configurata un’origine VPC, puoi utilizzare questo metodo per aggiornare l’origine all’origine VPC. Per ulteriori informazioni, consulta [Limitazione dell’accesso con VPC Origins](private-content-vpc-origins.md).

**Note**  
La `selectRequestOriginById()` funzione non può selezionare un'origine con TLS (origine) reciproco abilitato. Il tentativo di selezionare un'origine mutua abilitata per TLS (origine) utilizzando questa funzione genererà un errore di convalida.
Se il tuo caso d'uso richiede una selezione dinamica dell'origine con TLS reciproco (origine), utilizza `updateRequestOrigin()` invece, assicurandoti che tutte le origini di destinazione utilizzino lo stesso certificato client.

**Richiesta**

```
cf.selectRequestOriginById(origin_id, {origin_overrides})
```

Nell'esempio precedente, `origin_id` è una stringa che punta al nome di origine di un'origine nella distribuzione che esegue la funzione. Il `origin_overrides ` parametro può contenere quanto segue:

**HostHeader (opzionale, per origini personalizzate non S3)**  
L'intestazione host da utilizzare quando si effettua la richiesta all'origine. Se non viene fornito, viene utilizzato il valore del `domainName` parametro.   
Se non vengono forniti né l'intestazione host né il parametro del nome di dominio, viene utilizzato il nome di dominio dell'origine assegnata o l'intestazione host della richiesta in entrata se la politica di inoltro all'origine (FTO) include l'host. L'intestazione host non può includere i due punti (`:`) e non può essere un indirizzo IP. L'intestazione host può contenere fino a 253 caratteri.

**sni (opzionale, per origini personalizzate non S3)**  
La Server Name Indication (SNI) è un'estensione del protocollo Transport Layer Security (TLS) con cui un client indica a quale nome host sta tentando di connettersi all'inizio del processo di handshake TLS. Questo valore deve corrispondere a un nome comune su un certificato TLS sul server di origine. In caso contrario, il server di origine potrebbe generare un errore.   
Se questo non viene fornito, viene utilizzato il valore del `hostHeader` parametro. Se l'intestazione dell'host non viene fornita, viene utilizzato il valore del `domainName` parametro.   
Se non vengono forniti né l'intestazione host né il parametro del nome di dominio, viene utilizzato il nome di dominio dell'origine assegnata o l'intestazione host della richiesta in entrata se la politica di inoltro all'origine (FTO) include l'host. L'SNI non può includere i due punti (`:`) e non può essere un indirizzo IP. Il codice SNI può contenere fino a 253 caratteri.

**allowedCertificateNames (opzionale, per origini personalizzate non S3)**  
È possibile includere un elenco di nomi di certificati validi da utilizzare per CloudFront convalidare la corrispondenza del dominio con il certificato TLS del server di origine durante l'handshake TLS con il server di origine. Questo campo prevede una matrice di nomi di dominio validi e può includere domini wildcard, come. `*.example.com`   
È possibile specificare fino a 20 nomi di certificato consentiti. Ogni nome di certificato può contenere fino a 64 caratteri.

**Richiesta**

```
selectRequestOriginById(origin_id)
```

Nell’esempio precedente, `origin_id` è una stringa che punta al nome dell’origine nella distribuzione che esegue la funzione.

**Example — Selezione dell’origine della richiesta Amazon S3**  
Nell’esempio seguente viene selezionata l’origine denominata `amzn-s3-demo-bucket-in-us-east-1` dall’elenco delle origini associate alla distribuzione e applicate le impostazioni di configurazione dell’origine `amzn-s3-demo-bucket-in-us-east-1` alla richiesta.  

```
cf.selectRequestOriginById("amzn-s3-demo-bucket-in-us-east-1");
```

**Example — Selezione dell’origine della richiesta Application Load Balancer**  
Nell’esempio seguente viene selezionata un’origine Application Load Balancer denominata `myALB-prod` dall’elenco delle origini associate alla distribuzione e applicate le impostazioni di configurazione di `myALB-prod` alla richiesta.  

```
cf.selectRequestOriginById("myALB-prod");
```

**Example — Seleziona l'origine della richiesta Application Load Balancer e sovrascrivi l'intestazione dell'host**  
Come nell'esempio precedente, l'esempio seguente seleziona un'origine Application Load Balancer `myALB-prod` denominata dall'elenco di origini associate alla distribuzione e applica le impostazioni `myALB-prod` di configurazione di alla richiesta. Tuttavia, questo esempio sostituisce il valore dell'intestazione dell'host utilizzando. `origin_overrides`  

```
cf.overrideRequestOrigin("myALB-prod",{ 
        "hostHeader" : "test.example.com"
});
```

## createRequestOriginMetodo Group ()
<a name="create-request-origin-group-helper-function"></a>

Utilizza `createRequestOriginGroup()` per definire due origini da utilizzare come [gruppo di origine](high_availability_origin_failover.md#concept_origin_groups.creating) per il failover in scenari che richiedono un’elevata disponibilità.

Un gruppo di origine include due origini (una primaria e una secondaria) e un criterio di failover specificato. Si crea un gruppo di origine per supportare il failover di origine in CloudFront. Quando si crea o si aggiorna un gruppo di origine utilizzando questo metodo, è possibile specificare il gruppo di origine anziché una singola origine. CloudFront eseguirà il failover dall'origine primaria all'origine secondaria, utilizzando i criteri di failover.

Se nella distribuzione è configurata un’origine VPC, puoi utilizzare questo metodo per creare un gruppo di origini utilizzando un’origine VPC. Per ulteriori informazioni, consulta [Limitazione dell’accesso con VPC Origins](private-content-vpc-origins.md).

**Note**  
La `createRequestOriginGroup()` funzione non supporta la creazione di gruppi di origine che includono origini abilitate per Mutual TLS (origin). I gruppi di origine con origini Mutual TLS (origin) non possono essere creati dinamicamente tramite Functions. CloudFront 
Se hai bisogno di funzionalità di failover di origine con Mutual TLS (origin), configura i gruppi di origine direttamente nelle impostazioni di CloudFront distribuzione anziché crearli dinamicamente nelle funzioni.

### Richiesta
<a name="create-origin-group-request"></a>

```
createRequestOriginGroup({origin_group_properties})
```

Nell’esempio precedente, `origin_group_properties` può contenere quanto segue:

**originIds (obbligatorio)**  
Array di `origin_ids`, dove `origin_id` è una stringa che punta al nome di origine di un’origine nella distribuzione che esegue la funzione. È necessario fornire due origini come parte dell’array. La prima origine nell’elenco è l’origine primaria, mentre la seconda funge da origine secondaria per il failover. 

**OriginOverrides (opzionale)**  
 È possibile sovrascrivere alcune impostazioni avanzate utilizzando il parametro. `{origin_overrides}` Le `origin overrides` possono contenere i seguenti valori:     
**HostHeader (opzionale, per origini personalizzate non S3)**  
L'intestazione host da utilizzare quando si effettua la richiesta all'origine. Se non viene fornito, viene utilizzato il valore del `domainName` parametro.   
Se non vengono forniti né l'intestazione host né il parametro del nome di dominio, viene utilizzato il nome di dominio dell'origine assegnata o l'intestazione host della richiesta in entrata se la politica di inoltro all'origine (FTO) include l'host. L'intestazione host non può includere i due punti (`:`) e non può essere un indirizzo IP. L'intestazione host può contenere fino a 253 caratteri.  
**sni (opzionale, per origini personalizzate non S3)**  
La Server Name Indication (SNI) è un'estensione del protocollo Transport Layer Security (TLS) con cui un client indica a quale nome host sta tentando di connettersi all'inizio del processo di handshake TLS. Questo valore deve corrispondere a un nome comune su un certificato TLS sul server di origine, altrimenti il server di origine potrebbe generare un errore.   
Se questo non viene fornito, viene utilizzato il valore del `hostHeader` parametro. Se l'intestazione dell'host non viene fornita, viene utilizzato il valore del `domainName` parametro.  
Se non vengono forniti né l'intestazione host né il parametro del nome di dominio, viene utilizzato il nome di dominio dell'origine assegnata o l'intestazione host della richiesta in entrata se la politica di inoltro all'origine (FTO) include l'host. L'SNI non può includere i due punti (`:`) e non può essere un indirizzo IP. Il codice SNI può contenere fino a 253 caratteri.  
**allowedCertificateNames (opzionale, per origini personalizzate non S3)**  
È possibile includere un elenco di nomi di certificati validi da utilizzare per CloudFront convalidare la corrispondenza del dominio con il certificato TLS del server di origine durante l'handshake TLS con il server di origine. Questo campo prevede una matrice di nomi di dominio validi e può includere domini wildcard, come. `*.example.com`   
È possibile specificare fino a 20 nomi di certificato consentiti. Ogni nome di certificato può contenere fino a 64 caratteri.

**selectionCriteria (facoltativo)**  
Scegli se utilizzare i criteri di failover di origine `default` o la logica di failover basata su `media-quality-score`. I valori validi sono:  
+ `default` utilizza i criteri di failover, in base ai codici di stato specificati in `failoverCriteria`. Se non si imposta `selectionCriteria` nella funzione, verrà utilizzato `default`.
+ `media-quality-score` viene utilizzato quando è attiva la funzionalità di instradamento sensibile ai contenuti multimediali.

**failoverCriteria (obbligatorio)**  
Una serie di codici di stato che, se restituiti dall'origine principale, attivano CloudFront il failover sull'origine secondaria. Se si sovrascrive un gruppo di origine esistente, questo array sovrascriverà tutti i codici di stato di failover impostati nella configurazione originale del gruppo di origine.  
Quando lo utilizzi `media-quality-score``selectionCriteria`, CloudFront tenterà di indirizzare le richieste in base al punteggio di qualità multimediale. Se l'origine selezionata restituisce un codice di errore impostato in questo array, CloudFront eseguirà il failover sull'altra origine.

**Example — Creazione del gruppo di origini della richiesta**  
L'esempio seguente crea un gruppo di origine per una richiesta utilizzando l'origine IDs. Queste origini IDs provengono dalla configurazione del gruppo di origine per la distribuzione utilizzata per eseguire questa funzione.  
Facoltativamente, è possibile utilizzare `originOverrides` per sovrascrivere le configurazioni del gruppo di origine per`sni`, `hostHeader` e. `allowedCertificateNames`  

```
import cf from 'cloudfront';

function handler(event) {
    cf.createRequestOriginGroup({
        "originIds": [
            {
                "originId": "origin-1",
                "originOverrides": {
                    "hostHeader": "hostHeader.example.com",
                    "sni": "sni.example.com",
                    "allowedCertificateNames": ["cert1.example.com", "cert2.example.com", "cert3.example.com"]
                }
            },
            {
                "originId": "origin-2",
                "originOverrides": {
                    "hostHeader": "hostHeader2.example.com",
                    "sni": "sni2.example.com",
                    "allowedCertificateNames": ["cert4.example.com", "cert5.example.com"]
                }
            }
        ],
        "failoverCriteria": {
            "statusCodes": [500]
        }
    });
    
    event.request.headers['x-hookx'] = { value: 'origin-overrides' };
    return event.request;
}
```

# Metodi di supporto per le proprietà di CloudFront SaaS Manager
<a name="saas-specific-logic-function-code"></a>

Utilizza le seguenti funzioni di supporto per CloudFront SaaS Manager per recuperare i valori per le distribuzioni multi-tenant nella funzione che crei. Per utilizzare gli esempi in questa pagina, è necessario innanzitutto creare una CloudFront funzione utilizzando runtime 2.0. JavaScript Per ulteriori informazioni, consulta, [JavaScript funzionalità di runtime 2.0 per CloudFront Functions](functions-javascript-runtime-20.md).

**Topics**
+ [

## Gruppi di connessioni
](#connection-groups-helper-function)
+ [

## Tenant di distribuzione
](#distribution-tenants-helper-functions)

## Gruppi di connessioni
<a name="connection-groups-helper-function"></a>

Il gruppo di connessioni associato ai tenant di distribuzione dispone di un nome di dominio.

Per ottenere questo valore, utilizza il campo `endpoint` dell’oggetto secondario `context` dell’oggetto evento. 

**Richiesta**

```
const value = event.context.endpoint;
```

**Risposta**

La risposta è una `string` che contiene il nome di dominio del gruppo di connessioni, ad esempio d111111abcdef8.cloudfront.net. Il campo `endpoint` viene visualizzato solo quando la funzione viene invocata per una distribuzione multi-tenant con un gruppo di connessioni associato. Per ulteriori informazioni, consulta [Oggetto Context](functions-event-structure.md#functions-event-structure-context).

## Tenant di distribuzione
<a name="distribution-tenants-helper-functions"></a>

CloudFront Functions dispone di un modulo che fornisce l'accesso a valori specifici del tenant di distribuzione.

Per utilizzare questo modulo, includi la seguente istruzione nella prima riga del codice funzione:

```
import cf from 'cloudfront';
```

Puoi utilizzare i seguenti esempi solo nella funzione `handler`, direttamente o tramite qualsiasi funzione di chiamata nidificata.

### Campo `distributionTenant.id`
<a name="distribution-tenants-field"></a>

Utilizza questo campo per ottenere il valore dell’ID del tenant di distribuzione.

**Richiesta**

```
const value = cf.distributionTenant.id;
```

**Risposta**

La risposta è una `string` che contiene l’ID del tenant di distribuzione, ad esempio `dt_1a2b3c4d5e6f7`.

**Gestione errori**

Se la funzione viene invocata per una distribuzione standard, specificando il campo `distributionTenant.id` verrà restituito l’errore di tipo `distributionTenant module is not available`. Per gestire questo caso d’uso, puoi aggiungere un blocco `catch` e `try` al codice.

### Metodo `distributionTenant.parameters.get()`
<a name="distribution-tenant-parameters-get-method"></a>

Utilizza questo metodo per restituire il valore dei nomi dei parametri tenant di distribuzione specificati.

```
distributionTenant.parameters.get("key");
```

`key`: il nome del parametro tenant di distribuzione di cui desideri recuperare il valore.

**Richiesta**

```
const value = distributionTenant.parameters.get("key");
```

**Risposta**

La risposta è una `string` che contiene il valore per il parametro tenant di distribuzione. Ad esempio, se il nome della chiave è `TenantPath`, il valore di questo parametro potrebbe essere `tenant1`.

**Gestione errori**

Potrebbero verificarsi i seguenti errori:
+ Se la funzione viene invocata per una distribuzione standard, il metodo `distributionTenant.parameters.get()` restituirà l’errore di tipo `distributionTenant module is not available`. 
+ L’errore `DistributionTenantParameterKeyNotFound` viene restituito quando il parametro tenant di distribuzione specificato non esiste. 

Per gestire questi casi d’uso, puoi aggiungere un blocco `try` e `catch` al codice.

# Uso di async e await
<a name="async-await-syntax"></a>

CloudFront Le funzioni JavaScript di runtime di Functions 2.0 forniscono una `async` `await` sintassi per gestire `Promise` gli oggetti. Le promesse rappresentano risultati con ritardo a cui è possibile accedere tramite la parola chiave `await` nelle funzioni contrassegnate come `async`. Diverse nuove WebCrypto funzioni utilizzano Promises.

Per ulteriori informazioni sugli oggetti `Promise`, consulta [Promessa](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).

**Nota**  
È necessario utilizzare JavaScript runtime 2.0 per i seguenti esempi di codice.  
`await` può essere utilizzato solo all’interno delle funzioni `async`. Argomenti e chiusure `async` non sono supportati.

```
async function answer() {
    return 42;
}

// Note: async, await can be used only inside an async function. async arguments and closures are not supported.

async function handler(event) {
    // var answer_value = answer(); // returns Promise, not a 42 value
    let answer_value = await answer(); // resolves Promise, 42
    console.log("Answer"+answer_value);
    event.request.headers['answer'] = { value : ""+answer_value };
    return event.request;
}
```

Il JavaScript codice di esempio seguente mostra come visualizzare le promesse con il metodo `then` chain. È possibile utilizzare `catch` per visualizzare gli errori.

**avvertimento**  
L’uso dei combinatori di promesse (ad esempio, `Promise.all`, `Promise.any`) e dei metodi di catena di promesse (ad esempio, `then` e `catch`) può richiedere un elevato utilizzo della memoria delle funzioni. Se la funzione supera la quota [massima di memoria delle funzioni](cloudfront-limits.md#limits-functions), non verrà eseguita. Per evitare questo errore, ti consigliamo di utilizzare la sintassi `await` anziché i metodi `promise`.

```
async function answer() {
    return 42;
}

async function squared_answer() {
   return answer().then(value => value * value)
} 
// Note: async, await can be used only inside an async function. async arguments and closures are not supported.
async function handler(event) {
    // var answer_value = answer(); // returns Promise, not a 42 value
    let answer_value = await squared_answer(); // resolves Promise, 42
    console.log("Answer"+answer_value);
    event.request.headers['answer'] = { value : ""+answer_value };
    return event.request;
}
```

# Supporto CWT per le funzioni CloudFront
<a name="cwt-support-cloudfront-functions"></a>

Questa sezione fornisce dettagli sul supporto per i token Web CBOR (CWT) nelle CloudFront funzioni, che consente l'autenticazione e l'autorizzazione sicure basate su token presso le edge location. CloudFront Questo supporto viene fornito come modulo, accessibile nella funzione. CloudFront 

Per utilizzare questo modulo, create una CloudFront funzione utilizzando JavaScript runtime 2.0 e includete la seguente istruzione nella prima riga del codice della funzione: 

```
import cf from 'cloudfront';
```

I metodi associati a questo modulo sono accessibili tramite (dove\$1 è un jolly che rappresenta le diverse funzioni presenti nel modulo):

```
cf.cwt.*
```

Per ulteriori informazioni, consulta [JavaScript funzionalità di runtime 2.0 per CloudFront Functions](functions-javascript-runtime-20.md).

Attualmente, il modulo supporta solo la struttura MAC0 con algoritmo HS256 (HMAC-SHA256) con un limite di 1 KB per la dimensione massima del token.

## Struttura dei token
<a name="token-structure"></a>

Questa sezione illustra la struttura dei token prevista dal modulo CWT. Il modulo si aspetta che il token sia etichettato e identificabile correttamente (ad esempio COSE MAC0). Inoltre, per quanto riguarda la struttura del token, il modulo segue gli standard stabiliti da [CBOR Object Signing and Encryption (COSE) [](https://datatracker.ietf.org/doc/html/rfc8152)RFC 8152].

```
( // CWT Tag (Tag value: 61) --- optional    
    ( // COSE MAC0 Structure Tag (Tag value: 17) --- required        
        [            
            protectedHeaders,            
            unprotectedHeaders,            
            payload,            
            tag,        
        ]    
    )
)
```

**Example : CWT utilizza la struttura COSE MAC0**  

```
61( // CWT tag     
    17( // COSE_MAC0 tag       
        [         
            { // Protected Headers           
                1: 4  // algorithm : HMAC-256-64         
            },         
            { // Unprotected Headers           
                4: h'53796d6d6574726963323536' // kid : Symmetric key id          
            },         
            { // Payload           
                1: "https://iss.example.com", // iss           
                2: "exampleUser", // sub           
                3: "https://aud.example.com", // aud           
                4: 1444064944, // exp           
                5: 1443944944, // nbf           
                6: 1443944944, // iat         
            },         
            h'093101ef6d789200' // tag       
        ]     
    )   
)
```
Il tag CWT è opzionale per la generazione di token. Tuttavia, il tag di struttura COSE è obbligatorio.

## metodo validateToken ()
<a name="validatetoken-method"></a>

La funzione decodifica e convalida un token CWT utilizzando la chiave specificata. Se la convalida ha esito positivo, restituisce il token CWT decodificato. Altrimenti, genera un errore. Tieni presente che questa funzione non esegue alcuna convalida sul set di attestazioni.

### Richiesta
<a name="validatetoken-request"></a>

```
cf.cwt.validateToken(token, handlerContext{key})
```Parameters

**token (richiesto)**  
Token codificato per la convalida. Questo deve essere un JavaScript buffer.

**HandlerContext (obbligatorio)**  
Un JavaScript oggetto che memorizza il contesto per la chiamata validateToken. Al momento, è supportata solo la proprietà key.

**chiave (obbligatoria)**  
Chiave segreta per il calcolo del message digest. Può essere fornita come stringa o JavaScript buffer.

### Risposta
<a name="validatetoken-response"></a>

Quando il `validateToken()` metodo restituisce un token convalidato correttamente, la risposta della funzione è a `CWTObject` nel seguente formato. Una volta decodificate, tutte le chiavi di rivendicazione vengono rappresentate come stringhe.

```
CWTObject {    
    protectedHeaders,    
    unprotectedHeaders,    
    payload
}
```

### Esempio: convalida il token con kid inviato come parte del token
<a name="validatetoken-example"></a>

Questo esempio dimostra la convalida del token CWT, in cui il kid viene estratto dall'header. Il bambino viene quindi passato KeyValueStore a CloudFront Functions per recuperare la chiave segreta usata per convalidare il token.

```
import cf from 'cloudfront'

const CwtClaims = {
   iss: 1,
   aud: 3,
   exp: 4
}

async function handler(event) {
    try {
        let request = event.request;
        let encodedToken = request.headers['x-cwt-token'].value;
        let kid = request.headers['x-cwt-kid'].value;
                
        // Retrieve the secret key from the kvs
        let secretKey = await cf.kvs().get(kid);
                 
        // Now you can use the secretKey to decode & validate the token.
        let tokenBuffer = Buffer.from(encodedToken, 'base64url');
                
        let handlerContext = {
           key: secretKey,
        }
                
        try {
            let cwtObj = cf.cwt.validateToken(tokenBuffer, handlerContext);
                        
            // Check if token is expired
            const currentTime = Math.floor(Date.now() / 1000); // Current time in seconds
            if (cwtObj[CwtClaims.exp] && cwtObj[CwtClaims.exp] < currentTime) {
                return {
                    statusCode: 401,
                    statusDescription: 'Token expired'
                };
            }
        } catch (error) {
            return {
               statusCode: 401,
               statusDescription: 'Invalid token'
            };
         }
    } catch (error) {
        return {
            statusCode: 402,
            statusDescription: 'Token processing failed'
        };
     }
    return request;
}
```

## metodo generateToken ()
<a name="generatetoken-method"></a>

Questa funzione genera un nuovo token CWT utilizzando il payload e le impostazioni di contesto fornite.

### Richiesta
<a name="generatetoken-request"></a>

```
cf.cwt.generateToken(generatorContext, payload)
```Parameters

**GeneratorContext (obbligatorio)**  
Si tratta di un JavaScript oggetto che viene utilizzato come contesto per la generazione del token e contiene le seguenti coppie chiave-valore:    
**CwtTag (opzionale)**  
Questo valore è un booleano, che se lo `true` specifica deve essere aggiunto. `cwtTag`  
**CoseTag (obbligatorio)**  
Specifica il tipo di tag COSE. Attualmente supporta `MAC0` solo.  
**chiave (richiesta)**  
Chiave segreta per calcolare il message digest. Questo valore può essere una stringa o. JavaScript `Buffer`

**payload (obbligatorio)**  
Payload di token per la codifica. Il payload deve essere in formato. `CWTObject`

### Risposta
<a name="generatetoken-response"></a>

Restituisce un JavaScript Buffer contenente il token codificato.

**Example : genera un token CWT**  

```
import cf from 'cloudfront';

const CwtClaims = {
    iss: 1,
    sub: 2,
    exp: 4
};

const CatClaims = {
    catu: 401,
    catnip: 402,
    catm: 403,
    catr: 404
};

const Catu = {
    host: 1,
    path: 2,
    ext: 3
};

const CatuMatchTypes = {
    prefix_match: 1,
    suffix_match: 2,
    exact_match: 3
};

const Catr = {
    renewal_method: 1,
    next_renewal_time: 2,
    max_uses: 3
};

async function handler(event) {
    try {
        const response = {
            statusCode: 200,
            statusDescription: 'OK',
            headers: {}
        };
        
        const commonAccessToken = {
            protected: {
                1: "5",
            },
            unprotected: {},
            payload: {
                [CwtClaims.iss]: "cloudfront-documentation",
                [CwtClaims.sub]: "cwt-support-on-cloudfront-functions",
                [CwtClaims.exp]: 1740000000,
                [CatClaims.catu]: {
                    [Catu.host]: {
                        [CatuMatchTypes.suffix_match]: ".cloudfront.net"
                    },
                    [Catu.path]: {
                        [CatuMatchTypes.prefix_match]: "/media/live-stream/cf-4k/"
                    },
                    [Catu.ext]: {
                        [CatuMatchTypes.exact_match]: [
                            ".m3u8",
                            ".ts",
                            ".mpd"
                        ]
                    }
                },
                [CatClaims.catnip]: [
                    "[IP_ADDRESS]",
                    "[IP_ADDRESS]"
                ],
                [CatClaims.catm]: [
                    "GET",
                    "HEAD"
                ],
                [CatClaims.catr]: {
                    [Catr.renewal_method]: "header_renewal",
                    [Catr.next_renewal_time]: 1750000000,
                    [Catr.max_uses]: 5
                }
            }
        };
        
        if (!request.headers['x-cwt-kid']) {
            throw new Error('Missing x-cwt-kid header');
        }
        
        const kid = request.headers['x-cwt-kid'].value;
        const secretKey = await cf.kvs().get(kid);
        
        if (!secretKey) {
            throw new Error('Secret key not found for provided kid');
        }
        
        try {
            const genContext = {
                cwtTag: true,
                coseTag: "MAC0",
                key: secretKey
            };
            
            const tokenBuffer = cf.cwt.generateToken(commonAccessToken, genContext);
            response.headers['x-generated-cwt-token'] = { value: tokenBuffer.toString('base64url') };
                        
            return response;
        } catch (tokenError) {
            return {
                statusCode: 401,
                statusDescription: 'Could not generate the token'
            };
        }
    } catch (error) {
        return {
            statusCode: 402,
            statusDescription: 'Token processing failed'
        };
    }
}
```

**Example : Aggiorna il token in base a una logica**  

```
import cf from 'cloudfront'

const CwtClaims = {
   iss: 1,
   aud: 3,
   exp: 4
}

async function handler(event) {
    try {
        let request = event.request;
        let encodedToken = request.headers['x-cwt-token'].value;
        let kid = request.headers['x-cwt-kid'].value;
        let secretKey = await cf.kvs().get(kid); // Retrieve the secret key from the kvs
                
        // Now you can use the secretKey to decode & validate the token.
        let tokenBuffer = Buffer.from(encodedToken, 'base64url');
                
        let handlerContext = {
           key: secretKey,
        }
                
        try {
            let cwtJSON = cf.cwt.validateToken(tokenBuffer, handlerContext);
                        
            // Check if token is expired
            const currentTime = Math.floor(Date.now() / 1000); // Current time in seconds
            if (cwtJSON[CwtClaims.exp] && cwtJSON[CwtClaims.exp] < currentTime) {
                // We can regnerate the token and add 8 hours to the expiry time
                cwtJSON[CwtClaims.exp] = Math.floor(Date.now() / 1000) + (8 * 60 * 60);
                                
                let genContext = {
                  coseTag: "MAC0",
                  key: secretKey
                }
                                
                let newTokenBuffer = cf.cwt.generateToken(cwtJSON, genContext);
                 request.headers['x-cwt-regenerated-token'] = newTokenBuffer.toString('base64url');
            }
        } catch (error) {
            return {
               statusCode: 401,
               statusDescription: 'Invalid token'
            };
         }
    }
    catch (error) {
        return {
            statusCode: 402,
            statusDescription: 'Token processing failed'
        };
     }
    return request;
}
```

# Metodi generali di supporto
<a name="general-helper-methods"></a>

Questa pagina fornisce metodi di supporto aggiuntivi all'interno CloudFront di Functions. Per utilizzare questi metodi, create una CloudFront funzione utilizzando JavaScript runtime 2.0.

```
import cf from 'cloudfront';
```

Per ulteriori informazioni, consulta [JavaScript funzionalità di runtime 2.0 per CloudFront Functions](functions-javascript-runtime-20.md).

## `edgeLocation`metadati
<a name="edge-location-metadata"></a>

Questo metodo richiede l'utilizzo del `cloudfront` modulo.

**Nota**  
È possibile utilizzare questo metodo solo per le funzioni di richiesta del visualizzatore. Per le funzioni di risposta del visualizzatore, questo metodo è vuoto.

Utilizzate questo JavaScript oggetto per ottenere il codice dell'aeroporto della edge location, la regione [Regional Edge Cache](HowCloudFrontWorks.md#CloudFrontRegionaledgecaches) prevista o l'indirizzo IP del CloudFront server utilizzato per gestire la richiesta. Questi metadati sono disponibili solo nel trigger dell'evento di richiesta del visualizzatore.

```
cf.edgeLocation = {
    name: SEA
    serverIp: 1.2.3.4
    region: us-west-2
}
```

L'`cf.edgeLocation`oggetto può contenere quanto segue:

**nome**  
Il [codice IATA](https://en.wikipedia.org/wiki/IATA_airport_code) a tre lettere dell'edge location che ha gestito la richiesta.

**IP del server**  
L' IPv6 indirizzo IPv4 o del server che ha gestito la richiesta.

**region**  
La CloudFront Regional Edge Cache (REC) che la richiesta *dovrebbe utilizzare in* caso di perdita della cache. Questo valore non viene aggiornato nel caso in cui il REC previsto non sia disponibile e per la richiesta venga utilizzato un REC di backup. Questo non include la posizione Origin Shield utilizzata, tranne nei casi in cui il REC principale e l'Origin Shield si trovino nella stessa posizione.

**Nota**  
CloudFront Functions non viene richiamato una seconda volta quando CloudFront è configurato per utilizzare il failover di origine. Per ulteriori informazioni, consulta [Ottimizza l'alta disponibilità con il failover di CloudFront origine](high_availability_origin_failover.md).

## Metodo `rawQueryString()`
<a name="raw-query-string-method"></a>

Questo metodo non richiede il `cloudFront` modulo.

Utilizzate il `rawQueryString()` metodo per recuperare la stringa di query non analizzata e inalterata come stringa.

**Richiesta**

```
function handler(event) {
    var request = event.request;
    const qs = request.rawQueryString();
}
```

**Risposta**

Restituisce la stringa di query completa della richiesta in entrata come valore di stringa senza l'iniziale. `?` 
+ Se non è presente una stringa di query, ma `?` è presente, le funzioni restituiscono una stringa vuota. 
+ Se non è presente una stringa di query e `?` non è presente, la funzione restituisce`undefined`.

**Caso 1: restituita la stringa di query completa (senza interlinea`?`)**  
URL della richiesta in entrata: `https://example.com/page?name=John&age=25&city=Boston`  
`rawQueryString()`restituisce: `"name=John&age=25&city=Boston"`

**Caso 2: restituita una stringa vuota (quando `?` è presente ma senza parametri)**  
URL della richiesta in entrata: `https://example.com/page?`  
`rawQueryString()`restituisce: `""`

**Caso 3: `undefined` restituito (nessuna stringa di query e no`?`)**  
URL della richiesta in entrata: `https://example.com/page`  
`rawQueryString()`restituisce: `undefined`