Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Écriture du code de la fonction
<a name="writing-function-code"></a>

Vous pouvez utiliser CloudFront Functions pour écrire des fonctions légères dans le cadre de personnalisations JavaScript de CDN à grande échelle et sensibles à la latence. Votre code de fonction peut manipuler les demandes et les réponses qui circulent CloudFront, effectuer une authentification et une autorisation de base, générer des réponses HTTP à la périphérie, etc.

Pour vous aider à écrire du code de fonction pour CloudFront Functions, consultez les rubriques suivantes. Pour des exemples de code, voir [CloudFront Exemples de fonctions pour CloudFront](service_code_examples_cloudfront_functions_examples.md) et le [amazon-cloudfront-functions référentiel](https://github.com/aws-samples/amazon-cloudfront-functions) sur GitHub.

**Topics**
+ [Détermination de l’objectif de la fonction](function-code-choose-purpose.md)
+ [Structure d’évènements](functions-event-structure.md)
+ [JavaScript fonctionnalités d'exécution](functions-javascript-runtime-features.md)
+ [Méthodes d’aide pour les magasins de clés-valeurs](functions-custom-methods.md)
+ [Méthodes d’assistance pour la modification de l’origine](helper-functions-origin-modification.md)
+ [Méthodes d'assistance pour les propriétés de CloudFront SaaS Manager](saas-specific-logic-function-code.md)
+ [Utilisation de async et await](async-await-syntax.md)
+ [Support CWT pour Functions CloudFront](cwt-support-cloudfront-functions.md)
+ [Méthodes d'assistance générales](general-helper-methods.md)

# Détermination de l’objectif de la fonction
<a name="function-code-choose-purpose"></a>

Avant d'écrire votre code de fonction, déterminez le but de votre fonction. La plupart des CloudFront fonctions de Functions ont l'un des objectifs suivants.

**Topics**
+ [Modification de la requête HTTP dans un type d'événement de demande de visionnage](#function-code-modify-request)
+ [Génération d'une réponse HTTP dans un type d'événement de demande de visionnage](#function-code-generate-response)
+ [Modification de la réponse HTTP dans un type d'événement de demande de visionnage](#function-code-modify-response)
+ [Valider les connexions mTLS dans un type d'événement de demande de connexion](#function-code-connection-request)
+ [Informations connexes](#related-information-cloudfront-functions-purpose)

Quel que soit le but de votre fonction, `handler` est le point d'entrée pour n'importe quelle fonction. Il ne prend qu'un seul argument appelé`event`, qui est transmis à la fonction par CloudFront. `event` est un objet JSON qui contient une représentation de la requête HTTP (et la réponse, si votre fonction modifie la réponse HTTP). 

## Modification de la requête HTTP dans un type d'événement de demande de visionnage
<a name="function-code-modify-request"></a>

Votre fonction peut modifier la requête HTTP envoyée CloudFront par le visualiseur (client) et renvoyer la demande modifiée CloudFront pour un traitement continu. Par exemple, votre code de fonction peut normaliser la [clé de cache](understanding-the-cache-key.md) ou modifier les en-têtes de requêtes.

Après avoir créé et publié une fonction qui modifie la demande HTTP, veillez à ajouter une association pour le type d’événement *demande de l’utilisateur*. Pour de plus amples informations, veuillez consulter [Créer la fonction](functions-tutorial.md#functions-tutorial-create). Cela permet à la fonction de s'exécuter chaque fois qu' CloudFront elle reçoit une demande d'un visualiseur, avant de vérifier si l'objet demandé se trouve dans le CloudFront cache.

**Example Exemple**  
Le pseudocode suivant montre la structure d'une fonction qui modifie la requête HTTP.  

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

    // Modify the request object here.

    return request;
}
```
La fonction renvoie l'`request`objet modifié à CloudFront. CloudFrontpoursuit le traitement de la demande renvoyée en vérifiant la CloudFront présence d'un accès au cache et en envoyant la demande à l'origine si nécessaire.

## Génération d'une réponse HTTP dans un type d'événement de demande de visionnage
<a name="function-code-generate-response"></a>

Votre fonction peut générer une réponse HTTP à la périphérie et la renvoyer directement au visualiseur (client) sans vérifier la présence d'une réponse en cache ni aucun autre traitement par CloudFront. Par exemple, votre code de fonction peut rediriger la requête vers une nouvelle URL, ou vérifier l'autorisation et renvoyer une réponse `401` ou `403` à des requêtes non autorisées.

Lorsque vous créez une fonction qui génère une réponse HTTP, veillez à choisir le type d'évènement *requête utilisateur*. Cela signifie que la fonction s'exécute chaque fois qu' CloudFront elle reçoit une demande d'un utilisateur, avant CloudFront de poursuivre le traitement de la demande.

**Example Exemple**  
Le pseudocode suivant montre la structure d'une fonction qui génère une réponse HTTP.  

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

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

    return response;
}
```
La fonction renvoie un `response` objet à CloudFront, qui revient CloudFront immédiatement au visualiseur sans vérifier le CloudFront cache ni envoyer de demande à l'origine.

## Modification de la réponse HTTP dans un type d'événement de demande de visionnage
<a name="function-code-modify-response"></a>

Votre fonction peut modifier la réponse HTTP avant de l' CloudFront envoyer au visualiseur (client), que la réponse provienne du CloudFront cache ou de l'origine. Par exemple, votre code de fonction peut ajouter ou modifier des en-têtes de réponse, des codes de statut et le contenu du corps.

Lorsque vous créez une fonction qui modifie la réponse HTTP, veillez à choisir le type d'évènement *réponse utilisateur*. Cela signifie que la fonction s'exécute avant de CloudFront renvoyer une réponse au visualiseur, que la réponse provienne du CloudFront cache ou de l'origine.

**Example Exemple**  
Le pseudocode suivant montre la structure d'une fonction qui modifie la réponse 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 fonction renvoie l'`response`objet modifié à CloudFront, qui revient CloudFront immédiatement au visualiseur.

## Valider les connexions mTLS dans un type d'événement de demande de connexion
<a name="function-code-connection-request"></a>

Les fonctions de connexion sont un type de CloudFront fonctions qui s'exécutent pendant les connexions TLS pour fournir une logique de validation et d'authentification personnalisée. Les fonctions de connexion sont actuellement disponibles pour les connexions TLS mutuelles (mTLS), où vous pouvez valider les certificats clients et implémenter une logique d'authentification personnalisée au-delà de la validation standard des certificats. Les fonctions de connexion s'exécutent pendant le processus de prise de contact TLS et peuvent autoriser ou refuser des connexions en fonction des propriétés des certificats, des adresses IP des clients ou d'autres critères.

Après avoir créé et publié une fonction de connexion, assurez-vous d'ajouter une association pour le type d'événement de *demande de connexion* avec une distribution compatible MTLS. Cela permet à la fonction de s'exécuter chaque fois qu'un client tente d'établir une connexion mTLS avec CloudFront.

**Example**  
Le pseudocode suivant montre la structure d'une fonction de connexion :  

```
function connectionHandler(connection) {
    // Validate certificate and connection properties here.
    
    if (/* validation passes */) {
        connection.allow();
    } else {
        connection.deny();
    }
}
```
La fonction utilise des méthodes d'assistance pour déterminer s'il convient d'autoriser ou de refuser la connexion. Contrairement aux fonctions de demande et de réponse de l'utilisateur, les fonctions de connexion ne peuvent pas modifier les requêtes ou les réponses HTTP.

## Informations connexes
<a name="related-information-cloudfront-functions-purpose"></a>

Pour plus d'informations sur l'utilisation des CloudFront fonctions, consultez les rubriques suivantes :
+ [Structure d’évènements](functions-event-structure.md)
+ [JavaScript fonctionnalités d'exécution](functions-javascript-runtime-features.md)
+ [CloudFront Exemples de fonctions ](service_code_examples_cloudfront_functions_examples.md)
+ [Restrictions sur les fonctions périphériques](edge-functions-restrictions.md)

# CloudFront Fonctions et structure des événements
<a name="functions-event-structure"></a>

CloudFront Functions transmet un `event` objet à votre code de fonction en entrée lors de l'exécution de la fonction. Lorsque vous [testez une fonction](test-function.md), vous créez l'objet `event` et le transférez à votre fonction. Lorsque vous créez un objet `event` pour tester une fonction, vous pouvez omettre les champs `distributionDomainName`, `distributionId` et `requestId` de l'objet `context`. Assurez-vous que les noms des en-têtes sont en minuscules, ce qui est toujours le cas dans l'`event`objet que CloudFront Functions transmet à votre fonction en production.

La section suivante présente une vue d'ensemble de la structure de cet objet d'évènement. 

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

Pour plus d’informations, consultez les rubriques suivantes :

**Topics**
+ [Champ Version](#functions-event-structure-version)
+ [Objet Contexte](#functions-event-structure-context)
+ [Structure des événements de connexion](#functions-event-structure-connection)
+ [Objet Utilisateur](#functions-event-structure-viewer)
+ [Objet Requête](#functions-event-structure-request)
+ [Objet Réponse](#functions-event-structure-response)
+ [Code de statut et corps](#functions-event-structure-status-body)
+ [Structure d'une chaîne de requête, d'un en-tête ou d'un cookie](#functions-event-structure-query-header-cookie)
+ [Exemple d'objet de réponse](#functions-response-structure-example)
+ [Exemple d'objet d'événement](#functions-event-structure-example)

## Champ Version
<a name="functions-event-structure-version"></a>

Le `version` champ contient une chaîne qui indique la version de l'objet d'événement CloudFront Functions. La version actuelle est `1.0`.

## Objet Contexte
<a name="functions-event-structure-context"></a>

L'objet `context` contient des informations contextuelles sur l'évènement. Il inclut les champs suivants :

**`distributionDomainName`**  
Le nom CloudFront de domaine (par exemple, d111111abcdef8.cloudfront.net) de la distribution standard associée à l'événement.  
Le champ `distributionDomainName` n’apparaît que lorsque votre fonction est invoquée pour les distributions standard.

**`endpoint`**  
Le nom CloudFront de domaine (par exemple, d111111abcdef8.cloudfront.net) du groupe de connexion associé à l'événement.  
Le champ `endpoint` n’apparaît que lorsque votre fonction est invoquée pour les distributions multi-locataires.

**`distributionId`**  
L'ID de la distribution (par EDFDVBD6 exemple, EXAMPLE) associée à l'événement.

**`eventType`**  
Le type d'évènement, `viewer-request` ou `viewer-response`.

**`requestId`**  
Chaîne qui identifie de manière unique une CloudFront demande (et la réponse associée).

## Structure des événements de connexion
<a name="functions-event-structure-connection"></a>

Les fonctions de connexion reçoivent une structure d'événements différente de celle des fonctions de visualisation. Pour des informations détaillées sur la structure des événements de connexion et le format de réponse, consultez[Associer une fonction CloudFront de connexion](connection-functions.md).

## Objet Utilisateur
<a name="functions-event-structure-viewer"></a>

L'objet `viewer` comporte un champ `ip` dont la valeur est l'adresse IP de l'utilisateur (client) qui a envoyé la requête. Si la requête utilisateur a été envoyée via un proxy HTTP ou un équilibreur de charge, la valeur correspond à l'adresse IP du proxy ou de l'équilibreur de charge.

## Objet Requête
<a name="functions-event-structure-request"></a>

L'`request`objet contient une représentation d'une requête viewer-to-CloudFront HTTP. Dans l'`event`objet transmis à votre fonction, l'`request`objet représente la demande réelle CloudFront reçue du visualiseur.

Si votre code de fonction renvoie un `request` objet à CloudFront, il doit utiliser cette même structure.

L'objet `request` comporte les champs suivants :

**`method`**  
Méthode HTTP de la demande. Si votre code de fonction renvoie une `request`, il ne peut pas modifier ce champ. Il s'agit du seul champ en lecture seule de l'objet `request`.

**`uri`**  
Chemin d’accès relatif de l’objet demandé.   
Si votre fonction modifie la valeur `uri`, les règles suivantes s’appliquent :  
+ La nouvelle valeur `uri` doit commencer par une barre oblique (`/`).
+ Lorsqu'une fonction modifie la valeur `uri`, elle change l'objet que l'utilisateur demande.
+ Quand une fonction modifie la valeur `uri`, elle *ne modifie pas* le comportement de cache pour la demande ni l'origine vers laquelle la demande d'origine est envoyée.

**`querystring`**  
Objet qui représente la chaîne de requête dans la requête. Si la demande n'inclut pas de chaîne de requête, l'objet `request` inclut néanmoins un objet `querystring` vide.  
L'objet `querystring` comporte un champ pour chaque paramètre de chaîne de requête dans la requête.

**`headers`**  
Objet qui représente les en-têtes HTTP dans la requête. Si la requête contient des en-têtes `Cookie`, ces derniers ne font pas partie de l'objet `headers`. Les cookies sont représentés séparément dans l'objet `cookies`.  
L'objet `headers` comporte un champ pour chaque en-tête de la requête. Les noms des en-têtes sont convertis en minuscules ASCII dans l’objet d’événement, et les noms des en-têtes doivent être en minuscules ASCII lorsqu’ils sont ajoutés par votre code de fonction. Lorsque CloudFront Functions reconvertit l'objet d'événement en requête HTTP, la première lettre de chaque mot dans les noms d'en-tête est en majuscule, s'il s'agit d'une lettre ASCII. CloudFront Functions n'applique aucune modification aux symboles non ASCII dans les noms d'en-tête. Par exemple, `TÈst-header` deviendra `tÈst-header` à l’intérieur de la fonction. Le symbole non ASCII `È` est inchangé.  
Les mots sont séparés par un trait d’union (`-`). Par exemple, si votre code de fonction ajoute un en-tête nommé`example-header-name`, il le CloudFront convertit en en-tête `Example-Header-Name` dans la requête HTTP.

**`cookies`**  
Objet qui représente les cookies dans la requête (en-têtes `Cookie`).  
L'objet `cookies` comporte un champ pour chaque cookie dans la requête.

Pour plus d'informations sur la structure des chaînes de requêtes, des en-têtes et des cookies, consultez [Structure d'une chaîne de requête, d'un en-tête ou d'un cookie](#functions-event-structure-query-header-cookie).

Pour un exemple d’objet `event`, consultez [Exemple d'objet d'événement](#functions-event-structure-example).

## Objet Réponse
<a name="functions-event-structure-response"></a>

L'`response`objet contient une représentation d'une réponse CloudFront-to-viewer HTTP. Dans l'`event`objet transmis à votre fonction, l'`response`objet représente la réponse réelle CloudFront de l'utilisateur à une demande de consultation.

Si votre code de fonction renvoie un objet `response`, il doit utiliser cette même structure.

L'objet `response` comporte les champs suivants :

**`statusCode`**  
Code de statut HTTP de la réponse. Cette valeur est un entier, pas une chaîne.  
Votre fonction peut générer ou modifier le `statusCode`.

**`statusDescription`**  
Description de l’état HTTP de la réponse. Si votre code de fonction génère une réponse, ce champ est facultatif.

**`headers`**  
Objet qui représente les en-têtes HTTP dans la réponse. Si la réponse contient des en-têtes `Set-Cookie`, ces derniers ne font pas partie de l'objet `headers`. Les cookies sont représentés séparément dans l'objet `cookies`.  
L'objet `headers` comporte un champ pour chaque en-tête de la réponse. Les noms des en-têtes sont convertis en minuscules dans l'objet d'événement, et les noms des en-têtes doivent être en minuscules lorsqu'ils sont ajoutés par votre code de fonction. Lorsque CloudFront Functions reconvertit l'objet d'événement en réponse HTTP, la première lettre de chaque mot des noms d'en-tête est mise en majuscule. Les mots sont séparés par un trait d’union (`-`). Par exemple, si votre code de fonction ajoute un en-tête nommé`example-header-name`, il le CloudFront convertit en `Example-Header-Name` dans la réponse HTTP.

**`cookies`**  
Objet qui représente les cookies dans la réponse (en-têtes `Set-Cookie`).  
L'objet `cookies` comporte un champ pour chaque cookie dans la réponse.

**`body`**  
L'ajout du champ `body` est facultatif et il ne sera pas présent dans l'objet `response` à moins que vous ne le spécifiiez dans votre fonction. Votre fonction n'a pas accès au corps d'origine renvoyé par le CloudFront cache ou l'origine. Si vous ne spécifiez pas le `body` champ dans votre fonction de réponse du spectateur, le corps d'origine renvoyé par le CloudFront cache ou l'origine est renvoyé au visualiseur.  
Si vous CloudFront souhaitez renvoyer un corps personnalisé au visualiseur, spécifiez le contenu du corps dans le `data` champ et le codage du corps dans le `encoding` champ. Vous pouvez spécifier le codage sous forme de texte brut (`"encoding": "text"`) ou de contenu codé en Base64 (`"encoding": "base64"`).  
Comme raccourci, vous pouvez également spécifier le contenu du corps directement dans le champ `body` (`"body": "<specify the body content here>"`). Dans ce cas, omettez les `encoding` champs `data` et. CloudFront traite le corps comme du texte brut dans ce cas.    
`encoding`  
Codage du contenu de `body` (champ `data`). Les seuls encodages valides sont `text` et `base64`.  
Si vous spécifiez `encoding` as `base64` mais que le corps n'est pas valide en base64, CloudFront renvoie une erreur.  
`data`  
Contenu de `body`.

Pour plus d'informations sur les codes de statut modifiés et le contenu du corps, consultez [Code de statut et corps](#functions-event-structure-status-body).

Pour plus d'informations sur la structure des en-têtes et des cookies, consultez [Structure d'une chaîne de requête, d'un en-tête ou d'un cookie](#functions-event-structure-query-header-cookie).

Pour un exemple d’objet `response`, consultez [Exemple d'objet de réponse](#functions-response-structure-example).

## Code de statut et corps
<a name="functions-event-structure-status-body"></a>

Avec CloudFront Functions, vous pouvez mettre à jour le code d'état de la réponse du lecteur, remplacer l'intégralité du corps de la réponse par un nouveau ou supprimer le corps de la réponse. Parmi les scénarios courants de mise à jour de la réponse du spectateur après avoir évalué certains aspects de la réponse provenant du CloudFront cache ou de l'origine, citons les suivants :
+ Modification du statut pour définir un code de statut HTTP 200 et création d'un contenu de corps statique à renvoyer à l'utilisateur.
+ Modification du statut pour définir un code de statut HTTP 301 ou 302 afin de rediriger l'utilisateur vers un autre site Web.
+ Décider de diffuser ou de supprimer le corps de la réponse d'utilisateur.

**Note**  
Si l'origine renvoie une erreur HTTP supérieure ou égale à 400, la CloudFront fonction ne sera pas exécutée. Pour de plus amples informations, veuillez consulter [Restrictions sur toutes les fonctions périphériques](edge-function-restrictions-all.md).

Lorsque vous travaillez avec la réponse HTTP, CloudFront Functions n'a pas accès au corps de la réponse. Vous pouvez remplacer le contenu du corps en lui attribuant la valeur souhaitée, ou supprimer le corps en définissant une valeur vide. Si vous ne mettez pas à jour le champ body de votre fonction, le corps d'origine renvoyé par le CloudFront cache ou l'origine est renvoyé au visualiseur.

**Astuce**  
Lorsque vous utilisez CloudFront des fonctions pour remplacer un corps, veillez à aligner les en-têtes correspondants, tels que`content-encoding`, ou `content-type``content-length`, sur le nouveau contenu du corps.   
Par exemple, si l' CloudFront origine ou le cache sont renvoyés `content-encoding: gzip` mais que la fonction de réponse de l'utilisateur définit un corps en texte brut, la fonction doit également modifier `content-type` les en-têtes `content-encoding` et en conséquence.

Si votre CloudFront fonction est configurée pour renvoyer une erreur HTTP de 400 ou plus, votre lecteur ne verra pas la [page d'erreur personnalisée](creating-custom-error-pages.md) que vous avez spécifiée pour le même code d'état.

## Structure d'une chaîne de requête, d'un en-tête ou d'un cookie
<a name="functions-event-structure-query-header-cookie"></a>

Les chaînes de requête, les en-têtes et les cookies partagent la même structure. Les chaînes de requête peuvent apparaître dans les demandes. Les en-têtes apparaissent dans les demandes et les réponses. Les cookies apparaissent dans les demandes et les réponses.

Chaque chaîne de requête, en-tête ou cookie est un champ unique au sein de l'objet parent `querystring`, `headers` ou `cookies`. Le nom du champ est le nom de la chaîne de requête, de l'en-tête ou du cookie. Chaque champ comporte une propriété `value` avec la valeur de la chaîne de requête, de l'en-tête ou du cookie.

**Contents**
+ [Valeurs de chaînes de requête ou objets de chaîne de requête](#functions-event-structure-query)
+ [Considérations spéciales pour les en-têtes](#functions-event-structure-headers)
+ [Dupliquer les chaînes de requêtes, les en-têtes et les cookies (tableau `multiValue`)](#functions-event-structure-multivalue)
+ [Attributs de cookies](#functions-event-structure-cookie-attributes)

### Valeurs de chaînes de requête ou objets de chaîne de requête
<a name="functions-event-structure-query"></a>

Une fonction peut renvoyer une valeur de chaîne de requête en plus d'un objet de chaîne de requête. La valeur de chaîne de requête peut être utilisée pour organiser les paramètres de chaîne de requête dans n'importe quel ordre personnalisé. 

**Example Exemple**  
Pour modifier une chaîne de requête dans le code d’une fonction, utilisez un code analogue au suivant.  

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

### Considérations spéciales pour les en-têtes
<a name="functions-event-structure-headers"></a>

Pour les en-têtes uniquement, les noms des en-têtes sont convertis en minuscules dans l'objet d'événement, et les noms des en-têtes doivent être en minuscules lorsqu'ils sont ajoutés par votre code de fonction. Lorsque CloudFront Functions reconvertit l'objet d'événement en requête ou réponse HTTP, la première lettre de chaque mot des noms d'en-tête est mise en majuscule. Les mots sont séparés par un trait d’union (`-`). Par exemple, si votre code de fonction ajoute un en-tête nommé`example-header-name`, il le CloudFront convertit `Example-Header-Name` dans la requête ou la réponse HTTP.

**Example Exemple**  
Examinez l’en-tête `Host` suivant dans une demande HTTP.  

```
Host: video.example.com
```
Cet en-tête est représenté comme suit dans l'objet `request` :  

```
"headers": {
    "host": {
        "value": "video.example.com"
    }
}
```
Pour accéder à l'en-tête `Host` dans votre code de fonction, utilisez le code comme suit :  

```
var request = event.request;
var host = request.headers.host.value;
```
Pour ajouter ou modifier un en-tête dans votre code de fonction, utilisez le code suivant (ce code ajoute un en-tête nommé `X-Custom-Header` avec la valeur `example value`) :  

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

### Dupliquer les chaînes de requêtes, les en-têtes et les cookies (tableau `multiValue`)
<a name="functions-event-structure-multivalue"></a>

Une requête ou une réponse HTTP peut contenir plusieurs chaînes de requêtes, en-têtes ou cookies portant le même nom. Dans ce cas, les chaînes de requêtes, les en-têtes ou les cookies en double sont regroupés dans un champ de l'objet `request` ou `response`, mais ce champ comporte une propriété supplémentaire nommée `multiValue`. La propriété `multiValue` contient un tableau avec les valeurs de chacun des en-têtes, cookies ou chaînes de requêtes dupliqués.

**Example Exemple**  
Imaginons une requête HTTP qui inclut les en-têtes `Accept` suivants.  

```
Accept: application/json
Accept: application/xml
Accept: text/html
```
Ces en-têtes sont représentés comme suit dans l’objet `request`.  

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

**Note**  
La première valeur d’en-tête (dans ce cas, `application/json`) est répétée dans les propriétés `value` et `multiValue`. Cela vous permet d'accéder à *toutes* les valeurs en faisant une boucle dans le tableau `multiValue`.

Si le code de votre fonction modifie une chaîne de requête, un en-tête ou un cookie contenant un `multiValue` tableau, CloudFront Functions applique les règles suivantes pour appliquer les modifications :

1. Si le tableau `multiValue` existe et comporte des modifications, ces dernières sont appliquées. Le premier élément de la propriété `value` est ignoré.

1. Sinon, toute modification apportée à la propriété `value` est appliquée, et les valeurs suivantes (si elles existent) restent inchangées.

La propriété `multiValue` est utilisée uniquement lorsque la requête ou la réponse HTTP contient des chaînes de requêtes, des en-têtes ou des cookies en double portant le même nom, comme indiqué dans l'exemple précédent. Toutefois, s'il existe plusieurs valeurs dans un seul en-tête, cookie ou chaîne de requête, la propriété `multiValue` n'est pas utilisée.

**Example Exemple**  
Prenons l’exemple d’une demande avec un en-tête `Accept` contenant trois valeurs.  

```
Accept: application/json, application/xml, text/html
```
Cet en-tête est représenté comme suit dans l’objet `request`.  

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

### Attributs de cookies
<a name="functions-event-structure-cookie-attributes"></a>

Dans un en-tête `Set-Cookie` d'une réponse HTTP, l'en-tête contient la paire nom-valeur du cookie et éventuellement un ensemble d'attributs séparés par des points-virgules. 

**Example Exemple**  

```
Set-Cookie: cookie1=val1; Secure; Path=/; Domain=example.com; Expires=Wed, 05 Apr 2021 07:28:00 GMT
```
Dans l'objet `response`, ces attributs sont représentés dans la propriété `attributes` du champ cookie. Par exemple, l'en-tête `Set-Cookie` précédent est représenté comme suit :  

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

## Exemple d'objet de réponse
<a name="functions-response-structure-example"></a>

L'exemple suivant montre un objet `response` (la sortie d'une fonction de réponse d'utilisateur) dans lequel le corps a été remplacé par une fonction de réponse d'utilisateur.

```
{
  "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>"
    }
  }
}
```

## Exemple d'objet d'événement
<a name="functions-event-structure-example"></a>

L'exemple suivant illustre un objet `event` complet. Il s’agit d’un exemple d’invocation pour une distribution standard, et non pour une distribution multi-locataires. Pour les distributions multi-locataires, le `endpoint` champ est utilisé à la place de `distributionDomainName` La valeur de `endpoint` est le nom de CloudFront domaine (par exemple, d111111abcdef8.cloudfront.net) du groupe de connexion associé à l'événement.

**Note**  
L'objet `event` représente l'entrée de votre fonction. Votre fonction renvoie uniquement l'objet `request` ou `response`, et non l'objet `event` complet.

```
{
    "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 fonctionnalités d'exécution pour CloudFront Functions
<a name="functions-javascript-runtime-features"></a>

L'environnement JavaScript d'exécution CloudFront Functions est compatible avec [ECMAScript (ES) version 5.1](https://www.ecma-international.org/ecma-262/5.1/) et prend également en charge certaines fonctionnalités des versions ES 6 à 12.

Pour la plupart des up-to-date fonctionnalités, nous vous recommandons JavaScript d'utiliser Runtime 2.0. 

Les fonctionnalités JavaScript d'exécution 2.0 présentent les modifications suivantes par rapport à la version 1.0 :
+ Les méthodes du module Buffer sont disponibles
+ Les méthodes de prototype de chaîne non standard suivantes ne sont pas disponibles :
  + `String.prototype.bytesFrom()`
  + `String.prototype.fromBytes()`
  + `String.prototype.fromUTF8()`
  + `String.prototype.toBytes()`
  + `String.prototype.toUTF8()`
+ Voici les nouveautés du module cryptographique :
  + `hash.digest()` : le type de retour est remplacé par `Buffer` si aucun encodage n’est fourni
  + `hmac.digest()` : le type de retour est remplacé par `Buffer` si aucun encodage n’est fourni
+ Pour plus d’informations sur les nouvelles fonctionnalités supplémentaires, consultez [JavaScript fonctionnalités d'exécution 2.0 pour CloudFront Functions](functions-javascript-runtime-20.md).

**Topics**
+ [JavaScript fonctionnalités de Runtime 1.0](functions-javascript-runtime-10.md)
+ [JavaScript fonctionnalités de Runtime 2.0](functions-javascript-runtime-20.md)

# JavaScript fonctionnalités de Runtime 1.0 pour CloudFront Functions
<a name="functions-javascript-runtime-10"></a>

L'environnement JavaScript d'exécution CloudFront Functions est compatible avec [ECMAScript (ES) version 5.1](https://262.ecma-international.org/5.1/) et prend également en charge certaines fonctionnalités des versions ES 6 à 9. Il fournit également des méthodes non standard qui ne font pas partie des spécifications ES. 

Les rubriques suivantes répertorient toutes les fonctions de langages prises en charge.

**Topics**
+ [Fonctions de base](#writing-functions-javascript-features-core)
+ [Objets primitifs](#writing-functions-javascript-features-primitive-objects)
+ [Objets intégrés](#writing-functions-javascript-features-builtin-objects)
+ [Types d’erreurs](#writing-functions-javascript-features-error-types)
+ [Globals](#writing-functions-javascript-features-globals)
+ [Modules intégrés](#writing-functions-javascript-features-builtin-modules)
+ [Fonctions limitées](#writing-functions-javascript-features-restricted-features)

## Fonctions de base
<a name="writing-functions-javascript-features-core"></a>

Les fonctions de base suivantes d'ES sont prises en charge.

**Types**  
Tous les types ES 5.1 sont pris en charge, notamment les valeurs booléennes, les nombres, les chaînes, les objets, les tableaux, les fonctions, les constructeurs de fonctions et les expressions régulières.

**Opérateurs**  
Tous les opérateurs ES 5.1 sont pris en charge.  
L’opérateur d’exponentiation ES 7 (`**`) est pris en charge.

**Instructions**  
Les instructions `const` et `let` ne sont pas prises en charge.
Les instructions ES 5.1 suivantes sont prises en charge :  
+ `break`
+ `catch`
+ `continue`
+ `do-while`
+ `else`
+ `finally`
+ `for`
+ `for-in`
+ `if`
+ `return`
+ `switch`
+ `throw`
+ `try`
+ `var`
+ `while`
+ Instructions étiquetées

**Littéraux**  
Les littéraux de modèles ES 6 sont pris en charge : chaînes multiligne, interpolation d'expression et modèles d'imbrication.

**Fonctions**  
Toutes les fonctions ES 5.1 sont prises en charge.  
Les fonctions de flèche ES 6 ainsi que la syntaxe des paramètres du reste ES 6 sont prises en charge.

**Unicode**  
Le texte source et les littéraux de chaînes peuvent contenir des caractères Unicode. Les séquences d’échappement de points de code Unicode de six caractères (par exemple `\uXXXX`) sont également prises en charge.

**Mode strict**  
Les fonctions opèrent en mode strict par défaut. Vous n’avez donc pas besoin d’ajouter une instruction `use strict` dans votre code de fonction. Elles ne peuvent pas être modifiées.

## Objets primitifs
<a name="writing-functions-javascript-features-primitive-objects"></a>

Les objets primitifs suivants d'ES sont pris en charge.

**Objet**  
Les méthodes ES 5.1 suivantes sur les objets sont prises en charge :  
+ `create` (sans liste de propriétés)
+ `defineProperties`
+ `defineProperty`
+ `freeze`
+ `getOwnPropertyDescriptor`
+ `getOwnPropertyNames`
+ `getPrototypeOf`
+ `hasOwnProperty`
+ `isExtensible`
+ `isFrozen`
+ `prototype.isPrototypeOf`
+ `isSealed`
+ `keys`
+ `preventExtensions`
+ `prototype.propertyIsEnumerable`
+ `seal`
+ `prototype.toString`
+ `prototype.valueOf`
Les méthodes ES 6 suivantes sur les objets sont prises en charge :  
+ `assign`
+ `is`
+ `prototype.setPrototypeOf`
Les méthodes ES 8 suivantes sur les objets sont prises en charge :  
+ `entries`
+ `values`

**String**  
Les méthodes ES 5.1 suivantes sur les chaînes sont prises en charge :  
+ `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`
Les méthodes ES 6 suivantes sur les chaînes sont prises en charge :  
+ `fromCodePoint`
+ `prototype.codePointAt`
+ `prototype.endsWith`
+ `prototype.includes`
+ `prototype.repeat`
+ `prototype.startsWith`
Les méthodes ES 8 suivantes sur les chaînes sont prises en charge :  
+ `prototype.padStart`
+ `prototype.padEnd`
Les méthodes ES 9 suivantes sur les chaînes sont prises en charge :  
+ `prototype.trimStart`
+ `prototype.trimEnd`
Les méthodes non standard suivantes sur les chaînes sont prises en charge :  
+ `prototype.bytesFrom(array | string, encoding)`

  Crée une chaîne d'octets à partir d'un tableau d'octets ou d'une chaîne encodée. Les options d'encodage de chaînes sont `hex`, `base64` et `base64url`.
+ `prototype.fromBytes(start[, end])`

  Crée une chaîne Unicode à partir d'une chaîne d'octets où chaque octet est remplacé par le point de code Unicode correspondant.
+ `prototype.fromUTF8(start[, end])`

  Crée une chaîne Unicode à partir d'une chaîne d'octets encodée en UTF-8. Si l'encodage est incorrect, il renvoie `null`.
+ `prototype.toBytes(start[, end])`

  Crée une chaîne d'octets à partir d'une chaîne Unicode. Tous les caractères doivent être dans la plage [0,255]. Dans le cas contraire, `null` est renvoyé.
+ `prototype.toUTF8(start[, end])`

  Crée une chaîne d'octets encodée en UTF-8 à partir d'une chaîne Unicode.

**Nombre**  
Toutes les méthodes ES 5.1 sur les nombres sont prises en charge.  
Les méthodes ES 6 suivantes sur les nombres sont prises en charge :  
+ `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`

## Objets intégrés
<a name="writing-functions-javascript-features-builtin-objects"></a>

Les objets intégrés suivants d'ES sont pris en charge.

**Mathématiques**  
Toutes les méthodes mathématiques ES 5.1 sont prises en charge.  
Dans l'environnement d'exécution de CloudFront Functions, l'`Math.random()`implémentation utilise `arc4random` OpenBSD prédéfini avec l'horodatage de l'exécution de la fonction.
Les méthodes mathématiques ES 6 suivantes sont prises en charge :  
+ `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`

**Date**  
Toutes les fonctions `Date` ES 5.1 sont prises en charge.  
Pour des raisons de sécurité, `Date` renvoie toujours la même valeur (l’heure de début de la fonction) pendant la durée de vie d’une même exécution de la fonction. Pour plus d’informations, consultez [Fonctions limitées](#writing-functions-javascript-features-restricted-features).

**Fonction**  
Les méthodes `apply`, `bind` et `call` sont prises en charge.  
Les constructeurs de fonctions ne sont pas pris en charge.

**Expressions régulières**  
Toutes les fonctions d'expression régulière ES 5.1 sont prises en charge. Le langage d’expression régulière est compatible Perl. Les groupes de capture nommés ES 9 sont pris en charge.

**JSON**  
Toutes les fonctions JSON ES 5.1 sont prises en charge, notamment `parse` et `stringify`.

**Array**  
Les méthodes ES 5.1 suivantes sur les tableaux sont prises en charge :  
+ `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`
Les méthodes ES 6 suivantes sur les tableaux sont prises en charge :  
+ `of`
+ `prototype.copyWithin`
+ `prototype.fill`
+ `prototype.find`
+ `prototype.findIndex`
Les méthodes ES 7 suivantes sur les tableaux sont prises en charge :  
+ `prototype.includes`

**Tableaux typés**  
Les tableaux typés ES 6 suivants sont pris en charge :  
+ `Int8Array`
+ `Uint8Array`
+ `Uint8ClampedArray`
+ `Int16Array`
+ `Uint16Array`
+ `Int32Array`
+ `Uint32Array`
+ `Float32Array`
+ `Float64Array`
+ `prototype.copyWithin`
+ `prototype.fill`
+ `prototype.join`
+ `prototype.set`
+ `prototype.slice`
+ `prototype.subarray`
+ `prototype.toString`

**ArrayBuffer**  
Les méthodes suivantes sur `ArrayBuffer` sont prises en charge :  
+ `prototype.isView`
+ `prototype.slice`

**Promesse**  
Les méthodes suivantes sur les promesses sont prises en charge :  
+ `reject`
+ `resolve`
+ `prototype.catch`
+ `prototype.finally`
+ `prototype.then`

**Cryptographie**  
Le module cryptographique fournit des aides standard en matière de hachage et de code d'authentification de message basé sur le hachage (HMAC). Vous pouvez charger le module en utilisant `require('crypto')`. Le module fournit les méthodes suivantes, qui se comportent exactement comme leurs homologues Node.js :  
+ `createHash(algorithm)`
+ `hash.update(data)`
+ `hash.digest([encoding])`
+ `createHmac(algorithm, secret key)`
+ `hmac.update(data)`
+ `hmac.digest([encoding])`
Pour plus d'informations, consultez [Cryptographie (hachage et HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) dans la section Modules intégrés.

**Console**  
Il s'agit d'un objet d'aide pour le débogage. Il ne prend en charge que la méthode `log()`, pour enregistrer les messages de journaux.  
CloudFront Les fonctions ne prennent pas en charge la syntaxe des virgules, telle que`console.log('a', 'b')`. Utilisez plutôt le format `console.log('a' + ' ' + 'b')`.

## Types d’erreurs
<a name="writing-functions-javascript-features-error-types"></a>

Les objets d’erreurs suivants sont pris en charge :
+ `Error`
+ `EvalError`
+ `InternalError`
+ `MemoryError`
+ `RangeError`
+ `ReferenceError`
+ `SyntaxError`
+ `TypeError`
+ `URIError`

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

L’objet `globalThis` est pris en charge.

Les fonctions globales ES 5.1 suivantes sont prises en charge :
+ `decodeURI`
+ `decodeURIComponent`
+ `encodeURI`
+ `encodeURIComponent`
+ `isFinite`
+ `isNaN`
+ `parseFloat`
+ `parseInt`

Les constantes globales suivantes sont prises en charge :
+ `NaN`
+ `Infinity`
+ `undefined`

## Modules intégrés
<a name="writing-functions-javascript-features-builtin-modules"></a>

Les modules intégrés suivants sont pris en charge.

**Topics**
+ [Cryptographie (hachage et HMAC)](#writing-functions-javascript-features-builtin-modules-crypto)
+ [Chaîne de requête](#writing-functions-javascript-features-builtin-modules-query-string)

### Cryptographie (hachage et HMAC)
<a name="writing-functions-javascript-features-builtin-modules-crypto"></a>

Le module cryptographique (`crypto`) fournit des aides standard en matière de hachage et de code d’authentification de message basé sur le hachage (HMAC). Vous pouvez charger le module en utilisant `require('crypto')`. Le module fournit les méthodes suivantes, qui se comportent exactement comme leurs homologues Node.js.

**Méthodes de hachage**

`crypto.createHash(algorithm)`  
Crée et renvoie un objet de hachage que vous pouvez utiliser pour générer des résumés de hachage à l’aide de l’algorithme donné : `md5`, `sha1` ou `sha256`.

`hash.update(data)`  
Met à jour le contenu de hachage avec les `data` données

`hash.digest([encoding])`  
Calcule le résumé de toutes les données transmises à l’aide de `hash.update()`. L’encodage peut être `hex`, `base64` ou `base64url`.

**Méthodes HMAC**

`crypto.createHmac(algorithm, secret key)`  
Crée et renvoie un objet HMAC qui utilise le `algorithm` et la `secret key` donnés. L’algorithme peut être `md5`, `sha1` ou `sha256`.

`hmac.update(data)`  
Met à jour le contenu HMAC avec les `data` données.

`hmac.digest([encoding])`  
Calcule le résumé de toutes les données transmises à l’aide de `hmac.update()`. L’encodage peut être `hex`, `base64` ou `base64url`.

### Chaîne de requête
<a name="writing-functions-javascript-features-builtin-modules-query-string"></a>

**Note**  
L'[objet d'événement CloudFront Functions](functions-event-structure.md) analyse automatiquement les chaînes de requête d'URL pour vous. Cela signifie que, dans la plupart des cas, vous n'avez pas besoin d'utiliser ce module.

Le module de chaînes de requêtes (`querystring`) fournit des méthodes d’analyse et de formatage des chaînes de requêtes URL. Vous pouvez charger le module en utilisant `require('querystring')`. Le module fournit les méthodes suivantes :

`querystring.escape(string)`  
Encode par URL la `string` donnée, en renvoyant une chaîne de requêtes échappée. La méthode est utilisée par `querystring.stringify()` et ne doit pas être utilisée directement.

`querystring.parse(string[, separator[, equal[, options]]])`  
Analyse une chaîne de requêtes (`string`) et renvoie un objet.  
Le paramètre `separator` est une sous-chaîne permettant de délimiter les paires clé-valeur dans la chaîne de requêtes. Par défaut, il s’agit de `&`.  
Le paramètre `equal` est une sous-chaîne permettant de délimiter les clés et les valeurs dans la chaîne de requêtes. Par défaut, il s’agit de `=`.  
Le paramètre `options` est un objet avec les clés suivantes :    
`decodeURIComponent function`  
Fonction pour décoder les caractères encodés en pourcentage dans la chaîne de requêtes. Par défaut, il s’agit de `querystring.unescape()`.  
`maxKeys number`  
Nombre maximal de clés à analyser. Par défaut, il s’agit de `1000`. Utilisez une valeur de `0` pour supprimer les limitations pour le comptage des clés.
Par défaut, les caractères encodés en pourcentage dans la chaîne de requêtes sont supposés utiliser l'encodage UTF-8. Les séquences UTF-8 non valides sont remplacées par le caractère de remplacement `U+FFFD`.  
Par exemple, pour la chaîne de requêtes suivante :  

```
'name=value&abc=xyz&abc=123'
```
La valeur renvoyée de `querystring.parse()` est :  

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

`querystring.stringify(object[, separator[, equal[, options]]])`  
Sérialise un `object` et renvoie une chaîne de requêtes.  
Le paramètre `separator` est une sous-chaîne permettant de délimiter les paires clé-valeur dans la chaîne de requêtes. Par défaut, il s’agit de `&`.  
Le paramètre `equal` est une sous-chaîne permettant de délimiter les clés et les valeurs dans la chaîne de requêtes. Par défaut, il s’agit de `=`.  
Le paramètre `options` est un objet avec les clés suivantes :    
`encodeURIComponent function`  
Fonction à utiliser pour convertir des caractères non sûrs pour une URL en encodage en pourcentage dans la chaîne de requêtes. Par défaut, il s’agit de `querystring.escape()`.
Par défaut, les caractères qui nécessitent un encodage en pourcentage dans la chaîne de requêtes sont encodés en UTF-8. Pour utiliser un encodage différent, spécifiez l’option `encodeURIComponent`.  
Par exemple, pour le code suivant :  

```
querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' });
```
La valeur renvoyée est :  

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

`querystring.unescape(string)`  
Décode les caractères encodés en pourcentage URL dans la `string` donnée, en renvoyant une chaîne de requêtes non échappée. Cette méthode est utilisée par `querystring.parse()` et ne doit pas être utilisée directement.

## Fonctions limitées
<a name="writing-functions-javascript-features-restricted-features"></a>

Les fonctionnalités JavaScript linguistiques suivantes ne sont pas prises en charge ou sont restreintes pour des raisons de sécurité.

**Évaluation dynamique du code**  
L'évaluation dynamique du code n'est pas prise en charge. Les deux constructeurs `eval()` et `Function` renvoient une erreur en cas de tentative. Par exemple, `const sum = new Function('a', 'b', 'return a + b')` renvoie une erreur.

**Temporisateurs**  
Les fonctions `setTimeout()`, `setImmediate()` et `clearTimeout()` ne sont pas prises en charge. Il n'y a aucune disposition relative au report ou au produit dans une exécution de fonction. Votre fonction doit s'exécuter de manière synchrone jusqu'à la fin.

**Horodatages**  
Pour des raisons de sécurité, il n'y a pas d'accès aux temporisateurs haute résolution. Toutes les méthodes `Date` pour interroger l’heure actuelle retournent toujours la même valeur pendant la durée de vie d’une même exécution de la fonction. L'horodatage renvoyé est l'heure à laquelle la fonction a commencé à s'exécuter. Par conséquent, vous ne pouvez pas mesurer le temps écoulé dans votre fonction.

**Accès au système de fichiers**  
Il n’y a pas d’accès au système de fichiers. Par exemple, il n’y a pas de module `fs` pour l’accès au système de fichiers comme dans Node.js.

**Accès au traitement**  
Il n’y a aucun accès au traitement. Par exemple, il n’existe pas d’objet global `process` pour accéder aux informations de traitement, comme c’est le cas dans Node.js.

**Variables d’environnement**  
Il n’y a aucun accès aux variables d’environnement.   
Vous pouvez plutôt créer une banque CloudFront KeyValueStore de données centralisée de paires clé-valeur pour vos fonctions. CloudFront CloudFront KeyValueStore permet des mises à jour dynamiques de vos données de configuration sans qu'il soit nécessaire de déployer des modifications de code. Vous devez utiliser [JavaScript Runtime 2.0](functions-javascript-runtime-20.md) pour utiliser CloudFront KeyValueStore. Pour de plus amples informations, veuillez consulter [Amazon CloudFront KeyValueStore](kvs-with-functions.md).

**Accès réseau**  
Les appels réseau ne sont pas pris en charge. Par exemple, XHR, HTTP(S) et socket ne sont pas pris en charge.

# JavaScript fonctionnalités d'exécution 2.0 pour CloudFront Functions
<a name="functions-javascript-runtime-20"></a>

L'environnement JavaScript d'exécution CloudFront Functions est compatible avec [ECMAScript (ES) version 5.1](https://262.ecma-international.org/5.1/) et prend également en charge certaines fonctionnalités des versions ES 6 à 12. Il fournit également des méthodes non standard qui ne font pas partie des spécifications ES. Les rubriques suivantes répertorient toutes les fonctionnalités de cet environnement d’exécution.

**Topics**
+ [Fonctions de base](#writing-functions-javascript-features-core-20)
+ [Objets primitifs](#writing-functions-javascript-features-primitive-objects-20)
+ [Objets intégrés](#writing-functions-javascript-features-builtin-objects-20)
+ [Types d’erreurs](#writing-functions-javascript-features-error-types-20)
+ [Globals](#writing-functions-javascript-features-globals-20)
+ [Modules intégrés](#writing-functions-javascript-features-builtin-modules-20)
+ [Fonctions limitées](#writing-functions-javascript-features-restricted-features-20)

## Fonctions de base
<a name="writing-functions-javascript-features-core-20"></a>

Les fonctions de base suivantes d'ES sont prises en charge.

**Types**  
Tous les types ES 5.1 sont pris en charge, notamment les valeurs booléennes, les nombres, les chaînes, les objets, les tableaux, les fonctions et les expressions régulières.

**Opérateurs**  
Tous les opérateurs ES 5.1 sont pris en charge.  
L’opérateur d’exponentiation ES 7 (`**`) est pris en charge.

**Instructions**  
Les instructions ES 5.1 suivantes sont prises en charge :  
+ `break`
+ `catch`
+ `continue`
+ `do-while`
+ `else`
+ `finally`
+ `for`
+ `for-in`
+ `if`
+ `label`
+ `return`
+ `switch`
+ `throw`
+ `try`
+ `var`
+ `while`
Les instructions ES 6 suivantes sont prises en charge :  
+ `const`
+ `let`
Les instructions ES 8 suivantes sont prises en charge :  
+ `async`
+ `await`
`async`, `await``const`, et `let` sont pris en charge dans JavaScript Runtime 2.0.  
`await` ne peut être utilisé qu’à l’intérieur de fonctions `async`. Les arguments et fermetures `async` ne sont pas pris en charge.

**Littéraux**  
Les littéraux de modèles ES 6 sont pris en charge : chaînes multiligne, interpolation d'expression et modèles d'imbrication.

**Fonctions**  
Toutes les fonctions ES 5.1 sont prises en charge.  
Les fonctions de flèche ES 6 ainsi que la syntaxe des paramètres du reste ES 6 sont prises en charge.

**Unicode**  
Le texte source et les littéraux de chaînes peuvent contenir des caractères Unicode. Les séquences d’échappement de points de code Unicode de six caractères (par exemple `\uXXXX`) sont également prises en charge.

**Mode strict**  
Les fonctions opèrent en mode strict par défaut. Vous n’avez donc pas besoin d’ajouter une instruction `use strict` dans votre code de fonction. Elles ne peuvent pas être modifiées.

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

Les objets primitifs suivants d'ES sont pris en charge.

**Objet**  
Les méthodes ES 5.1 suivantes sur les objets sont prises en charge :  
+ `Object.create()` (sans liste de propriétés)
+ `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()`
Les méthodes ES 6 suivantes sur les objets sont prises en charge :  
+ `Object.assign()`
Les méthodes ES 8 suivantes sur les objets sont prises en charge :  
+ `Object.entries()`
+ `Object.values()`
Les méthodes de prototype d’ES 5.1 suivantes sur les objets sont prises en charge :  
+ `Object.prototype.hasOwnProperty()`
+ `Object.prototype.isPrototypeOf()`
+ `Object.prototype.propertyIsEnumerable()`
+ `Object.prototype.toString()`
+ `Object.prototype.valueOf()`
Les méthodes de prototype d’ES 6 suivantes sur les objets sont prises en charge :  
+ `Object.prototype.is()`
+ `Object.prototype.setPrototypeOf()`

**String**  
Les méthodes ES 5.1 suivantes sur les chaînes sont prises en charge :  
+ `String.fromCharCode()`
Les méthodes ES 6 suivantes sur les chaînes sont prises en charge :  
+ `String.fromCodePoint()`
Les méthodes de prototype d’ES 5.1 suivantes sur les chaînes sont prises en charge :  
+ `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()`
Les méthodes de prototype d’ES 6 suivantes sur les chaînes sont prises en charge :  
+ `String.prototype.codePointAt()`
+ `String.prototype.endsWith()`
+ `String.prototype.includes()`
+ `String.prototype.repeat()`
+ `String.prototype.startsWith()`
Les méthodes de prototype d’ES 8 suivantes sur les chaînes sont prises en charge :  
+ `String.prototype.padStart()`
+ `String.prototype.padEnd()`
Les méthodes de prototype d’ES 9 suivantes sur les chaînes sont prises en charge :  
+ `String.prototype.trimStart()`
+ `String.prototype.trimEnd()`
Les méthodes de prototype d’ES 12 suivantes sur les chaînes sont prises en charge :  
+ `String.prototype.replaceAll()`
**Note**  
`String.prototype.replaceAll()`est nouveau dans JavaScript Runtime 2.0.

**Number**  
TOUS les nombres d’ES 5 sont pris en charge.  
Les propriétés d’ES 6 suivantes sur les nombres sont prises en charge :  
+ `Number.EPSILON`
+ `Number.MAX_SAFE_INTEGER`
+ `Number.MIN_SAFE_INTEGER`
+ `Number.MAX_VALUE`
+ `Number.MIN_VALUE`
+ `Number.NaN`
+ `Number.NEGATIVE_INFINITY`
+ `Number.POSITIVE_INFINITY`
Les méthodes ES 6 suivantes sur les nombres sont prises en charge :  
+ `Number.isFinite()`
+ `Number.isInteger()`
+ `Number.isNaN()`
+ `Number.isSafeInteger()`
+ `Number.parseInt()`
+ `Number.parseFloat()`
Les méthodes de prototype d’ES 5.1 suivantes sur les nombres sont prises en charge :  
+ `Number.prototype.toExponential()`
+ `Number.prototype.toFixed()`
+ `Number.prototype.toPrecision()`
Les séparateurs numériques d’ES 12 sont pris en charge.  
Les séparateurs numériques ES 12 sont nouveaux dans JavaScript Runtime 2.0.

## Objets intégrés
<a name="writing-functions-javascript-features-builtin-objects-20"></a>

Les objets intégrés suivants d'ES sont pris en charge.

**Mathématiques**  
Toutes les méthodes mathématiques ES 5.1 sont prises en charge.  
Dans l'environnement d'exécution de CloudFront Functions, l'`Math.random()`implémentation utilise `arc4random` OpenBSD prédéfini avec l'horodatage de l'exécution de la fonction.
Les propriétés mathématiques d’ES 6 suivantes sont prises en charge :  
+ `Math.E`
+ `Math.LN10`
+ `Math.LN2`
+ `Math.LOG10E`
+ `Math.LOG2E`
+ `Math.PI`
+ `Math.SQRT1_2`
+ `Math.SQRT2`
Les méthodes mathématiques ES 6 suivantes sont prises en charge :  
+ `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()`

**Date**  
Toutes les fonctions `Date` ES 5.1 sont prises en charge.  
Pour des raisons de sécurité, `Date` renvoie toujours la même valeur (l’heure de début de la fonction) pendant la durée de vie d’une même exécution de la fonction. Pour plus d’informations, consultez [Fonctions limitées](functions-javascript-runtime-10.md#writing-functions-javascript-features-restricted-features).

**Fonction**  
Les méthodes de prototype d’ES 5.1 suivantes sont prises en charge :  
+ `Function.prototype.apply()`
+ `Function.prototype.bind()`
+ `Function.prototype.call()`
Les constructeurs de fonctions ne sont pas pris en charge.

**Expressions régulières**  
Toutes les fonctions d'expression régulière ES 5.1 sont prises en charge. Le langage d’expression régulière est compatible Perl.  
Les propriétés d’accesseur de prototype d’ES 5.1 suivantes sont prises en charge :  
+ `RegExp.prototype.global`
+ `RegExp.prototype.ignoreCase`
+ `RegExp.protoype.multiline`
+ `RegExp.protoype.source`
+ `RegExp.prototype.sticky`
+ `RegExp.prototype.flags`
**Note**  
`RegExp.prototype.sticky`et `RegExp.prototype.flags` sont nouveaux dans JavaScript Runtime 2.0.
Les méthodes de prototype d’ES 5.1 suivantes sont prises en charge :  
+ `RegExp.prototype.exec()`
+ `RegExp.prototype.test()`
+ `RegExp.prototype.toString()`
+ `RegExp.prototype[@@replace]()`
+ `RegExp.prototype[@@split]()`
**Note**  
`RegExp.prototype[@@split]()`est nouveau dans JavaScript Runtime 2.0.
Les propriétés d’instance d’ES 5.1 suivantes sont prises en charge :  
+ `lastIndex`
Les groupes de capture nommés ES 9 sont pris en charge.

**JSON**  
Les méthodes d’ES 5.1 suivantes sont prises en charge :  
+ `JSON.parse()`
+ `JSON.stringify()`

**Array**  
Les méthodes ES 5.1 suivantes sur les tableaux sont prises en charge :  
+ `Array.isArray()`
Les méthodes ES 6 suivantes sur les tableaux sont prises en charge :  
+ `Array.of()`
Les méthodes de prototype d’ES 5.1 suivantes sont prises en charge :  
+ `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()`
Les méthodes de prototype d’ES 6 suivantes sont prises en charge :  
+ `Array.prototype.copyWithin()`
+ `Array.prototype.fill()`
+ `Array.prototype.find()`
+ `Array.prototype.findIndex()`
Les méthodes de prototype d’ES 7 suivantes sont prises en charge :  
+ `Array.prototype.includes()`

**Tableaux typés**  
Les constructeurs de tableaux typés d’ES 6 suivants sont pris en charge :  
+ `Float32Array`
+ `Float64Array`
+ `Int8Array`
+ `Int16Array`
+ `Int32Array`
+ `Uint8Array`
+ `Uint8ClampedArray`
+ `Uint16Array`
+ `Uint32Array`
Les méthodes d’ES 6 suivantes sont prises en charge :  
+ `TypedArray.from()`
+ `TypedArray.of()`
**Note**  
`TypedArray.from()`et `TypedArray.of()` sont nouveaux dans JavaScript Runtime 2.0.
Les méthodes de prototype d’ES 6 suivantes sont prises en charge :  
+ `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()`
**Note**  
`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()`, et `TypedArray.prototype.some()` sont nouveaux dans JavaScript Runtime 2.0.

**ArrayBuffer**  
Les méthodes ES 6 suivantes ArrayBuffer sont prises en charge :  
+ `isView()`
Les méthodes de prototypage ES 6 suivantes ArrayBuffer sont prises en charge :  
+ `ArrayBuffer.prototype.slice()`

**Promesse**  
Les méthodes d’ES 6 suivantes sur les promesses sont prises en charge :  
+ `Promise.all()`
+ `Promise.allSettled()`
+ `Promise.any()`
+ `Promise.reject()`
+ `Promise.resolve()`
+ `Promise.race()`
**Note**  
`Promise.all()`, `Promise.allSettled()``Promise.any()`, et `Promise.race()` sont nouveaux dans JavaScript Runtime 2.0.
Les méthodes de prototype d’ES 6 suivantes sur les promesses sont prises en charge :  
+ `Promise.prototype.catch()`
+ `Promise.prototype.finally()`
+ `Promise.prototype.then()`

**DataView**  
Les méthodes de prototype d’ES 6 suivantes sont prises en charge :  
+ `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()`
**Note**  
Toutes les méthodes de prototypage de Dataview ES 6 sont nouvelles dans JavaScript Runtime 2.0.

**Symbol**  
Les méthodes d’ES 6 suivantes sont prises en charge :  
+ `Symbol.for()`
+ `Symbol.keyfor()`
**Note**  
Toutes les méthodes Symbol ES 6 sont nouvelles dans JavaScript Runtime 2.0.

**TextDecoder**  
Les méthodes de prototype suivantes sont prises en charge :  
+ `TextDecoder.prototype.decode()`
Les propriétés d’accesseur de prototype suivantes sont prises en charge :  
+ `TextDecoder.prototype.encoding`
+ `TextDecoder.prototype.fatal`
+ `TextDecoder.prototype.ignoreBOM`

**TextEncoder**  
Les méthodes de prototype suivantes sont prises en charge :  
+ `TextEncoder.prototype.encode()`
+ `TextEncoder.prototype.encodeInto()`

**Console**  
Il s'agit d'un objet d'aide pour le débogage. Il ne prend en charge que la méthode `log()`, pour enregistrer les messages de journaux.  
CloudFront Les fonctions ne prennent pas en charge la syntaxe des virgules, telle que`console.log('a', 'b')`. Utilisez plutôt le format `console.log('a' + ' ' + 'b')`.

## Types d’erreurs
<a name="writing-functions-javascript-features-error-types-20"></a>

Les objets d’erreurs suivants sont pris en charge :
+ `Error`
+ `EvalError`
+ `InternalError`
+ `RangeError`
+ `ReferenceError`
+ `SyntaxError`
+ `TypeError`
+ `URIError`

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

L’objet `globalThis` est pris en charge.

Les fonctions globales ES 5.1 suivantes sont prises en charge :
+ `decodeURI()`
+ `decodeURIComponent()`
+ `encodeURI()`
+ `encodeURIComponent()`
+ `isFinite()`
+ `isNaN()`
+ `parseFloat()`
+ `parseInt()`

Les fonctions globales d’ES 6 suivantes sont prises en charge :
+ `atob()`
+ `btoa()`
**Note**  
`atob()`et `btoa()` sont nouveaux dans JavaScript Runtime 2.0.

Les constantes globales suivantes sont prises en charge :
+ `NaN`
+ `Infinity`
+ `undefined`
+ `arguments`

## Modules intégrés
<a name="writing-functions-javascript-features-builtin-modules-20"></a>

Les modules intégrés suivants sont pris en charge.

**Topics**
+ [Buffer](#writing-functions-javascript-features-builtin-modules-buffer-20)
+ [Chaîne de requête](#writing-functions-javascript-features-builtin-modules-query-string-20)
+ [Cryptographie](#writing-functions-javascript-features-builtin-modules-crypto-20)

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

Le module fournit les méthodes suivantes :
+ `Buffer.alloc(size[, fill[, encoding]])`

  Allouez un élément `Buffer`.
  + `size` : taille du tampon. Entrez un entier.
  + `fill`: Facultatif. Entrez une chaîne, un élément `Buffer`, un élément Uint8Array ou un entier. La valeur par défaut est `0`. 
  + `encoding`: Facultatif. Quand `fill` est une chaîne, entrez l’une des valeurs suivantes : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`.
+ `Buffer.allocUnsafe(size)`

  Allouez un élément `Buffer` non initialisé.
  + `size` : entrez un entier.
+ `Buffer.byteLength(value[, encoding])`

  Renvoie la longueur d’une valeur, en octets.
  + `value`: chaîne, `Buffer` TypedArray, Dataview ou Arraybuffer.
  + `encoding`: Facultatif. Quand `value` est une chaîne, entrez l’une des valeurs suivantes : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`.
+ `Buffer.compare(buffer1, buffer2)`

  Comparez deux éléments `Buffer` pour faciliter le tri des tableaux. Renvoie `0` s’ils sont identiques, `-1` si `buffer1` figure en premier, ou `1` si `buffer2` figure en premier.
  + `buffer1` : entrez un élément `Buffer`.
  + `buffer2` : entrez un autre élément `Buffer`.
+ `Buffer.concat(list[, totalLength])`

  Concaténez plusieurs éléments `Buffer`. Renvoie `0` s’il n’y en a aucun. Renvoie jusqu’à `totalLength`.
  + `list` : entrez une liste d’éléments `Buffer`. Notez que cela sera tronqué à `totalLength`.
  + `totalLength`: Facultatif. Entrez un entier non signé. Utilisez la somme des instances `Buffer` dans la liste si le paramètre est vide.
+ `Buffer.from(array)`

  Créez un élément `Buffer` à partir d’un tableau.
  + `array` : entrez un tableau d’octets de `0` à `255`. 
+ `Buffer.from(arrayBuffer, byteOffset[, length]))`

  Créez une vue à partir de `arrayBuffer`, en commençant par le décalage `byteOffset` avec la longueur `length`.
  + `arrayBuffer` : entrez un tableau `Buffer`.
  + `byteOffset` : entrez un entier.
  + `length`: Facultatif. Entrez un entier.
+ `Buffer.from(buffer)`

  Créez une copie de l’élément `Buffer`.
  + `buffer` : entrez un élément `Buffer`.
+ `Buffer.from(object[, offsetOrEncoding[, length]])`

  Créez un élément `Buffer` à partir d’un objet. Renvoie `Buffer.from(object.valueOf(), offsetOrEncoding, length)` si `valueOf()` n’est pas égal à l’objet.
  + `object` : entrez un objet.
  + `offsetOrEncoding`: Facultatif. Entrez un entier ou une chaîne d’encodage.
  + `length`: Facultatif. Entrez un entier.
+ `Buffer.from(string[, encoding])`

  Créez un élément `Buffer` à partir d’une chaîne.
  + `string` : entrez une chaîne.
  + `encoding`: Facultatif. Entrez l’un des éléments suivants : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`.
+ `Buffer.isBuffer(object)`

  Vérifiez si `object` est un tampon. Renvoie `true` ou `false`.
  + `object` : entrez un objet.
+ `Buffer.isEncoding(encoding)`

  Vérifiez si `encoding` est pris en charge. Renvoie `true` ou `false`.
  + `encoding`: Facultatif. Entrez l’un des éléments suivants : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`.

Le module fournit les méthodes de prototype de tampon suivantes :
+ `Buffer.prototype.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])`

  Comparez `Buffer` avec la cible. Renvoie `0` s’ils sont identiques, `1` si `buffer` figure en premier, ou `-1` si `target` figure en premier.
  + `target` : entrez un élément `Buffer`.
  + `targetStart`: Facultatif. Entrez un entier. La valeur par défaut est 0.
  + `targetEnd`: Facultatif. Entrez un entier. La valeur par défaut est la longueur `target`.
  + `sourceStart`: Facultatif. Entrez un entier. La valeur par défaut est 0.
  + `sourceEnd`: Facultatif. Entrez un entier. La valeur par défaut est la longueur de `Buffer`.
+ `Buffer.prototype.copy(target[, targetStart[, sourceStart[, sourceEnd]]])`

  Copiez le tampon dans `target`.
  + `target` : entrez un élément `Buffer` ou `Uint8Array`.
  + `targetStart`: Facultatif. Entrez un entier. La valeur par défaut est 0.
  + `sourceStart`: Facultatif. Entrez un entier. La valeur par défaut est 0.
  + `sourceEnd`: Facultatif. Entrez un entier. La valeur par défaut est la longueur de `Buffer`.
+ `Buffer.prototype.equals(otherBuffer)`

  Comparez `Buffer` à `otherBuffer`. Renvoie `true` ou `false`.
  + `otherBuffer` : entrez une chaîne.
+ `Buffer.prototype.fill(value[, offset[, end][, encoding])`

  Remplissez `Buffer` avec `value`.
  + `value` : entrez une chaîne, `Buffer` ou un entier.
  + `offset`: Facultatif. Entrez un entier.
  + `end`: Facultatif. Entrez un entier.
  + `encoding`: Facultatif. Entrez l’un des éléments suivants : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`.
+ `Buffer.prototype.includes(value[, byteOffset][, encoding])`

  Recherchez `value` dans `Buffer`. Renvoie `true` ou `false`.
  + `value` : entrez une chaîne, un élément `Buffer`, `Uint8Array` ou un entier.
  + `byteOffset`: Facultatif. Entrez un entier.
  + `encoding`: Facultatif. Entrez l’un des éléments suivants : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`.
+ `Buffer.prototype.indexOf(value[, byteOffset][, encoding])`

  Recherchez le premier élément `value` dans `Buffer`. Retourne `index` s’il est trouvé ou `-1` dans le cas contraire.
  + `value` : entrez une chaîne, `Buffer`, Unit8Array ou un entier compris entre 0 et 255. 
  + `byteOffset`: Facultatif. Entrez un entier.
  + `encoding`: Facultatif. Entrez l’un des éléments suivants si `value` est une chaîne : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`.
+ `Buffer.prototype.lastIndexOf(value[, byteOffset][, encoding])`

  Recherchez le dernier élément `value` dans `Buffer`. Retourne `index` s’il est trouvé ou `-1` dans le cas contraire.
  + `value` : entrez une chaîne, `Buffer`, Unit8Array ou un entier compris entre 0 et 255. 
  + `byteOffset`: Facultatif. Entrez un entier.
  + `encoding`: Facultatif. Entrez l’un des éléments suivants si `value` est une chaîne : `utf8`, `hex`, `base64`, `base64url`. La valeur par défaut est `utf8`.
+ `Buffer.prototype.readInt8(offset)`

  Lisez `Int8` à la position `offset` à partir de `Buffer`.
  + `offset` : entrez un entier.
+ `Buffer.prototype.readIntBE(offset, byteLength)`

  Lisez `Int` dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`.
  + `offset` : entrez un entier.
  + `byteLength`: Facultatif. Entrez un entier compris entre `1` et `6`.
+ `Buffer.prototype.readInt16BE(offset)`

  Lisez `Int16` dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`.
  + `offset` : entrez un entier.
+ `Buffer.prototype.readInt32BE(offset)`

  Lisez `Int32` dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`.
  + `offset` : entrez un entier.
+ `Buffer.prototype.readIntLE(offset, byteLength)`

  Lisez `Int` dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.readInt16LE(offset)`

  Lisez `Int16` dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`.
  + `offset` : entrez un entier.
+ `Buffer.prototype.readInt32LE(offset)`

  Lisez `Int32` dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`.
  + `offset` : entrez un entier.
+ `Buffer.prototype.readUInt8(offset)`

  Lisez `UInt8` à la position `offset` à partir de `Buffer`.
  + `offset` : entrez un entier.
+ `Buffer.prototype.readUIntBE(offset, byteLength)`

  Lisez `UInt` dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.readUInt16BE(offset)`

  Lisez `UInt16` dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`.
+ 
  + `offset` : entrez un entier.
+ `Buffer.prototype.readUInt32BE(offset)`

  Lisez `UInt32` dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`.
  + `offset` : entrez un entier.
+ `Buffer.prototype.readUIntLE(offset, byteLength)`

  Lisez `UInt` dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.readUInt16LE(offset)`

  Lisez `UInt16` dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`.
  + `offset` : entrez un entier.
+ `Buffer.prototype.readUInt32LE(offset)`

  Lisez `UInt32` dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`.
  + `offset` : entrez un entier.
+ `Buffer.prototype.readDoubleBE([offset])`

  Lisez une valeur double 64 bits dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`.
  + `offset`: Facultatif. Entrez un entier.
+ `Buffer.prototype.readDoubleLE([offset])`

  Lisez une valeur double 64 bits dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`.
  + `offset`: Facultatif. Entrez un entier.
+ `Buffer.prototype.readFloatBE([offset])`

  Lisez une valeur float 32 bits dans l’ordre gros-boutiste à la position `offset` à partir de `Buffer`.
  + `offset`: Facultatif. Entrez un entier.
+ `Buffer.prototype.readFloatLE([offset])`

  Lisez une valeur float 32 bits dans l’ordre petit-boutiste à la position `offset` à partir de `Buffer`.
  + `offset`: Facultatif. Entrez un entier.
+ `Buffer.prototype.subarray([start[, end]])`

  Renvoie une copie de l’élément `Buffer` décalée et recadrée avec de nouveaux éléments `start` et `end`.
  + `start`: Facultatif. Entrez un entier. La valeur par défaut est 0.
  + `end`: Facultatif. Entrez un entier. La valeur par défaut est la longueur du tampon.
+ `Buffer.prototype.swap16()`

  Échangez l’ordre des octets du tableau `Buffer` en le traitant comme un tableau de nombres de 16 bits. La longueur de `Buffer` doit être divisible par 2, sans quoi vous recevrez une erreur.
+ `Buffer.prototype.swap32()`

  Échangez l’ordre des octets du tableau `Buffer` en le traitant comme un tableau de nombres de 32 bits. La longueur de `Buffer` doit être divisible par 4, sans quoi vous recevrez une erreur.
+ `Buffer.prototype.swap64()`

  Échangez l’ordre des octets du tableau `Buffer` en le traitant comme un tableau de nombres de 64 bits. La longueur de `Buffer` doit être divisible par 8, sans quoi vous recevrez une erreur.
+ `Buffer.prototype.toJSON()`

  Renvoie l’élément `Buffer` au format JSON. 
+ `Buffer.prototype.toString([encoding[, start[, end]]])`

  Convertissez l’élément `Buffer`, de `start` à `end`, en chaîne encodée.
  + `encoding`: Facultatif. Entrez l’un des éléments suivants : `utf8`, `hex`, `base64` ou `base64url`. La valeur par défaut est `utf8`.
  + `start`: Facultatif. Entrez un entier. La valeur par défaut est 0.
  + `end`: Facultatif. Entrez un entier. La valeur par défaut est la longueur du tampon.
+ `Buffer.prototype.write(string[, offset[, length]][, encoding])`

  Écrivez l’élément `string` encodé dans `Buffer` s’il y a de l’espace, ou un élément `string` tronqué s’il n’y a pas assez d’espace.
  + `string` : entrez une chaîne.
  + `offset`: Facultatif. Entrez un entier. La valeur par défaut est 0.
  + `length`: Facultatif. Entrez un entier. La valeur par défaut est la longueur de la chaîne.
  + `encoding`: Facultatif. Entrez éventuellement l’un des éléments suivants : `utf8`, `hex`, `base64` ou `base64url`. La valeur par défaut est `utf8`.
+ `Buffer.prototype.writeInt8(value, offset, byteLength)`

  Écrivez l’élément `value` `Int8` de `byteLength` à la position `offset` dans l’élément `Buffer`.
  + `value` : entrez un entier.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeIntBE(value, offset, byteLength)`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste.
  + `value` : entrez un entier.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeInt16BE(value, offset, byteLength)`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste.
  + `value` : entrez un entier.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeInt32BE(value, offset, byteLength)`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste.
  + `value` : entrez un entier.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeIntLE(offset, byteLength)`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeInt16LE(offset, byteLength)`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeInt32LE(offset, byteLength)`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeUInt8(value, offset, byteLength)`

  Écrivez l’élément `value` `UInt8` de `byteLength` à la position `offset` dans `Buffer`.
  + `value` : entrez un entier.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeUIntBE(value, offset, byteLength)`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste.
  + `value` : entrez un entier.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeUInt16BE(value, offset, byteLength)`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste.
  + `value` : entrez un entier.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeUInt32BE(value, offset, byteLength)`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste.
  + `value` : entrez un entier.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeUIntLE(value, offset, byteLength)`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste.
  + `value` : entrez un entier.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeUInt16LE(value, offset, byteLength)`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste.
  + `value` : entrez un entier.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeUInt32LE(value, offset, byteLength)`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste.
  + `value` : entrez un entier.
  + `offset` : entrez un entier.
  + `byteLength` : entrez un entier entre `1` et `6`.
+ `Buffer.prototype.writeDoubleBE(value, [offset])`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste.
  + `value` : entrez un entier.
  + `offset`: Facultatif. Entrez un entier. La valeur par défaut est 0.
+ `Buffer.prototype.writeDoubleLE(value, [offset])`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste.
  + `value` : entrez un entier.
  + `offset`: Facultatif. Entrez un entier. La valeur par défaut est 0.
+ `Buffer.prototype.writeFloatBE(value, [offset])`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre gros-boutiste.
  + `value` : entrez un entier.
  + `offset`: Facultatif. Entrez un entier. La valeur par défaut est 0.
+ `Buffer.prototype.writeFloatLE(value, [offset])`

  Écrivez `value` à la position `offset` dans `Buffer` en utilisant l’ordre petit-boutiste.
  + `value` : entrez un entier.
  + `offset`: Facultatif. Entrez un entier. La valeur par défaut est 0.

Les méthodes d’instance suivantes sont prises en charge :
+ `buffer[index]`

  Obtenez et définissez l’octet (byte) à la position `index` dans l’élément `Buffer`. 
  + Obtenez un nombre entre `0` et `255`. Ou définissez un nombre entre `0` et `255`.

Les propriétés d’instance suivantes sont prises en charge :
+ `buffer`

  Obtenez l’objet `ArrayBuffer` pour le tampon. 
+ `byteOffset`

  Obtenez l’élément `byteOffset` de l’objet `Arraybuffer` du tampon.
+ `length`

  Obtenez le nombre d’octets du tampon.

**Note**  
Toutes les méthodes du module Buffer sont nouvelles dans JavaScript Runtime 2.0.

### Chaîne de requête
<a name="writing-functions-javascript-features-builtin-modules-query-string-20"></a>

**Note**  
L'[objet d'événement CloudFront Functions](functions-event-structure.md) analyse automatiquement les chaînes de requête d'URL pour vous. Cela signifie que, dans la plupart des cas, vous n'avez pas besoin d'utiliser ce module.

Le module de chaînes de requêtes (`querystring`) fournit des méthodes d’analyse et de formatage des chaînes de requêtes URL. Vous pouvez charger le module en utilisant `require('querystring')`. Le module fournit les méthodes suivantes :

`querystring.escape(string)`  
Encode par URL la `string` donnée, en renvoyant une chaîne de requêtes échappée. La méthode est utilisée par `querystring.stringify()` et ne doit pas être utilisée directement.

`querystring.parse(string[, separator[, equal[, options]]])`  
Analyse une chaîne de requêtes (`string`) et renvoie un objet.  
Le paramètre `separator` est une sous-chaîne permettant de délimiter les paires clé-valeur dans la chaîne de requêtes. Par défaut, il s’agit de `&`.  
Le paramètre `equal` est une sous-chaîne permettant de délimiter les clés et les valeurs dans la chaîne de requêtes. Par défaut, il s’agit de `=`.  
Le paramètre `options` est un objet avec les clés suivantes :    
`decodeURIComponent function`  
Fonction pour décoder les caractères encodés en pourcentage dans la chaîne de requêtes. Par défaut, il s’agit de `querystring.unescape()`.  
`maxKeys number`  
Nombre maximal de clés à analyser. Par défaut, il s’agit de `1000`. Utilisez une valeur de `0` pour supprimer les limitations pour le comptage des clés.
Par défaut, les caractères encodés en pourcentage dans la chaîne de requêtes sont supposés utiliser l'encodage UTF-8. Les séquences UTF-8 non valides sont remplacées par le caractère de remplacement `U+FFFD`.  
Par exemple, pour la chaîne de requêtes suivante :  

```
'name=value&abc=xyz&abc=123'
```
La valeur renvoyée de `querystring.parse()` est :  

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

`querystring.stringify(object[, separator[, equal[, options]]])`  
Sérialise un `object` et renvoie une chaîne de requêtes.  
Le paramètre `separator` est une sous-chaîne permettant de délimiter les paires clé-valeur dans la chaîne de requêtes. Par défaut, il s’agit de `&`.  
Le paramètre `equal` est une sous-chaîne permettant de délimiter les clés et les valeurs dans la chaîne de requêtes. Par défaut, il s’agit de `=`.  
Le paramètre `options` est un objet avec les clés suivantes :    
`encodeURIComponent function`  
Fonction à utiliser pour convertir des caractères non sûrs pour une URL en encodage en pourcentage dans la chaîne de requêtes. Par défaut, il s’agit de `querystring.escape()`.
Par défaut, les caractères qui nécessitent un encodage en pourcentage dans la chaîne de requêtes sont encodés en UTF-8. Pour utiliser un encodage différent, spécifiez l’option `encodeURIComponent`.  
Par exemple, pour le code suivant :  

```
querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' });
```
La valeur renvoyée est :  

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

`querystring.unescape(string)`  
Décode les caractères encodés en pourcentage URL dans la `string` donnée, en renvoyant une chaîne de requêtes non échappée. Cette méthode est utilisée par `querystring.parse()` et ne doit pas être utilisée directement.

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

Le module cryptographique (`crypto`) fournit des aides standard en matière de hachage et de code d’authentification de message basé sur le hachage (HMAC). Vous pouvez charger le module en utilisant `require('crypto')`.

**Méthodes de hachage**

`crypto.createHash(algorithm)`  
Crée et renvoie un objet de hachage que vous pouvez utiliser pour générer des résumés de hachage à l’aide de l’algorithme donné : `md5`, `sha1` ou `sha256`.

`hash.update(data)`  
Met à jour le contenu de hachage avec les `data` données

`hash.digest([encoding])`  
Calcule le résumé de toutes les données transmises à l’aide de `hash.update()`. L’encodage peut être `hex`, `base64` ou `base64url`.

**Méthodes HMAC**

`crypto.createHmac(algorithm, secret key)`  
Crée et renvoie un objet HMAC qui utilise le `algorithm` et la `secret key` donnés. L’algorithme peut être `md5`, `sha1` ou `sha256`.

`hmac.update(data)`  
Met à jour le contenu HMAC avec les `data` données.

`hmac.digest([encoding])`  
Calcule le résumé de toutes les données transmises à l’aide de `hmac.update()`. L’encodage peut être `hex`, `base64` ou `base64url`.

## Fonctions limitées
<a name="writing-functions-javascript-features-restricted-features-20"></a>

Les fonctionnalités JavaScript linguistiques suivantes ne sont pas prises en charge ou sont restreintes pour des raisons de sécurité.

**Évaluation dynamique du code**  
L'évaluation dynamique du code n'est pas prise en charge. Les deux constructeurs `eval()` et `Function` renvoient une erreur en cas de tentative. Par exemple, `const sum = new Function('a', 'b', 'return a + b')` renvoie une erreur.

**Temporisateurs**  
Les fonctions `setTimeout()`, `setImmediate()` et `clearTimeout()` ne sont pas prises en charge. Il n'y a aucune disposition relative au report ou au produit dans une exécution de fonction. Votre fonction doit s'exécuter de manière synchrone jusqu'à la fin.

**Horodatages**  
Pour des raisons de sécurité, il n'y a pas d'accès aux temporisateurs haute résolution. Toutes les méthodes `Date` pour interroger l’heure actuelle retournent toujours la même valeur pendant la durée de vie d’une même exécution de la fonction. L'horodatage renvoyé est l'heure à laquelle la fonction a commencé à s'exécuter. Par conséquent, vous ne pouvez pas mesurer le temps écoulé dans votre fonction.

**Accès au système de fichiers**  
Il n’y a pas d’accès au système de fichiers. Par exemple, il n’y a pas de module `fs` pour l’accès au système de fichiers comme dans Node.js.

**Accès au traitement**  
Il n’y a aucun accès au traitement. Par exemple, il n’existe pas d’objet global `process` pour accéder aux informations de traitement, comme c’est le cas dans Node.js.

**Variables d’environnement**  
Il n’y a aucun accès aux variables d’environnement. Vous pouvez plutôt créer une banque CloudFront KeyValueStore de données centralisée de paires clé-valeur pour vos fonctions. CloudFront CloudFront KeyValueStore permet des mises à jour dynamiques de vos données de configuration sans qu'il soit nécessaire de déployer des modifications de code. Pour de plus amples informations, veuillez consulter [Amazon CloudFront KeyValueStore](kvs-with-functions.md).

**Accès réseau**  
Les appels réseau ne sont pas pris en charge. Par exemple, XHR, HTTP(S) et socket ne sont pas pris en charge.

# Méthodes d’aide pour les magasins de clés-valeurs
<a name="functions-custom-methods"></a>

**Note**  
Les appels à la méthode d'assistance au stockage des valeurs clés depuis CloudFront Functions ne déclenchent aucun événement de AWS CloudTrail données. Ces événements ne sont pas enregistrés dans l'historique des CloudTrail événements. Pour de plus amples informations, veuillez consulter [Journalisation des appels CloudFront d'API Amazon à l'aide AWS CloudTrail](logging_using_cloudtrail.md).

Cette section s'applique si vous utilisez le [CloudFront Key Value Store](kvs-with-functions.md) pour inclure des valeurs clés dans la fonction que vous créez. CloudFront Functions possède un module qui fournit trois méthodes d'assistance pour lire les valeurs du magasin de valeurs clés.

Pour utiliser ce module dans le code de fonction, assurez-vous d’avoir [associé un magasin de clés-valeurs](kvs-with-functions-associate.md) à la fonction. 

Ajoutez ensuite les instructions suivantes dans les premières lignes du code de fonction :

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



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

Utilisez cette méthode pour renvoyer la valeur associée au nom de clé que vous spécifiez. 

**Demande**

```
get("key", options);
```
+ `key` : nom de la clé dont la valeur doit être extraite
+ `options` : vous disposez d’une option, `format`. Elle garantit que la fonction analyse correctement les données. Valeurs possibles :
  + `string`: UTF8 encodé (par défaut)
  + `json` 
  + `bytes` : tampon de données binaires brutes

**Exemple de demande**

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

**Réponse**

La réponse est une `promise` qui aboutit à une valeur au format demandé en grâce aux `options`. Par défaut, la valeur est renvoyée sous forme de chaîne.

### Gestion des erreurs
<a name="error-handling-exists-method"></a>

La méthode `get()` renvoie une erreur lorsque la clé que vous avez demandée n’existe pas dans le magasin de clés-valeurs associé. Pour gérer ce cas d’utilisation, vous pouvez ajouter un bloc `try` et `catch` à votre code.

**Avertissement**  
L’utilisation de combinateurs de promesses (par exemple : `Promise.all`, `Promise.any`) ainsi que de méthodes de chaînage de promesses (par exemple : `then` et `catch`) peut entraîner une utilisation élevée de la mémoire de la fonction. Si votre fonction dépasse le quota de [mémoire de fonction maximale](cloudfront-limits.md#limits-functions), elle ne pourra pas s’exécuter. Pour éviter cette erreur, nous vous recommandons d’utiliser la syntaxe `await` de manière séquentielle ou en boucle pour demander plusieurs valeurs.  
**Exemple**  

```
var value1 = await kvs.get('key1');
var value2 = await kvs.get('key2');
```
Actuellement, l’utilisation de combinateurs de promesses pour obtenir plusieurs valeurs n’améliore pas les performances, comme dans l’exemple suivant.  

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

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

Utilisez cette méthode pour déterminer si la clé existe ou non dans le magasin de clés-valeurs.

**Demande**

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

**Exemple de demande**

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

**Réponse**

La réponse est une `promise` qui renvoie une valeur booléenne (`true` ou `false`). Cette valeur indique si la clé existe ou non dans le magasin de clés-valeurs.

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

Utilisez cette méthode pour renvoyer les métadonnées concernant le magasin de clés-valeurs.

**Demande**

```
meta();
```

**Exemple de demande**

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

**Réponse**

La réponse est un élément `promise` qui se résout à un objet doté des propriétés suivantes :
+ `creationDateTime` : date et heure de création du magasin de clés-valeurs, au format ISO 8601.
+ `lastUpdatedDateTime` : date et heure de la dernière synchronisation du magasin de clés-valeurs depuis la source, au format ISO 8601. La valeur n’inclut pas la durée de propagation jusqu’à la périphérie.
+ `keyCount` : nombre total de clés dans le magasin de clés-valeurs après la dernière synchronisation depuis la source.

**Exemple de réponse**

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

# Méthodes d’assistance pour la modification de l’origine
<a name="helper-functions-origin-modification"></a>

Cette section s'applique si vous mettez à jour ou modifiez dynamiquement l'origine utilisée dans la demande dans votre code CloudFront Functions. Vous pouvez mettre à jour l'origine uniquement à *la CloudFront demande du spectateur*. CloudFront Functions possède un module qui fournit des méthodes d'assistance pour mettre à jour ou modifier dynamiquement l'origine.

Pour utiliser ce module, créez une CloudFront fonction à l'aide de JavaScript Runtime 2.0 et incluez l'instruction suivante dans la première ligne du code de fonction :

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

Pour de plus amples informations, veuillez consulter [JavaScript fonctionnalités d'exécution 2.0 pour CloudFront Functions](functions-javascript-runtime-20.md).

**Note**  
Les pages de l’API de test et de la console de test ne vérifient pas si une modification de l’origine s’est produite. Cependant, les tests garantissent que le code de fonction s’exécute sans erreur.

## Choisissez entre CloudFront Functions et Lambda @Edge
<a name="origin-modification-considerations"></a>

Vous pouvez mettre à jour vos origines en utilisant CloudFront Functions ou Lambda @Edge.

Lorsque vous utilisez CloudFront Functions pour mettre à jour les origines, vous utilisez le déclencheur d'événement de *demande du visualiseur*, ce qui signifie que cette logique s'exécutera à chaque demande lorsque cette fonction est utilisée. Lorsque vous utilisez Lambda@Edge, les fonctionnalités de mise à jour de l’origine se trouvent sur le déclencheur d’événement *demande à l’origine*, ce qui signifie que cette logique ne s’exécute qu’en cas d’échec du cache.

Votre choix dépend largement de votre charge de travail et de toute utilisation existante de CloudFront Functions et Lambda @Edge dans vos distributions. Les considérations suivantes peuvent vous aider à décider d'utiliser CloudFront Functions ou Lambda @Edge pour mettre à jour vos origines.

CloudFront Les fonctions sont particulièrement utiles dans les situations suivantes :
+ Lorsque vos demandes sont dynamiques (c'est-à-dire qu'elles ne peuvent pas être mises en cache) et qu'elles vont toujours à l'origine. CloudFront Les fonctions offrent de meilleures performances et un coût global inférieur.
+ Lorsque vous disposez déjà d'une CloudFront fonction de demande d'affichage qui s'exécute sur chaque demande, vous pouvez ajouter la logique de mise à jour de l'origine à la fonction existante.

Pour utiliser CloudFront Functions pour mettre à jour les origines, consultez les méthodes d'assistance décrites dans les rubriques suivantes.

Lambda@Edge est particulièrement utile dans les cas suivants :
+ Lorsque le contenu peut être facilement mis en cache, Lambda @Edge peut être plus rentable car il s'exécute uniquement en cas d'erreur de cache, CloudFront tandis que Functions s'exécute sur chaque requête.
+ Lorsque vous disposez déjà d’une fonction Lambda@Edge de type demande à l’origine, vous pouvez y ajouter la logique de mise à jour de l’origine.
+ Lorsque votre logique de mise à jour d’origine nécessite de récupérer des données à partir de sources de données tierces, telles qu’Amazon DynamoDB ou Amazon S3.

Pour plus d’informations sur Lambda@Edge, consultez [Personnalisation en périphérie avec Lambda@Edge](lambda-at-the-edge.md).

## updateRequestOrigin() méthode
<a name="update-request-origin-helper-function"></a>

Utilisez la méthode `updateRequestOrigin()` pour mettre à jour les paramètres d’origine d’une demande. Vous pouvez utiliser cette méthode pour mettre à jour les propriétés d’origine existantes pour les origines déjà définies dans votre distribution, ou pour définir une nouvelle origine pour la demande. Pour ce faire, spécifiez les propriétés que vous souhaitez modifier.

**Important**  
Tous les paramètres que vous ne spécifiez pas dans `updateRequestOrigin()` hériteront des *paramètres* définis dans la configuration de l’origine existante.

L'origine définie par la `updateRequestOrigin()` méthode peut être n'importe quel point de terminaison HTTP et il n'est pas nécessaire qu'il s'agisse d'une origine existante au sein de votre CloudFront distribution.

**Remarques**  
Si vous mettez à jour une origine qui fait partie d’un groupe d’origines, seule l’*origine principale* du groupe d’origines est mise à jour. L’origine secondaire reste inchangée. Tout code de réponse provenant de l’origine modifiée qui correspond aux critères de basculement déclenchera un basculement vers l’origine secondaire.
Si vous modifiez le type d’origine et que l’OAC est activé, veillez à ce que le type d’origine dans `originAccessControlConfig` corresponde au nouveau type d’origine.
Vous ne pouvez pas utiliser la méthode `updateRequestOrigin()` pour mettre à jour les [origines VPC](private-content-vpc-origins.md). La demande échouera.

**Demande**

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

Les `origin properties` peuvent contenir les éléments suivants :

**domainName (facultatif)**  
Nom de domaine de l’origine. Si cette valeur n’est pas fournie, le nom de domaine de l’origine associée est utilisé à la place.    
**Pour les origines personnalisées**  
Spécifiez un nom de domaine DNS, tel que `www.example.com`. Le nom de domaine ne peut pas inclure de deux-points (`:`) et ne peut pas être une adresse IP. Le nom du domaine peut contenir jusqu’à 253 caractères.  
**Pour les origines S3**  
Spécifiez le nom de domaine DNS du compartiment Amazon S3, tel que `amzn-s3-demo-bucket.s3.eu-west-1.amazonaws.com`. Il peut comporter jusqu’à 128 caractères, qui doivent tous être en minuscules.

**HostHeader (facultatif, pour les origines personnalisées autres que S3)**  
L'en-tête de l'hôte à utiliser lorsque vous envoyez la demande à l'origine. Si ce n'est pas le cas, la valeur du paramètre DomainName est utilisée. Si aucun en-tête d'hôte ou paramètre de nom de domaine n'est fourni, le nom de domaine de l'origine attribuée est utilisé ou l'en-tête de l'hôte de la demande entrante si la politique de transfert vers l'origine (FTO) inclut l'hôte. L'en-tête de l'hôte ne peut pas inclure de deux-points (`:`) et ne peut pas être une adresse IP. L'en-tête de l'hôte peut comporter jusqu'à 253 caractères.

**originPath (facultatif)**  
Chemin de répertoire à l’origine où la demande doit localiser le contenu. Ce chemin doit commencer par une barre oblique (/) mais ne doit pas se terminer par une barre oblique. Par exemple, il ne doit pas se terminer par `example-path/`. Si cette valeur n’est pas fournie, le chemin d’origine de l’origine associée est utilisé.    
**Pour les origines personnalisées**  
Le chemin d’accès doit être codé en URL et ne pas dépasser 255 caractères.

**customHeaders (facultatif)**  
Vous pouvez inclure des en-têtes personnalisés dans la requête en spécifiant un nom et une valeur d'en-tête pour chacun d'eux. Le format est différent de celui des en-têtes de demande et de réponse dans la structure de l’événement. Utilisez la syntaxe de paire clé-valeur suivante :  

```
{"key1": "value1", "key2": "value2", ...}
```
Vous ne pouvez pas ajouter d’en-têtes non autorisés, et un en-tête portant le même nom ne peut pas déjà être présent dans la demande entrante `headers`. Le nom de l’en-tête doit être en minuscules dans le code de votre fonction. Lorsque CloudFront Functions reconvertit l'objet d'événement en requête HTTP, la première lettre de chaque mot dans les noms d'en-tête est mise en majuscule et les mots sont séparés par un trait d'union.  
Par exemple, si le code de votre fonction ajoute un en-tête nommé`example-header-name`, le CloudFront convertit en en-tête `Example-Header-Name` dans la requête HTTP. Pour plus d’informations, consultez [En-têtes personnalisés qui ne CloudFront peuvent pas être ajoutés aux demandes d'origine](add-origin-custom-headers.md#add-origin-custom-headers-denylist) et [Restrictions sur les fonctions périphériques](edge-functions-restrictions.md).  
Si cette valeur n’est pas fournie, les en-têtes personnalisés de l’origine associée sont utilisés.

**connectionAttempts (facultatif)**  
Le nombre de CloudFront tentatives de connexion à l'origine. La valeur minimale est 1 et la valeur maximale est 3. Si cette valeur n’est pas fournie, les tentatives de connexion provenant de l’origine attribuée sont utilisées.

**originShield (facultatif)**  
Cela active ou met à jour CloudFront Origin Shield. L'utilisation d'Origin Shield permet de réduire la charge sur votre origine. Pour de plus amples informations, veuillez consulter [Utiliser Amazon CloudFront Origin Shield](origin-shield.md). Si cette valeur n’est pas fournie, les paramètres Origin Shield de l’origine attribuée sont utilisés.    
**enabled (obligatoire)**  
Expression booléenne permettant d’activer ou de désactiver Origin Shield. Accepte la valeur `true` ou `false`.  
**region (obligatoire lorsqu’elle est activée)**  
Le Région AWS pour Origin Shield. Spécifiez l' Région AWS dont la latence est la plus faible par rapport à votre origine. Utilisez le code de région et non le nom de la région. Par exemple, utilisez `us-east-2` pour spécifier la région USA Est (Ohio).  
Lorsque vous activez CloudFront Origin Shield, vous devez Région AWS le spécifier. Pour obtenir la liste des Régions AWS disponibles et choisir la région la plus appropriée pour votre origine, consultez [Choisissez la AWS région pour Origin Shield](origin-shield.md#choose-origin-shield-region).

**originAccessControlConfig (facultatif)**  
L’identifiant unique d’un contrôle d’accès d’origine (OAC) pour cette origine. Ceci n'est utilisé que lorsque l'origine prend en charge un CloudFront OAC, tel qu'Amazon S3, la URLs fonction Lambda et la MediaStore V2. MediaPackage Si cette valeur n’est pas fournie, les paramètres OAC de l’origine attribuée sont utilisés.  
L’identité d’accès d’origine (OAI) héritée n’est pas prise en charge. Pour de plus amples informations, veuillez consulter [Restreindre l'accès à une AWS origine](private-content-restricting-access-to-origin.md).    
**enabled (obligatoire)**  
Expression booléenne permettant d’activer ou de désactiver l’OAC. Accepte la valeur `true` ou `false`.  
**signingBehavior (obligatoire si activé)**  
Spécifie les demandes CloudFront signées (ajoute des informations d'authentification à). Spécifiez `always` pour le cas d'utilisation le plus courant. Pour de plus amples informations, veuillez consulter [Paramètres avancés pour le contrôle d'accès à l'origine](private-content-restricting-access-to-s3.md#oac-advanced-settings-s3).   
Ce champ peut avoir l'une des valeurs suivantes :  
+ `always`— CloudFront signe toutes les demandes d'origine, en remplaçant l'`Authorization`en-tête de la demande du lecteur s'il en existe une.
+ `never`— CloudFront ne signe aucune demande d'origine. Cette valeur désactive le contrôle d’accès d’origine pour l’origine.
+ `no-override`— Si la demande du lecteur ne contient pas l'`Authorization`en-tête, CloudFront signe la demande d'origine. Si la demande du visualiseur contient l'`Authorization`en-tête, CloudFront elle ne signe pas la demande d'origine et transmet à la place l'`Authorization`en-tête de la demande du visualiseur.
**Avertissement**  
Pour transmettre l’en-tête `Authorization` de la demande de l’utilisateur, vous devez l’ajouter à une politique de demande d’origine pour tous les comportements de cache qui utilisent les origines associées à ce contrôle d’accès d’origine. Pour de plus amples informations, veuillez consulter [Contrôle des demandes d’origine à l’aide d’une stratégie](controlling-origin-requests.md).  
**signingProtocol (obligatoire si activé)**  
Protocole de signature de l'OAC, qui détermine la manière dont les demandes sont CloudFront signées (authentifiées). La seule valeur valide est `sigv4`.  
**originType (obligatoire si activé)**  
Le type d’origine de cet OAC. Les valeurs valides sont les suivantes : `s3`, `mediapackagev2`, `mediastore` et `lambda`. 

**timeouts (facultatif)**  
Les délais d'expiration que vous pouvez spécifier CloudFront doivent tenter d'attendre que les origines répondent ou envoient des données. Si cette valeur n’est pas fournie, les paramètres de délai d’attente de l’origine attribuée sont utilisés.   
Sauf indication contraire, ces délais prennent en charge les origines personnalisées et Amazon S3.   
**readTimeout (facultatif)**  
`readTimeout` s’applique aux deux valeurs suivantes :  
+ Durée (en secondes) d' CloudFront attente d'une réponse après avoir transmis une demande à l'origine.
+ Durée (en secondes) d' CloudFront attente après réception d'un paquet de réponse de l'origine et avant de recevoir le paquet suivant. 
Le délai minimum est de 1 seconde et le délai maximum est de 120 secondes. Pour de plus amples informations, veuillez consulter [Délai de réponse](DownloadDistValuesOrigin.md#DownloadDistValuesOriginResponseTimeout).  
**responseCompletionTimeout (facultatif)**  
Durée (en secondes) pendant laquelle une demande provenant CloudFront de l'origine peut rester ouverte et attendre une réponse. Si la réponse complète n'est pas reçue de l'origine à ce moment-là, CloudFront met fin à la connexion.  
La valeur de `responseCompletionTimeout` doit être supérieure ou égale à la valeur de `readTimeout`. Pour de plus amples informations, veuillez consulter [Délai d’exécution de la réponse](DownloadDistValuesOrigin.md#response-completion-timeout).  
**keepAliveTimeout (facultatif)**  
Ce délai s’applique uniquement aux origines personnalisées, et non aux origines Amazon S3. (Les configurations d’origine S3 ignoreront ces paramètres.)   
`keepAliveTimeout`Spécifie la durée pendant CloudFront laquelle vous devez essayer de maintenir la connexion à l'origine après avoir reçu le dernier paquet de la réponse. Le délai minimum est de 1 seconde et le délai maximum est de 120 secondes. Pour de plus amples informations, veuillez consulter [Délai d’attente des connexions actives (origines personnalisées et VPC uniquement)](DownloadDistValuesOrigin.md#DownloadDistValuesOriginKeepaliveTimeout).  
**connectionTimeout (facultatif)**  
Le nombre de secondes d' CloudFront attente lorsque vous essayez d'établir une connexion avec l'origine. Le délai minimum est de 1 seconde et le délai maximum est de 10 secondes. Pour de plus amples informations, veuillez consulter [Délai de connexion](DownloadDistValuesOrigin.md#origin-connection-timeout).

**customOriginConfig (facultatif)**  
Utilisez `customOriginConfig` pour spécifier les paramètres de connexion des origines qui ne sont *pas* un compartiment Amazon S3. Il existe une exception : vous pouvez spécifier ces paramètres si le compartiment S3 est configuré avec un hébergement de site web statique. (Les autres types de configurations de compartiment S3 ignoreront ces paramètres.) Si `customOriginConfig` n’est pas renseigné, les paramètres de l’origine attribuée sont utilisés.    
**port (obligatoire)**  
Port HTTP CloudFront utilisé pour se connecter à l'origine. Spécifiez le port HTTP sur lequel l'origine personnalisée écoute.   
**protocol (obligatoire)**  
Spécifie le protocole (HTTP ou HTTPS) CloudFront utilisé pour se connecter à l'origine. Les valeurs valides sont les suivantes :  
+ `http`— utilise CloudFront toujours le protocole HTTP pour se connecter à l'origine
+ `https`— utilise CloudFront toujours HTTPS pour se connecter à l'origine  
**sslProtocols (obligatoire)**  
Une liste qui indique le SSL/TLS protocole minimal à CloudFront utiliser lors de la connexion à votre point d'origine via HTTPS. Les valeurs valides sont les suivantes : `SSLv3`, `TLSv1`, `TLSv1.1` et `TLSv1.2`. Pour de plus amples informations, veuillez consulter [Minimum de protocole SSL d’origine](DownloadDistValuesOrigin.md#DownloadDistValuesOriginSSLProtocols).  
**ipAddressType (facultatif)**  
Spécifie le type d'adresse IP CloudFront utilisé pour se connecter à l'origine. Les valeurs valides sont `ipv4`, `ipv6` et `dualstack`. La modification de `ipAddressType` n’est prise en charge que lorsque la propriété `domainName` est également modifiée.

**sni (facultatif, pour les origines personnalisées autres que S3)**  
L'indication du nom du serveur (SNI) est une extension du protocole TLS (Transport Layer Security) par laquelle un client indique le nom d'hôte auquel il tente de se connecter au début du processus de prise de contact TLS. Cette valeur doit correspondre à un nom courant figurant sur un certificat TLS sur votre serveur d'origine. Dans le cas contraire, votre serveur d'origine risque de générer une erreur.   
Si ce n'est pas le cas, la valeur du `hostHeader` paramètre est utilisée. Si l'en-tête de l'hôte n'est pas fourni, la valeur du `domainName` paramètre est utilisée.  
Si aucun en-tête d'hôte ou paramètre de nom de domaine n'est fourni, le nom de domaine de l'origine attribuée est utilisé ou l'en-tête de l'hôte de la demande entrante si la politique de transfert vers l'origine (FTO) inclut l'hôte. Le SNI ne peut pas inclure de deux-points (`:`) et ne peut pas être une adresse IP. Le SNI peut comporter jusqu'à 253 caractères.

**allowedCertificateNames (facultatif, pour les origines personnalisées autres que S3)**  
Vous pouvez inclure une liste de noms de certificats valides à utiliser pour valider le domaine correspondant CloudFront au certificat TLS de votre serveur d'origine lors de la prise de contact TLS avec votre serveur d'origine. Ce champ attend un tableau de noms de domaine valides et peut inclure des domaines génériques, tels que`*.example.com`.   
Vous pouvez spécifier jusqu'à 20 noms de certificats autorisés. Chaque nom de certificat peut comporter jusqu'à 64 caractères.

**Example – mise à jour de l’origine de la demande Amazon S3**  
L’exemple suivant modifie l’origine de la demande de l’utilisateur pour la remplacer par un compartiment S3, active l’OAC et réinitialise les en-têtes personnalisés envoyés à l’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 – mise à jour de l’origine de demande Application Load Balancer**  
L’exemple suivant modifie l’origine de la demande de l’utilisateur pour la remplacer par une origine Application Load Balancer et définit un en-tête personnalisé ainsi que des délais d’attente.  

```
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 – mise à jour vers une origine avec Origin Shield activé**  
Dans l’exemple suivant, Origin Shield est activé sur l’origine de la distribution. Le code de fonction met à jour uniquement le nom de domaine utilisé pour l’origine et omet tous les autres paramètres facultatifs. Dans ce cas, Origin Shield continuera d’être utilisé avec le nom de domaine d’origine modifié, puisque les paramètres Origin Shield n’ont pas été mis à jour.  

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

**Example — Met à jour l'en-tête de l'hôte, le SNI et les noms des certificats autorisés**  
Dans la plupart des cas d'utilisation, vous n'aurez pas besoin d'utiliser ce type de modification pour les demandes envoyées à votre origine. Ces paramètres ne doivent pas être utilisés à moins que vous ne compreniez l'impact de la modification de ces valeurs. 
L'exemple suivant remplace le nom de domaine, l'en-tête de l'hôte, le SNI et les certificats autorisés sur la demande par l'origine.   

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

## selectRequestOriginById() méthode
<a name="select-request-origin-id-helper-function"></a>

Utilisez `selectRequestOriginById()` pour mettre à jour une origine existante en sélectionnant une autre origine déjà configurée dans votre distribution. Cette méthode utilise les mêmes paramètres que ceux définis par l’origine mise à jour.

Cette méthode accepte uniquement les origines déjà définies dans la même distribution que celle utilisée lors de l’exécution de la fonction. Les origines sont référencées par l’ID d’origine, qui est le nom d’origine que vous avez défini lors de la configuration de l’origine.

Si une origine VPC est configurée dans votre distribution, vous pouvez utiliser cette méthode pour mettre à jour votre origine vers votre origine VPC. Pour de plus amples informations, veuillez consulter [Restriction de l’accès avec les origines de VPC](private-content-vpc-origins.md).

**Remarques**  
La `selectRequestOriginById()` fonction ne peut pas sélectionner une origine pour laquelle le protocole TLS mutuel (origine) est activé. Toute tentative de sélection d'une origine compatible TLS (origine) mutuelle à l'aide de cette fonction entraînera une erreur de validation.
Si votre cas d'utilisation nécessite une sélection d'origine dynamique avec TLS mutuel (origine), utilisez-le `updateRequestOrigin()` plutôt en vous assurant que toutes les origines cibles utilisent le même certificat client.

**Demande**

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

Dans l'exemple précédent, `origin_id` il s'agit d'une chaîne qui pointe vers le nom d'origine d'une origine dans la distribution qui exécute la fonction. Le `origin_overrides ` paramètre peut contenir les éléments suivants :

**HostHeader (facultatif, pour les origines personnalisées autres que S3)**  
L'en-tête de l'hôte à utiliser lorsque vous envoyez la demande à l'origine. Si ce n'est pas le cas, la valeur du `domainName` paramètre est utilisée.   
Si aucun en-tête d'hôte ou paramètre de nom de domaine n'est fourni, le nom de domaine de l'origine attribuée est utilisé ou l'en-tête de l'hôte de la demande entrante si la politique de transfert vers l'origine (FTO) inclut l'hôte. L'en-tête de l'hôte ne peut pas inclure de deux-points (`:`) et ne peut pas être une adresse IP. L'en-tête de l'hôte peut comporter jusqu'à 253 caractères.

**sni (facultatif, pour les origines personnalisées autres que S3)**  
L'indication du nom du serveur (SNI) est une extension du protocole TLS (Transport Layer Security) par laquelle un client indique le nom d'hôte auquel il tente de se connecter au début du processus de prise de contact TLS. Cette valeur doit correspondre à un nom courant figurant sur un certificat TLS sur votre serveur d'origine. Dans le cas contraire, votre serveur d'origine risque de générer une erreur.   
Si ce n'est pas le cas, la valeur du `hostHeader` paramètre est utilisée. Si l'en-tête de l'hôte n'est pas fourni, la valeur du `domainName` paramètre est utilisée.   
Si aucun en-tête d'hôte ou paramètre de nom de domaine n'est fourni, le nom de domaine de l'origine attribuée est utilisé ou l'en-tête de l'hôte de la demande entrante si la politique de transfert vers l'origine (FTO) inclut l'hôte. Le SNI ne peut pas inclure de deux-points (`:`) et ne peut pas être une adresse IP. Le SNI peut comporter jusqu'à 253 caractères.

**allowedCertificateNames (facultatif, pour les origines personnalisées autres que S3)**  
Vous pouvez inclure une liste de noms de certificats valides à utiliser pour valider le domaine correspondant CloudFront au certificat TLS de votre serveur d'origine lors de la prise de contact TLS avec votre serveur d'origine. Ce champ attend un tableau de noms de domaine valides et peut inclure des domaines génériques, tels que`*.example.com`.   
Vous pouvez spécifier jusqu'à 20 noms de certificats autorisés. Chaque nom de certificat peut comporter jusqu'à 64 caractères.

**Demande**

```
selectRequestOriginById(origin_id)
```

Dans l’exemple précédent, `origin_id` est une chaîne qui fait référence au nom de l’origine dans la distribution où la fonction s’exécute.

**Example – sélection de l’origine de demande Amazon S3**  
L’exemple suivant sélectionne l’origine nommée `amzn-s3-demo-bucket-in-us-east-1` dans la liste des origines associées à la distribution et applique les paramètres de configuration de l’origine `amzn-s3-demo-bucket-in-us-east-1` à la demande.  

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

**Example – sélection de l’origine de demande Application Load Balancer**  
L’exemple suivant sélectionne une origine Application Load Balancer nommée `myALB-prod` dans la liste des origines associées à la distribution et applique les paramètres de configuration de l’origine `myALB-prod` à la demande.  

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

**Example — Sélectionnez l'origine de la demande Application Load Balancer et remplacez l'en-tête de l'hôte**  
Comme dans l'exemple précédent, l'exemple suivant sélectionne une origine Application Load Balancer nommée `myALB-prod` dans la liste des origines associées à la distribution, et applique les paramètres de configuration de `myALB-prod` à la demande. Toutefois, cet exemple remplace la valeur de l'en-tête de l'hôte en utilisant`origin_overrides`.  

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

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

Utilisez `createRequestOriginGroup()` pour définir deux origines à utiliser comme [groupe d’origines](high_availability_origin_failover.md#concept_origin_groups.creating) pour le basculement, dans les scénarios nécessitant une haute disponibilité.

Un groupe d’origine comprend deux origines (une origine principale et une origine secondaire), ainsi qu’un critère de basculement que vous spécifiez. Vous créez un groupe d'origine pour prendre en charge le basculement d'origine. CloudFront Lorsque vous créez ou mettez à jour un groupe d'origine à l'aide de cette méthode, vous pouvez spécifier le groupe d'origine au lieu d'une origine unique. CloudFront basculera de l'origine principale vers l'origine secondaire, en utilisant les critères de basculement.

Si une origine VPC est configurée dans votre distribution, vous pouvez utiliser cette méthode pour créer un groupe d’origines à l’aide de votre origine VPC. Pour de plus amples informations, veuillez consulter [Restriction de l’accès avec les origines de VPC](private-content-vpc-origins.md).

**Remarques**  
La `createRequestOriginGroup()` fonction ne prend pas en charge la création de groupes d'origine incluant des origines compatibles avec le protocole TLS mutuel (origine). Les groupes d'origine ayant des origines TLS mutuelles (origine) ne peuvent pas être créés dynamiquement via CloudFront Functions.
Si vous avez besoin de fonctionnalités de basculement d'origine avec Mutual TLS (origin), configurez les groupes d'origine directement dans vos paramètres de CloudFront distribution plutôt que de les créer dynamiquement dans les fonctions.

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

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

Dans les exemples précédents, `origin_group_properties` peut contenir les éléments suivants :

**originIds (obligatoire)**  
Tableau de `origin_ids`, où chaque `origin_id` est une chaîne qui pointe vers le nom de l’origine dans la distribution exécutant la fonction. Vous devez fournir deux origines dans le tableau. La première origine de la liste est l’origine principale et la seconde sert d’origine secondaire à des fins de basculement. 

**OriginOverrides (facultatif)**  
 Quelques paramètres avancés peuvent être remplacés à l'aide du `{origin_overrides}` paramètre. Les `origin overrides` peuvent contenir les éléments suivants :     
**HostHeader (facultatif, pour les origines personnalisées autres que S3)**  
L'en-tête de l'hôte à utiliser lorsque vous envoyez la demande à l'origine. Si ce n'est pas le cas, la valeur du `domainName` paramètre est utilisée.   
Si aucun en-tête d'hôte ou paramètre de nom de domaine n'est fourni, le nom de domaine de l'origine attribuée est utilisé ou l'en-tête de l'hôte de la demande entrante si la politique de transfert vers l'origine (FTO) inclut l'hôte. L'en-tête de l'hôte ne peut pas inclure de deux-points (`:`) et ne peut pas être une adresse IP. L'en-tête de l'hôte peut comporter jusqu'à 253 caractères.  
**sni (facultatif, pour les origines personnalisées autres que S3)**  
L'indication du nom du serveur (SNI) est une extension du protocole TLS (Transport Layer Security) par laquelle un client indique le nom d'hôte auquel il tente de se connecter au début du processus de prise de contact TLS. Cette valeur doit correspondre à un nom courant figurant sur un certificat TLS sur votre serveur d'origine, sinon celui-ci risque de générer une erreur.   
Si ce n'est pas le cas, la valeur du `hostHeader` paramètre est utilisée. Si l'en-tête de l'hôte n'est pas fourni, la valeur du `domainName` paramètre est utilisée.  
Si aucun en-tête d'hôte ou paramètre de nom de domaine n'est fourni, le nom de domaine de l'origine attribuée est utilisé ou l'en-tête de l'hôte de la demande entrante si la politique de transfert vers l'origine (FTO) inclut l'hôte. Le SNI ne peut pas inclure de deux-points (`:`) et ne peut pas être une adresse IP. Le SNI peut comporter jusqu'à 253 caractères.  
**allowedCertificateNames (facultatif, pour les origines personnalisées autres que S3)**  
Vous pouvez inclure une liste de noms de certificats valides à utiliser pour valider le domaine correspondant CloudFront au certificat TLS de votre serveur d'origine lors de la prise de contact TLS avec votre serveur d'origine. Ce champ attend un tableau de noms de domaine valides et peut inclure des domaines génériques, tels que`*.example.com`.   
Vous pouvez spécifier jusqu'à 20 noms de certificats autorisés. Chaque nom de certificat peut comporter jusqu'à 64 caractères.

**selectionCriteria (facultatif)**  
Sélectionnez si vous souhaitez utiliser les critères de basculement d’origine `default` ou appliquer la logique de basculement basée sur le `media-quality-score`. Les valeurs valides sont les suivantes :  
+ `default` utilise les critères de basculement, en fonction des codes d’état spécifiés dans `failoverCriteria`. Si vous ne définissez pas `selectionCriteria` dans la fonction, `default` sera utilisé.
+ `media-quality-score` est utilisé lorsque la fonctionnalité de routage tenant compte de la qualité média est utilisée.

**failoverCriteria (obligatoire)**  
Ensemble de codes d'état qui, lorsqu'ils sont renvoyés par l'origine principale, CloudFront déclenchent le basculement vers l'origine secondaire. Si vous remplacez un groupe d’origines existant, ce tableau remplacera tous les codes d’état de basculement définis dans la configuration d’origine du groupe d’origines.  
Lorsque vous utilisez `media-quality-score``selectionCriteria`, CloudFront tentera d'acheminer les demandes en fonction du niveau de qualité du média. Si l'origine sélectionnée renvoie un code d'erreur défini dans ce tableau, elle CloudFront basculera vers l'autre origine.

**Example – création du groupe d’origines de la demande**  
L'exemple suivant crée un groupe d'origine pour une demande à l'aide de l'origine IDs. Ces origines IDs proviennent de la configuration du groupe d'origine de la distribution utilisée pour exécuter cette fonction.  
Vous pouvez éventuellement utiliser `originOverrides` pour remplacer les configurations du groupe d'origine pour `sni``hostHeader`, et`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;
}
```

# Méthodes d'assistance pour les propriétés de CloudFront SaaS Manager
<a name="saas-specific-logic-function-code"></a>

Utilisez les fonctions d'assistance suivantes pour CloudFront SaaS Manager afin de récupérer les valeurs de vos distributions multi-locataires dans la fonction que vous créez. Pour utiliser les exemples de cette page, vous devez d'abord créer une CloudFront fonction à l'aide de JavaScript Runtime 2.0. Pour plus d’informations, consultez [JavaScript fonctionnalités d'exécution 2.0 pour CloudFront Functions](functions-javascript-runtime-20.md).

**Topics**
+ [Groupes de connexions](#connection-groups-helper-function)
+ [Locataires de distribution](#distribution-tenants-helper-functions)

## Groupes de connexions
<a name="connection-groups-helper-function"></a>

Le groupe de connexions associé à vos locataires de distribution possède un nom de domaine.

Pour obtenir cette valeur, utilisez le champ `endpoint` du sous-objet `context` de l’objet d’événement. 

**Demande**

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

**Réponse**

La réponse est une `string` contenant le nom de domaine du groupe de connexion, par exemple : d111111abcdef8.cloudfront.net. Le champ `endpoint` n’apparaît que lorsque votre fonction est invoquée pour les distributions multi-locataires avec un groupe de connexions associé. Pour de plus amples informations, veuillez consulter [Objet Contexte](functions-event-structure.md#functions-event-structure-context).

## Locataires de distribution
<a name="distribution-tenants-helper-functions"></a>

CloudFront Functions possède un module qui permet d'accéder à des valeurs spécifiques des locataires de distribution.

Pour utiliser ce module, ajoutez l’instruction suivante à la première ligne de votre code de fonction :

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

Vous pouvez utiliser les exemples suivants uniquement dans la fonction `handler`, soit directement, soit par le biais d’une fonction appelée de manière imbriquée.

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

Utilisez ce champ pour obtenir la valeur de l’ID de locataire de distribution.

**Demande**

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

**Réponse**

La réponse est une `string` contenant l’ID du locataire de distribution, par exemple : `dt_1a2b3c4d5e6f7`.

**Gestion des erreurs**

Si votre fonction est invoquée pour une distribution standard, le fait de renseigner le champ `distributionTenant.id` renverra une erreur de type `distributionTenant module is not available`. Pour gérer ce cas d’utilisation, vous pouvez ajouter un bloc `try` et `catch` à votre code.

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

Utilisez cette méthode pour renvoyer la valeur des paramètres du locataire de distribution que vous avez spécifiés.

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

`key` : le nom du paramètre du locataire de distribution pour lequel vous souhaitez récupérer la valeur.

**Demande**

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

**Réponse**

La réponse est une `string` contenant la valeur du paramètre du locataire de distribution. Par exemple, si le nom de votre clé est `TenantPath`, la valeur de ce paramètre peut être `tenant1`.

**Gestion des erreurs**

Vous pourriez recevoir les erreurs suivantes :
+ Si votre fonction est invoquée pour une distribution standard, la méthode `distributionTenant.parameters.get()` renverra une erreur de type `distributionTenant module is not available`. 
+ L’erreur `DistributionTenantParameterKeyNotFound` est renvoyée lorsque le paramètre de locataire de distribution que vous avez spécifié n’existe pas. 

Pour gérer ces cas d’utilisation, vous pouvez ajouter un bloc `try` et `catch` à votre code.

# Utilisation de async et await
<a name="async-await-syntax"></a>

CloudFront Fonctions fournies par JavaScript Runtime Functions 2.0 `async` et `await` syntaxe permettant de gérer `Promise` les objets. Les promesses représentent des résultats différés accessibles via le mot clé `await` dans les fonctions marquées comme `async`. Diverses nouvelles WebCrypto fonctions utilisent Promises.

Pour plus d’informations sur les objets `Promise`, consultez [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).

**Note**  
Vous devez utiliser JavaScript Runtime 2.0 pour les exemples de code suivants.  
`await` ne peut être utilisé qu’à l’intérieur de fonctions `async`. Les arguments et fermetures `async` ne sont pas pris en charge.

```
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;
}
```

L'exemple de JavaScript code suivant montre comment afficher les promesses avec la méthode de la `then` chaîne. Vous pouvez utiliser `catch` pour visualiser les erreurs.

**Avertissement**  
L’utilisation de combinateurs de promesses (par exemple : `Promise.all`, `Promise.any`) ainsi que de méthodes de chaînage de promesses (par exemple : `then` et `catch`) peut entraîner une utilisation élevée de la mémoire de la fonction. Si votre fonction dépasse le quota de [mémoire de fonction maximale](cloudfront-limits.md#limits-functions), elle ne pourra pas s’exécuter. Pour éviter cette erreur, nous vous recommandons d’utiliser la syntaxe `await` plutôt que les méthodes `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;
}
```

# Support CWT pour Functions CloudFront
<a name="cwt-support-cloudfront-functions"></a>

Cette section fournit des détails sur la prise en charge des jetons Web CBOR (CWT) dans vos CloudFront fonctions, qui permettent une authentification et une autorisation sécurisées basées sur des jetons dans les emplacements périphériques. CloudFront Ce support est fourni sous forme de module, accessible dans votre CloudFront fonction. 

Pour utiliser ce module, créez une CloudFront fonction à l'aide de JavaScript Runtime 2.0 et incluez l'instruction suivante dans la première ligne du code de fonction : 

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

Les méthodes associées à ce module sont accessibles via (où \$1 est un caractère générique représentant les différentes fonctions présentes dans le module) :

```
cf.cwt.*
```

Pour de plus amples informations, veuillez consulter [JavaScript fonctionnalités d'exécution 2.0 pour CloudFront Functions](functions-javascript-runtime-20.md).

Actuellement, le module ne prend en charge que la structure MAC0 avec l'algorithme HS256 (HMAC-SHA256) avec une limite de 1 Ko pour la taille maximale du jeton.

## Structure du jeton
<a name="token-structure"></a>

Cette section couvre la structure des jetons attendue par le module CWT. Le module s'attend à ce que le jeton soit correctement étiqueté et identifiable (par exemple COSE MAC0). De plus, en ce qui concerne la structure du jeton, le module suit les normes établies par [CBOR Object Signing and Encryption (COSE) [RFC 8152](https://datatracker.ietf.org/doc/html/rfc8152)].

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

**Example : CWT utilisant la structure 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       
        ]     
    )   
)
```
La balise CWT est facultative lors de la génération de jetons. Cependant, la balise de structure COSE est requise.

## méthode validateToken ()
<a name="validatetoken-method"></a>

La fonction décode et valide un jeton CWT à l'aide de la clé spécifiée. Si la validation est réussie, elle renvoie le jeton CWT décodé. Dans le cas contraire, cela génère une erreur. Veuillez noter que cette fonction ne valide pas l'ensemble de réclamations.

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

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

**jeton (obligatoire)**  
Jeton codé pour validation. Il doit s'agir d'un JavaScript tampon.

**HandlerContext (obligatoire)**  
Un JavaScript objet qui stocke le contexte de l'appel ValidateToken. À l'heure actuelle, seule la propriété clé est prise en charge.

**clé (obligatoire)**  
Clé secrète pour le calcul du résumé du message. Peut être fourni sous forme de chaîne ou de JavaScript tampon.

### Réponse
<a name="validatetoken-response"></a>

Lorsque la `validateToken()` méthode renvoie un jeton validé avec succès, la réponse de la fonction est au format suivant. `CWTObject` Une fois décodées, toutes les clés de réclamation sont représentées sous forme de chaînes.

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

### Exemple - Valider un jeton avec un enfant envoyé dans le cadre du jeton
<a name="validatetoken-example"></a>

Cet exemple illustre la validation du jeton CWT, où l'enfant est extrait de l'en-tête. L'enfant est ensuite transmis KeyValueStore à CloudFront Functions pour récupérer la clé secrète utilisée pour valider le jeton.

```
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;
}
```

## méthode generateToken ()
<a name="generatetoken-method"></a>

Cette fonction génère un nouveau jeton CWT à l'aide de la charge utile et des paramètres contextuels fournis.

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

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

**GeneratorContext (obligatoire)**  
Il s'agit d'un JavaScript objet qui est utilisé comme contexte pour générer le jeton et qui contient les paires clé-valeur suivantes :    
**CWTtag (facultatif)**  
Cette valeur est une valeur booléenne qui, si elle `true` indique qu'elle `cwtTag` doit être ajoutée.  
**CoseTag (obligatoire)**  
Spécifie le type de balise COSE. Actuellement, seuls les supports`MAC0`.  
**clé (obligatoire)**  
Clé secrète pour calculer le résumé du message. Cette valeur peut être une chaîne ou JavaScript `Buffer`.

**charge utile (obligatoire)**  
Charge utile du jeton pour l'encodage. La charge utile doit être `CWTObject` formatée.

### Réponse
<a name="generatetoken-response"></a>

Renvoie un JavaScript Buffer contenant le jeton codé.

**Example : Génère un jeton 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 : Actualiser le jeton en fonction d'une certaine logique**  

```
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;
}
```

# Méthodes d'assistance générales
<a name="general-helper-methods"></a>

Cette page fournit des méthodes d'assistance supplémentaires dans CloudFront Functions. Pour utiliser ces méthodes, créez une CloudFront fonction à l'aide de JavaScript Runtime 2.0.

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

Pour de plus amples informations, veuillez consulter [JavaScript fonctionnalités d'exécution 2.0 pour CloudFront Functions](functions-javascript-runtime-20.md).

## `edgeLocation`métadonnées
<a name="edge-location-metadata"></a>

Cette méthode nécessite l'utilisation du `cloudfront` module.

**Note**  
Vous ne pouvez utiliser cette méthode que pour les fonctions de demande de consultation. Pour les fonctions de réponse du spectateur, cette méthode est vide.

Utilisez cet JavaScript objet pour obtenir le code de l'aéroport de localisation périphérique, la région de [cache périphérique régionale](HowCloudFrontWorks.md#CloudFrontRegionaledgecaches) attendue ou l'adresse IP CloudFront du serveur utilisée pour traiter la demande. Ces métadonnées ne sont disponibles que lors du déclencheur de l'événement de demande du spectateur.

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

L'`cf.edgeLocation`objet peut contenir les éléments suivants :

**name**  
Le [code IATA](https://en.wikipedia.org/wiki/IATA_airport_code) à trois lettres de l'emplacement périphérique qui a traité la demande.

**IP du serveur**  
 IPv6 Adresse IPv4 ou du serveur qui a traité la demande.

**region**  
Le cache périphérique CloudFront régional (REC) que la demande est *censée* utiliser en cas d'échec du cache. Cette valeur n'est pas mise à jour si le REC attendu n'est pas disponible et qu'un REC de sauvegarde est utilisé pour la demande. Cela n'inclut pas l'emplacement d'Origin Shield utilisé, sauf dans les cas où le REC principal et l'Origin Shield se trouvent au même endroit.

**Note**  
CloudFront Les fonctions ne sont pas invoquées une seconde fois lorsqu'elles CloudFront sont configurées pour utiliser le basculement d'origine. Pour de plus amples informations, veuillez consulter [Optimisez la haute disponibilité grâce au basculement CloudFront d'origine](high_availability_origin_failover.md).

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

Cette méthode ne nécessite pas le `cloudFront` module.

Utilisez `rawQueryString()` cette méthode pour récupérer la chaîne de requête non analysée et non modifiée sous forme de chaîne.

**Demande**

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

**Réponse**

Renvoie la chaîne de requête complète de la demande entrante sous forme de valeur de chaîne sans le début`?`. 
+ S'il n'y a pas de chaîne de requête, mais `?` que celle-ci est présente, les fonctions renvoient une chaîne vide. 
+ S'il n'y a pas de chaîne de requête et si elle `?` n'est pas présente, la fonction revient`undefined`.

**Cas 1 : chaîne de requête complète renvoyée (sans début`?`)**  
URL de la demande entrante : `https://example.com/page?name=John&age=25&city=Boston`  
`rawQueryString()`renvoie : `"name=John&age=25&city=Boston"`

**Cas 2 : chaîne vide renvoyée (lorsqu'elle `?` est présente mais sans paramètres)**  
URL de la demande entrante : `https://example.com/page?`  
`rawQueryString()`renvoie : `""`

**Cas 3 : `undefined` renvoyé (aucune chaîne de requête et non`?`)**  
URL de la demande entrante : `https://example.com/page`  
`rawQueryString()`renvoie : `undefined`