Here is your custom content.
" } } } ``` ## Exemple d'objet d'événement 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 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 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 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 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 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 Les objets d’erreurs suivants sont pris en charge : + `Error` + `EvalError` + `InternalError` + `MemoryError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Globals 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 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) 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 **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 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 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 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 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 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 Les objets d’erreurs suivants sont pris en charge : + `Error` + `EvalError` + `InternalError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Globals 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 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 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 **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 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 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 **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()` 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 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()` 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()` 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 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 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 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 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 () 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 ``` 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 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 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 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 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()` 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 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 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 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 () 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 ``` 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 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 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 () Cette fonction génère un nouveau jeton CWT à l'aide de la charge utile et des paramètres contextuels fournis. ### Demande ``` 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 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 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 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()` 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` # Création de fonctions La création d’une fonction se déroule en deux temps : 1. Création du code de fonction en JavaScript. Vous pouvez utiliser l’exemple par défaut de la console CloudFront ou écrire le vôtre. Pour plus d’informations, consultez les rubriques suivantes : + [Écriture du code de la fonction](writing-function-code.md) + [CloudFront Fonctions et structure des événements](functions-event-structure.md) + [CloudFront Exemples de fonctions pour CloudFront](service_code_examples_cloudfront_functions_examples.md) 1. Utilisation de CloudFront pour créer la fonction et inclure votre code. Le code existe à l’intérieur de la fonction (et non en tant que référence). ------ #### [ Console ] **Pour créer une fonction** 1. Connectez-vous à la console CloudFront à l’adresse [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) et sélectionnez la page **Fonctions**. 1. Sélectionnez **Créer une fonction**. 1. Entrez un nom de fonction unique au sein du Compte AWS, puis choisissez la version de JavaScript et choisissez **Continuer**. La page de détails s’affiche pour la nouvelle fonction. **Note** Si vous souhaitez utiliser des [paires clé-valeur](kvs-with-functions.md) dans la fonction, vous devez choisir l’environnement d’exécution JavaScript 2.0. 1. Dans la section **Code de fonction**, sélectionnez l’onglet **Création** et entrez votre code de fonction. L’exemple de code inclus dans l’onglet **Création** illustre la syntaxe de base du code de fonction. 1. Sélectionnez **Enregistrer les modifications**. 1. Si le code de fonction utilise des paires clé-valeur, vous devez associer un magasin de clés-valeurs. Vous pouvez associer le magasin de clés-valeurs lors de la création initiale de la fonction. Ou, vous pouvez l’associer ultérieurement, en [mettant à jour la fonction](update-function.md). Pour associer un magasin de clés-valeurs dès maintenant, procédez comme suit : + Accédez à la section **Magasin de clés-valeurs associé**, choisissez **Associer le magasin de clés-valeurs existant**. + Sélectionnez le magasin de clés-valeurs qui contient les paires clé-valeur de la fonction, puis choisissez **Associer KeyValueStore**. CloudFront associe immédiatement le magasin à la fonction. Vous n’avez pas besoin d’enregistrer la fonction. ------ #### [ CLI ] Si vous utilisez la CLI, vous commencez généralement par créer le code de fonction dans un fichier, puis vous créez la fonction avec AWS CLI. **Pour créer une fonction** 1. Créez le code de fonction dans un fichier et stockez-le dans un répertoire auquel votre ordinateur peut se connecter. 1. Exécutez la commande, comme illustré dans l’exemple. Cet exemple utilise la notation `fileb://` pour transmettre le fichier. Il inclut également des sauts de ligne pour rendre la commande plus lisible. ``` aws cloudfront create-function \ --name MaxAge \ --function-config '{"Comment":"Max Age 2 years","Runtime":"cloudfront-js-2.0","KeyValueStoreAssociations":{"Quantity":1,"Items":[{"KeyValueStoreARN":"arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"}]}}' \ --function-code fileb://function-max-age-v1.js ``` **Remarques** `Runtime` : la version de JavaScript. Pour utiliser des [paires clé-valeur](kvs-with-functions.md) dans la fonction, vous devez spécifier la version 2.0. `KeyValueStoreAssociations` : si votre fonction utilise des paires clé-valeur, vous pouvez associer le magasin de clés-valeurs lors de la création initiale de la fonction. Ou vous pouvez l’associer ultérieurement, en utilisant `update-function`. `Quantity` a toujours pour valeur `1`, car chaque fonction peut être associée uniquement à un seul magasin de clés-valeurs. Lorsque la commande s’exécute correctement, vous obtenez une sortie similaire à ce qui suit. ``` ETag: ETVABCEXAMPLE FunctionSummary: FunctionConfig: Comment: Max Age 2 years Runtime: cloudfront-js-2.0 KeyValueStoreAssociations= \ {Quantity=1, \ Items=[{KeyValueStoreARN='arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111'}]} \ FunctionMetadata: CreatedTime: '2021-04-18T20:38:56.915000+00:00' FunctionARN: arn:aws:cloudfront::111122223333:function/MaxAge LastModifiedTime: '2023-11-19T20:38:56.915000+00:00' Stage: DEVELOPMENT Name: MaxAge Status: UNPUBLISHED Location: https://cloudfront.amazonaws.com/2020-05-31/function/arn:aws:cloudfront:::function/MaxAge ``` La plupart des informations proviennent de la demande. Les autres informations sont ajoutées par CloudFront. **Remarques** `ETag` : cette valeur change chaque fois que vous modifiez le magasin de clés-valeurs. Vous utilisez cette valeur et le nom de la fonction pour référencer la fonction à l’avenir. Assurez-vous de toujours utiliser l’`ETag` actuel. `FunctionARN` : l’ARN de votre fonction CloudFront. 111122223333 : le Compte AWS. `Stage` : le stade de la fonction (`LIVE` ou `DEVELOPMENT`). `Status` : l’état de la fonction (`PUBLISHED` ou `UNPUBLISHED`). ------ Une fois que vous avez créé la fonction, elle est ajoutée à la phase `DEVELOPMENT`. Nous vous recommandons de [tester votre fonction](test-function.md) avant de la [publier](publish-function.md). Une fois que vous avez publié votre fonction, celle-ci passe à la phase `LIVE`. # Fonctions de test Avant de déployer la fonction en phase réelle (production), vous pouvez la tester afin de vérifier qu’elle fonctionne comme prévu. Pour tester une fonction, vous devez spécifier un *objet d'événement* qui représente une requête ou une réponse HTTP que votre CloudFront distribution pourrait recevoir en production. CloudFront Functions effectue les opérations suivantes : 1. Exécute la fonction, en utilisant l'objet d'événement fourni comme entrée. 1. Renvoie le résultat de la fonction (l'objet d'évènement modifié) ainsi que les journaux de fonction ou les messages d'erreurs et l'*utilisation du calcul* de la fonction. Pour plus d'informations sur l'utilisation du calcul, consultez [Présentation de l’utilisation du calcul](#compute-utilization). **Note** Lorsque vous testez une fonction, elle CloudFront ne valide que par rapport aux erreurs d'exécution de la fonction. CloudFrontne valide pas si la demande sera traitée correctement une fois publiée. Par exemple, si votre fonction supprime un en-tête obligatoire, le test sera validé puisqu’aucune erreur n’est détectée dans le code. Toutefois, si vous publiez la fonction et que vous l'associez à une distribution, elle échouera lorsqu'une demande sera envoyée CloudFront. **Contents** + [Configuration de l’objet d’événement](#test-function-create-event) + [Tester la fonction](#test-function-step-test) + [Présentation de l’utilisation du calcul](#compute-utilization) ## Configuration de l’objet d’événement Avant de tester une fonction, vous devez configurer l’objet d’événement avec lequel la tester. Il existe plusieurs options. **Option 1 : configurer un objet d’événement sans l’enregistrer** Vous pouvez configurer un objet d'événement dans l'éditeur visuel de la CloudFront console sans l'enregistrer. Vous pouvez utiliser cet objet d'événement pour tester la fonction depuis la CloudFront console, même si elle n'est pas enregistrée. **Option 2 : créer un objet d’événement dans l’éditeur visuel** Vous pouvez configurer un objet d'événement dans l'éditeur visuel de la CloudFront console sans l'enregistrer. Vous pouvez créer 10 objets d’événement pour chaque fonction afin de pouvoir, par exemple, tester différentes entrées possibles. Lorsque vous créez l'objet d'événement de cette manière, vous pouvez l'utiliser pour tester la fonction dans la CloudFront console. Vous ne pouvez pas l'utiliser pour tester la fonction à l'aide d'une AWS API ou d'un SDK. **Option 3 : créer un objet d’événement à l’aide d’un éditeur de texte** Vous pouvez utiliser un éditeur de texte pour créer un objet d’événement au format JSON. Pour en savoir plus sur la structure d’un objet d’événement, consultez [Structure d’évènements](functions-event-structure.md). Vous pouvez utiliser cet objet d’événement pour tester la fonction à l’aide de la CLI. Mais vous ne pouvez pas l'utiliser pour tester la fonction dans la CloudFront console. **Pour créer un objet d’évènement (option 1 ou 2)** 1. Connectez-vous à la CloudFront console à l'adresse [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) et sélectionnez la page **Fonctions**. Choisissez la fonction que vous souhaitez tester. 1. Sur la page de détails de la fonction, choisissez l’onglet **Test**. 1. Pour **Type d’événement**, choisissez l’une des options suivantes : + Choisissez **Demande de l’utilisateur** si la fonction modifie une requête HTTP ou génère une réponse basée sur la demande. La section **Demande** apparaît. + Choisissez **Réponse de l’utilisateur**. Les sections **Demande** et **Réponse** apparaissent. 1. Complétez les champs que vous souhaitez inclure dans l’événement. Vous pouvez choisir **Modifier JSON** pour afficher le code JSON brut. 1. (Facultatif) Pour enregistrer l’événement, choisissez **Enregistrer** et dans le champ **Enregistrer l’événement de test**, entrez un nom, puis sélectionnez **Enregistrer**. Vous pouvez également choisir **Modifier le JSON**, copier le JSON brut et l'enregistrer dans votre propre fichier, en dehors de CloudFront. **Pour créer un objet d’évènement (option 3)** Créez l’objet d’événement à l’aide d’un éditeur de texte. Stockez le fichier dans un répertoire auquel votre ordinateur peut se connecter. Assurez-vous de suivre les consignes suivantes : + Omettez les champs `distributionDomainName`, `distributionId` et `requestId`. + Les noms des en-têtes, des cookies et des chaînes de requête doivent être en minuscule. Une option permettant de créer un objet d’événement de cette manière consiste à créer un échantillon à l’aide de l’éditeur visuel. Vous pouvez être sûr que l’échantillon est correctement formaté. Vous pouvez ensuite copier le code JSON brut, le coller dans un éditeur de texte et enregistrer le fichier. Pour plus d’informations sur la structure d’un évènement, consultez [Structure d’évènements](functions-event-structure.md). ## Tester la fonction Vous pouvez tester une fonction dans la CloudFront console ou avec le AWS Command Line Interface (AWS CLI). ------ #### [ Console ] **Pour tester la fonction** 1. Connectez-vous à la CloudFront console à l'adresse [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) et sélectionnez la page **Fonctions**. 1. Choisissez la fonction que vous souhaitez tester. 1. Choisissez l’onglet **Test**. 1. Assurez-vous que l’événement correct est affiché. Pour remplacer l’événement actuellement affiché, choisissez un autre événement dans le champ **Sélectionnez un événement de test**. 1. Choisissez **Fonction de test**. La console affiche la sortie de la fonction, y compris les journaux de la fonction et l’utilisation du calcul. ------ #### [ CLI ] Vous pouvez tester une fonction à l’aide de la commande **aws cloudfront test-function**. **Pour tester la fonction** 1. Ouvrez une fenêtre de ligne de commande. 1. Exécutez la commande suivante depuis le même répertoire que celui qui contient le fichier indiqué. Cet exemple utilise la notation `fileb://` pour transmettre le fichier d’objet d’événement. Il inclut également des sauts de ligne pour rendre la commande plus lisible. ``` aws cloudfront test-function \ --name MaxAge \ --if-match ETVABCEXAMPLE \ --event-object fileb://event-maxage-test01.json \ --stage DEVELOPMENT ``` **Remarques** Vous référencez la fonction par son nom et ETag (dans le `if-match` paramètre). Vous référencez l’objet d’événement par son emplacement dans votre système de fichiers. Il peut s’agir de la phase `DEVELOPMENT` ou `LIVE`. Lorsque la commande s’exécute correctement, vous obtenez une sortie similaire à ce qui suit. ``` TestResult: ComputeUtilization: '21' FunctionErrorMessage: '' FunctionExecutionLogs: [] FunctionOutput: '{"response":{"headers":{"cloudfront-functions":{"value":"generated-by-CloudFront-Functions"},"location":{"value":"https://aws.amazon.com/cloudfront/"}},"statusDescription":"Found","cookies":{},"statusCode":302}}' FunctionSummary: FunctionConfig: Comment: MaxAge function Runtime: cloudfront-js-2.0 KeyValueStoreAssociations= \ {Quantity=1, \ Items=[{KeyValueStoreARN='arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111'}]} \ FunctionMetadata: CreatedTime: '2021-04-18T20:38:56.915000+00:00' FunctionARN: arn:aws:cloudfront::111122223333:function/MaxAge LastModifiedTime: '2023-17-20T10:38:57.057000+00:00' Stage: DEVELOPMENT Name: MaxAge Status: UNPUBLISHED ``` ------ **Remarques** `FunctionExecutionLogs` contient une liste de lignes de journaux que la fonction a écrites dans les instructions `console.log()` (le cas échéant). `ComputeUtilization` contient des informations sur l’exécution de votre fonction. Consultez [Présentation de l’utilisation du calcul](#compute-utilization). `FunctionOutput` contient l'objet d'évènement renvoyé par la fonction. ## Présentation de l’utilisation du calcul L'**utilisation du calcul** est la durée d'exécution de la fonction en pourcentage de la durée maximale autorisée. Par exemple, une valeur de 35 signifie que la durée d’exécution de la fonction représente 35 % du temps maximum autorisé. Si une fonction dépasse continuellement la durée maximale autorisée CloudFront , elle ralentit. La liste suivante explique la probabilité qu'une fonction soit limitée en fonction de la valeur d'utilisation du calcul. **Valeur d'utilisation du calcul :** + **1 – 50** : la fonction est largement inférieure à la durée maximale autorisée et devrait s'exécuter sans aucune limitation. + **51 – 70** : la fonction approche de la durée maximale autorisée. Pensez à optimiser le code de fonction. + **71 — 100** — La durée maximale autorisée de la fonction est très proche ou supérieure. CloudFront est susceptible de limiter cette fonction si vous l'associez à une distribution. # Mise à jour de fonctions Vous pouvez mettre à jour une fonction à tout moment. Les modifications sont apportées uniquement à la version de la fonction qui figure dans la phase `DEVELOPMENT`. Pour copier les mises à jour de la phase `DEVELOPMENT` vers `LIVE`, vous devez [publier la fonction](publish-function.md). Vous pouvez mettre à jour le code d'une fonction dans la CloudFront console ou avec le AWS Command Line Interface (AWS CLI). ------ #### [ Console ] **Pour mettre à jour le code de la fonction** 1. Connectez-vous à la CloudFront console à l'adresse [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) et sélectionnez la page **Fonctions**. Sélectionnez la fonction à mettre à jour. 1. Choisissez **Modifier** et apportez les modifications suivantes : + Mettez à jour tous les champs de la section **Détails**. + Modifiez ou supprimez le magasin de clés-valeurs associé. Pour plus d’informations sur les magasins de clés-valeurs, consultez [Amazon CloudFront KeyValueStore](kvs-with-functions.md). + Modifiez le code de la fonction. Choisissez l’onglet **Création**, apportez des modifications, puis sélectionnez **Enregistrer les modifications** pour enregistrer les modifications apportées au code. ------ #### [ CLI ] **Mettre à jour le code de la fonction.** 1. Ouvrez une fenêtre de ligne de commande. 1. Exécutez la commande suivante. Cet exemple utilise la notation `fileb://` pour transmettre le fichier. Il inclut également des sauts de ligne pour rendre la commande plus lisible. ``` aws cloudfront update-function \ --name MaxAge \ --function-config '{"Comment":"Max Age 2 years","Runtime":"cloudfront-js-2.0","KeyValueStoreAssociations":{"Quantity":1,"Items":[{"KeyValueStoreARN":"arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"}]}}' \ --function-code fileb://function-max-age-v1.js \ --if-match ETVABCEXAMPLE ``` **Remarques** Vous pouvez identifier la fonction à la fois par son nom et ETag (dans le `if-match` paramètre). Assurez-vous d'utiliser le courant ETag. Vous pouvez obtenir cette valeur à partir de l'opération [DescribeFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeFunction.html)d'API. Vous devez inclure l’élément `function-code`, même si vous ne voulez pas le modifier. Soyez prudent avec l’élément `function-config`. Vous devez transmettre tout ce que vous voulez conserver dans la configuration. En particulier, gérez le magasin de clés-valeurs comme suit : Pour conserver l’association de magasin de clés-valeurs existante (le cas échéant), spécifiez le nom du magasin *existant*. Pour modifier l’association, spécifiez le nom du *nouveau* magasin de clés-valeurs. Pour supprimer l’association, omettez le paramètre `KeyValueStoreAssociations`. Lorsque la commande s’exécute correctement, vous obtenez une sortie similaire à ce qui suit. ``` ETag: ETVXYZEXAMPLE FunctionSummary: FunctionConfig: Comment: Max Age 2 years \ Runtime: cloudfront-js-2.0 \ KeyValueStoreAssociations= \ {Quantity=1, \ Items=[{KeyValueStoreARN='arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111'}]} \ FunctionMetadata: \ CreatedTime: '2021-04-18T20:38:56.915000+00:00' \ FunctionARN: arn:aws:cloudfront::111122223333:function/MaxAge \ LastModifiedTime: '2023-12-19T23:41:15.389000+00:00' \ Stage: DEVELOPMENT \ Name: MaxAge \ Status: UNPUBLISHED ``` ------ La plupart des informations proviennent de la demande. D'autres informations sont ajoutées par CloudFront. **Remarques** `ETag` : cette valeur change chaque fois que vous modifiez le magasin de clés-valeurs. `FunctionARN`— L'ARN de votre CloudFront fonction. `Stage` : le stade de la fonction (`LIVE` ou `DEVELOPMENT`). `Status` : l’état de la fonction (`PUBLISHED` ou `UNPUBLISHED`). # Publication de fonctions Lorsque vous publiez votre fonction, celle-ci est copiée de l’étape `DEVELOPMENT` vers l’étape `LIVE`. Si aucun comportement de cache n’est associé à la fonction, sa publication vous permet de l’associer à un comportement de cache. Vous pouvez uniquement associer des comportements de cache à des fonctions qui sont à l'étape `LIVE`. **Important** Nous recommandons de [tester la fonction](test-function.md) avant de la publier. Une fois la fonction publiée, tous les comportements de cache qui lui sont associés commencent automatiquement à utiliser la nouvelle copie publiée, dès que les distributions ont terminé leur déploiement. Vous pouvez publier une fonction dans la console CloudFront ou avec AWS CLI. ------ #### [ Console ] **Pour publier une fonction** 1. Connectez-vous à la console CloudFront à l’adresse [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) et sélectionnez la page **Fonctions**. 1. Sélectionnez la fonction à mettre à jour. 1. Choisissez l’onglet **Publier**, puis sélectionnez **Publier**. Si votre fonction est déjà associée à un ou plusieurs comportements de cache, choisissez **Publier et mettre à jour**. 1. (Facultatif) Pour afficher les distributions associées à la fonction, choisissez **Distributions CloudFront associées** pour développer cette section. En cas de réussite, une bannière apparaît en haut de la page avec le message : ***Nom de la fonction* publié**. Vous pouvez également choisir l'onglet **Générer**, puis **Live** pour afficher la version live du code de fonction. ------ #### [ CLI ] **Pour publier une fonction** 1. Ouvrez une fenêtre de ligne de commande. 1. Exécutez la commande suivante **aws cloudfront publish-function**. Dans l’exemple, des sauts de ligne sont fournis pour rendre l’exemple plus lisible. ``` aws cloudfront publish-function \ --name MaxAge \ --if-match ETVXYZEXAMPLE ``` Lorsque la commande s’exécute correctement, vous obtenez une sortie similaire à ce qui suit. ``` FunctionSummary: FunctionConfig: Comment: Max Age 2 years Runtime: cloudfront-js-2.0 FunctionMetadata: CreatedTime: '2021-04-18T21:24:21.314000+00:00' FunctionARN: arn:aws:cloudfront::111122223333:function/ExampleFunction LastModifiedTime: '2023-12-19T23:41:15.389000+00:00' Stage: LIVE Name: MaxAge Status: UNASSOCIATED ``` ------ # Association de fonctions à des distributions Pour utiliser une fonction avec une distribution, associez la fonction à un ou plusieurs comportements de cache dans la distribution. Vous pouvez associer une fonction à plusieurs comportements de cache dans plusieurs distributions. Vous pouvez associer une fonction avec l’un des éléments suivants : + Un comportement de cache existant + Un nouveau comportement de cache dans une distribution existante + Un nouveau comportement de cache dans une nouvelle distribution Lorsque vous associez une fonction à un comportement de cache, vous devez choisir un *type d'évènement*. Le type d’évènement détermine quand CloudFront exécute la fonction. Vous pouvez choisir parmi les types d’événement suivants : + **Demande utilisateur** : la fonction s’exécute lorsque CloudFront reçoit une demande provenant d’un utilisateur. + **Réponse utilisateur** – la fonction s'exécute avant que CloudFront ne renvoie une réponse à l'utilisateur. Vous ne pouvez pas utiliser de types d’évènements orientés vers l’origine (*requête d’origine* et *réponse d’origine*) avec Fonctions CloudFront. Vous pouvez utiliser Lambda@Edge à la place. Pour plus d’informations, consultez [CloudFront événements pouvant déclencher une fonction Lambda @Edge](lambda-cloudfront-trigger-events.md). **Note** Avant d'associer une fonction, vous devez [la publier](publish-function.md) à l'étape `LIVE`. Vous pouvez associer une fonction à une distribution dans la console CloudFront ou avec l’AWS Command Line Interface (AWS CLI). La procédure suivante montre comment associer une fonction à un comportement de cache existant. ------ #### [ Console ] **Pour associer une fonction à un comportement de cache existant** 1. Connectez-vous à la console CloudFront à l’adresse [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) et sélectionnez la page **Fonctions**. 1. Choisissez la fonction que vous souhaitez associer. 1. Sur la page **Fonction**, choisissez l’onglet **Publier**. 1. Choisissez **Fonction Publier**. 1. Choisissez **Ajouter une association**. Dans la boîte de dialogue qui apparaît, choisissez une distribution, un type d’événement et/ou un comportement de cache. Pour le type d’événement, choisissez le moment où vous souhaitez que cette fonction s’exécute : + **Demande de l’utilisateur** : exécute la fonction chaque fois que CloudFront reçoit une demande. + **Réponse de l’utilisateur** : exécute la fonction chaque fois que CloudFront renvoie une réponse. 1. Pour enregistrer la configuration, choisissez **Ajouter une association**. CloudFront associe la distribution à la fonction. Attendez quelques minutes pour que la distribution associée termine son déploiement. Vous pouvez choisir **Afficher la distribution** sur la page de détails de la fonction pour vérifier la progression. ------ #### [ CLI ] **Pour associer une fonction à un comportement de cache existant** 1. Ouvrez une fenêtre de ligne de commande. 1. Saisissez la commande suivante pour enregistrer la configuration de distribution pour la distribution dont vous souhaitez associer le comportement de cache à une fonction. Cette commande enregistre la configuration de distribution dans un fichier nommé `dist-config.yaml`. Pour utiliser cette commande, procédez comme suit : + Remplacez *`DistributionID`* par l'ID de la distribution. + Exécutez la commande sur une ligne. Dans l’exemple, des sauts de ligne sont fournis pour rendre l’exemple plus lisible. ``` aws cloudfront get-distribution-config \ --id DistributionID \ --output yaml > dist-config.yaml ``` Lorsque la commande réussit, AWS CLI ne renvoie aucune sortie. 1. Ouvrez le fichier nommé `dist-config.yaml` que vous avez créé. Apportez les modifications suivantes au fichier. 1. Renommez le champ `ETag` en `IfMatch`, mais ne modifiez pas la valeur du champ. 1. Dans le comportement du cache, recherchez l'objet nommé `FunctionAssociations`. Mettez à jour cet objet pour ajouter une association de fonctions. La syntaxe YAML pour une association de fonctions ressemble à l'exemple ci-dessous. + L'exemple suivant montre un objet d'évènement de requête utilisateur (déclenchement). Pour utiliser le type d'évènement Réponse utilisateur, remplacez `viewer-request` par `viewer-response`. + Remplacez *`arn:aws:cloudfront::111122223333:function/ExampleFunction`* par l'Amazon Resource Name (ARN) de la fonction que vous associez à ce comportement de cache. Pour obtenir l'ARN de la fonction, vous pouvez utiliser la commande **aws cloudfront list-functions**. ``` FunctionAssociations: Items: - EventType: viewer-request FunctionARN: arn:aws:cloudfront::111122223333:function/ExampleFunction Quantity: 1 ``` 1. Après avoir effectué ces modifications, enregistrez le fichier. 1. Utilisez la commande suivante pour mettre à jour la distribution, en ajoutant l'association de fonctions. Pour utiliser cette commande, procédez comme suit : + Remplacez *`DistributionID`* par l'ID de la distribution. + Exécutez la commande sur une ligne. Dans l’exemple, des sauts de ligne sont fournis pour rendre l’exemple plus lisible. ``` aws cloudfront update-distribution \ --id DistributionID \ --cli-input-yaml file://dist-config.yaml ``` Lorsque la commande réussit, vous voyez une sortie similaire à la suivante, qui décrit la distribution qui vient d'être mise à jour avec l'association de fonctions. L'exemple de sortie suivant est tronqué pour plus de lisibilité. ``` Distribution: ARN: arn:aws:cloudfront::111122223333:distribution/EBEDLT3BGRBBW ... truncated ... DistributionConfig: ... truncated ... DefaultCacheBehavior: ... truncated ... FunctionAssociations: Items: - EventType: viewer-request FunctionARN: arn:aws:cloudfront::111122223333:function/ExampleFunction Quantity: 1 ... truncated ... DomainName: d111111abcdef8.cloudfront.net Id: EDFDVBD6EXAMPLE LastModifiedTime: '2021-04-19T22:39:09.158000+00:00' Status: InProgress ETag: E2VJGGQEG1JT8S ``` ------ Le `Status` de la distribution passe à `InProgress` pendant le redéploiement de la distribution. Lorsque la nouvelle configuration de distribution atteint un emplacement périphérique CloudFront, cet emplacement commence à utiliser la fonction associée. Lorsque la distribution est entièrement déployée, l’`Status` repasse à `Deployed`. Cela indique que la fonction CloudFront associée est active dans l’ensemble des emplacements périphériques CloudFront dans le monde. Cela prend généralement quelques minutes. # Amazon CloudFront KeyValueStore CloudFront KeyValueStore est une banque de données de valeurs clés sécurisée, globale et à faible latence qui permet un accès en lecture depuis [CloudFront Functions](cloudfront-functions.md), permettant ainsi une logique personnalisable avancée aux emplacements CloudFront périphériques. Vous pouvez ainsi mettre à jour le code de fonction et les données associées à une fonction indépendamment les unes des autres. CloudFront KeyValueStore Cette séparation simplifie le code des fonctions et facilite la mise à jour des données sans qu’il soit nécessaire de déployer des modifications de code. **Note** Pour être utilisée CloudFront KeyValueStore, votre CloudFront fonction doit utiliser le [JavaScript runtime 2.0](functions-javascript-runtime-20.md). La procédure générale d’utilisation des paires clé-valeur est la suivante : + Créez un magasin de clés-valeurs et remplissez-le avec un ensemble de paires clé-valeur. Vous pouvez ajouter vos magasins de clés-valeurs à un compartiment Amazon S3 ou les saisir manuellement. + Associez les magasins de valeurs clés à votre CloudFront fonction. + Dans votre code de fonction, utilisez le nom de la clé pour extraire la valeur associée à la clé ou pour évaluer si une clé existe. Pour plus d’informations sur l’utilisation de paires clé-valeur dans le code de fonction, ainsi que sur les méthodes d’assistance, consultez [Méthodes d’aide pour les magasins de clés-valeurs](functions-custom-methods.md). ## Cas d’utilisation Vous pouvez utiliser des paires clé-valeur pour les exemples suivants : + **Réécritures ou redirections d'URL** : la paire clé-valeur peut contenir la réécriture ou la redirection URLs . URLs + **Tests A/B et indicateurs de fonctionnalités** : vous pouvez créer une fonction pour effectuer des tests en attribuant un pourcentage de trafic à une version spécifique de votre site web. + **Autorisation d’accès** : vous pouvez implémenter un contrôle d’accès pour autoriser ou refuser les demandes en fonction de critères que vous avez définis et des données stockées dans un magasin de clés-valeurs. ## Formats de valeurs pris en charge Vous pouvez stocker la valeur d’une paire clé-valeur dans l’un des formats suivants : + String + Chaîne codée en octets + JSON ## Sécurité La CloudFront fonction et toutes ses valeurs clés stockent les données sont traitées de manière sécurisée, comme suit : + CloudFront chiffre chaque valeur clé stockée au repos et pendant le transit (lors de la lecture ou de l'écriture dans les magasins de valeurs clés) lorsque vous appelez les opérations de l'[CloudFront KeyValueStore](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_Operations_Amazon_CloudFront_KeyValueStore.html)API. + Lorsque la fonction est exécutée, CloudFront déchiffre chaque paire clé-valeur en mémoire aux emplacements périphériques. CloudFront Pour commencer CloudFront KeyValueStore, consultez les rubriques suivantes. **Topics** + [Cas d’utilisation](#key-value-store-use-cases) + [Formats de valeurs pris en charge](#key-value-store-supported-formats) + [Sécurité](#key-value-store-security) + [Utilisation de magasins de clés-valeurs](kvs-with-functions-kvs.md) + [Utilisation de données clé-valeur](kvs-with-functions-kvp.md) + Pour plus d'informations sur la mise en route CloudFront KeyValueStore, consultez le billet de CloudFront KeyValueStore AWS blog « [Présentation d'Amazon](https://aws.amazon.com/blogs/aws/introducing-amazon-cloudfront-keyvaluestore-a-low-latency-datastore-for-cloudfront-functions/) ». # Utilisation de magasins de clés-valeurs Vous devez créer un magasin clé-valeur pour contenir les paires clé-valeur que vous souhaitez utiliser dans CloudFront Functions. Après avoir créé les magasins de valeurs clés et les paires clé-valeur ajoutées, vous pouvez utiliser les valeurs clés dans votre code de CloudFront fonction. Pour commencer, consultez les rubriques suivantes : **Topics** + [Création d’un magasin de clés-valeurs](kvs-with-functions-create.md) + [Association d’un magasin de clés-valeurs à une fonction](kvs-with-functions-associate.md) + [Mise à jour d’un magasin de clés-valeurs](kvs-with-functions-edit.md) + [Obtention d’une référence à un magasin de clés-valeurs](kvs-with-functions-get-reference.md) + [Suppression d’un magasin de clés-valeurs](kvs-with-functions-delete.md) + [Format de fichier pour les paires clé-valeur](kvs-with-functions-create-s3-kvp.md) **Note** Le JavaScript runtime 2.0 inclut des méthodes d'assistance pour travailler avec des valeurs clés dans le code de fonction. Pour de plus amples informations, veuillez consulter [Méthodes d’aide pour les magasins de clés-valeurs](functions-custom-methods.md). # Création d’un magasin de clés-valeurs Vous pouvez créer un magasin de clés-valeurs et ses paires clé-valeur en même temps. Vous pouvez également créer un magasin de clés-valeurs vide, puis ajouter des paires clé-valeur ultérieurement. **Note** Si vous spécifiez votre source de données à partir d’un compartiment Amazon S3, vous devez disposer des autorisations `s3:GetObject` et `s3:GetBucketLocation` pour ce compartiment. Si vous ne disposez pas de ces autorisations, vous ne CloudFront pourrez pas créer correctement votre magasin de valeurs clés. Décidez si vous souhaitez ajouter des paires clé-valeur en même temps que vous créez le magasin de clés-valeurs. Vous pouvez importer vos paires clé-valeur à l'aide de la CloudFront console, de l' CloudFrontAPI ou. AWS SDKs Toutefois, vous ne pouvez importer votre fichier de paires clé-valeur que lorsque vous créez *initialement* le magasin de clés-valeurs. Pour créer un fichier de paires clé-valeur, consultez [Format de fichier pour les paires clé-valeur](kvs-with-functions-create-s3-kvp.md). ------ #### [ Console ] **Pour créer un magasin de clés-valeurs** 1. Connectez-vous à la page **Fonctions AWS Management Console et ouvrez-la** dans la CloudFront console à l'adresse[https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Choisissez l'**KeyValueStores**onglet, puis sélectionnez **Créer KeyValueStore**. 1. Entrez un nom et une description facultative pour le magasin de clés-valeurs. 1. Complétez **URI S3** : + Si vous disposez d’un fichier de paires clé-valeur, entrez le chemin d’accès au compartiment Amazon S3 où vous avez stocké le fichier. + Laissez ce champ vide si vous prévoyez d’entrer manuellement les paires clé-valeur. 1. Choisissez **Créer**. Le magasin de clés-valeurs existe désormais. La page de détails du nouveau magasin de clés-valeurs apparaît. Les informations figurant sur cette page incluent l’ID et l’ARN du magasin de clés-valeurs. + L'identifiant est une chaîne de caractères aléatoire unique dans votre Compte AWS. + La syntaxe de l’ARN est la suivante : *Compte AWS*`:key-value-store/`*the key value stores ID* 1. Examinez la section **Paires clé-valeur**. Si vous avez importé un fichier, cette section présente quelques paires clé-valeur. Vous pouvez effectuer les opérations suivantes : + Si vous avez importé un fichier, vous pouvez également ajouter d’autres valeurs manuellement. + Si vous n’avez pas importé de fichier d’un compartiment Amazon S3 et si vous souhaitez ajouter des paires clé-valeur dès maintenant, vous pouvez passer à l’étape suivante. + Vous pouvez ignorer cette étape et ajouter les paires clé-valeur ultérieurement. 1. Pour ajouter les paires dès maintenant : 1. Choisissez **Ajouter des paires clé-valeur**. 1. Choisissez **Ajouter une paire** et entrez un nom et une valeur. Répétez cette étape pour ajouter d’autres paires. 1. Lorsque vous avez terminé, choisissez **Enregistrer les modifications** pour enregistrer toutes les paires clé-valeur dans le magasin de clés-valeurs. Dans la boîte de dialogue qui s’affiche, cliquez sur **Terminé**. 1. Pour associer le magasin de clés-valeurs à une fonction dès maintenant, complétez la section **Fonctions associées**. Pour plus d’informations, consultez [Création de fonctions](create-function.md) ou [Mise à jour de fonctions](update-function.md). Vous pouvez également associer la fonction ultérieurement, soit depuis la page de détails de ce magasin de clés-valeurs, soit depuis la page de détails de la fonction. ------ #### [ AWS CLI ] **Pour créer un magasin de clés-valeurs** + Exécutez la commande suivante pour créer un magasin de clés-valeurs et importer les paires clé-valeur depuis un compartiment Amazon S3. ``` aws cloudfront create-key-value-store \ --name=keyvaluestore1 \ --comment="This is my key value store file" \ --import-source=SourceType=S3,SourceARN=arn:aws:s3:::amzn-s3-demo-bucket1/kvs-input.json ``` **Réponse** ``` { "ETag": "ETVABCEXAMPLE", "Location": "https://cloudfront.amazonaws.com/2020-05-31/key-value-store/arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example", "KeyValueStore": { "Name": "keyvaluestore1", "Id": "8aa76c93-3198-462c-aaf6-example", "Comment": "This is my key value store file", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example", "Status": "PROVISIONING", "LastModifiedTime": "2024-08-06T22:19:10.813000+00:00" } } ``` ------ #### [ API ] **Pour créer un magasin de clés-valeurs** 1. Utilisez l'[CloudFrontCreateKeyValueStore](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_CreateKeyValueStore.html)opération. L’opération prend plusieurs paramètres : + Un `name` du magasin de clés-valeurs. + Un paramètre `comment` qui inclut un commentaire. + Un paramètre `import-source` qui vous permet d’importer des paires clé-valeur à partir d’un fichier stocké dans un compartiment Amazon S3. Vous ne pouvez importer à partir d’un fichier qu’au moment de la création initiale du magasin de clés-valeurs. Pour plus d’informations sur la structure, consultez [Format de fichier pour les paires clé-valeur](kvs-with-functions-create-s3-kvp.md). La réponse de l’opération inclut les informations suivantes : + Les valeurs transmises dans la demande, y compris le nom que vous avez attribué. + Des données telles que l’heure de création. + Un `ETag` (par exemple, `ETVABCEXAMPLE`), l’ARN qui inclut le nom du magasin de clés-valeurs (par exemple, `arn:aws:cloudfront::123456789012:key-value-store/keyvaluestore1`). Vous utiliserez une combinaison de l’`ETag`, de l’ARN et du nom pour travailler avec le magasin de clés-valeurs par programmation. ------ ## États des magasins de clés-valeurs Lorsque vous créez un magasin de clés-valeurs, le magasin de données peut présenter les valeurs d’état suivantes. **** | Value | Description | | --- | --- | | **Approvisionnement** | Le magasin de valeurs clés a été créé et CloudFront traite la source de données que vous avez spécifiée. | | **Prêt** | Le magasin de valeurs clés a été créé et a traité CloudFront avec succès la source de données que vous avez spécifiée. | | **Échec de l’importation** | CloudFront n'a pas pu traiter la source de données que vous avez spécifiée. Cet état peut apparaître si le format de votre fichier n’est pas valide ou s’il dépasse la limite de taille. Pour de plus amples informations, veuillez consulter [Format de fichier pour les paires clé-valeur](kvs-with-functions-create-s3-kvp.md). | # Association d’un magasin de clés-valeurs à une fonction Après avoir créé votre magasin de clés-valeurs, vous pouvez mettre à jour votre fonction pour l’associer à votre magasin de clés-valeurs. Vous devez établir cette association pour pouvoir utiliser les paires clé-valeur de ce magasin dans cette fonction. Les règles suivantes s’appliquent : + Une fonction peut avoir un seul magasin de clés-valeurs + Vous pouvez associer le même magasin de clés-valeurs à plusieurs fonctions ------ #### [ Console ] **Pour associer un magasin de clés-valeurs à une fonction** 1. Connectez-vous à la CloudFront console à l'adresse [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) et sélectionnez la page **Fonctions**. 1. Choisissez le nom de la fonction. 1. Accédez à la KeyValueStore section **Associer** et choisissez **Associer existant KeyValueStore**. 1. **Sélectionnez le magasin clé-valeur qui contient les paires clé-valeur de la fonction, puis choisissez Associer. KeyValueStore** CloudFront associe immédiatement le magasin à la fonction. Vous n’avez pas besoin d’enregistrer la fonction. 1. Pour spécifier un autre magasin de valeurs clés, choisissez **Mettre à jour associé KeyValueStore**, sélectionnez un autre nom de magasin de valeurs clés, puis choisissez **Associer KeyValueStore**. Pour de plus amples informations, veuillez consulter [Mise à jour de fonctions](update-function.md). ------ #### [ AWS CLI ] **Pour associer un magasin de clés-valeurs à une fonction** + Exécutez la commande suivante pour mettre à jour la fonction `MaxAge` et associer une ressource de magasin de clés-valeurs. ``` aws cloudfront update-function \ --name MaxAge \ --function-config '{"Comment":"Max Age 2 years","Runtime":"cloudfront-js-2.0","KeyValueStoreAssociations":{"Quantity":1,"Items":[{"KeyValueStoreARN":"arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example"}]}}' \ --function-code fileb://function-max-age-v1.js \ --if-match ETVABCEXAMPLE ``` + Pour associer un magasin de clés-valeurs à une fonction, spécifiez le paramètre `KeyValueStoreAssociations` et l’ARN du magasin de clés-valeurs. + Pour modifier l’association, spécifiez un autre ARN de magasin de clés-valeurs. + Pour supprimer l’association, supprimez le paramètre `KeyValueStoreAssociations`. Pour de plus amples informations, veuillez consulter [Mise à jour de fonctions](update-function.md). ------ #### [ API ] **Pour associer un magasin de clés-valeurs à une fonction** + Utilisez l’opération d’API [UpdateFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateFunction.html). Pour de plus amples informations, veuillez consulter [Mise à jour de fonctions](update-function.md). ------ **Remarques** Si vous modifiez un magasin de clés-valeurs sans modifier les paires clé-valeur, ou si vous ne modifiez que les paires clé-valeur dans le magasin, vous n’avez pas besoin d’associer de nouveau le magasin de clés-valeurs. Vous n’avez pas non plus besoin de republier la fonction. Toutefois, nous vous recommandons de tester la fonction afin de vérifier qu’elle fonctionne comme prévu. Pour de plus amples informations, veuillez consulter [Fonctions de test](test-function.md). Vous pouvez afficher toutes les fonctions qui utilisent des magasins de clés-valeurs spécifiques. Sur la CloudFront console, choisissez la page de détails du magasin de valeurs clés. # Mise à jour d’un magasin de clés-valeurs Lorsque vous mettez à jour un magasin de clés-valeurs, vous pouvez modifier les paires clé-valeur ou modifier l’association entre le magasin de clés-valeurs et la fonction. ------ #### [ Console ] **Pour mettre à jour un magasin de clés-valeurs** 1. Connectez-vous à la page **Fonctions AWS Management Console et ouvrez-la** dans la CloudFront console à l'adresse[https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Cliquez sur l'onglet **KeyValueStores**. 1. Sélectionnez le magasin de clés-valeurs que vous souhaitez mettre à jour. + Pour mettre à jour les paires clé-valeur, choisissez **Modifier** dans la section **Paires clé-valeur**. Vous pouvez ajouter ou supprimer n’importe quelle paire clé-valeur. Vous pouvez également modifier la valeur d’une paire clé-valeur existante. Lorsque vous avez terminé, sélectionnez **Enregistrer les modifications**. + Pour mettre à jour l’association pour ce magasin de clés-valeurs, choisissez **Accéder aux fonctions**. Pour de plus amples informations, veuillez consulter [Association d’un magasin de clés-valeurs à une fonction](kvs-with-functions-associate.md). ------ #### [ AWS CLI ] **Pour mettre à jour un magasin de clés-valeurs** 1. **Modifier les paires clé-valeur** : vous pouvez ajouter d’autres paires clé-valeur, supprimer une ou plusieurs paires clé-valeur et modifier la valeur d’une paire clé-valeur existante. Pour de plus amples informations, veuillez consulter [Utilisation de données clé-valeur](kvs-with-functions-kvp.md). 1. **Modifier l’association de la fonction pour le magasin de clés-valeurs** : pour mettre à jour l’association de la fonction pour le magasin de clés-valeurs, consultez [Association d’un magasin de clés-valeurs à une fonction](kvs-with-functions-associate.md). **Astuce** Vous aurez besoin de l’ARN du magasin de clés-valeurs. Pour de plus amples informations, veuillez consulter [Obtention d’une référence à un magasin de clés-valeurs](kvs-with-functions-get-reference.md). ------ #### [ API ] **Pour mettre à jour un magasin de clés-valeurs** 1. **Modifier les paires clé-valeur** : vous pouvez ajouter d’autres paires clé-valeur, supprimer une ou plusieurs paires clé-valeur et modifier la valeur d’une paire clé-valeur existante. Pour de plus amples informations, veuillez consulter [Utilisation de données clé-valeur](kvs-with-functions-kvp.md). 1. **Modifier l'association de fonction pour le magasin de valeurs clés** : pour mettre à jour l'association de fonctions pour le magasin de valeurs clés, utilisez l'opération [UpdateFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateFunction.html)API. Pour de plus amples informations, veuillez consulter [Mise à jour de fonctions](update-function.md). **Astuce** Vous aurez besoin de l’ARN du magasin de clés-valeurs. Pour de plus amples informations, veuillez consulter [Obtention d’une référence à un magasin de clés-valeurs](kvs-with-functions-get-reference.md). ------ # Obtention d’une référence à un magasin de clés-valeurs Pour utiliser le magasin de clés-valeurs par programmation, vous avez besoin de l’`ETag` et du nom du magasin de clés-valeurs. Pour obtenir les deux valeurs, vous pouvez utiliser le AWS Command Line Interface (AWS CLI) ou l' CloudFront API. ------ #### [ AWS CLI ] **Pour obtenir la référence à un magasin de clés-valeurs** 1. Pour renvoyer une liste des magasins de clés-valeurs, exécutez la commande suivante. Recherchez ensuite le nom du magasin de clés-valeurs que vous souhaitez modifier. ``` aws cloudfront list-key-value-stores ``` 1. Dans la réponse, recherchez le nom du magasin de clés-valeurs souhaité. **Réponse** ``` { "KeyValueStoreList": { "Items": [ { "Name": "keyvaluestore3", "Id": "37435e19-c205-4271-9e5c-example3", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example3", "Status": "READY", "LastModifiedTime": "2024-05-08T14:50:18.876000+00:00" }, { "Name": "keyvaluestore2", "Id": "47970d59-6408-474d-b850-example2", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/47970d59-6408-474d-b850-example2", "Status": "READY", "LastModifiedTime": "2024-05-30T21:06:22.113000+00:00" }, { "Name": "keyvaluestore1", "Id": "8aa76c93-3198-462c-aaf6-example", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example", "Status": "READY", "LastModifiedTime": "2024-08-06T22:19:30.510000+00:00" } ] } } ``` 1. Exécutez la commande suivante pour renvoyer l’`ETag` du magasin de clés-valeurs spécifié. ``` aws cloudfront describe-key-value-store \ --name=keyvaluestore1 ``` **Réponse** ``` { "ETag": "E3UN6WX5RRO2AG", "KeyValueStore": { "Name": "keyvaluestore1", "Id": "8aa76c93-3198-462c-aaf6-example", "Comment": "This is an example KVS", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example", "Status": "READY", "LastModifiedTime": "2024-08-06T22:19:30.510000+00:00" } } ``` ------ #### [ API ] **Pour obtenir la référence à un magasin de clés-valeurs** 1. Utilisez l’opération d’API [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html) pour renvoyer une liste de magasins de clés-valeurs. Recherchez le nom du magasin de clés-valeurs que vous souhaitez modifier. 1. Utilisez l’opération d’API [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeKeyValueStore.html) et indiquez le nom du magasin de clés-valeurs que vous avez renvoyé à l’étape précédente. ------ La réponse inclut un UUID, l’ARN du magasin de clés-valeurs et l’`ETag` du magasin de clés-valeurs. + Un `ETag`, par exemple `E3UN6WX5RRO2AG` + L’UUID est de 128 bits, tel que `8aa76c93-3198-462c-aaf6-example` + L'ARN inclut le Compte AWS nombre, la constante `key-value-store` et l'UUID, comme dans l'exemple suivant : `arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example` Pour plus d’informations sur l’opération `DescribeKeyValueStore`, consultez [À propos de CloudFront KeyValueStore](kvs-with-functions-kvp.md#kvs-with-functions-api-describe). # Suppression d’un magasin de clés-valeurs Vous pouvez supprimer votre boutique de valeurs clés à l'aide de la CloudFront console ou de l'API Amazon. ------ #### [ Console ] **Pour supprimer un magasin de clés-valeurs** 1. Connectez-vous à la page **Fonctions AWS Management Console et ouvrez-la** dans la CloudFront console à l'adresse[https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Choisissez le nom de la fonction. 1. Dans la KeyValueStore section **Associé**, vérifiez si un magasin de valeurs clés est associé à la fonction. Si tel est le cas, supprimez l'association en choisissant **Dissocier**, KeyValueStore puis en choisissant **Supprimer l'association**. 1. Dans le volet de navigation, choisissez la page **Fonctions**, puis sélectionnez l'**KeyValueStores**onglet. 1. Sélectionnez le magasin de clés-valeurs que vous souhaitez supprimer, puis choisissez **Supprimer**. ------ #### [ AWS CLI ] **Pour supprimer un magasin de clés-valeurs** 1. Obtenez l’`ETag` et le nom du magasin de clés-valeurs. Pour de plus amples informations, veuillez consulter [Obtention d’une référence à un magasin de clés-valeurs](kvs-with-functions-get-reference.md). 1. Vérifiez si le magasin de clés-valeurs est associé à une fonction. S’il l’est, supprimez l’association. Pour plus d’informations sur ces étapes, consultez [Mise à jour de fonctions](update-function.md). 1. Une fois que vous disposez du nom et de l’`ETag` du magasin clé-valeur et qu’il n’est plus associé à une fonction, vous pouvez le supprimer. Exécutez la commande suivante pour supprimer le magasin de clés-valeurs spécifié. ``` aws cloudfront delete-key-value-store \ --name=keyvaluestore1 \ --if-match=E3UN6WX5RRO2AG ``` ------ #### [ API ] **Pour supprimer un magasin de clés-valeurs** 1. Obtenez l’`ETag` et le nom du magasin de clés-valeurs. Pour de plus amples informations, veuillez consulter [Obtention d’une référence à un magasin de clés-valeurs](kvs-with-functions-get-reference.md). 1. Vérifiez si le magasin de clés-valeurs est associé à une fonction. S’il l’est, supprimez l’association. Pour plus d’informations sur ces étapes, consultez [Mise à jour de fonctions](update-function.md). 1. Pour supprimer le magasin de valeurs clés, utilisez l'opération CloudFront [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DeleteKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DeleteKeyValueStore.html)API. ------ # Format de fichier pour les paires clé-valeur Lorsque vous créez un fichier codé en UTF-8, utilisez le format JSON suivant : ``` { "data":[ { "key":"key1", "value":"value" }, { "key":"key2", "value":"value" } ] } ``` Votre fichier ne peut pas inclure de clés en double. Si vous avez indiqué un fichier invalide dans votre compartiment Amazon S3, vous pouvez mettre le fichier à jour pour supprimer les doublons, puis réessayer de créer votre magasin de clés-valeurs. Pour de plus amples informations, veuillez consulter [Création d’un magasin de clés-valeurs](kvs-with-functions-create.md). **Note** Le fichier de votre source de données et ses paires clé-valeur présentent les limites suivantes : Taille du fichier : 5 Mo Taille de la clé : 512 caractères Taille de la valeur : 1024 caractères # Utilisation de données clé-valeur Cette rubrique décrit comment ajouter des paires clé-valeur à un magasin de clés-valeurs existant. Pour inclure des paires clé-valeur lorsque vous créez initialement le magasin de clés-valeurs, consultez [Création d’un magasin de clés-valeurs](kvs-with-functions-create.md). **Topics** + [Utilisation de paires clé-valeur (console)](#kvs-with-functions-kvp-using-console) + [À propos de CloudFront KeyValueStore](#kvs-with-functions-api-describe) + [Utilisation des paires clé-valeur (AWS CLI)](#work-with-kvs-cli-keys) + [Utilisation des paires clé-valeur (API)](#kvs-with-functions-kvp-using-api) ## Utilisation de paires clé-valeur (console) Vous pouvez utiliser la CloudFront console pour travailler avec vos paires clé-valeur. **Pour utiliser les paires clé-valeur** 1. Connectez-vous à la page **Fonctions AWS Management Console et ouvrez-la** dans la CloudFront console à l'adresse[https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Cliquez sur l'onglet **KeyValueStores**. 1. Sélectionnez le magasin de clés-valeurs que vous souhaitez modifier. 1. Dans la section **Paires clé-valeur**, choisissez **Modifier**. 1. Vous pouvez ajouter une paire clé-valeur, supprimer une paire clé-valeur ou modifier la valeur d’une paire clé-valeur existante. 1. Lorsque vous avez terminé, sélectionnez **Enregistrer les modifications**. ## À propos de CloudFront KeyValueStore **Astuce** L' CloudFront KeyValueStore API est un service mondial qui utilise Signature Version 4A (SigV4A) pour l'authentification. L’utilisation d’informations d’identification temporaires avec SigV4A nécessite des jetons de session de version 2. Pour de plus amples informations, veuillez consulter [Utilisation d'informations d'identification temporaires avec l' CloudFront KeyValueStore API](cloudfront-function-restrictions.md#regional-endpoint-for-key-value-store). Si vous utilisez le AWS Command Line Interface (AWS CLI) ou votre propre code pour appeler l' CloudFront KeyValueStore API, consultez les sections suivantes. Lorsque vous utilisez un magasin de clés-valeurs et ses paires clé-valeur, le service que vous appelez dépend de votre cas d’utilisation : + Pour utiliser des paires clé-valeur dans un magasin clé-valeur *existant*, utilisez le CloudFront KeyValueStore service. + Pour inclure des paires clé-valeur dans le magasin clé-valeur lorsque vous créez *initialement* le magasin clé-valeur, utilisez le CloudFront service. L' CloudFront API et l' CloudFront KeyValueStore API fonctionnent toutes deux. `DescribeKeyValueStore` Vous les appelez pour différentes raisons. Pour comprendre les différences, consultez le tableau suivant. | | API CloudFront DescribeKeyValueStore | API CloudFront KeyValueStore DescribeKeyValueStore | | --- | --- | --- | | Données relatives au magasin de clés-valeurs | Renvoie des données, telles que l’état et la date à laquelle le magasin de clés-valeurs lui-même a été modifié pour la dernière fois. | Renvoie les données relatives au *contenu* de la ressource de stockage : les paires clé-valeur figurant dans le magasin et la taille du contenu. | | Données qui identifient le magasin de clés-valeurs | Renvoie un `ETag`, l’UUID et l’ARN du magasin de clés-valeurs. | Renvoie un `ETag` et l’ARN du magasin de clés-valeurs. | **Remarques** Chaque opération DescribeKeyValueStore renvoie un `ETag` *différent*. Les `ETags` ne sont pas interchangeables. Lorsque vous appelez une opération d’API pour effectuer une action, vous devez spécifier l’`ETag` provenant de l’API appropriée. Par exemple, dans l' CloudFront KeyValueStore[ DeleteKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DeleteKey.html)opération, vous spécifiez `ETag` ce que vous avez renvoyé après l' CloudFront KeyValueStore [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html)opération. Lorsque vous appelez vos CloudFront fonctions en utilisant CloudFront KeyValueStore, les valeurs du magasin de valeurs clés ne sont ni mises à jour ni modifiées lors de l'appel de la fonction. Les mises à jour sont traitées entre deux invocations d’une fonction. ## Utilisation des paires clé-valeur (AWS CLI) Vous pouvez exécuter les AWS Command Line Interface commandes suivantes pour CloudFront KeyValueStore. **Contents** + [Liste des paires clé-valeur](#kvs-cli-list-keys) + [Obtention des paires clé-valeur](#kvs-cli-get-keys) + [Description d’un magasin de clés-valeurs](#kvs-cli-describe-keys) + [Création d’une paire clé-valeur](#kvs-cli-create-keys) + [Suppression d’une paire clé-valeur](#kvs-cli-delete-keys) + [Mise à jour d’une paire clé-valeur](#kvs-cli-update-key) ### Liste des paires clé-valeur Pour répertorier les paires clé-valeur dans votre magasin de clés-valeurs, exécutez la commande suivante. ``` aws cloudfront-keyvaluestore list-keys \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Réponse** ``` { "Items": [ { "Key": "key1", "Value": "value1" } ] } ``` ### Obtention des paires clé-valeur Pour obtenir les paires clé-valeur dans votre magasin de clés-valeurs, exécutez la commande suivante. ``` aws cloudfront-keyvaluestore get-key \ --key=key1 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Réponse** ``` { "Key": "key1", "Value": "value1", "ItemCount": 1, "TotalSizeInBytes": 11 } ``` ### Description d’un magasin de clés-valeurs Pour décrire un magasin de clés-valeurs, exécutez la commande suivante. ``` aws cloudfront-keyvaluestore describe-key-value-store \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Réponse** ``` { "ETag": "KV1F83G8C2ARO7P", "ItemCount": 1, "TotalSizeInBytes": 11, "KvsARN": "arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example", "Created": "2024-05-08T07:48:45.381000-07:00", "LastModified": "2024-08-05T13:50:58.843000-07:00", "Status": "READY" } ``` ### Création d’une paire clé-valeur Pour créer une paire clé-valeur dans votre magasin de clés-valeurs, exécutez la commande suivante. ``` aws cloudfront-keyvaluestore put-key \ --if-match=KV1PA6795UKMFR9 \ --key=key2 \ --value=value2 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Réponse** ``` { "ETag": "KV13V1IB3VIYZZH", "ItemCount": 3, "TotalSizeInBytes": 31 } ``` ### Suppression d’une paire clé-valeur Pour supprimer une paire clé-valeur, exécutez la commande suivante. ``` aws cloudfront-keyvaluestore delete-key \ --if-match=KV13V1IB3VIYZZH \ --key=key1 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Sortie** ``` { "ETag": "KV1VC38T7YXB528", "ItemCount": 2, "TotalSizeInBytes": 22 } ``` ### Mise à jour d’une paire clé-valeur Vous pouvez utiliser la commande `update-keys` pour mettre à jour plusieurs paires clé-valeur. Par exemple, pour supprimer une paire clé-valeur existante et en créer une autre, exécutez la commande suivante. ``` aws cloudfront-keyvaluestore update-keys \ --if-match=KV2EUQ1WTGCTBG2 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example \ --deletes '[{"Key":"key2"}]' \ --puts '[{"Key":"key3","Value":"value3"}]' ``` **Réponse** ``` { "ETag": "KV3AEGXETSR30VB", "ItemCount": 3, "TotalSizeInBytes": 28 } ``` ## Utilisation des paires clé-valeur (API) Suivez cette section pour utiliser vos paires clé-valeur par programmation. **Contents** + [Obtention d’une référence à un magasin de clés-valeurs](#kvs-with-functions-api-ref) + [Modification de paires clé-valeur dans un magasin de clés-valeurs](#kvs-with-functions-api-actions) + [Exemple de code pour CloudFront KeyValueStore](#example-code-key-value-store) ### Obtention d’une référence à un magasin de clés-valeurs Lorsque vous utilisez l' CloudFront KeyValueStore API pour appeler une opération d'écriture, vous devez spécifier l'ARN et le `ETag` du magasin de valeurs clés. Pour obtenir ces données, procédez comme suit : **Pour obtenir une référence à un magasin de clés-valeurs** 1. Utilisez l’opération d’API [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html) pour obtenir une liste de magasins de clés-valeurs. Recherchez le magasin de clés-valeurs que vous souhaitez modifier. 1. Utilisez l’[opération d’API CloudFrontKeyValueStore DescribeKeyValueStore](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html) et indiquez le magasin de clés-valeurs identifié à l’étape précédente. La réponse inclut l’ARN et l’`ETag` du magasin de clés-valeurs. + L'ARN inclut le Compte AWS nombre, la constante `key-value-store` et l'UUID, comme dans l'exemple suivant : `arn:aws:cloudfront::123456789012:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111` + Un `ETag` ressemble à l’exemple suivant : `ETVABCEXAMPLE2` ### Modification de paires clé-valeur dans un magasin de clés-valeurs Vous pouvez spécifier le magasin de clés-valeurs qui contient la paire clé-valeur que vous souhaitez mettre à jour. Consultez les opérations CloudFront KeyValueStore d'API suivantes : + [CloudFrontKeyValueStore DeleteKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DeleteKey.html)— Supprime une paire clé-valeur + [CloudFrontKeyValueStore GetKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_GetKey.html)— Renvoie une paire clé-valeur + [CloudFrontKeyValueStore ListKeys](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_ListKeys.html)— Renvoie une liste de paires clé-valeur + [CloudFrontKeyValueStore PutKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_PutKey.html)— Vous pouvez effectuer les tâches suivantes : + Créer une paire clé-valeur dans un magasin de clés-valeurs en indiquant un nouveau nom de clé et une valeur. + Définir une valeur différente dans une paire clé-valeur existante en spécifiant un nom de clé existant et une nouvelle valeur. + [CloudFrontKeyValueStore UpdateKeys](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_UpdateKeys.html)— Vous pouvez effectuer une ou plusieurs des actions suivantes en une seule all-or-nothing opération : + Supprimer une ou plusieurs paires clé-valeur + Créer une ou plusieurs nouvelles paires clé-valeur + Définir une valeur différente dans une ou plusieurs paires clé-valeur existantes ### Exemple de code pour CloudFront KeyValueStore **Example** Le code suivant vous montre comment appeler l’opération d’API `DescribeKeyValueStore` pour un magasin de clés-valeurs. ``` const { CloudFrontKeyValueStoreClient, DescribeKeyValueStoreCommand, } = require("@aws-sdk/client-cloudfront-keyvaluestore"); require("@aws-sdk/signature-v4-crt"); (async () => { try { const client = new CloudFrontKeyValueStoreClient({ region: "us-east-1" }); const input = { KvsARN: "arn:aws:cloudfront::123456789012:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111", }; const command = new DescribeKeyValueStoreCommand(input); const response = await client.send(command); } catch (e) { console.log(e); } })(); ``` # Personnalisez avec les fonctions CloudFront de connexion CloudFront Les fonctions de connexion vous permettent d'écrire des JavaScript fonctions légères pour la validation des certificats mTLS et la logique d'authentification personnalisée. Vos fonctions de connexion s'exécutent lors de l'établissement de la connexion MTL pour valider les certificats clients, implémenter des règles d'authentification spécifiques à l'appareil et gérer les scénarios de révocation de certificats. L'environnement d'exécution Connection Functions offre des temps de démarrage inférieurs à la milliseconde, s'adapte immédiatement pour gérer des millions de connexions par seconde et est hautement sécurisé. Les fonctions de connexion sont une fonctionnalité native de CloudFront, ce qui signifie que vous pouvez créer, tester et déployer votre code entièrement en interne CloudFront. Lorsque vous associez une fonction de connexion à une CloudFront distribution compatible MTLS, vous CloudFront interceptez les demandes de connexion TLS aux emplacements CloudFront périphériques et transmettez les informations de certificat à votre fonction. Vous pouvez appeler les fonctions de connexion lorsque l'événement suivant se produit : + Pendant l'établissement de la connexion TLS (demande de connexion), pour les connexions TLS mutuelles (MTLS) Pour plus d'informations sur les fonctions de connexion, consultez les rubriques suivantes. **Topics** + [Vue d'ensemble et flux de travail](connection-functions-overview.md) + [Configuration et limites](connection-function-configuration-limits.md) + [Création de fonctions de CloudFront connexion pour la validation mutuelle du protocole TLS (viewer)](create-connection-functions.md) + [Écrire le code de la fonction de CloudFront connexion pour la validation mutuelle du protocole TLS (viewer)](write-connection-function-code.md) + [Tester les fonctions de CloudFront connexion avant le déploiement](test-connection-functions.md) + [Associer des fonctions de connexion à des distributions](associate-connection-functions.md) + [Implémenter la révocation des certificats pour le TLS mutuel (viewer) avec Functions et CloudFront KeyValueStore](implement-certificate-revocation.md) # Vue d'ensemble et flux de travail CloudFront Les fonctions de connexion sont un type spécialisé de CloudFront fonctions qui s'exécutent pendant le handshake TLS lorsqu'un client tente d'établir une connexion mTLS. Votre fonction de connexion peut accéder aux informations du certificat client, aux paramètres de configuration mTLS, aux résultats du contrôle de révocation du certificat et à l'adresse IP du client. Les fonctions de connexion sont invoquées après CloudFront avoir effectué la validation standard des certificats (chaîne de confiance, expiration, vérification des signatures) mais peuvent être exécutées même si les vérifications de révocation des certificats échouent. Cela vous permet d'implémenter une logique personnalisée pour gérer les certificats révoqués ou ajouter des critères de validation supplémentaires. 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. CloudFront Les fonctions de connexion suivent un cycle de vie en deux étapes qui vous permet de développer et de tester des fonctions avant de les déployer en production. Ce flux de travail garantit le bon fonctionnement de vos fonctions de connexion avant qu'elles n'affectent le trafic réel. **Topics** + [Étapes de fonctionnement](#connection-function-stages) + [Flux de travail du développement](#connection-function-development-workflow) + [Différences par rapport aux autres types de fonctions](#connection-function-differences) ## Étapes de fonctionnement Les fonctions de connexion se déclinent en deux étapes : + **DÉVELOPPEMENT** — Les fonctions de cette étape peuvent être modifiées, testées et mises à jour. Utilisez cette étape pour écrire et débugger le code de votre fonction. + **LIVE** — Les fonctions de cette étape sont en lecture seule et gèrent le trafic de production. Vous ne pouvez pas modifier directement les fonctions de la scène LIVE. Lorsque vous créez une nouvelle fonction de connexion, elle commence dans la phase de **DÉVELOPPEMENT**. Après le test et la validation, vous publiez la fonction pour la déplacer vers le stage **LIVE**. ## Flux de travail du développement Suivez ce flux de travail pour développer et déployer des fonctions de connexion : 1. **Créer** — Créez une nouvelle fonction de connexion dans la phase de développement avec votre code et votre configuration initiaux. 1. **Test** : utilisez la fonctionnalité de test pour valider votre fonction à l'aide d'exemples d'événements de connexion avant le déploiement. 1. **Mettre à jour** : modifiez le code de fonction et la configuration selon les besoins en fonction des résultats des tests. 1. **Publier** — Lorsque vous êtes prête pour la production, publiez la fonction pour la faire passer de la phase DEVELOPMENT à la phase LIVE. 1. **Associer** : associez la fonction publiée à votre distribution compatible MTLS pour gérer les connexions en direct. Pour apporter des modifications à une fonction LIVE, vous devez mettre à jour la version DEVELOPMENT et la publier à nouveau. Cela crée une nouvelle version dans la phase LIVE. ## Différences par rapport aux autres types de fonctions Les fonctions de connexion diffèrent des fonctions de demande et de réponse du spectateur de plusieurs manières importantes : + Les fonctions de connexion s'exécutent après la prise de contact mTLS, avant tout traitement HTTP + Les fonctions de connexion ont accès aux informations du certificat TLS au lieu des données HTTP request/response + Les fonctions de connexion peuvent uniquement autoriser ou refuser la connexion, pas modifier les données HTTP + Les fonctions de connexion ne sont invoquées que pour les nouvelles connexions TLS, et non pour la réutilisation des connexions + La reprise de session TLS n'est pas prise en charge par MTLS pour garantir que la validation des certificats a lieu à chaque connexion + Les fonctions de connexion s'exécutent en plus des fonctions standard de demande et de réponse du spectateur + Vous associez les fonctions de connexion au niveau de la distribution plutôt qu’au niveau du comportement du cache. + Les fonctions de connexion ne sont compatibles qu'avec JavaScript Runtime 2.0. # Configuration et limites CloudFront Les fonctions de connexion ont des exigences de configuration et des limites de service spécifiques en raison de leur rôle spécialisé dans la validation des connexions TLS et des exigences de performance de l'informatique de pointe. **Topics** + [Exigences relatives au code de fonction](#connection-function-code-requirements) + [Service Limits](#connection-function-service-limits) + [Options de filtrage des fonctions](#connection-function-filtering-options) ## Exigences relatives au code de fonction Les fonctions de connexion nécessitent un JavaScript code qui traite les événements de connexion TLS. Le code de fonction doit : + Être écrit en JavaScript + Traitez les événements de connexion et prenez allow/deny des décisions + Exécution complète dans les délais + Gérer la logique de validation des certificats et des connexions ## Service Limits Les fonctions de connexion sont soumises aux limites suivantes : + **Taille de la fonction** — Le code de fonction et la configuration sont limités en taille + **Temps d'exécution** — Les fonctions ont des limites de temps d'exécution strictes pour le traitement des connexions TLS + **Limites d'association** — Chaque distribution ne peut être associée qu'à une seule fonction de connexion + **Restrictions de scène** — Seules les fonctions de scène LIVE peuvent être associées aux distributions ## Options de filtrage des fonctions Lorsque vous listez les fonctions de connexion, vous pouvez utiliser les filtres suivants : + **Filtre de scène** — Filtrez par stade DEVELOPMENT ou LIVE + **Filtre d'association** : filtrez par ID de distribution ou associations clé-valeur d'ID de magasin Ces filtres vous aident à organiser et à gérer les fonctions de connexion dans différents environnements et cas d'utilisation. # Création de fonctions de CloudFront connexion pour la validation mutuelle du protocole TLS (viewer) Vous créez une fonction de CloudFront connexion en deux étapes : 1. Créez le code de fonction sous la forme JavaScript. Vous pouvez utiliser l'exemple par défaut de la CloudFront console ou écrire le vôtre. Pour plus d’informations, consultez les rubriques suivantes : + Écrire le code CloudFront de la fonction de connexion pour la validation mTLS + CloudFront Structure des événements de la fonction de connexion et format de réponse + Exemples de code de fonction de connexion 1. CloudFront À utiliser pour créer la fonction de connexion et inclure votre code. Le code existe à l’intérieur de la fonction (et non en tant que référence). **Topics** + [CloudFront console](#create-connection-function-console) + [AWS CLI](#create-connection-function-cli) ## CloudFront console **Pour créer une fonction de connexion** 1. Connectez-vous à la CloudFront console AWS Management Console et ouvrez-la à l'adresse[https://console.aws.amazon.com/cloudfront/v4/home](https://console.aws.amazon.com/cloudfront/v4/home). 1. Choisissez **Créer une fonction**. 1. Entrez un nom de fonction unique dans le Compte AWS, choisissez **Fonction de connexion** comme type de fonction, puis choisissez **Continuer**. 1. La page de détails de la nouvelle fonction de connexion apparaît. **Note** Les fonctions de connexion ne sont compatibles qu'avec JavaScript Runtime 2.0. Pour utiliser l' KeyValueStore intégration de la fonction de CloudFront connexion dans la fonction, vous devez utiliser cette version d'exécution. 1. Dans la section **Code de fonction**, choisissez l'onglet **Créer** et entrez votre code de fonction de connexion. L'exemple de code inclus dans l'onglet Construire illustre la syntaxe de base du code de fonction de connexion. 1. Sélectionnez **Enregistrer les modifications**. 1. Si le code de fonction de connexion est utilisé KeyValueStore pour vérifier la révocation des certificats ou valider l'appareil, vous devez associer un KeyValueStore. Vous pouvez les associer KeyValueStore lorsque vous créez la fonction pour la première fois. Vous pouvez également l'associer ultérieurement, en associant des fonctions de connexion. Pour associer un KeyValueStore maintenant, procédez comme suit : + Accédez à la KeyValueStore section **Associer** et choisissez **Associer existant KeyValueStore**. + Sélectionnez celui KeyValueStore qui contient les données de certificat pour votre fonction de connexion, puis choisissez **Associer KeyValueStore**. CloudFront associe immédiatement le magasin à la fonction. Vous n’avez pas besoin d’enregistrer la fonction. ## AWS CLI Si vous utilisez le AWS CLI, vous créez généralement d'abord le code de la fonction de connexion dans un fichier, puis vous créez la fonction avec le AWS CLI. **Pour créer une fonction de connexion** 1. Créez le code de la fonction de connexion dans un fichier et stockez-le dans un répertoire auquel votre ordinateur peut se connecter. 1. Exécutez la commande, comme illustré dans l’exemple. Cet exemple utilise la notation `fileb://` pour transmettre le fichier. Il inclut également des sauts de ligne pour rendre la commande plus lisible. ``` aws cloudfront create-connection-function \ --name CertificateValidator \ --connection-function-config '{ "Comment":"Device certificate validation", "Runtime":"cloudfront-js-2.0", "KeyValueStoreAssociations":{ "Quantity":1, "Items":[{ "KeyValueStoreARN":"arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111" }] } }' \ --connection-function-code fileb://certificate-validator.js ``` **Note** **Runtime** — Les fonctions de connexion ne prennent en charge que le JavaScript runtime 2.0 (cloudfront-js-2.0). **KeyValueStoreAssociations**— Si votre fonction de connexion l'utilise KeyValueStore pour la validation des certificats, vous pouvez l'associer KeyValueStore lorsque vous créez la fonction pour la première fois. Ou vous pouvez l’associer ultérieurement, en utilisant update-connection-function. La quantité est toujours égale à 1 car une seule fonction de connexion ne peut être KeyValueStore associée qu'à une seule. 1. Lorsque la commande s’exécute correctement, vous obtenez une sortie similaire à ce qui suit. ``` ETag: ETVABCEXAMPLE ConnectionFunctionSummary: ConnectionFunctionConfig: Comment: Device certificate validation Runtime: cloudfront-js-2.0 KeyValueStoreAssociations: Quantity: 1 Items: - KeyValueStoreARN: arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111 ConnectionFunctionMetadata: CreatedTime: '2024-09-04T16:32:54.292000+00:00' ConnectionFunctionARN: arn:aws:cloudfront::111122223333:connection-function/CertificateValidator LastModifiedTime: '2024-09-04T16:32:54.292000+00:00' Stage: DEVELOPMENT Name: CertificateValidator Status: UNPUBLISHED Location: https://cloudfront.amazonaws.com/2020-05-31/connection-function/arn:aws:cloudfront:::connection-function/CertificateValidator ``` La plupart des informations proviennent de la demande. D'autres informations sont ajoutées par CloudFront. **Note** **ETag**— Cette valeur change chaque fois que vous modifiez la fonction de connexion. Vous avez besoin de cette valeur pour mettre à jour ou publier la fonction. **Étape** — Les nouvelles fonctions de connexion commencent lors de la phase de DÉVELOPPEMENT. Vous devez publier la fonction pour la déplacer vers la scène LIVE avant de l'associer à une distribution. **État : le statut** de la fonction est NON PUBLIÉ tant que vous ne le publiez pas sur la scène LIVE. # Écrire le code de la fonction de CloudFront connexion pour la validation mutuelle du protocole TLS (viewer) CloudFront Les fonctions de connexion vous permettent d'écrire des JavaScript fonctions légères pour la validation des certificats mTLS et la logique d'authentification personnalisée. Votre code de fonction de connexion permet de valider les certificats clients, de mettre en œuvre des règles d'authentification spécifiques à l'appareil, de gérer les scénarios de révocation de certificats et de prendre des allow/deny décisions concernant les connexions TLS sur des sites périphériques dans CloudFront le monde entier. Les fonctions de connexion constituent un moyen puissant d'étendre CloudFront la validation des certificats intégrée à votre propre logique métier. Contrairement aux fonctions de demande et de réponse de l'utilisateur qui traitent les données HTTP, les fonctions de connexion fonctionnent au niveau de la couche TLS et ont accès aux informations de certificat, aux adresses IP des clients et aux détails de connexion TLS. Ils sont donc idéaux pour mettre en œuvre des modèles de sécurité Zero Trust, des systèmes d'authentification des appareils et des politiques de validation de certificats personnalisées qui vont au-delà de la validation PKI standard. Le code de votre fonction de connexion s'exécute dans un environnement isolé et sécurisé avec des temps de démarrage inférieurs à la milliseconde et peut être adapté pour gérer des millions de connexions par seconde. Le runtime est optimisé pour les charges de travail de validation des certificats et fournit une intégration intégrée CloudFront KeyValueStore pour les opérations de recherche de données en temps réel, permettant des scénarios d'authentification sophistiqués tels que la vérification des listes de révocation de certificats et la validation des listes d'autorisation des appareils. Pour vous aider à écrire un code de fonction de connexion efficace, consultez les rubriques suivantes. Pour des exemples de code complets et des step-by-step didacticiels, consultez les sections du didacticiel de ce guide et explorez les exemples de fonctions de connexion disponibles dans la CloudFront console. **Topics** + [CloudFront Cas d'utilisation et objectifs de la fonction de connexion](#connection-function-use-cases) + [CloudFront Structure des événements de la fonction de connexion et format de réponse](#connection-function-event-structure) + [CloudFront Fonctionnalités JavaScript d'exécution des fonctions de connexion](#connection-function-javascript-runtime) + [CloudFront Méthodes d'assistance à la fonction de connexion et APIs](#connection-function-helper-methods) + [CloudFront KeyValueStore Intégration de la fonction de connexion](#connection-function-kvs-integration) + [Utilisez l'async et attendez](#connection-function-async-await) + [Exemples de code de fonction de connexion](#connection-function-code-examples) ## CloudFront Cas d'utilisation et objectifs de la fonction de connexion Avant d'écrire votre fonction de CloudFront connexion, déterminez soigneusement le type de logique d'authentification ou de validation de certificat que vous devez implémenter. Les fonctions de connexion sont conçues pour des cas d'utilisation spécifiques qui nécessitent une validation personnalisée allant au-delà de la vérification des certificats PKI standard. Comprendre votre cas d'utilisation vous permet de concevoir un code efficace qui répond à vos exigences de sécurité tout en maintenant des performances optimales. Les cas d'utilisation courants des fonctions de connexion incluent : + **Gestion de la révocation des certificats** : mettez en œuvre des politiques personnalisées pour gérer les certificats révoqués, notamment des périodes de grâce pour la rotation des certificats, des exceptions réseau fiables pour les appareils internes ou des scénarios d'accès d'urgence dans lesquels les certificats révoqués peuvent nécessiter un accès temporaire. + **Support MTL en option** : gérez les connexions MTL et non MTLS avec différentes politiques d'authentification, ce qui vous permet de renforcer la sécurité des clients qui prennent en charge les certificats tout en préservant la compatibilité avec les anciens clients. + **Authentification basée sur l'IP** : combinez la validation des certificats à la vérification de l'adresse IP du client pour renforcer la sécurité, par exemple en restreignant l'accès depuis des régions géographiques spécifiques, des réseaux d'entreprise ou des plages d'adresses IP malveillantes connues. + **Validation des certificats multi-locataires** : implémentez des règles de validation spécifiques au locataire dans lesquelles différentes autorités de certification ou critères de validation s'appliquent en fonction de l'émetteur du certificat client ou des attributs du sujet. + **Contrôle d'accès basé sur** le temps : appliquez des restrictions temporelles selon lesquelles les certificats ne sont valides que pendant des heures, des périodes de maintenance ou des périodes commerciales spécifiques, même si le certificat lui-même n'a pas expiré. Les fonctions de connexion s'exécutent CloudFront après avoir effectué la validation standard des certificats (vérification de la chaîne de confiance, contrôles d'expiration et validation des signatures) mais avant que la connexion TLS ne soit établie. Ce calendrier vous donne la flexibilité d'ajouter des critères de validation personnalisés tout en bénéficiant CloudFront de la validation des certificats intégrée. Votre fonction reçoit les résultats de la validation standard et peut prendre des décisions éclairées quant à l'autorisation ou au refus de la connexion en fonction de critères standard et personnalisés. Lorsque vous concevez votre fonction de connexion, tenez compte des implications de votre logique de validation en termes de performances. Les fonctions ayant une limite d'exécution de 5 millisecondes, les opérations complexes doivent être optimisées en termes de rapidité. Utilisez-le KeyValueStore pour des recherches de données rapides plutôt que pour des calculs complexes, et structurez votre logique de validation de manière à ce qu'elle échoue rapidement en cas de certificats non valides. ## CloudFront Structure des événements de la fonction de connexion et format de réponse CloudFront Les fonctions de connexion reçoivent une structure d'événements différente de celle des fonctions de demande et de réponse de l'utilisateur. Au lieu des request/response données HTTP, les fonctions de connexion reçoivent des informations de certificat et de connexion que vous pouvez utiliser pour prendre des décisions d'authentification. **Topics** + [Structure d'événements pour les fonctions de connexion](#connection-function-event-structure-details) + [Format de réponse des fonctions de connexion](#connection-function-response-format) ### Structure d'événements pour les fonctions de connexion Les fonctions de connexion reçoivent un objet d'événement contenant des informations de certificat et de connexion. La structure des événements de la fonction est illustrée ci-dessous : ``` { "clientCertificate": { "certificates": { "leaf": { "serialNumber": "string", "issuer": "string", "subject": "string", "validity": { "notBefore": "string", "notAfter": "string", }, "sha256Fingerprint": "string" } } }, "clientIp": "string", "endpoint": "string", "distributionId": "string", "connectionId": "string" } ``` Vous trouverez ci-dessous un exemple de structure d'objet d'événement : ``` { "clientCertificate": { "certificates": { "leaf": { "serialNumber": "00:9e:2a:af:16:56:e5:47:25:7d:2e:38:c3:f9:9d:57:fa", "issuer": "C=US, O=Ram, OU=Edge, ST=WA, CN=mTLS-CA, L=Snoqualmie", "subject": "C=US, O=Ram, OU=Edge, ST=WA, CN=mTLS-CA, L=Snoqualmie", "validity": { "notBefore": "2025-09-10T23:43:10Z", "notAfter": "2055-09-11T00:43:02Z" }, "sha256Fingerprint": "_w6bJ7aOAlGOj7NUhJxTfsfee-ONg_xop3_PTgTJpqs=" } } }, "clientIp": "127.0.0.1", "endpoint": "d3lch071jze0cb.cloudfront.net", "distributionId": "E1NXS4MQZH501R", "connectionId": "NpvTe1925xfj24a67sPQr7ae42BIq03FGhJJKfrQYWZcWZFp96SIIg==" } ``` ### Format de réponse des fonctions de connexion Votre fonction de connexion doit renvoyer un objet de réponse indiquant s'il faut autoriser ou refuser la connexion. Utilisez les méthodes d'assistance pour prendre des décisions de connexion : ``` function connectionHandler(connection) { // Helper methods to allow or deny connections if (/* some logic to determine if function should allow connection */) { connection.allow(); } else { connection.deny(); } } ``` 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. Ils peuvent uniquement autoriser ou refuser la connexion TLS. ## CloudFront Fonctionnalités JavaScript d'exécution des fonctions de connexion CloudFront Les fonctions de connexion utilisent le CloudFront Functions JavaScript Runtime 2.0, qui fournit un environnement sécurisé et performant spécifiquement optimisé pour les charges de travail de validation de certificats. Le runtime est conçu pour démarrer en quelques millisecondes et gérer des millions d'exécutions simultanées sur le réseau périphérique CloudFront mondial. L'environnement d'exécution inclut une prise en charge JavaScript linguistique complète : + **ECMAScript Support 2020 (ES11)** — JavaScript Fonctionnalités modernes, notamment le chaînage optionnel (?.) , fusion nulle (? ?) , et BigInt pour le traitement de grands numéros de série de certificats + **Objets intégrés** : JavaScript objets standard tels que Object, Array, JSON, Math et Date + **Journalisation de la console** : utilisez console.log () pour le débogage et le suivi des décisions de validation des certificats. Les journaux sont disponibles en temps réel pendant les tests et peuvent aider à résoudre les problèmes liés à la logique de validation lors du développement + **KeyValueStore intégration** — Accès natif CloudFront KeyValueStore pour des opérations de recherche de données ultrarapides, permettant la vérification en temps réel de la révocation des certificats, la validation de la liste des appareils autorisés et la récupération de la configuration spécifique au locataire Les fonctions de connexion sont optimisées pour des performances élevées dans les scénarios de validation de certificats. Le moteur d'exécution gère automatiquement la gestion de la mémoire, le ramassage des déchets et le nettoyage des ressources afin de garantir des performances constantes sur des millions de connexions simultanées. Toutes les opérations sont conçues pour être déterministes et rapides, les recherches s'effectuant généralement KeyValueStore en quelques microsecondes. L'environnement d'exécution est complètement isolé entre les exécutions de fonctions, ce qui garantit l'absence de fuite de données entre les différentes connexions client. Chaque exécution de fonction commence par un état propre et n'a aucun accès aux résultats d'exécution précédents ni aux données client provenant d'autres connexions. ## CloudFront Méthodes d'assistance à la fonction de connexion et APIs CloudFront Les fonctions de connexion fournissent des méthodes d'assistance spécialisées conçues pour simplifier les décisions de validation des certificats et améliorer l'observabilité. Ces méthodes sont optimisées pour le flux de travail de validation des connexions et s'intègrent parfaitement aux systèmes CloudFront de journalisation et de surveillance des connexions. + **connection.allow ()** — Autorise la connexion TLS à se poursuivre. Cette méthode indique CloudFront de terminer la prise de contact TLS et de permettre au client d'établir la connexion. Utilisez-le lorsque la validation du certificat est réussie et que toute logique d'authentification personnalisée est satisfaite + **connection.deny ()** — Refuse la connexion TLS et met fin à la poignée de main. Cette méthode ferme immédiatement la connexion et empêche le trafic HTTP de circuler. Le client recevra un message d'erreur de connexion TLS. Utilisez-le pour les certificats non valides, l'échec de l'authentification ou les violations des politiques + **connexion. logCustomData()** — Ajoutez des données personnalisées aux journaux de connexion (jusqu'à 800 octets de texte UTF-8). Cette méthode vous permet d'inclure les résultats de validation, les détails du certificat ou les justifications des décisions dans les journaux de CloudFront connexion à des fins de surveillance de la sécurité, d'audit de conformité et de résolution des problèmes Ces méthodes fournissent une interface claire et déclarative pour prendre des décisions de connexion et enregistrer les informations pertinentes pour la surveillance et le débogage. Le allow/deny modèle garantit que l'intention de votre fonction est claire et CloudFront peut optimiser la gestion des connexions en fonction de votre décision. Les données de journalisation personnalisées sont immédiatement disponibles dans les journaux de CloudFront connexion et peuvent être utilisées avec les outils d'analyse des journaux pour la surveillance de la sécurité et des informations opérationnelles. Appelez toujours connection.allow () ou connection.deny () avant que votre fonction ne soit terminée. Si aucune des deux méthodes n'est appelée, CloudFront refusera la connexion par défaut par mesure de sécurité. ## CloudFront KeyValueStore Intégration de la fonction de connexion CloudFront Les fonctions de connexion peuvent être utilisées CloudFront KeyValueStore pour effectuer des recherches de données ultrarapides pour les scénarios de validation de certificats. KeyValueStore est particulièrement puissant pour les fonctions de connexion, car il fournit un accès global aux données, finalement cohérent, avec des temps de recherche de l'ordre de la microseconde sur tous les CloudFront emplacements périphériques. Il est donc idéal pour gérer les listes de révocation de certificats, les listes d'appareils autorisés, les configurations des locataires et les autres données de validation qui doivent être accessibles lors des connexions TLS. KeyValueStore l'intégration est conçue spécifiquement pour les flux de travail de validation des connexions à hautes performances : + **KVSHandle.exists (key)** — Vérifie si une clé existe dans le sans récupérer la KeyValueStore valeur. Il s'agit de la méthode la plus efficace pour les scénarios de validation binaire tels que le contrôle de révocation des certificats, dans lesquels il suffit de savoir si le numéro de série d'un certificat figure dans une liste de révocation + **KVSHandle.get (key)** — Récupérez une valeur dans le KeyValueStore pour les scénarios de validation plus complexes. Utilisez-le lorsque vous devez accéder aux données de configuration, aux règles de validation ou aux métadonnées associées à un certificat ou à un identifiant d'appareil KeyValueStore les opérations sont asynchrones et doivent être utilisées avec la syntaxe async/await. KeyValueStore Il a une limite de taille totale de 10 Mo et prend en charge jusqu'à 10 millions de paires clé-valeur. KeyValueStore les données sont finalement cohérentes sur tous les sites périphériques, les mises à jour se propageant généralement en quelques secondes. Pour des performances optimales, structurez vos KeyValueStore clés afin de minimiser les opérations de recherche. Utilisez les numéros de série des certificats comme clés pour une simple vérification de révocation, ou créez des clés composites combinant le hachage de l'émetteur et le numéro de série pour les environnements multi-CA. Tenez compte des compromis entre complexité clé et KeyValueStore capacité lors de la conception de votre structure de données. ## Utilisez l'async et attendez Les fonctions de connexion prennent en charge les opérations asynchrones à l'aide de async/await la syntaxe, ce qui est essentiel lorsque vous travaillez avec KeyValueStore des opérations ou d'autres tâches asynchrones. Ce async/await modèle garantit que votre fonction attend la fin des recherches avant de KeyValueStore prendre des décisions de connexion, tout en conservant les caractéristiques de haute performance requises pour le traitement des poignées de main TLS. Une async/await utilisation appropriée est essentielle pour les fonctions de connexion, car les KeyValueStore opérations, bien que très rapides, restent des opérations réseau qui nécessitent une coordination au sein CloudFront de l'infrastructure distribuée. Le moteur d'exécution gère automatiquement la résolution des promesses et garantit que votre fonction s'exécute dans le délai d'exécution de 5 millisecondes. **Example : Fonction de connexion asynchrone avec KeyValueStore** ``` import cf from 'cloudfront'; async function connectionHandler(connection) { const kvsHandle = cf.kvs(); // Async operation to check KeyValueStore for certificate revocation const isRevoked = await kvsHandle.exists(connection.clientCertificate.certificates.leaf.serialNumber); if (isRevoked) { // Log the revocation decision with certificate details connection.logCustomData(`REVOKED_CERT:${connection.clientCertificate.certificates.leaf.serialNumber}:${connection.clientCertificate.certificates.leaf.issuer}`); console.log(`Denying connection for revoked certificate: ${connection.clientCertificate.certificates.leaf.serialNumber}`); return connection.deny(); } // Log successful validation for monitoring connection.logCustomData(`VALID_CERT:${connection.clientCertificate.certificates.leaf.serialNumber}`); console.log(`Allowing connection for valid certificate: ${connection.clientCertificate.certificates.leaf.serialNumber}`); return connection.allow(); } ``` À toujours utiliser async/await lors de l'appel de KeyValueStore méthodes ou d'autres opérations asynchrones. Le moteur d'exécution de la fonction de connexion gère automatiquement la résolution des promesses et garantit un flux d'exécution correct dans les limites temporelles strictes du traitement des poignées de main TLS. Évitez d'utiliser .then () ou des modèles de rappel, car async/await permet une gestion des erreurs plus propre et de meilleures performances dans l'environnement des fonctions de connexion. Lorsque vous concevez des fonctions de connexion asynchrones, structurez votre code de manière à minimiser le nombre d' KeyValueStore opérations et exécutez-les le plus tôt possible dans votre logique de validation. Cela garantit des performances maximales et réduit le risque de problèmes de temporisation pendant les périodes de forte affluence. Envisagez de regrouper les contrôles de validation associés et d'utiliser la KeyValueStore méthode la plus efficace (exists () vs get ()) pour votre cas d'utilisation. ## Exemples de code de fonction de connexion Les exemples suivants illustrent les modèles de fonctions de connexion courants pour différents scénarios de validation. Utilisez ces exemples comme points de départ pour vos propres implémentations de fonctions de connexion. **Example : Validation du certificat de l'appareil** Cet exemple valide les numéros de série des appareils et les champs d'objet du certificat pour les appareils IoT, les consoles de jeu et d'autres scénarios d'authentification client : ``` async function connectionHandler(connection) { // Custom validation: check device serial number format const serialNumber = connection.clientCertificate.certificates.leaf.serialNumber; if (!serialNumber.startsWith("DEV")) { connection.logCustomData(`INVALID_SERIAL:${serialNumber}`); return connection.deny(); } // Validate certificate subject contains required organizational unit const subject = connection.clientCertificate.certificates.leaf.subject; if (!subject.includes("OU=AuthorizedDevices")) { connection.logCustomData(`INVALID_OU:${subject}`); return connection.deny(); } // Allow connection for valid devices connection.logCustomData(`VALID_DEVICE:${serialNumber}`); return connection.allow(); } ``` Cette fonction effectue plusieurs contrôles de validation au-delà de la validation standard des certificats, notamment le format du numéro de série de l'appareil et la vérification de l'unité organisationnelle. **Example : MTL optionnels avec authentification mixte** Cet exemple gère à la fois les connexions MTLS et non MTLS avec des politiques d'authentification différentes : ``` async function connectionHandler(connection) { if (connection.clientCertificate) { // mTLS connection - enhanced validation for certificate holders const subject = connection.clientCertificate.certificates.leaf.subject; connection.logCustomData(`MTLS_SUCCESS:${subject}:${connection.clientIp}`); console.log(`mTLS connection from: ${subject}`); return connection.allow(); } else { // Non-mTLS connection - apply IP-based restrictions const clientIp = connection.clientIp; // Only allow non-mTLS from specific IP ranges if (clientIp.startsWith("203.0.113.") || clientIp.startsWith("198.51.100.")) { connection.logCustomData(`NON_MTLS_ALLOWED:${clientIp}`); console.log(`Non-mTLS connection allowed from: ${clientIp}`); return connection.allow(); } connection.logCustomData(`NON_MTLS_DENIED:${clientIp}`); return connection.deny(); } } ``` Cette fonction améliore la sécurité des clients détenteurs de certificats tout en préservant la compatibilité avec les anciens clients issus de plages d'adresses IP fiables. # Tester les fonctions de CloudFront connexion avant le déploiement Vous pouvez tester les fonctions de CloudFront connexion dans la phase de développement à l'aide de l'opération TestConnectionFunction API. Les tests vous permettent de valider la logique de votre fonction à l'aide d'exemples d'événements de connexion avant de les publier sur la scène LIVE. **Topics** + [Processus de test](#connection-function-testing-process) + [Résultats des tests](#connection-function-test-results) + [Objet de test de connexion](#connection-test-object) ## Processus de test Pour tester une fonction de connexion : 1. Création d'une fonction de connexion dans la phase de développement 1. Préparez un objet de connexion de test qui représente l'événement de connexion TLS 1. Utilisez l'opération TestConnectionFunction API pour exécuter votre fonction avec les données de test 1. Passez en revue les résultats des tests, y compris les résultats des fonctions, les journaux d'exécution et les éventuels messages d'erreur 1. Mettez à jour votre code de fonction si nécessaire et répétez le processus de test ## Résultats des tests Lorsque vous testez une fonction de connexion, les résultats sont les suivants : + **Résumé de la fonction** — Métadonnées relatives à la fonction testée + **Utilisation du calcul** — Mesures de performance indiquant l'utilisation des ressources + **Journaux d'exécution** : sortie de console de votre fonction, y compris les instructions de journalisation + **Sortie de fonction** — Le résultat renvoyé par votre fonction + **Messages d'erreur** : toutes les erreurs d'exécution ou exceptions survenues pendant l'exécution ## Objet de test de connexion L'objet de test de connexion est un blob binaire (jusqu'à 40 Ko) qui représente l'événement de connexion TLS que votre fonction traitera. Cet objet contient le certificat et les informations de connexion que votre fonction utilise pour prendre des décisions d'authentification. **Note** La structure et le format spécifiques de l'objet de test de connexion sont définis par le moteur d'exécution CloudFront Connection Functions. Consultez la documentation ou contactez CloudFront Functions AWS Support pour plus de détails sur la création d'objets de test adaptés à votre cas d'utilisation. Après avoir créé votre fonction de connexion, vous pouvez : + **Testez la fonction** : utilisez la fonctionnalité de test de la console ou de la CLI pour valider votre fonction à l'aide d'exemples d'événements de connexion. Pour plus d'informations, consultez la section Test des fonctions de connexion. + **Mettre à jour la fonction** : modifiez le code de la fonction et la configuration selon vos besoins. Les fonctions de connexion en phase de développement peuvent être mises à jour à tout moment. + **Publier la fonction** : lorsque vous êtes prête pour la production, publiez la fonction pour la faire passer de la phase DEVELOPMENT à la phase LIVE. Pour plus d'informations, consultez la section association de fonctions de connexion. + **Associer à une distribution** : associez la fonction publiée à une distribution compatible MTLS pour gérer les connexions en direct. Pour plus d'informations, consultez la section association de fonctions de connexion. # Associer des fonctions de connexion à des distributions Après avoir publié une fonction de connexion sur le stage LIVE, vous devez l'associer à une distribution compatible MTLS pour gérer les connexions en direct. Les fonctions de connexion sont associées au niveau de la distribution, contrairement aux fonctions de demande et de réponse de l'utilisateur qui sont associées aux comportements du cache. **Topics** + [Exigences relatives à l'association](#connection-function-association-requirements) + [Organisation des fonctions à l'aide de filtres](#connection-function-organizing-filters) + [Considérations relatives au déploiement](#connection-function-deployment-considerations) ## Exigences relatives à l'association Pour associer une fonction de connexion à une distribution : + La fonction doit être en phase LIVE + Les MTLs doivent être activés pour la distribution + Un trust store valide doit être configuré pour la distribution. + Vous ne pouvez associer qu'une seule fonction de connexion par distribution ## Organisation des fonctions à l'aide de filtres CloudFront fournit des fonctionnalités de filtrage pour vous aider à organiser et à gérer les fonctions de connexion : + **Filtre d'ID de distribution** — Recherche les fonctions associées à des distributions spécifiques + **Filtre de stockage clé-valeur** : recherche les fonctions qui utilisent des magasins de valeurs clés spécifiques pour la recherche de données + **Filtre d'étape** : liste les fonctions dans la phase DEVELOPMENT ou LIVE Utilisez ces filtres lorsque vous gérez plusieurs fonctions de connexion dans différentes distributions ou environnements de développement. ## Considérations relatives au déploiement Tenez compte des facteurs suivants lors du déploiement des fonctions de connexion : + **Déploiement mondial** — Les fonctions de connexion sont déployées CloudFront sur tous les sites périphériques du monde entier, ce qui peut prendre plusieurs minutes + **Gestion des versions** — Chaque version publiée crée une nouvelle fonction LIVE qui remplace la version précédente + **Stratégie de rétrogradation** : planifiez la rétrogradation en conservant les versions fonctionnelles précédentes de votre code de fonction + **Tests en production** — Envisagez d'utiliser des distributions distinctes pour les environnements de préparation et de production # Implémenter la révocation des certificats pour le TLS mutuel (viewer) avec Functions et CloudFront KeyValueStore Vous pouvez utiliser les fonctions de CloudFront connexion KeyValueStore pour implémenter le contrôle de révocation des certificats. Cela vous permet de conserver une liste des numéros de série des certificats révoqués et de vérifier les certificats clients par rapport à cette liste lors de la prise de contact TLS. Pour implémenter la révocation des certificats, vous avez besoin des composants suivants : + Une distribution configurée avec les lecteurs MTL de visualisation + A KeyValueStore contenant les numéros de série des certificats révoqués + Une fonction de connexion qui interroge le KeyValueStore pour vérifier l'état du certificat Lorsqu'un client se connecte, CloudFront valide le certificat par rapport au trust store, puis exécute votre fonction de connexion. Votre fonction vérifie le numéro de série du certificat par rapport au KeyValueStore et autorise ou refuse la connexion. **Topics** + [Étape 1 : Création d'un formulaire KeyValueStore pour les certificats révoqués](create-kvs-revoked-certificates.md) + [Étape 2 : Création de la fonction de connexion de révocation](create-revocation-connection-function.md) + [Étape 3 : Testez votre fonction de révocation](test-revocation-function.md) + [Étape 4 : associer la fonction à votre distribution](associate-function-distribution.md) + [Scénarios de révocation avancés](advanced-revocation-scenarios.md) # Étape 1 : Création d'un formulaire KeyValueStore pour les certificats révoqués Créez un KeyValueStore pour stocker les numéros de série des certificats révoqués que votre fonction de connexion peut vérifier lors des connexions mTLS. Préparez d'abord les numéros de série de vos certificats révoqués au format JSON : ``` { "data": [ { "key": "ABC123DEF456", "value": "" }, { "key": "789XYZ012GHI", "value": "" } ] } ``` Téléchargez ce fichier JSON dans un compartiment S3, puis créez KeyValueStore : ``` aws s3 cp revoked-serials.json s3://your-bucket-name/revoked-serials.json aws cloudfront create-key-value-store \ --name revoked-serials-kvs \ --import-source '{ "SourceType": "S3", "SourceARN": "arn:aws:s3:::your-bucket-name/revoked-serials.json" }' ``` Attendez que le KeyValueStore provisionnement soit terminé. Vérifiez le statut avec : ``` aws cloudfront get-key-value-store --name "revoked-serials-kvs" ``` # Étape 2 : Création de la fonction de connexion de révocation Créez une fonction de connexion qui vérifie les numéros de série des certificats par rapport KeyValueStore aux afin de déterminer si les certificats sont révoqués. Créez une fonction de connexion qui vérifie les numéros de série des certificats par rapport aux KeyValueStore : ``` aws cloudfront create-connection-function \ --name "revocation-control" \ --connection-function-config file://connection-function-config.json \ --connection-function-code file://connection-function-code.txt ``` Le fichier de configuration indique l' KeyValueStore association : ``` { "Runtime": "cloudfront-js-2.0", "Comment": "A function that implements revocation control via KVS", "KeyValueStoreAssociations": { "Quantity": 1, "Items": [ { "KeyValueStoreArn": "arn:aws:cloudfront::account-id:key-value-store/kvs-id" } ] } } ``` Le code de la fonction de connexion vérifie la présence KeyValueStore de certificats révoqués : ``` import cf from 'cloudfront'; async function connectionHandler(connection) { const kvsHandle = cf.kvs(); // Get parsed client serial number from client certificate const clientSerialNumber = connection.clientCertInfo.serialNumber; // Check KVS to see if serial number exists as a key const serialNumberExistsInKvs = await kvsHandle.exists(clientSerialNumber); // Deny connection if serial number exists in KVS if (serialNumberExistsInKvs) { console.log("Connection denied - certificate revoked"); return connection.deny(); } // Allow connections that don't exist in kvs console.log("Connection allowed"); return connection.allow(); } ``` # Étape 3 : Testez votre fonction de révocation Utilisez la CloudFront console pour tester votre fonction de connexion à l'aide d'exemples de certificats. Accédez à la fonction de connexion dans la console et utilisez l'onglet Test. **Test avec des exemples de certificats** 1. Collez un exemple de certificat au format PEM dans l'interface de test 1. Spécifiez éventuellement une adresse IP client pour tester la logique basée sur IP 1. Choisissez **la fonction Test** pour voir les résultats de l'exécution 1. Consultez les journaux d'exécution pour vérifier la logique de votre fonction Testez avec des certificats valides et révoqués pour vous assurer que votre fonction gère correctement les deux scénarios. Les journaux d'exécution affichent le résultat du fichier console.log et toutes les erreurs survenues lors de l'exécution de la fonction. # Étape 4 : associer la fonction à votre distribution Une fois que vous avez publié votre fonction de connexion, associez-la à votre distribution compatible MTLS pour activer le contrôle de révocation des certificats. Vous pouvez associer la fonction depuis la page des paramètres de distribution ou depuis le tableau des distributions associé à la fonction de connexion. Accédez à vos paramètres de distribution, accédez à la section **Authentification mutuelle du visualiseur (mTLS)**, sélectionnez votre fonction de connexion et enregistrez les modifications. # Scénarios de révocation avancés Pour des exigences de révocation de certificats plus complexes, envisagez les configurations supplémentaires suivantes : **Topics** + [Convertir les listes de révocation de certificats (CRL) au format KeyValueStore](#convert-crl-kvs-format) + [Gérez plusieurs autorités de certification](#handle-multiple-cas) + [Ajouter des données personnalisées aux journaux de connexion](#add-custom-data-logs) + [Gérer les mises à jour de la CRL](#manage-crl-updates) + [KeyValueStore Capacité du plan](#plan-kvs-capacity) ## Convertir les listes de révocation de certificats (CRL) au format KeyValueStore Si vous avez un fichier de liste de révocation de certificats (CRL), vous pouvez le convertir au format KeyValueStore JSON à l'aide d'OpenSSL et de jq : **Convertir CRL en format KeyValueStore ** Extrayez les numéros de série du fichier CRL : ``` openssl crl -text -noout -in rfc5280_CRL.crl | \ awk '/Serial Number:/ {print $3}' | \ cut -d'=' -f2 | \ sed 's/../&:/g;s/:$//' >> serialnumbers.txt ``` Convertissez les numéros de série au format KeyValueStore JSON : ``` jq -R -s 'split("\n") | map(select(length > 0)) | {data: map({"key": ., "value": ""})}' \ serialnumbers.txt >> serialnumbers_kvs.json ``` Téléchargez le fichier formaté sur S3 et créez-le KeyValueStore comme décrit à l'étape 1. ## Gérez plusieurs autorités de certification Lorsque vous avez TrustStore plusieurs autorités de certification (CAs), incluez les informations relatives à l'émetteur dans vos KeyValueStore clés afin d'éviter les conflits entre des certificats provenant de différentes entités CAs susceptibles de porter le même numéro de série. Pour les scénarios multi-CA, utilisez une combinaison du SHA1 hachage de l'émetteur et du numéro de série comme clé : ``` import cf from 'cloudfront'; async function connectionHandler(connection) { const kvsHandle = cf.kvs(); const clientCert = connection.clientCertInfo; // Create composite key with issuer hash and serial number const issuer = clientCert.issuer.replace(/[^a-zA-Z0-9]/g, '').substring(0, 20); const serialno = clientCert.serialNumber; const compositeKey = `${issuer}_${serialno}`; const cert_revoked = await kvsHandle.exists(compositeKey); if (cert_revoked) { console.log(`Blocking revoked cert: ${serialno} from issuer: ${issuer}`); connection.deny(); } else { connection.allow(); } } ``` **Note** L'utilisation de l'identifiant de l'émetteur et du numéro de série crée des clés plus longues, ce qui peut réduire le nombre total d'entrées que vous pouvez stocker dans le KeyValueStore. ## Ajouter des données personnalisées aux journaux de connexion Les fonctions de connexion peuvent ajouter des données personnalisées aux journaux de CloudFront connexion à l'aide de logCustomData cette méthode. Cela vous permet d'inclure les résultats du contrôle de révocation, les informations de certificat ou d'autres données pertinentes dans vos journaux. ``` async function connectionHandler(connection) { const kvsHandle = cf.kvs(); const clientSerialNumber = connection.clientCertInfo.serialNumber; const serialNumberExistsInKvs = await kvsHandle.exists(clientSerialNumber); if (serialNumberExistsInKvs) { // Log revocation details to connection logs connection.logCustomData(`REVOKED:${clientSerialNumber}:DENIED`); console.log("Connection denied - certificate revoked"); return connection.deny(); } // Log successful validation connection.logCustomData(`VALID:${clientSerialNumber}:ALLOWED`); console.log("Connection allowed"); return connection.allow(); } ``` Les données personnalisées sont limitées à 800 octets de texte UTF-8 valide. Si vous dépassez cette limite, CloudFront tronque les données à la limite UTF-8 valide la plus proche. **Note** L'enregistrement personnalisé des données ne fonctionne que lorsque les journaux de connexion sont activés pour votre distribution. Si les journaux de connexion ne sont pas configurés, la logCustomData méthode est interdite. ## Gérer les mises à jour de la CRL Les autorités de certification peuvent délivrer deux types de CRLs : + **Complet CRLs** : contient une liste complète de tous les certificats révoqués + **Delta CRLs** : liste uniquement les certificats révoqués depuis la dernière CRL complète Pour les mises à jour complètes de la CRL, créez-en une nouvelle KeyValueStore avec les données mises à jour et redirigez l'association de la fonction de connexion vers la nouvelle KeyValueStore. Cette approche est plus simple que le calcul des différences et l'exécution de mises à jour incrémentielles. Pour les mises à jour de la CRL delta, utilisez la commande update-keys pour ajouter de nouveaux certificats révoqués aux certificats existants : KeyValueStore ``` aws cloudfront update-key-value-store \ --name "revoked-serials-kvs" \ --if-match "current-etag" \ --put file://delta-revoked-serials.json ``` ## KeyValueStore Capacité du plan KeyValueStore a une limite de taille de 5 Mo et prend en charge jusqu'à 10 millions de paires clé-valeur. Planifiez la capacité de votre liste de révocation en fonction du format de votre clé et de la taille des données : + **Numéro de série uniquement** : stockage efficace pour une vérification simple des révocations + **Identifiant de l'émetteur et numéro de série** : clés plus longues pour les environnements multi-CA Pour les listes de révocation volumineuses, envisagez de mettre en œuvre une approche à plusieurs niveaux dans le cadre de laquelle vous maintenez des listes distinctes KeyValueStores pour les différentes catégories de certificats ou périodes. # Personnalisation en périphérie avec Lambda@Edge Lambda @Edge est une extension de. AWS Lambda Lambda @Edge est un service de calcul qui vous permet d'exécuter des fonctions qui personnalisent le contenu diffusé par Amazon CloudFront . Vous pouvez créer des fonctions Node.js ou Python dans la console Lambda dans l'une d'elles Région AWS, dans l'est des États-Unis (Virginie du Nord). Après avoir créé la fonction, vous pouvez ajouter des déclencheurs à l'aide de la console Lambda ou CloudFront de la console Lambda afin que les fonctions s'exécutent dans AWS des emplacements plus proches du visualiseur, sans provisionner ni gérer de serveurs. Vous pouvez éventuellement utiliser les opérations Lambda et CloudFront API pour configurer vos fonctions et vos déclencheurs par programmation. Lambda@Edge s'adapte automatiquement, de quelques requêtes par jour jusqu'à des milliers de requêtes par seconde. Le traitement des demandes à AWS des emplacements plus proches de l'utilisateur plutôt que sur les serveurs d'origine réduit considérablement le temps de latence et améliore l'expérience utilisateur. **Note** Lambda@Edge n’est pas pris en charge avec les demandes gRPC. Pour plus d’informations, consultez [Utilisation de gRPC avec des distributions CloudFront](distribution-using-grpc.md). **Topics** + [Fonctionnement de Lambda@Edge avec les demandes et les réponses](lambda-edge-event-request-response.md) + [Comment utiliser Lambda@Edge](lambda-edge-ways-to-use.md) + [Mise en route des fonctions Lambda@Edge (console)](lambda-edge-how-it-works.md) + [Définition des autorisations et rôles IAM pour Lambda@Edge](lambda-edge-permissions.md) + [Écriture et création d’une fonction Lambda@Edge](lambda-edge-create-function.md) + [Ajout de déclencheurs pour une fonction Lambda@Edge](lambda-edge-add-triggers.md) + [Test et débogage des fonctions Lambda@Edge](lambda-edge-testing-debugging.md) + [Suppression des fonctions et des réplicas Lambda@Edge](lambda-edge-delete-replicas.md) + [Structure d'événement Lambda@Edge](lambda-event-structure.md) + [Utilisation des demandes et des réponses](lambda-generating-http-responses.md) + [Exemples de fonctions Lambda@Edge](lambda-examples.md) # Fonctionnement de Lambda@Edge avec les demandes et les réponses Lorsque vous associez une CloudFront distribution à une fonction Lambda @Edge, elle CloudFront intercepte les demandes et les réponses à CloudFront des emplacements périphériques. Vous pouvez exécuter des fonctions Lambda lorsque les CloudFront événements suivants se produisent : + Quand CloudFront reçoit une demande d'un téléspectateur (demande du téléspectateur) + Avant CloudFront de transmettre une demande à l'origine (demande d'origine) + Quand CloudFront reçoit une réponse de l'origine (réponse d'origine) + Before CloudFront renvoie la réponse au spectateur (réponse du spectateur) Si vous l'utilisez AWS WAF, la demande du visualiseur Lambda @Edge est exécutée une fois les AWS WAF règles appliquées. Pour plus d’informations, consultez [Utilisation des demandes et des réponses](lambda-generating-http-responses.md) et [Structure d'événement Lambda@Edge](lambda-event-structure.md). # Comment utiliser Lambda@Edge Le traitement Lambda @Edge peut être utilisé à de nombreuses fins dans votre CloudFront distribution Amazon, comme dans les exemples suivants : + Une fonction Lambda peut inspecter les cookies et les réécrire URLs afin que les utilisateurs puissent consulter les différentes versions d'un site à tester. A/B + CloudFront peuvent renvoyer différents objets aux spectateurs en fonction de l'appareil qu'ils utilisent en vérifiant l'`User-Agent`en-tête, qui contient des informations sur les appareils. Par exemple, ils CloudFront peuvent renvoyer différentes images en fonction de la taille de l'écran de leur appareil. De même, la fonction peut prendre en compte la valeur de l'`Referer`en-tête et CloudFront renvoyer les images aux robots dont la résolution disponible est la plus faible. + Ou, vous pouvez vérifier les cookies pour d'autres critères. Par exemple, sur un site Web de vente au détail qui vend des vêtements, si vous utilisez des cookies pour indiquer la couleur choisie par un utilisateur pour une veste, une fonction Lambda peut modifier la demande afin de CloudFront renvoyer l'image d'une veste dans la couleur sélectionnée. + Une fonction Lambda peut générer des réponses HTTP lorsque des événements de demande d' CloudFront utilisateur ou de demande d'origine se produisent. + Une fonction peut inspecter les en-têtes ou les jetons d'autorisation et insérer un en-tête pour contrôler l'accès à votre contenu avant de CloudFront transmettre la demande à votre origine. + Une fonction Lambda peut également effectuer des appels réseau à des ressources externes pour confirmer les informations d'identification utilisateur, ou récupérer du contenu supplémentaire pour personnaliser une réponse. Pour plus d’informations, avec un exemple de code à l’appui, consultez [Exemples de fonctions Lambda@Edge](lambda-examples.md). Pour plus d’informations sur la configuration de Lambda@Edge dans la console, consultez [Didacticiel : création d’une fonction Lambda@Edge basique (console)](lambda-edge-how-it-works-tutorial.md). # Mise en route des fonctions Lambda@Edge (console) Avec Lambda @Edge, vous pouvez utiliser des CloudFront déclencheurs pour appeler une fonction Lambda. Lorsque vous associez une CloudFront distribution à une fonction Lambda, CloudFront [intercepte les demandes et les réponses à des](https://docs.aws.amazon.com/lambda/latest/dg/lambda-edge.html) emplacements CloudFront périphériques et exécute la fonction. Les fonctions Lambda peuvent améliorer la sécurité ou personnaliser des informations à proximité de vos utilisateurs, afin d’améliorer les performances. La liste suivante fournit un aperçu de base de la création et de l'utilisation de fonctions Lambda avec. CloudFront **Présentation : Création et utilisation de fonctions Lambda avec CloudFront** 1. Créez une fonction Lambda dans la région USA Est (Virginie du Nord). 1. Enregistrez et publiez une version numérotée de la fonction. Si vous souhaitez modifier la fonction, vous devez modifier la version \$1LATEST de la fonction dans la région USA Est (Virginie du Nord). Ensuite, avant de le configurer pour qu'il fonctionne CloudFront, vous publiez une nouvelle version numérotée. 1. Associez la fonction à un comportement CloudFront de distribution et de cache. Spécifiez ensuite un ou plusieurs CloudFront événements (*déclencheurs*) à l'origine de l'exécution de la fonction. Par exemple, vous pouvez créer un déclencheur pour que la fonction s'exécute lorsqu'elle CloudFront reçoit une demande d'un utilisateur. 1. Lorsque vous créez un déclencheur, Lambda crée des réplicas de la fonction dans les emplacements AWS à travers le monde. **Astuce** Pour plus d'informations, consultez les [sections Création et mise à jour de fonctions](lambda-edge-create-function.md)[, structure d'événement](lambda-event-structure.md) et [ajout de CloudFront déclencheurs](lambda-edge-add-triggers.md). Vous pouvez également trouver d'autres idées et obtenir des exemples de code dans [Exemples de fonctions Lambda@Edge](lambda-examples.md). Pour un step-by-step didacticiel, consultez la rubrique suivante : **Topics** + [Didacticiel : création d’une fonction Lambda@Edge basique (console)](lambda-edge-how-it-works-tutorial.md) # Didacticiel : création d’une fonction Lambda@Edge basique (console) Ce didacticiel explique comment démarrer avec Lambda @Edge en créant et en configurant un exemple de fonction Node.js qui s'exécute dans. CloudFront Cet exemple ajoute des en-têtes de sécurité HTTP à une réponse lors de la CloudFront récupération d'un fichier. (Cette opération peut améliorer la sécurité et la confidentialité d’un site web.) Vous n’avez pas besoin d’avoir un site web pour suivre ce didacticiel. Cependant, lorsque vous choisissez de créer votre propre solution Lambda@Edge, vous suivez des étapes similaires et sélectionnez les mêmes options. **Topics** + [Étape 1 : Inscrivez-vous à un Compte AWS](#lambda-edge-how-it-works-tutorial-AWS) + [Étape 2 : Création d'une CloudFront distribution](#lambda-edge-how-it-works-tutorial-cloudfront) + [Étape 3 : créer votre fonction](#lambda-edge-how-it-works-tutorial-create-function) + [Étape 4 : ajouter un CloudFront déclencheur pour exécuter la fonction](#lambda-edge-how-it-works-tutorial-add-trigger) + [Étape 5 : vérifier l’exécution de la fonction](#lambda-edge-how-it-works-tutorial-verify) + [Étape 6 : résoudre les problèmes](#lambda-edge-how-it-works-tutorial-troubleshoot) + [Étape 7 : nettoyer votre exemple de ressources](#lambda-edge-how-it-works-tutorial-cleanup-resources) + [Informations connexes](#lambda-edge-how-it-works-tutorial-resources) ## Étape 1 : Inscrivez-vous à un Compte AWS Si vous ne l’avez pas encore fait, créez un Compte AWS. Pour de plus amples informations, veuillez consulter [Inscrivez-vous pour un Compte AWS](setting-up-cloudfront.md#sign-up-for-aws). ## Étape 2 : Création d'une CloudFront distribution Avant de créer l'exemple de fonction Lambda @Edge, vous devez disposer d'un CloudFront environnement de travail incluant une origine à partir de laquelle diffuser le contenu. Dans cet exemple, vous créez une CloudFront distribution qui utilise un compartiment Amazon S3 comme origine de la distribution. Si vous avez déjà un environnement à utiliser, vous pouvez ignorer cette étape. **Pour créer une CloudFront distribution avec une origine Amazon S3** 1. Créez un compartiment Amazon S3 avec un fichier ou deux, par exemple des fichiers image, comme exemples de contenu. Pour obtenir de l'aide, suivez les étapes dans [Chargement de votre contenu sur Amazon S3](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/GettingStarted.html#GettingStartedUploadContent). Assurez-vous de définir des autorisations pour accorder l'accès public en lecture sur les objets de votre compartiment. 1. Créez une CloudFront distribution et ajoutez votre compartiment S3 comme origine, en suivant les étapes décrites dans [Créer une distribution CloudFront Web](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/GettingStarted.html#GettingStartedCreateDistribution). Si vous avez déjà une distribution, vous pouvez, au lieu de cela, ajouter le compartiment en tant qu'origine pour cette distribution. **Astuce** Notez votre ID de distribution. Plus loin dans ce didacticiel, lorsque vous ajoutez un CloudFront déclencheur pour votre fonction, vous devez choisir l'ID de votre distribution dans une liste déroulante, par exemple,. `E653W22221KDDL` ## Étape 3 : créer votre fonction Au cours de cette étape, vous créez une fonction Lambda à partir d’un modèle de plan dans la console Lambda. La fonction ajoute du code pour mettre à jour les en-têtes de sécurité dans votre distribution CloudFront. **Pour créer une fonction Lambda** 1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). **Important** **Assurez-vous que vous êtes dans le **US-east-1 (Virginie du Nord) (** Région AWS us-east-1).** Vous devez être dans cette région pour créer des fonctions Lambda@Edge. 1. Choisissez **Créer une fonction**. 1. Sur la page **Créer une fonction**, choisissez **Utiliser un plan**, puis filtrez les CloudFront plans en les saisissant **cloudfront** dans le champ de recherche. **Note** CloudFront **les plans ne sont disponibles que dans la **région US-east-1 (Virginie du Nord) (us-east-1**).** 1. Choisissez le plan **Modifier l’en-tête de réponse HTTP** comme modèle pour votre fonction. 1. Entrez les informations suivantes sur votre fonction : + **Nom de la fonction** : entrez un nom pour votre fonction. + **Rôle d’exécution** : choisissez la façon de définir les autorisations pour votre fonction. Pour utiliser le modèle de politique d'autorisation de base recommandé par Lambda @Edge, choisissez **Create a new role from AWS policy** templates. + **Nom du rôle** : entrez un nom pour le rôle créé par le modèle de stratégie. + **Modèles de politique** — Lambda ajoute automatiquement le modèle de stratégie Basic **Lambda @Edge permissions** parce que vous avez choisi un CloudFront plan comme base pour votre fonction. Ce modèle de politique ajoute des autorisations de rôle d'exécution qui CloudFront permettent d'exécuter votre fonction Lambda pour vous dans le CloudFront monde entier. Pour de plus amples informations, veuillez consulter [Définition des autorisations et rôles IAM pour Lambda@Edge](lambda-edge-permissions.md). 1. Dans le bas de la page, choisissez **Créer une fonction**. 1. Dans le volet **Déployer sur Lambda@Edge** qui apparaît, choisissez **Annuler**. (Pour ce didacticiel, vous devez modifier le code de la fonction avant de déployer la fonction sur Lambda@Edge.) 1. Faites défiler la page jusqu’à la section **Source du code**. 1. Remplacez le code de modèle par une fonction qui modifie les en-têtes de sécurité renvoyés par votre origine. Par exemple, vous pouvez utiliser du code tel que : ``` 'use strict'; export const handler = (event, context, callback) => { //Get contents of response const response = event.Records[0].cf.response; const headers = response.headers; //Set new headers headers['strict-transport-security'] = [{key: 'Strict-Transport-Security', value: 'max-age= 63072000; includeSubdomains; preload'}]; headers['content-security-policy'] = [{key: 'Content-Security-Policy', value: "default-src 'none'; img-src 'self'; script-src 'self'; style-src 'self'; object-src 'none'"}]; headers['x-content-type-options'] = [{key: 'X-Content-Type-Options', value: 'nosniff'}]; headers['x-frame-options'] = [{key: 'X-Frame-Options', value: 'DENY'}]; headers['x-xss-protection'] = [{key: 'X-XSS-Protection', value: '1; mode=block'}]; headers['referrer-policy'] = [{key: 'Referrer-Policy', value: 'same-origin'}]; //Return modified response callback(null, response); }; ``` 1. Choisissez **Fichier**, puis **Enregistrer** pour enregistrer votre code mis à jour. 1. Choisissez **Déployer**. Passez à la section suivante pour ajouter un CloudFront déclencheur permettant d'exécuter la fonction. ## Étape 4 : ajouter un CloudFront déclencheur pour exécuter la fonction Maintenant que vous disposez d'une fonction Lambda pour mettre à jour les en-têtes de sécurité, configurez le CloudFront déclencheur pour exécuter votre fonction afin d'ajouter les en-têtes dans toute réponse CloudFront reçue de l'origine de votre distribution. **Pour configurer le CloudFront déclencheur de votre fonction** 1. Dans la console Lambda, sur la page **Présentation de la fonction**, choisissez **Ajouter un déclencheur**. 1. Pour la **configuration du déclencheur**, choisissez **CloudFront**. 1. Choisissez **Déployer sur Lambda@Edge**. 1. Dans le volet **Deploy to Lambda @Edge**, sous **Configurer le CloudFront déclencheur**, entrez les informations suivantes : + **Distribution** : ID de CloudFront distribution à associer à votre fonction. Dans la liste déroulante, choisissez l’ID de distribution. + **Comportement de cache** : le comportement de cache à utiliser avec le déclencheur. Pour cet exemple, laissez la valeur définie sur **\$1**, qui correspond au comportement de cache par défaut de votre distribution. Pour plus d’informations, consultez [Paramètres de comportement du cache](DownloadDistValuesCacheBehavior.md) dans la rubrique [Référence de tous les paramètres de distribution](distribution-web-values-specify.md). + **CloudFront event** — Le déclencheur qui indique le moment où votre fonction s'exécute. Nous voulons que la fonction d'en-têtes de sécurité s'exécute chaque fois que CloudFront renvoie une réponse depuis l'origine. Dans la liste déroulante, choisissez **Réponse de l’origine**. Pour de plus amples informations, veuillez consulter [Ajout de déclencheurs pour une fonction Lambda@Edge](lambda-edge-add-triggers.md). 1. Cochez la case **Confirmer le déploiement sur Lambda@Edge**. 1. Choisissez **Déployer** pour ajouter le déclencheur et répliquer la fonction dans le monde AWS entier. 1. Attendez que la réplication de la fonction soit terminée. Cela prend généralement plusieurs minutes. Vous pouvez vérifier si la réplication est terminée en [accédant à la console CloudFront](https://console.aws.amazon.com/cloudfront/v4/home) et en visualisant votre distribution. Attendez que l’état de la distribution passe de **Déploiement** à une date et une heure, ce qui indique que votre fonction a été répliquée. Pour vérifier que la fonction s'exécute correctement, suivez les étapes de la section suivante. ## Étape 5 : vérifier l’exécution de la fonction Maintenant que vous avez créé votre fonction Lambda et configuré un déclencheur pour l'exécuter pour une CloudFront distribution, assurez-vous que la fonction répond à vos attentes. Dans cet exemple, nous vérifions les en-têtes HTTP que CloudFront renvoie pour nous assurer que les en-têtes de sécurité sont ajoutés. **Pour vérifier que votre fonction Lambda@Edge ajoute des en-têtes de sécurité** 1. Dans un navigateur, entrez l'URL d'un fichier dans votre compartiment S3. Par exemple, vous pouvez utiliser une URL similaire à `https://d111111abcdef8.cloudfront.net/image.jpg`. Pour plus d'informations sur le nom de CloudFront domaine à utiliser dans l'URL du fichier, consultez[Personnalisez le format d'URL pour les fichiers dans CloudFront](LinkFormat.md). 1. Ouvrez la barre d'outils Web Developer de votre navigateur. Par exemple, dans votre fenêtre de navigateur Chrome, ouvrez le menu contextuel (clic droit), puis choisissez **Inspecter**. 1. Choisissez l'onglet **Network (Réseau)**. 1. Rechargez la page pour afficher votre image, puis choisissez une demande HTTP dans le volet de gauche. Vous voyez les en-têtes HTTP s'afficher dans un volet distinct. 1. Parcourez la liste des en-têtes HTTP pour vérifier que les en-têtes de sécurité attendus sont inclus dans la liste. Par exemple, vous pourrez peut-être voir des en-têtes similaires à ceux affichés dans la capture d'écran suivante. ![\[Liste d'en-têtes HTTP avec les en-têtes de sécurité attendus mis en évidence.\]](http://docs.aws.amazon.com/fr_fr/AmazonCloudFront/latest/DeveloperGuide/images/lambda-at-edge-security-headers-list.png) Si les en-têtes de sécurité sont inclus dans votre liste d'en-têtes, cela signifie que vous avez créé avec succès votre première fonction Lambda@Edge. En cas d'erreur de CloudFront retour ou d'autres problèmes, passez à l'étape suivante pour résoudre les problèmes. ## Étape 6 : résoudre les problèmes Si elle CloudFront renvoie des erreurs ou n'ajoute pas les en-têtes de sécurité comme prévu, vous pouvez étudier l'exécution de votre fonction en consultant CloudWatch Logs. Veillez à utiliser les journaux stockés à l' AWS emplacement le plus proche de l'endroit où la fonction est exécutée. Par exemple, si vous consultez le fichier depuis Londres, essayez de remplacer la région dans la CloudWatch console par Europe (Londres). **Pour examiner les CloudWatch journaux de votre fonction Lambda @Edge** 1. Connectez-vous à la CloudWatch console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Modifiez **Région** en spécifiant l'emplacement qui est montré lorsque vous affichez le fichier dans votre navigateur. C'est là que la fonction s'exécute. 1. Dans le volet de gauche, choisissez **Logs (Journaux)** pour afficher les journaux de votre distribution. Pour plus d’informations, consultez [Surveillez CloudFront les métriques avec Amazon CloudWatch](monitoring-using-cloudwatch.md). ## Étape 7 : nettoyer votre exemple de ressources Si vous avez créé un compartiment et une CloudFront distribution Amazon S3 uniquement pour ce didacticiel, supprimez les AWS ressources que vous avez allouées afin de ne plus payer de frais. Une fois que vous avez supprimé vos AWS ressources, le contenu que vous avez ajouté n'est plus disponible. **Tâches** + [Supprimer le compartiment S3](#lambda-edge-how-it-works-tutorial-delete-bucket) + [Supprimer la fonction Lambda](#lambda-edge-how-it-works-tutorial-delete-function) + [Supprimer la CloudFront distribution](#lambda-edge-how-it-works-tutorial-delete-distribution) ### Supprimer le compartiment S3 Avant de supprimer votre compartiment Amazon S3, assurez-vous que la journalisation est désactivée pour le compartiment. Sinon, AWS continue d'écrire des journaux dans votre compartiment lorsque vous le supprimez. **Pour désactiver la journalisation pour un compartiment** 1. Ouvrez la console Amazon S3 à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/). 1. Sélectionnez le compartiment, puis choisissez **Properties (Propriétés)**. 1. Dans **Properties (Propriétés)**, choisissez **Logging (Journalisation)**. 1. Désactivez la case à cocher **Activé**. 1. Choisissez **Enregistrer**. Vous pouvez maintenant supprimer votre compartiment. Pour plus d’informations, consultez [Suppression d’un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html) dans le *Guide de l’utilisateur de la console Amazon Simple Storage Service*. ### Supprimer la fonction Lambda Pour obtenir les instructions permettant de supprimer l’association à la fonction Lambda et, éventuellement, la fonction elle-même, consultez [Suppression des fonctions et des réplicas Lambda@Edge](lambda-edge-delete-replicas.md). ### Supprimer la CloudFront distribution Avant de supprimer une CloudFront distribution, vous devez la désactiver. Une distribution désactivée n'est plus fonctionnelle et n'accumule pas de frais. Vous pouvez activer une distribution désactivée à tout moment. Une fois que vous avez supprimé une distribution désactivée, celle-ci n'est plus disponible. **Pour désactiver et supprimer une CloudFront distribution** 1. Ouvrez la CloudFront console à l'adresse[https://console.aws.amazon.com/cloudfront/v4/home](https://console.aws.amazon.com/cloudfront/v4/home). 1. Sélectionnez la distribution que vous souhaitez désactiver, puis choisissez **Désactiver)**. 1. Lorsque vous serez invité à confirmer l'opération, choisissez **Oui, désactiver**. 1. Sélectionnez la distribution désactivée, puis choisissez **Supprimer**. 1. Lorsque vous êtes invité à confirmer l'opération, choisissez **Oui, supprimer**. ## Informations connexes Maintenant que vous avez une idée générale de la manière dont les fonctions Lambda@Edge s'exécutent, lisez les documents suivants pour en savoir plus : + [Exemples de fonctions Lambda@Edge](lambda-examples.md) + [Bonnes pratiques de conception Lambda @Edge](https://aws.amazon.com/blogs/networking-and-content-delivery/lambdaedge-design-best-practices/) + [Réduction de la latence et transfert du calcul vers la périphérie avec Lambda @Edge](https://aws.amazon.com/blogs/networking-and-content-delivery/reducing-latency-and-shifting-compute-to-the-edge-with-lambdaedge/) # Définition des autorisations et rôles IAM pour Lambda@Edge Pour configurer Lambda@Edge, vous devez disposer des autorisations et des rôles IAM pour AWS Lambda : + [Autorisations IAM](#lambda-edge-permissions-required) : ces autorisations vous permettent de créer votre fonction Lambda et de l'associer CloudFront à votre distribution. + [Un rôle d’exécution de fonction Lambda](#lambda-edge-permissions-function-execution) (rôle IAM) : les principaux de service Lambda assument ce rôle pour exécuter votre fonction. + [Rôles liés à un service pour Lambda @Edge — Les rôles](#using-service-linked-roles-lambda-edge) liés à un service permettent à des utilisateurs spécifiques de Services AWS répliquer des fonctions Lambda dans des fichiers journaux et de les utiliser. Régions AWS CloudWatch CloudFront ## Autorisations IAM requises pour associer les fonctions Lambda @Edge aux distributions CloudFront Outre les autorisations IAM dont vous avez besoin pour Lambda, vous avez besoin des autorisations suivantes pour associer les fonctions Lambda aux distributions : CloudFront + `lambda:GetFunction` : accorde l’autorisation d’obtenir les informations de configuration de votre fonction Lambda ainsi qu’une URL pré-signée pour télécharger un fichier `.zip` contenant la fonction. + `lambda:EnableReplication*` : accorde une autorisation à la politique de ressource afin que le service de réplication Lambda puisse récupérer le code et la configuration de la fonction. + `lambda:DisableReplication*` : accorde une autorisation à la politique de ressource afin que le service de réplication Lambda puisse supprimer la fonction. **Important** Vous devez ajouter l’astérisque (`*`) à la fin des actions `lambda:EnableReplication*` et `lambda:DisableReplication*`. + Pour la ressource, spécifiez l'ARN de la version de fonction que vous souhaitez exécuter lorsqu'un CloudFront événement se produit, comme dans l'exemple suivant : `arn:aws:lambda:us-east-1:123456789012:function:TestFunction:2` + `iam:CreateServiceLinkedRole`— Accorde l'autorisation de créer un rôle lié à un service que Lambda @Edge utilise pour répliquer les fonctions Lambda. CloudFront Après avoir configuré Lambda@Edge pour la première fois, le rôle lié au service est créé automatiquement pour vous. Il n’est pas nécessaire d’ajouter cette autorisation aux autres distributions qui utilisent Lambda@Edge. + `cloudfront:UpdateDistribution` ou `cloudfront:CreateDistribution` : accorde l’autorisation de mettre à jour ou de créer une distribution. Pour plus d’informations, consultez les rubriques suivantes : + [Identity and Access Management pour Amazon CloudFront](security-iam.md) + [Autorisations d’accès aux ressources Lambda](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role) dans le *Guide du développeur AWS Lambda * ## Rôle d'exécution de fonction pour les principaux de service Vous devez créer un rôle IAM que les principaux de service `lambda.amazonaws.com` et `edgelambda.amazonaws.com` peuvent assumer lorsqu’ils exécutent votre fonction. **Astuce** Lorsque vous créez votre fonction dans la console Lambda, vous pouvez choisir de créer un nouveau rôle d'exécution à l'aide d'un modèle de AWS politique. Cette étape ajoute *automatiquement* les autorisations Lambda@Edge requises pour exécuter votre fonction. Consultez [l’étape 5 du Didacticiel : création d’une fonction Lambda@Edge simple](lambda-edge-how-it-works-tutorial.md#lambda-edge-how-it-works-tutorial-create-function). Pour plus d’informations sur la création manuelle d’un rôle IAM, consultez [Création des rôles et association des politiques (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions_create-policies.html) dans le *Guide de l’utilisateur IAM*. **Example Exemple : stratégie d’approbation du rôle** Vous pouvez ajouter ce rôle sous l’onglet **Relations d’approbation** dans la console IAM. N’ajoutez pas cette politique sous l’onglet **Autorisations**. **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com", "edgelambda.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] } ``` Pour plus d’informations sur les autorisations que vous devez associer au rôle d’exécution, consultez [Autorisations d’accès aux ressources Lambda](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role) dans le *Guide du développeur AWS Lambda *. **Remarques** Par défaut, chaque fois qu'un CloudFront événement déclenche une fonction Lambda, les données sont écrites dans Logs. CloudWatch Si vous souhaitez utiliser ces journaux, le rôle d'exécution doit être autorisé à écrire des données dans les CloudWatch journaux. Vous pouvez utiliser le AWSLambdaBasicExecutionRole prédéfini pour accorder l’autorisation nécessaire au rôle d’exécution. Pour plus d'informations sur CloudWatch les journaux, consultez[Journaux des fonctions de périphérie](edge-functions-logs.md). Si votre code de fonction Lambda accède à d'autres AWS ressources, telles que la lecture d'un objet depuis un compartiment S3, le rôle d'exécution doit être autorisé pour effectuer cette action. ## Rôles liés à un service pour Lambda@Edge Lambda@Edge utilise des [rôles liés à un service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) IAM. Un rôle lié à un service est un type unique de rôle IAM lié directement à un service. Les rôles liés à un service sont prédéfinis par le service et comprennent toutes les autorisations nécessaires au service pour appeler d'autres services AWS en votre nom. Lambda@Edge utilise les rôles liés à un service IAM suivants : + **AWSServiceRoleForLambdaReplicator** – Lambda@Edge utilise ce rôle pour autoriser Lambda@Edge à répliquer des fonctions vers Régions AWS. Lorsque vous ajoutez un déclencheur Lambda @Edge pour la première fois CloudFront, un rôle nommé AWSServiceRoleForLambdaReplicator est créé automatiquement pour permettre à Lambda @Edge de répliquer des fonctions sur. Régions AWS Ce rôle est obligatoire pour utiliser les fonctions Lambda@Edge. L’ARN du rôle AWSServiceRoleForLambdaReplicator ressemble à l’exemple suivant : `arn:aws:iam::123456789012:role/aws-service-role/replicator.lambda.amazonaws.com/AWSServiceRoleForLambdaReplicator` + **AWSServiceRoleForCloudFrontLogger**— CloudFront utilise ce rôle pour transférer les fichiers journaux dans CloudWatch. Vous pouvez utiliser des fichiers journaux pour corriger les erreurs de validation Lambda@Edge. Le AWSServiceRoleForCloudFrontLogger rôle est créé automatiquement lorsque vous ajoutez une association de fonctions Lambda @Edge pour permettre de transférer les fichiers CloudFront journaux d'erreurs Lambda @Edge vers. CloudWatch L’ARN pour le rôle AWSServiceRoleForCloudFrontLogger prend la forme suivante : `arn:aws:iam::account_number:role/aws-service-role/logger.cloudfront.amazonaws.com/AWSServiceRoleForCloudFrontLogger` Un rôle lié à un service simplifie la configuration et l'utilisation de Lambda@Edge, car vous n'avez pas besoin d'ajouter manuellement les autorisations requises. Lambda@Edge définit les autorisations de ses rôles liés un service et seul Lambda@Edge peut endosser ces rôles. Les autorisations définies comprennent la politique d'approbation et la politique d'autorisations. Vous ne pouvez pas attacher la politique d'autorisations à une autre entité IAM. Vous devez supprimer toutes les ressources associées CloudFront ou Lambda @Edge avant de pouvoir supprimer un rôle lié à un service. Cela vous aide à protéger vos ressources Lambda@Edge afin d’éviter la suppression d’un rôle lié à un service qui est encore nécessaire pour accéder à des ressources actives. Pour plus d’informations sur les rôles liés à un service, consultez [Rôles liés à un service pour CloudFront](security_iam_service-with-iam.md#security_iam_service-with-iam-roles-service-linked). ### Autorisations du rôle lié à un service pour Lambda@Edge Lambda@Edge utilise deux rôles liés à un service nommé **AWSServiceRoleForLambdaReplicator** et **AWSServiceRoleForCloudFrontLogger**. Les sections suivantes décrivent comment gérer les autorisations pour chacun de ces rôles. **Contents** + [Autorisations du rôle lié à un service pour Lambda Replicator](#slr-permissions-lambda-replicator) + [Autorisations de rôle liées au service pour l'enregistreur CloudFront](#slr-permissions-cloudfront-logger) #### Autorisations du rôle lié à un service pour Lambda Replicator Ce rôle lié à un service permet à Lambda de répliquer les fonctions Lambda@Edge vers Régions AWS. Le rôle lié à un service AWSServiceRoleForLambdaReplicator fait confiance au service `replicator.lambda.amazonaws.com` pour endosser le rôle. La politique d'autorisations du rôle permet à Lambda@Edge de réaliser les actions suivantes sur les ressources spécifiées : + `lambda:CreateFunction` sur `arn:aws:lambda:*:*:function:*` + `lambda:DeleteFunction` sur `arn:aws:lambda:*:*:function:*` + `lambda:DisableReplication` sur `arn:aws:lambda:*:*:function:*` + `iam:PassRole` sur `all AWS resources` + `cloudfront:ListDistributionsByLambdaFunction` sur `all AWS resources` #### Autorisations de rôle liées au service pour l'enregistreur CloudFront Ce rôle lié à un service permet de CloudFront transférer des fichiers journaux CloudWatch afin que vous puissiez corriger les erreurs de validation Lambda @Edge. Le rôle lié à un service AWSServiceRoleForCloudFrontLogger fait confiance au service `logger.cloudfront.amazonaws.com` pour endosser le rôle. La politique d’autorisations du rôle permet à Lambda@Edge de réaliser les actions suivantes sur les ressources `arn:aws:logs:*:*:log-group:/aws/cloudfront/*` spécifiées : + `logs:CreateLogGroup` `` + `logs:CreateLogStream` + `logs:PutLogEvents` Vous devez configurer les autorisations de manière à permettre à une entité IAM (comme un utilisateur, groupe ou rôle) de supprimer les rôles liés à un service Lambda@Edge. Pour plus d’informations, consultez [Autorisations de rôles liés à un service](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) dans le *Guide de l’utilisateur IAM*. ### Création de rôles liés à un service pour Lambda@Edge Vous n'avez généralement pas besoin de créer manuellement les rôles liés à un service pour Lambda@Edge. Le service crée les rôles automatiquement pour vous dans les scénarios suivants : + Lorsque vous créez un déclencheur pour la première fois, le service crée le rôle AWSServiceRoleForLambdaReplicator (s’il n’existe pas encore.). Ce rôle permet à Lambda de répliquer les fonctions Lambda@Edge vers Régions AWS. Si vous supprimez le rôle lié à un service, le rôle sera à nouveau créé lorsque vous ajouterez un nouveau déclencheur pour Lambda@Edge dans une distribution. + Lorsque vous mettez à jour ou créez une CloudFront distribution associée à Lambda @Edge, le service crée le AWSServiceRoleForCloudFrontLogger rôle (si le rôle n'existe pas déjà). Ce rôle permet CloudFront de transférer vos fichiers journaux vers CloudWatch. Si vous supprimez le rôle lié à un service, le rôle sera créé à nouveau lorsque vous mettrez à jour ou créerez une CloudFront distribution associée à Lambda @Edge. Pour créer manuellement ces rôles liés à un service, vous pouvez exécuter les commandes suivantes AWS Command Line Interface (AWS CLI) : **Pour créer le rôle AWSServiceRoleForLambdaReplicator** + Exécutez la commande suivante. ``` aws iam create-service-linked-role --aws-service-name replicator.lambda.amazonaws.com ``` **Pour créer le rôle AWSServiceRoleForCloudFrontLogger** + Exécutez la commande suivante. ``` aws iam create-service-linked-role --aws-service-name logger.cloudfront.amazonaws.com ``` ### Modification des rôles liés à un service Lambda@Edge. Lambda@Edge ne vous permet pas de modifier les rôles liés à un service AWSServiceRoleForLambdaReplicator ou AWSServiceRoleForCloudFrontLogger. Une fois que le service a créé un rôle lié à un service, vous ne pouvez pas changer le nom du rôle, car plusieurs entités peuvent y faire référence. Néanmoins, vous pouvez utiliser IAM pour modifier la description du rôle. Pour plus d’informations, consultez [Modification d’un rôle lié à un service](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) dans le *Guide de l’utilisateur IAM*. ### Pris en charge Régions AWS pour les rôles liés au service Lambda @Edge CloudFront prend en charge l'utilisation de rôles liés à un service pour Lambda @Edge dans les domaines suivants : Régions AWS + USA Est (Virginie du Nord) – `us-east-1` + USA Est (Ohio) – `us-east-2` + USA Ouest (Californie du Nord) – `us-west-1` + USA Ouest (Oregon) – `us-west-2` + Asie-Pacifique (Mumbai) – `ap-south-1` + Asie-Pacifique (Séoul) – `ap-northeast-2` + Asie-Pacifique (Singapour) – `ap-southeast-1` + Asie-Pacifique (Sydney) – `ap-southeast-2` + Asie-Pacifique (Tokyo) : `ap-northeast-1` + Europe (Francfort) – `eu-central-1` + Europe (Irlande) – `eu-west-1` + Europe (Londres) – `eu-west-2` + South America (São Paulo) – `sa-east-1` # Écriture et création d’une fonction Lambda@Edge Pour utiliser Lambda@Edge, vous devez *écrire* le code de votre fonction AWS Lambda . Pour vous aider à écrire des fonctions Lambda@Edge, consultez les ressources suivantes : + [Structure d'événement Lambda@Edge](lambda-event-structure.md) : comprenez la structure d’événement à utiliser avec Lambda@Edge. + [Exemples de fonctions Lambda@Edge](lambda-examples.md)— Exemples de fonctions, telles que le A/B test et la génération d'une redirection HTTP. Le modèle de programmation pour utiliser Node.js ou Python avec Lambda@Edge est le même que pour l’utilisation de Lambda dans une Région AWS. Pour plus d’informations, consultez [Création de fonctions Lambda avec Node.js](https://docs.aws.amazon.com/lambda/latest/dg/lambda-nodejs.html) ou [Création de fonctions Lambda avec Python](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html) dans le *Guide du développeur AWS Lambda *. Dans votre fonction Lambda@Edge, insérez le paramètre `callback` et renvoyez l’objet applicable pour les événements de demande ou de réponse : + **Événements de demande** – Incluez l'objet `cf.request` dans la réponse. Si vous générez une réponse, incluez l'objet `cf.response` dans la réponse. Pour plus d’informations, consultez [Génération de réponses HTTP dans les déclencheurs de demande](lambda-generating-http-responses.md#lambda-generating-http-responses-in-requests). + **Événements de réponse** – Incluez l'objet `cf.response` dans la réponse. Après avoir écrit votre propre code ou utilisé l’un des exemples, vous créez la fonction dans Lambda. Pour créer une fonction ou modifier une fonction existante, consultez les rubriques suivantes : **Topics** + [Création d’une fonction Lambda@Edge](lambda-edge-create-in-lambda-console.md) + [Modification d’une fonction Lambda](lambda-edge-edit-function.md) *Après avoir créé la fonction dans Lambda, vous configurez Lambda pour qu'elle exécute la fonction en fonction d' CloudFront événements spécifiques, appelés déclencheurs.* Pour de plus amples informations, veuillez consulter [Ajout de déclencheurs pour une fonction Lambda@Edge](lambda-edge-add-triggers.md). # Création d’une fonction Lambda@Edge AWS Lambda Pour configurer l'exécution de fonctions Lambda basées sur des CloudFront événements, suivez cette procédure. **Pour créer une fonction Lambda@Edge** 1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Si vous avez déjà une ou plusieurs fonctions Lambda, choisissez **Create function (Créer fonction)**. Si vous n'avez aucune fonction, choisissez **Mise en route**. 1. Dans la liste des régions située en haut de la page, choisissez **US East (N. Virginia) (USA Est (Virginie du Nord))**. 1. Créez une fonction à l'aide de votre propre code ou en partant d'un plan CloudFront . + Pour créer une fonction à l'aide de votre propre code, choisissez **Créer à partir de zéro**. + **Pour afficher une liste de plans pour CloudFront, saisissez **cloudfront** dans le champ de filtre, puis choisissez Entrée.** Si vous trouvez un plan que vous souhaitez utiliser, choisissez le nom de ce plan. 1. Dans la section **Informations de base**, spécifiez les valeurs suivantes : 1. **Nom** : saisissez le nom de votre fonction. 1. **Rôle** : pour démarrer rapidement, choisissez **Créer un rôle à partir de modèles**. Vous pouvez également sélectionner **Choisir un rôle existant** ou **Créer un rôle personnalisé**, puis suivre les invites pour compléter les informations de cette section. 1. **Nom du rôle** : entrez un nom pour le rôle. 1. **Modèles de stratégies** : choisissez **Autorisations Lambda de périphérique standard**. 1. Si vous avez choisi **Créer à partir de zéro** à l'étape 4, passez directement à l'étape 7. Si vous avez choisi un plan à l'étape 4, la section **cloudfront** vous permet de créer un déclencheur, qui associe cette fonction à un cache dans une CloudFront distribution et à un événement. CloudFront Pour l'instant, nous vous recommandons de choisir **Supprimer**, afin qu'il n'y ait pas de déclencheur pour la fonction lorsqu'elle sera créée. Vous pourrez ajouter des déclencheurs par la suite. **Astuce** Nous vous recommandons de tester et déboguer la fonction avant d’ajouter des déclencheurs. Si vous ajoutez un déclencheur maintenant, la fonction s'exécutera dès que vous la créerez, qu'elle aura fini de se répliquer AWS dans le monde entier et que la distribution correspondante sera déployée. 1. Choisissez **Créer une fonction**. Lambda crée deux versions de votre fonction : \$1LATEST et Version 1. Vous pouvez modifier uniquement la version \$1LATEST, mais la console affiche initialement la version 1. 1. Pour modifier la fonction, choisissez **Version 1** en haut de la page, sous l'ARN de la fonction. Puis, dans l'onglet **Versions**, choisissez **\$1LATEST**. (Si vous avez quitté la fonction, puis êtes revenu à celle-ci, le bouton est appelé **Qualificateurs**.) 1. Dans l'onglet **Configuration**, choisissez le **Type d'entrée de code** applicable. Ensuite, suivez les instructions pour modifier ou charger votre code. 1. Pour **Exécution**, choisissez la valeur en fonction du code de votre fonction. 1. Dans la section **Balises**, ajoutez les éventuelles balises applicables. 1. Choisissez **Actions**, puis **Publier une nouvelle version**. 1. Saisissez la description de la nouvelle version de la fonction. 1. Choisissez **Publish**. 1. Testez et déboguez la fonction. Pour plus d’informations sur les tests de la console Lambda, consultez [Invoquer une fonction Lambda avec la console](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html#get-started-invoke-manually) dans le *Guide du développeur AWS Lambda *. 1. Lorsque vous êtes prêt à exécuter la fonction pour des CloudFront événements, publiez une autre version et modifiez la fonction pour ajouter des déclencheurs. Pour de plus amples informations, veuillez consulter [Ajout de déclencheurs pour une fonction Lambda@Edge](lambda-edge-add-triggers.md). # Modification d’une fonction Lambda Après avoir créé une fonction Lambda@Edge, vous pouvez utiliser la console Lambda pour la modifier. **Remarques** La version d'origine est étiquetée \$1LATEST. Vous ne pouvez modifier que la version \$1LATEST. Chaque fois que vous modifiez la version \$1LATEST, vous devez publier une nouvelle version numérotée. Vous ne pouvez pas créer de déclencheurs pour \$1LATEST. Lorsque vous publiez une nouvelle version d'une fonction, Lambda ne copie pas automatiquement les déclencheurs à partir de la version précédente vers la nouvelle version. Vous devez reproduire les déclencheurs pour la nouvelle version. Lorsque vous ajoutez un déclencheur pour un CloudFront événement à une fonction, s'il existe déjà un déclencheur pour la même distribution, le même comportement de cache et le même événement pour une version antérieure de la même fonction, Lambda supprime le déclencheur de la version précédente. Après avoir mis à jour une CloudFront distribution, par exemple en ajoutant des déclencheurs, vous devez attendre que les modifications se propagent aux emplacements périphériques pour que les fonctions que vous avez spécifiées dans les déclencheurs fonctionnent. **Pour modifier une fonction Lambda** 1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Dans la liste des régions située en haut de la page, choisissez **US East (N. Virginia) (USA Est (Virginie du Nord))**. 1. Dans la liste des fonctions, choisissez le nom de la fonction. Par défaut, la console affiche la version \$1LATEST. Vous pouvez consulter les versions précédentes (choisissez **Qualificateurs**), mais vous ne pouvez modifier que \$1 LATEST. 1. Dans l'onglet **Code**, pour **Code entry type (Type d'entrée de code)**, choisissez de modifier le code dans le navigateur, de charger un fichier .zip ou de charger un fichier depuis Amazon S3. 1. Choisissez **Enregistrer** ou **Enregistrer et tester**. 1. Choisissez **Actions**, puis **Publish new version (Publier nouvelle version)**. 1. Dans la boîte de dialogue **Publier la nouvelle version à partir de \$1LATEST**, indiquez une description de la nouvelle version. Cette description s'affiche dans la liste des versions, accompagnée d'un numéro de version généré automatiquement. 1. Choisissez **Publish**. La nouvelle version devient automatiquement la version la plus récente. Le numéro de version s’affiche dans la zone **Version** dans l’angle supérieur gauche de la page. **Note** Si vous n’avez pas encore ajouté de déclencheurs pour votre fonction, consultez [Ajout de déclencheurs pour une fonction Lambda@Edge](lambda-edge-add-triggers.md). 1. Choisissez l’onglet **Déclencheurs**. 1. Choisissez **Add trigger (Ajouter déclencheur)**. 1. Dans la boîte de dialogue **Add trigger (Ajouter déclencheur)**, choisissez la zone en pointillé, puis **CloudFront**. **Note** Si vous avez déjà créé un ou plusieurs déclencheurs pour une fonction, CloudFront c'est le service par défaut. 1. Spécifiez les valeurs suivantes pour indiquer le moment où vous voulez que la fonction Lambda s’exécute. 1. **ID de distribution** : choisissez l’ID de la distribution que vous souhaitez ajouter au déclencheur. 1. **Comportement du cache** : choisissez le comportement de cache qui spécifie les objets sur lesquels vous souhaitez exécuter la fonction. 1. **CloudFront event** — Choisissez l' CloudFront événement à l'origine de l'exécution de la fonction. 1. **Activer le déclencheur et répliquer** : cochez cette case pour que Lambda effectue une réplication globale de la fonction vers les Régions AWS . 1. Sélectionnez **Soumettre**. 1. Pour ajouter d'autres déclencheurs pour cette fonction, répétez les étapes 10 à 13. Pour plus d’informations sur les tests et le débogage de la console Lambda, consultez [Invoquer une fonction Lambda avec la console](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html#get-started-invoke-manually) dans le *Guide du développeur AWS Lambda *. Lorsque vous êtes prêt à exécuter la fonction pour des CloudFront événements, publiez une autre version et modifiez la fonction pour ajouter des déclencheurs. Pour de plus amples informations, veuillez consulter [Ajout de déclencheurs pour une fonction Lambda@Edge](lambda-edge-add-triggers.md). # Ajout de déclencheurs pour une fonction Lambda@Edge Un déclencheur Lambda @Edge est une combinaison d'une CloudFront distribution, d'un comportement de cache et d'un événement qui entraîne l'exécution d'une fonction. Par exemple, vous pouvez créer un déclencheur qui entraîne l'exécution de la fonction lorsqu'un utilisateur CloudFront reçoit une demande concernant un comportement de cache spécifique que vous avez configuré pour votre distribution. Vous pouvez spécifier un ou plusieurs CloudFront déclencheurs. **Astuce** Lorsque vous créez une CloudFront distribution, vous spécifiez des paramètres qui indiquent CloudFront comment répondre lorsqu'elle reçoit différentes demandes. Les paramètres par défaut correspondent au *comportement de cache par défaut* pour la distribution. Vous pouvez configurer des comportements de cache supplémentaires qui définissent la manière dont il CloudFront répond dans des circonstances spécifiques, par exemple lorsqu'il reçoit une demande pour un type de fichier spécifique. Pour de plus amples informations, veuillez consulter [Paramètres de comportement du cache](DownloadDistValuesCacheBehavior.md). Lorsque vous créez pour la première fois une fonction Lambda, vous ne pouvez spécifier qu’*un* seul déclencheur. Vous pouvez ajouter d'autres déclencheurs à la même fonction ultérieurement en utilisant la console Lambda ou en modifiant la distribution dans la CloudFront console. + La console Lambda fonctionne bien si vous souhaitez ajouter d'autres déclencheurs à une fonction pour la même CloudFront distribution. + La CloudFront console peut être meilleure si vous souhaitez ajouter des déclencheurs pour plusieurs distributions, car il est plus facile de trouver la distribution que vous souhaitez mettre à jour. Vous pouvez également mettre à jour d'autres CloudFront paramètres en même temps. **Topics** + [CloudFront événements pouvant déclencher une fonction Lambda @Edge](lambda-cloudfront-trigger-events.md) + [Choix de l’événement qui déclenche la fonction](lambda-how-to-choose-event.md) + [Ajout de déclencheurs à une fonction Lambda@Edge](lambda-edge-add-triggers-console.md) # CloudFront événements pouvant déclencher une fonction Lambda @Edge Pour chaque comportement de cache dans une CloudFront distribution Amazon, vous pouvez ajouter jusqu'à quatre déclencheurs (associations) qui déclenchent l'exécution d'une fonction Lambda lorsque des CloudFront événements spécifiques se produisent. CloudFront les déclencheurs peuvent être basés sur l'un des quatre CloudFront événements suivants, comme le montre le schéma suivant. ![\[Graphique conceptuel qui montre comment les événements CloudFront déclencheurs pour les fonctions Lambda s'intègrent à. CloudFront\]](http://docs.aws.amazon.com/fr_fr/AmazonCloudFront/latest/DeveloperGuide/images/cloudfront-events-that-trigger-lambda-functions.png) Les CloudFront événements qui peuvent être utilisés pour déclencher les fonctions Lambda @Edge sont les suivants : **Demande utilisateur** La fonction s'exécute lorsqu'elle CloudFront reçoit une demande d'un visualiseur, avant de vérifier si l'objet demandé se trouve dans le CloudFront cache. La fonction ne s’exécute pas dans les cas suivants : + Lors de la récupération d’une page d’erreur personnalisée. + Lorsque redirige CloudFront automatiquement une requête HTTP vers HTTPS (lorsque la valeur de [Viewer Protocol Policy](DownloadDistValuesCacheBehavior.md#DownloadDistValuesViewerProtocolPolicy) est **Rediriger HTTP vers HTTPS**). **demande à l’origine** La fonction s'exécute *uniquement* lorsque CloudFront vous transmettez une demande à votre origine. Lorsque l'objet demandé est dans le CloudFront cache, la fonction ne s'exécute pas. **Réponse de l’origine** La fonction s'exécute après avoir CloudFront reçu une réponse de l'origine et avant de mettre en cache l'objet dans la réponse. Notez que la fonction s'exécute même si une erreur est renvoyée de l'origine. La fonction ne s’exécute pas dans les cas suivants : + Lorsque le fichier demandé est dans le CloudFront cache et n'a pas expiré. + Lorsque la réponse est générée à partir d'une fonction qui a été déclenchée par un événement de demande à l'origine. **Réponse utilisateur** La fonction s'exécute avant de renvoyer le fichier demandé à l'utilisateur. Notez que la fonction s'exécute indépendamment du fait que le fichier soit déjà dans le CloudFront cache ou non. La fonction ne s’exécute pas dans les cas suivants : + Lorsque l'origine renvoie un code de statut HTTP égal ou supérieur à 400. + Lorsqu'une page d'erreur personnalisée est renvoyée. + Lorsque la réponse est générée à partir d'une fonction qui a été déclenchée par un événement de demande utilisateur. + Lorsque redirige CloudFront automatiquement une requête HTTP vers HTTPS (lorsque la valeur de [Viewer Protocol Policy](DownloadDistValuesCacheBehavior.md#DownloadDistValuesViewerProtocolPolicy) est **Rediriger HTTP vers HTTPS**). Lorsque vous ajoutez plusieurs déclencheurs au même comportement de cache, vous pouvez les utiliser pour exécuter la même fonction ou des fonctions différentes pour chaque déclencheur. Vous pouvez associer la même fonction à plusieurs distributions. **Note** Lorsqu'un CloudFront événement déclenche l'exécution d'une fonction Lambda, celle-ci doit se terminer *avant* de CloudFront pouvoir continuer. Par exemple, si une fonction Lambda est déclenchée par un événement de demande d'affichage, elle CloudFront ne renverra pas de réponse au CloudFront visualiseur ni ne transmettra la demande à l'origine tant que la fonction Lambda n'aura pas fini de s'exécuter. Cela signifie que chaque demande qui déclenche une fonction Lambda augmente sa latence. Vous souhaitez ainsi que la fonction s’exécute le plus vite possible. # Choix de l’événement qui déclenche la fonction Lorsque vous décidez quel CloudFront événement vous souhaitez utiliser pour déclencher une fonction Lambda, tenez compte des points suivants : **Je souhaite CloudFront mettre en cache des objets modifiés par une fonction Lambda** Pour mettre en cache un objet qui a été modifié par une fonction Lambda afin de CloudFront pouvoir le servir depuis l'emplacement périphérique lors de sa prochaine demande, utilisez l'événement de *demande d'origine* ou de *réponse d'origine*. Cela réduit la charge sur l'origine, réduit la latence pour les demandes suivantes et réduit le coût de l'appel de Lambda@Edge sur les demandes suivantes. Par exemple, si vous souhaitez ajouter, supprimer ou modifier les en-têtes des objets renvoyés par l'origine et que vous souhaitez CloudFront mettre le résultat en cache, utilisez l'événement de réponse d'origine. **Je souhaite que la fonction s’exécute pour chaque demande** Pour exécuter la fonction pour chaque demande CloudFront reçue pour la distribution, utilisez les événements de *demande du visualiseur* ou de *réponse du visualiseur*. Les événements de demande d'origine et de réponse d'origine se produisent uniquement lorsqu'un objet demandé n'est pas mis en cache dans un emplacement périphérique et CloudFront transmet une demande à l'origine. **Je souhaite que la fonction modifie la clé de cache** Pour modifier une valeur que vous utilisez comme base pour la mise en cache, utilisez l’événement *demande utilisateur*. Par exemple, si une fonction modifie l'URL pour inclure une abréviation de langue dans le chemin d'accès (par exemple, parce que l'utilisateur a choisi sa langue dans une liste déroulante), utilisez l'événement de demande utilisateur : + **URL dans la demande du visualiseur** — https://example.com/en/ index.html + **URL lorsque la demande provient d'une adresse IP en Allemagne** https://example.com/de/ — index.html Vous utilisez également l'événement de demande utilisateur si vous mettez en cache en fonction des cookies ou des en-têtes de demande. Si la fonction modifie les cookies ou les en-têtes, configurez CloudFront pour transmettre la partie applicable de la demande à l'origine. Pour plus d’informations, consultez les rubriques suivantes : + [Mise en cache de contenu basée sur des cookies](Cookies.md) + [Mise en cache de contenu basée sur des en-têtes de demandes](header-caching.md) **La fonction affecte la réponse provenant de l’origine** Pour modifier la demande d’une manière qui affecte la réponse de l’origine, utilisez l’événement *demande à l’origine*. En général, la plupart des événements de demande du visiteur ne sont pas transmis à l'origine. CloudFront répond à une demande avec un objet qui se trouve déjà dans le cache périphérique. Si la fonction modifie la demande en fonction d'un événement de demande d'origine, met en CloudFront cache la réponse à la demande d'origine modifiée. # Ajout de déclencheurs à une fonction Lambda@Edge Vous pouvez utiliser la AWS Lambda console ou la CloudFront console Amazon pour ajouter un déclencheur à votre fonction Lambda @Edge. **Important** Vous ne pouvez créer des déclencheurs que pour les versions numérotées de votre fonction (et non pour le **\$1LATEST**). ------ #### [ Lambda console ] **Pour ajouter des déclencheurs d' CloudFront événements à une fonction Lambda @Edge** 1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Dans la liste des régions située en haut de la page, choisissez **US East (N. Virginia) (USA Est (Virginie du Nord))**. 1. Sur la page **Fonctions**, choisissez le nom de la fonction pour laquelle vous souhaitez ajouter des déclencheurs. 1. Sur la page **Présentation de la fonction**, choisissez l’onglet **Versions**. 1. Choisissez la version à laquelle vous souhaitez ajouter des déclencheurs. Une fois que vous avez choisi une version, le texte du bouton est remplacé par **Version: \$1LATEST** ou **Version:** *numéro de version*. 1. Choisissez l’onglet **Triggers (Déclencheurs)**. 1. Choisissez **Add trigger (Ajouter déclencheur)**. 1. Pour **la configuration du déclencheur**, choisissez **Sélectionner une source****cloudfront**, entrez, puis choisissez **CloudFront**. **Note** Si vous avez déjà créé un ou plusieurs déclencheurs, CloudFront c'est le service par défaut. 1. Spécifiez les valeurs suivantes pour indiquer le moment où vous voulez que la fonction Lambda s’exécute. 1. **Distribution** : choisissez la distribution que vous souhaitez ajouter au déclencheur. 1. **Comportement du cache** : choisissez le comportement de cache qui spécifie les objets sur lesquels vous souhaitez exécuter la fonction. **Note** Si vous spécifiez `*` pour le comportement de cache, la fonction Lambda se déploie sur le comportement de cache par défaut. 1. **CloudFront event** — Choisissez l'CloudFront événement à l'origine de l'exécution de la fonction. 1. **Inclure le corps** : cochez cette case si vous souhaitez accéder au corps de la demande dans votre fonction. 1. **Confirmer le déploiement sur Lambda@Edge** : cochez cette case pour qu’ AWS Lambda réplique la fonction dans les Régions AWS du monde entier. 1. Choisissez **Ajouter**. La fonction commence à traiter les demandes relatives aux CloudFront événements spécifiés lorsque la CloudFront distribution mise à jour est déployée. Pour déterminer si une distribution a été déployée, choisissez **Distributions** dans le panneau de navigation. Lorsqu’une distribution a été déployée, la valeur de la colonne **Statut** correspondant à la distribution passe de **Déploiement** à la date et l’heure du déploiement. ------ #### [ CloudFront console ] **Pour ajouter des déclencheurs d' CloudFront événements à une fonction Lambda @Edge** 1. Obtenez le nom ARN de la fonction Lambda pour laquelle vous voulez ajouter des déclencheurs : 1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Dans la liste des régions située en haut de la page, choisissez **US East (N. Virginia) (USA Est (Virginie du Nord))**. 1. Dans la liste des fonctions, choisissez le nom de la fonction à laquelle vous voulez ajouter des déclencheurs. 1. Sur la page **Présentation de la fonction**, choisissez l’onglet **Versions** et sélectionnez la version numérotée à laquelle vous voulez ajouter des déclencheurs. 1. Choisissez le bouton **Copier l’ARN** pour copier l’ARN dans votre presse-papiers. L’ARN de la fonction Lambda ressemble à ceci : `arn:aws:lambda:us-east-1:123456789012:function:TestFunction:2` Le numéro à la fin (**2** dans cet exemple) est le numéro de version de la fonction. 1. Ouvrez la CloudFront console à l'adresse[https://console.aws.amazon.com/cloudfront/v4/home](https://console.aws.amazon.com/cloudfront/v4/home). 1. Dans la liste des distributions, choisissez l'ID de la distribution à laquelle vous voulez ajouter des déclencheurs. 1. Choisissez l'onglet **Comportements**. 1. Sélectionnez le comportement de cache auquel vous souhaitez ajouter des déclencheurs, puis choisissez **Modifier**. 1. Dans **Associations de fonctions**, dans la liste **Type de fonction**, choisissez **Lambda@Edge** pour exécuter la fonction lors des demandes utilisateur, des réponses utilisateur, des demandes d’origine ou des réponses d’origine. Pour de plus amples informations, veuillez consulter [Choix de l’événement qui déclenche la fonction](lambda-how-to-choose-event.md). 1. Dans la zone de texte **ARN/Nom de la fonction**, collez l’ARN de la fonction Lambda que vous souhaitez exécuter lorsque l’événement choisi se produit. Il s’agit de la valeur que vous avez copiée à partir de la console Lambda. 1. Cochez la case **Inclure corps** si vous souhaitez accéder au corps de la demande dans votre fonction. Si vous souhaitez simplement remplacer le corps de la demande, vous n'avez pas besoin de sélectionner cette option. 1. Pour exécuter la même fonction pour plusieurs types d’événements, répétez les étapes 6 et 7. 1. Sélectionnez **Enregistrer les modifications**. 1. Pour ajouter des déclencheurs à d'autres comportements de cache pour cette distribution, répétez les étapes 5 à 10. La fonction commence à traiter les demandes relatives aux CloudFront événements spécifiés lorsque la CloudFront distribution mise à jour est déployée. Pour déterminer si une distribution a été déployée, choisissez **Distributions** dans le panneau de navigation. Lorsqu’une distribution a été déployée, la valeur de la colonne **Statut** correspondant à la distribution passe de **Déploiement** à la date et l’heure du déploiement. ------ # Test et débogage des fonctions Lambda@Edge Il est important de tester votre code de fonction Lambda @Edge de manière autonome, pour vous assurer qu'il exécute la tâche prévue, et de réaliser des tests d'intégration pour vous assurer que la fonction fonctionne correctement avec. CloudFront Au cours des tests d'intégration ou après le déploiement de votre fonction, il se peut que vous deviez CloudFront corriger des erreurs, telles que des erreurs HTTP 5xx. Les erreurs peuvent être de différents types : une réponse non valide renvoyée par la fonction Lambda, des erreurs d'exécution lorsque la fonction est déclenchée, ou encore des erreurs en raison de la limitation d'exécution par le service Lambda. Les sections de cette rubrique donnent des stratégies pour déterminer le type de défaillance qui est à l'origine du problème, puis les étapes à suivre afin de résoudre le problème. **Note** Lorsque vous consultez des fichiers CloudWatch journaux ou des indicateurs pour résoudre des erreurs, sachez qu'ils sont affichés ou stockés à l'emplacement le Région AWS plus proche de l'endroit où la fonction s'est exécutée. Ainsi, si vous avez un site Web ou une application Web avec des utilisateurs au Royaume-Uni, et qu'une fonction Lambda est associée à votre distribution, par exemple, vous devez modifier la région pour afficher les métriques ou CloudWatch les fichiers journaux de Londres. Région AWS Pour de plus amples informations, veuillez consulter [Définition de la région Lambda@Edge](#lambda-edge-testing-debugging-determine-region). **Topics** + [Test de vos fonctions Lambda@Edge](#lambda-edge-testing-debugging-test-function) + [Identifiez les erreurs de fonction Lambda @Edge dans CloudFront](#lambda-edge-identifying-function-errors) + [Dépannage en cas de réponses de fonction Lambda@Edge non valide (erreurs de validation)](#lambda-edge-testing-debugging-troubleshooting-invalid-responses) + [Dépannage des erreurs d’exécution de fonction Lambda@Edge](#lambda-edge-testing-debugging-execution-errors) + [Définition de la région Lambda@Edge](#lambda-edge-testing-debugging-determine-region) + [Déterminez si votre compte envoie les journaux vers CloudWatch](#lambda-edge-testing-debugging-cloudwatch-logs-enabled) ## Test de vos fonctions Lambda@Edge Il existe deux étapes pour tester votre fonction Lambda : le test autonome et le test d'intégration. **Test de la fonctionnalité autonome** Avant d'ajouter votre fonction Lambda à CloudFront, assurez-vous de la tester d'abord en utilisant les fonctionnalités de test de la console Lambda ou en utilisant d'autres méthodes. Pour plus d’informations sur les tests de la console Lambda, consultez [Invoquer une fonction Lambda avec la console](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html#get-started-invoke-manually) dans le *Guide du développeur AWS Lambda *. **Testez le fonctionnement de votre fonction dans CloudFront** Il est important de réaliser des tests d'intégration, dans lesquels votre fonction est associée à une distribution et s'exécute en fonction d'un CloudFront événement. Assurez-vous que la fonction est déclenchée pour le bon événement, et qu'elle renvoie une réponse valide et correcte CloudFront. Par exemple, assurez-vous que la structure de l’événement est correcte, que seuls les en-têtes valides sont inclus, etc. Au fur et à mesure que vous testez l'intégration de votre fonction dans la console Lambda, reportez-vous aux étapes du didacticiel Lambda @Edge pour modifier votre code ou CloudFront le déclencheur qui appelle votre fonction. Par exemple, vérifiez que vous travaillez avec une version numérotée de votre fonction, comme le décrit cette étape du tutoriel : [Étape 4 : ajouter un CloudFront déclencheur pour exécuter la fonction](lambda-edge-how-it-works-tutorial.md#lambda-edge-how-it-works-tutorial-add-trigger). Lorsque vous apportez des modifications et que vous les déployez, sachez qu'il faudra plusieurs minutes pour que votre fonction et vos CloudFront déclencheurs mis à jour soient répliqués dans toutes les régions. Cela prend généralement quelques minutes, mais peut durer jusqu'à 15 minutes. Vous pouvez vérifier si la réplication est terminée en accédant à la CloudFront console et en consultant votre distribution. **Pour vérifier si le déploiement de votre réplication est terminé** 1. Ouvrez la CloudFront console à l'adresse[https://console.aws.amazon.com/cloudfront/v4/home](https://console.aws.amazon.com/cloudfront/v4/home). 1. Choisissez le nom de la distribution. 1. Vérifiez que le statut de distribution passe de **En cours** à **Déployé**, ce qui signifie que votre fonction a été répliquée. Suivez les étapes de la section suivante afin de vérifier que la fonction s'exécute correctement. Sachez que les tests effectués dans la console valident uniquement la logique de votre fonction et n'appliquent pas de quotas (auparavant appelés limites) de service spécifiques à Lambda@Edge. ## Identifiez les erreurs de fonction Lambda @Edge dans CloudFront Une fois que vous avez vérifié que la logique de votre fonction fonctionne correctement, des erreurs HTTP 5xx peuvent encore s'afficher lors de l'exécution de votre fonction. CloudFront Les erreurs HTTP 5xx peuvent être renvoyées pour diverses raisons, notamment des erreurs liées à la fonction Lambda ou d'autres problèmes. CloudFront + Si vous utilisez les fonctions Lambda @Edge, vous pouvez utiliser les graphiques de la CloudFront console pour identifier la cause de l'erreur, puis essayer de la corriger. Par exemple, vous pouvez voir si les erreurs HTTP 5xx sont causées par CloudFront ou par des fonctions Lambda, puis, pour des fonctions spécifiques, vous pouvez consulter les fichiers journaux associés afin d'étudier le problème. + Pour résoudre les erreurs HTTP en général dans CloudFront, consultez les étapes de résolution des problèmes décrites dans la rubrique suivante :[Résolution des codes d'état des réponses aux erreurs dans CloudFront](troubleshooting-response-errors.md). ### Quelles sont les causes des erreurs de fonction Lambda @Edge dans CloudFront Il existe plusieurs raisons pour lesquelles une fonction Lambda peut entraîner une erreur HTTP 5xx. Les étapes de résolution à suivre dépendent du type d'erreur. Les erreurs peuvent être classées comme suit : **Une erreur d'exécution de la fonction Lambda** Une erreur d'exécution se produit lorsque Lambda CloudFront ne reçoit pas de réponse en raison d'exceptions non gérées dans la fonction ou d'une erreur dans le code. Par exemple, si le code comprend le rappel (Error). **Une réponse de fonction Lambda non valide est renvoyée à CloudFront** Une fois la fonction exécutée, CloudFront reçoit une réponse de Lambda. Une erreur est renvoyée si la structure d'objet de la réponse n'est pas conforme à [Structure d'événement Lambda@Edge](lambda-event-structure.md) ou si la réponse contient des en-têtes ou d'autres champs non valides. **L'exécution dans CloudFront est limitée en raison des quotas de service Lambda (anciennement appelés limites)** Le service Lambda limite les exécutions dans chaque région, et renvoie une erreur si vous dépassez le quota. Pour de plus amples informations, veuillez consulter [Quotas sur Lambda@Edge](cloudfront-limits.md#limits-lambda-at-edge). ### Comment déterminer le type d'échec Pour vous aider à décider sur quoi vous concentrer lorsque vous débugez et que vous vous efforcez de résoudre les erreurs renvoyées CloudFront, il est utile de déterminer pourquoi une erreur HTTP CloudFront est renvoyée. Pour commencer, vous pouvez utiliser les graphiques fournis dans la section **Surveillance** de la CloudFront console sur le AWS Management Console. Pour plus d'informations sur l'affichage des graphiques dans la section **Surveillance** de la CloudFront console, consultez[Surveillez CloudFront les métriques avec Amazon CloudWatch](monitoring-using-cloudwatch.md). Les graphiques suivants peuvent être particulièrement utiles lorsque vous souhaitez retracer si des erreurs sont renvoyées par les origines ou par une fonction Lambda, et pour réduire le type de problème lorsqu'il s'agit d'une erreur provenant d'une fonction Lambda. **Graphique des taux d'erreurs** L'un des graphiques que vous pouvez afficher dans l'onglet **Présentation** pour chacune de vos distributions est un graphique de **taux d'erreurs**. Ce graphique affiche le taux d'erreurs sous forme de pourcentage du nombre total de demandes adressées à votre distribution. Ce graphique montre le taux d'erreurs total, le total des erreurs 4xx, le total des erreurs 5xx et le total des erreurs 5xx provenant des fonctions Lambda. Selon le type d'erreur et le volume, vous pouvez prendre des mesures pour étudier et résoudre le problème initial. ![\[Graphique des taux d'erreur pour une CloudFront distribution\]](http://docs.aws.amazon.com/fr_fr/AmazonCloudFront/latest/DeveloperGuide/images/Distribution-error-rate-pct-full.png) + Si vous voyez des erreurs Lambda, vous pouvez poursuivre vos investigations en examinant les types d'erreurs spécifiques que la fonction renvoie. L'onglet **Lambda@Edge errors (Erreurs Lambda@Edge)** inclut des graphiques qui classent les erreurs de fonction par type pour vous aider à identifier le problème pour une fonction spécifique. + Si vous CloudFront constatez des erreurs, vous pouvez les résoudre et vous efforcer de corriger les erreurs d'origine ou de modifier votre CloudFront configuration. Pour de plus amples informations, veuillez consulter [Résolution des codes d'état des réponses aux erreurs dans CloudFront](troubleshooting-response-errors.md). **Graphiques des erreurs d'exécution et des réponses de fonction non valide** L'onglet **Lambda@Edge errors (Erreurs Lambda@Edge)** inclut des graphiques permettant de classer les erreurs Lambda@Edge pour une distribution spécifique, par type. Par exemple, un graphique montre toutes les erreurs d’exécution par Région AWS. Pour faciliter la résolution des problèmes, vous pouvez rechercher des problèmes spécifiques en ouvrant et en examinant les fichiers journaux des fonctions spécifiques par région. **Pour afficher les fichiers journaux d’une fonction spécifique par région** 1. Dans l’onglet **Erreurs Lambda@Edge**, sous **Fonctions Lambda@Edge associées**, choisissez le nom de la fonction, puis choisissez **Afficher les métriques**. 1. Ensuite, sur la page affichant le nom de votre fonction, dans le coin supérieur droit, choisissez **Afficher les journaux de fonction**, puis sélectionnez une Région. Par exemple, si vous constatez des problèmes dans le graphique **Erreurs** pour la Région USA Ouest (Oregon), choisissez cette Région dans la liste déroulante. Cela ouvre la CloudWatch console Amazon. 1. Dans la CloudWatch console de cette région, sous **Log streams**, choisissez un log stream pour afficher les événements liés à la fonction. De plus, lisez les sections suivantes de ce chapitre pour plus de recommandations sur le dépannage et la correction des erreurs. **Graphique des limitations** L'onglet **Lambda@Edge errors (Erreurs Lambda@Edge)** inclut également un graphique **Throttles (Limitations)**. Occasionnellement, le service Lambda limite vos appels de fonction par région si vous atteignez le quota (auparavant appelé limite) de simultanéité régionale. Si vous voyez une erreur de dépassement de limite, cela signifie que votre fonction a atteint un quota que le service Lambda impose sur les exécutions dans une région. Pour obtenir plus d’informations sur ces limites et découvrir comment demander une augmentation du quota, consultez [Quotas sur Lambda@Edge](cloudfront-limits.md#limits-lambda-at-edge). ![\[Graphique des limitations pour l’exécution de la fonction Lambda@Edge.\]](http://docs.aws.amazon.com/fr_fr/AmazonCloudFront/latest/DeveloperGuide/images/Lambda-throttles-page.png) Pour obtenir un exemple sur la façon d'utiliser ces informations pour résoudre des erreurs HTTP, consultez le billet de blog [Four steps for debugging your content delivery on AWS](https://aws.amazon.com/blogs/networking-and-content-delivery/four-steps-for-debugging-your-content-delivery-on-aws/). ## Dépannage en cas de réponses de fonction Lambda@Edge non valide (erreurs de validation) Si vous identifiez que votre problème est dû à une erreur de validation Lambda, cela signifie que votre fonction Lambda renvoie une réponse non valide à. CloudFront Suivez les instructions de cette section pour prendre les mesures nécessaires pour revoir votre fonction et vous assurer que votre réponse est conforme aux CloudFront exigences. CloudFront valide la réponse d'une fonction Lambda de deux manières : + **La réponse Lambda doit se conformer à la structure d'objet requise.** Voici des exemples de mauvaise structure d'objet : impossible d'analyser JSON, champs obligatoires manquants et la réponse contient un objet non valide. Pour de plus amples informations, veuillez consulter [Structure d'événement Lambda@Edge](lambda-event-structure.md). + **La réponse doit inclure uniquement les valeurs d'objet valides.** Une erreur se produit si la réponse inclut un objet valide mais dont les valeurs ne sont pas prises en charge. Les exemples incluent les éléments suivants : ajout ou mise à jour d'en-têtes non autorisés ou en lecture seule (voir [Restrictions sur les fonctions périphériques](edge-functions-restrictions.md)), dépassement des limitations de taille du corps (voir *Limites sur la taille de la réponse générée dans la rubrique Lambda@Edge [Erreurs](lambda-generating-http-responses.md#lambda-generating-http-responses-errors)*) et les caractères ou les valeurs non valables (voir [Structure d'événement Lambda@Edge](lambda-event-structure.md)). Lorsque Lambda renvoie une réponse non valide à CloudFront, des messages d'erreur sont écrits CloudWatch dans des fichiers journaux qui sont CloudFront redirigés vers la région où la fonction Lambda a été exécutée. C'est le comportement par défaut auquel envoyer les fichiers journaux en CloudWatch cas de réponse non valide. Toutefois, si vous avez associé une fonction Lambda à une fonction Lambda CloudFront avant son lancement, il est possible qu'elle ne soit pas activée pour votre fonction. Pour plus d'informations, consultez la section *Déterminez si votre compte transmet les fichiers journaux à CloudWatch* plus loin dans la rubrique. CloudFront envoie les fichiers journaux vers la région correspondant à l'endroit où votre fonction a été exécutée, dans le groupe de journaux associé à votre distribution. Les groupes de journaux ont le format suivant :`/aws/cloudfront/LambdaEdge/DistributionId`, où *DistributionId* est l'ID de votre distribution. Pour déterminer la région dans laquelle se trouvent les fichiers CloudWatch journaux, consultez la section *Détermination de la région Lambda @Edge* plus loin dans cette rubrique. Si l'erreur est reproductible, vous pouvez créer une nouvelle demande qui entraîne l'erreur, puis rechercher l'identifiant de la demande dans une CloudFront réponse ayant échoué (`X-Amz-Cf-Id`en-tête) afin de localiser un seul échec dans les fichiers journaux. L'entrée du fichier journal inclut des informations susceptibles de vous aider à identifier les raisons pour lesquelles l'erreur est renvoyée, et affiche aussi l'ID de demande Lambda correspondant, ce qui vous permet d'analyser la cause première dans le cadre d'une seule demande. Si une erreur est intermittente, vous pouvez utiliser les journaux d' CloudFront accès pour trouver l'identifiant d'une demande qui a échoué, puis rechercher dans CloudWatch les journaux les messages d'erreur correspondants. Pour plus d'informations, consultez la section précédente, *Détermination du type d'échec*. ## Dépannage des erreurs d’exécution de fonction Lambda@Edge Si le problème provient d'une erreur d'exécution Lambda, il peut être utile de créer des instructions de journalisation pour les fonctions Lambda, d'écrire des messages dans des fichiers CloudWatch journaux qui surveillent l'exécution de votre fonction CloudFront et déterminent si elle fonctionne comme prévu. Vous pouvez ensuite rechercher ces instructions dans les fichiers CloudWatch journaux pour vérifier que votre fonction fonctionne. **Note** Même si vous n'avez pas modifié votre fonction Lambda@Edge, les mises à jour de l'environnement d'exécution de la fonction Lambda peuvent l'affecter et renvoyer une erreur d'exécution. Pour plus d'informations sur les tests et la migration vers une version ultérieure, consultez [Prochaines mises à jour de l'environnement d'exécution AWS Lambda et AWS Lambda @Edge](https://aws.amazon.com/blogs/compute/upcoming-updates-to-the-aws-lambda-execution-environment/). ## Définition de la région Lambda@Edge Pour connaître les régions dans lesquelles votre fonction Lambda @Edge reçoit du trafic, consultez les métriques de la fonction sur la CloudFront console du. AWS Management Console Les statistiques sont affichées pour chaque AWS région. Sur la même page, vous pouvez choisir une région et afficher les fichiers journaux pour cette région afin de pouvoir rechercher des problèmes. Vous devez consulter les fichiers CloudWatch journaux dans la AWS région appropriée pour voir les fichiers journaux créés lors de l' CloudFront exécution de votre fonction Lambda. Pour plus d'informations sur l'affichage des graphiques dans la section **Surveillance** de la CloudFront console, consultez[Surveillez CloudFront les métriques avec Amazon CloudWatch](monitoring-using-cloudwatch.md). ## Déterminez si votre compte envoie les journaux vers CloudWatch Par défaut, CloudFront active la journalisation des réponses de fonction Lambda non valides et envoie les fichiers journaux vers CloudWatch . [Rôles liés à un service pour Lambda@Edge](lambda-edge-permissions.md#using-service-linked-roles-lambda-edge) Si vous avez ajouté des fonctions Lambda @Edge CloudFront avant la publication de la fonctionnalité de journal des réponses des fonctions Lambda non valide, la journalisation est activée lors de la prochaine mise à jour de votre configuration Lambda @Edge, par exemple en ajoutant un déclencheur. CloudFront Vous pouvez vérifier que le transfert des fichiers journaux vers CloudWatch est activé pour votre compte en procédant comme suit : + **Vérifiez si les journaux apparaissent dans CloudWatch** — Assurez-vous de regarder dans la région où la fonction Lambda @Edge s'est exécutée. Pour de plus amples informations, veuillez consulter [Définition de la région Lambda@Edge](#lambda-edge-testing-debugging-determine-region). + **Déterminez si le rôle lié au service associé existe dans votre compte IAM** : vous devez disposer du rôle IAM `AWSServiceRoleForCloudFrontLogger` dans votre compte. Pour plus d’informations sur ce rôle, consultez [Rôles liés à un service pour Lambda@Edge](lambda-edge-permissions.md#using-service-linked-roles-lambda-edge). # Suppression des fonctions et des réplicas Lambda@Edge Vous pouvez supprimer une fonction Lambda@Edge uniquement lorsque les réplicas de cette fonction ont été supprimés par CloudFront. Les réplicas d'une fonction Lambda sont automatiquement supprimés dans les cas suivants : + Après avoir supprimé la dernière association de la fonction de toutes vos distributions CloudFront. Si plusieurs distributions utilisent une fonction, les réplicas ne sont supprimés qu'après avoir supprimé l'association de fonctions de la dernière distribution. + Après avoir supprimé la dernière distribution à laquelle une fonction était associée. Ils sont généralement supprimés en quelques heures. Vous ne pouvez pas supprimer manuellement des réplicas de fonction Lambda@Edge. Cela permet d'éviter la suppression d'un réplica en cours d'utilisation, ce qui entraînerait une erreur. **Avertissement** Ne créez pas d'applications qui utilisent des répliques de fonctions Lambda @Edge en dehors de. CloudFront Ces réplicas sont supprimés lorsque leurs associations avec des distributions sont supprimées, ou lorsque les distributions elles-mêmes sont supprimées. Le réplica dont dépend une application externe pourrait être supprimé sans avertissement, ce qui entraînerait un échec. **Pour supprimer une association de fonctions Lambda @Edge d'une distribution CloudFront** 1. Connectez-vous à la CloudFront console AWS Management Console et ouvrez-la à l'adresse[https://console.aws.amazon.com/cloudfront/v4/home](https://console.aws.amazon.com/cloudfront/v4/home). 1. Choisissez l’ID de la distribution qui possède l’association de la fonction Lambda@Edge que vous souhaitez supprimer. 1. Choisissez l’onglet **Comportements**. 1. Sélectionnez le comportement de cache qui contient l’association à la fonction Lambda@Edge que vous souhaitez supprimer, puis choisissez **Modifier**. 1. Sous **Associations de fonctions**, **Type de fonction**, choisissez **Aucune association** pour supprimer l’association de fonctions Lambda@Edge. 1. Sélectionnez **Enregistrer les modifications**. Après avoir supprimé une association de fonctions Lambda @Edge d'une CloudFront distribution, vous pouvez éventuellement supprimer la fonction Lambda ou sa version de. AWS Lambda Patientez quelques heures après avoir supprimé l’association de la fonction pour permettre le nettoyage des réplicas de la fonction Lambda@Edge. Ensuite, vous pouvez supprimer la fonction à l'aide de la console Lambda, de l'API AWS CLI Lambda ou d'un SDK. AWS Vous pouvez également supprimer une *version* spécifique d'une fonction Lambda si aucune CloudFront distribution n'est associée à cette version. Une fois toutes les associations supprimées pour une version de fonction Lambda, patientez quelques heures. Vous pourrez alors supprimer la version de la fonction. # Structure d'événement Lambda@Edge Les rubriques suivantes décrivent les objets d'événements de demande et de réponse CloudFront transmis à une fonction Lambda @Edge lorsqu'elle est déclenchée. **Topics** + [Sélection de l'origine dynamique](#lambda-event-content-based-routing) + [Événements de demande](#lambda-event-structure-request) + [Événements de réponse](#lambda-event-structure-response) ## Sélection de l'origine dynamique Vous pouvez utiliser [le modèle de chemin dans un comportement de cache](DownloadDistValuesCacheBehavior.md#DownloadDistValuesPathPattern) pour router les demandes vers une origine, en fonction du chemin et du nom de l'objet demandé, tels que `images/*.jpg`. En utilisant Lambda@Edge, vous pouvez également acheminer des demandes vers une origine en fonction d'autres caractéristiques, comme les valeurs contenues dans les en-têtes de la demande. Cette sélection d'origine dynamique peut être utile de diverses façons. Par exemple, vous pouvez répartir les demandes entre des origines de différentes zones géographiques pour vous aider à réaliser un équilibrage de charge international. Ou vous pouvez acheminer de façon sélective des demandes vers différentes origines servant chacune une fonction donnée : gestion du robot, optimisation de la stratégie SEO, authentification, etc. Pour obtenir des exemples de code qui expliquent comment utiliser cette fonctionnalité, consultez [Sélection d'origine dynamique basée sur le contenu – exemples](lambda-examples.md#lambda-examples-content-based-routing-examples). Dans l'événement de demande CloudFront d'origine, l'`origin`objet de la structure d'événement contient des informations sur l'origine vers laquelle la demande serait acheminée, en fonction du modèle de chemin. Vous pouvez mettre à jour les valeurs de l'objet `origin` pour router une demande vers une autre origine. Quand vous mettez à jour l'objet `origin`, vous n'avez pas besoin de définir l'origine dans la distribution. Vous pouvez également remplacer un objet d'origine Amazon S3 par un objet d'origine personnalisée, et vice versa. Toutefois, vous ne pouvez spécifier qu'une seule origine par demande ; une origine personnalisée ou une origine Amazon S3, mais pas les deux. ## Événements de demande Les rubriques suivantes présentent la structure de l'objet qui est transmis à CloudFront une fonction Lambda pour les événements de [demande d'affichage et d'origine](lambda-cloudfront-trigger-events.md). Ces exemples montrent une demande `GET` sans corps. Après les exemples, vous trouverez la liste de tous les champs possibles dans les événements de demande d'utilisateur et d'origine. **Topics** + [Exemple de demande d'utilisateur](#example-viewer-request) + [Exemple de demande de l'origine](#example-origin-request) + [Champs d'événement de demande](#request-event-fields) ### Exemple de demande d'utilisateur L'exemple suivant montre un objet d'événement de demande d'utilisateur. ``` { "Records": [ { "cf": { "config": { "distributionDomainName": "d111111abcdef8.cloudfront.net", "distributionId": "EDFDVBD6EXAMPLE", "eventType": "viewer-request", "requestId": "4TyzHTaYWb1GX1qTfsHhEqV6HUDd_BzoBZnwfnvQc_1oF26ClkoUSEQ==" }, "request": { "clientIp": "203.0.113.178", "headers": { "host": [ { "key": "Host", "value": "d111111abcdef8.cloudfront.net" } ], "user-agent": [ { "key": "User-Agent", "value": "curl/7.66.0" } ], "accept": [ { "key": "accept", "value": "*/*" } ] }, "method": "GET", "querystring": "", "uri": "/" } } } ] } ``` ### Exemple de demande de l'origine L'exemple suivant montre un objet d'événement de demande d'origine. ``` { "Records": [ { "cf": { "config": { "distributionDomainName": "d111111abcdef8.cloudfront.net", "distributionId": "EDFDVBD6EXAMPLE", "eventType": "origin-request", "requestId": "4TyzHTaYWb1GX1qTfsHhEqV6HUDd_BzoBZnwfnvQc_1oF26ClkoUSEQ==" }, "request": { "clientIp": "203.0.113.178", "headers": { "x-forwarded-for": [ { "key": "X-Forwarded-For", "value": "203.0.113.178" } ], "user-agent": [ { "key": "User-Agent", "value": "Amazon CloudFront" } ], "via": [ { "key": "Via", "value": "2.0 2afae0d44e2540f472c0635ab62c232b.cloudfront.net (CloudFront)" } ], "host": [ { "key": "Host", "value": "example.org" } ], "cache-control": [ { "key": "Cache-Control", "value": "no-cache" } ] }, "method": "GET", "origin": { "custom": { "customHeaders": {}, "domainName": "example.org", "keepaliveTimeout": 5, "path": "", "port": 443, "protocol": "https", "readTimeout": 30, "responseCompletionTimeout": 30, "sslProtocols": [ "TLSv1", "TLSv1.1", "TLSv1.2" ] } }, "querystring": "", "uri": "/" } } } ] } ``` ### Champs d'événement de demande Les données d'objet d'événement de demande sont contenues dans deux sous-objets : `config` (`Records.cf.config`) et `request` (`Records.cf.request`). Les listes suivantes décrivent les champs de chaque sous-objet. #### Champs de l’objet config La liste suivante décrit les champs figurant dans l’objet `config` (`Records.cf.config`). **`distributionDomainName` (lecture seule)** Nom de domaine de la distribution qui est associée à la demande. **`distributionID` (lecture seule)** ID de la distribution qui est associée à la demande. **`eventType` (lecture seule)** Type de déclencheur associé à la demande : `viewer-request` ou `origin-request`. **`requestId` (lecture seule)** Chaîne cryptée qui identifie de manière unique une viewer-to-CloudFront demande. La valeur `requestId` apparaît également dans les journaux d'accès de CloudFront en tant que `x-edge-request-id`. Pour plus d’informations, consultez [Journaux d'accès (journaux standard)](AccessLogs.md) et [Champs du fichier journal](standard-logs-reference.md#BasicDistributionFileFormat). #### Champs de l'objet de demande La liste suivante décrit les champs figurant dans l’objet `request` (`Records.cf.request`). **`clientIp` (lecture seule)** Adresse IP de l'utilisateur qui a émis la requête. Si l'utilisateur a utilisé un proxy HTTP ou un équilibreur de charge pour envoyer la demande, la valeur correspond à l'adresse IP du proxy ou de l'équilibreur de charge. **en-têtes (lecture/écriture)** En-têtes de la requête. Remarques : + Les clés figurant dans l’objet `headers` sont les versions en minuscules des noms d’en-têtes HTTP standard. L'utilisation des minuscules vous permet d'accéder aux valeurs des en-têtes sans tenir compte de la casse. + Chaque objet d’en-tête (par exemple, `headers["accept"]` ou `headers["host"]`) est un tableau de paires clé-valeur. Pour un en-tête donné, le tableau contient une paire clé-valeur pour chaque valeur dans la demande. + `key` contient le nom sensible à la casse de l’en-tête tel qu’il apparaissait dans la demande HTTP ; par exemple, `Host`, `User-Agent`, `X-Forwarded-For`, `Cookie`, etc. + `value` contient la valeur d'en-tête telle qu'elle apparaissait dans la requête HTTP. + Lorsque votre fonction Lambda ajoute ou modifie des en-têtes de demande et que vous n'incluez pas le champ `key` d'en-tête, Lambda@Edge insère automatiquement une clé (`key`) d'en-tête en utilisant le nom d'en-tête que vous fournissez. Quelle que soit la manière dont vous avez formaté le nom d'en-tête, la clé d'en-tête qui est insérée automatiquement est formatée avec une majuscule initiale pour chaque partie, séparée par des tirets (-). Par exemple, vous pouvez ajouter un en-tête comme le suivant, sans clé (`key`) d’en-tête : ``` "user-agent": [ { "value": "ExampleCustomUserAgent/1.X.0" } ] ``` Dans cet exemple, Lambda@Edge insère automatiquement `"key": "User-Agent"`. Pour plus d’informations sur les restrictions applicables à l’utilisation d’en-têtes, consultez [Restrictions sur les fonctions périphériques](edge-functions-restrictions.md). **`method` (lecture seule)** Méthode HTTP de la demande. **`querystring` (lecture/écriture)** Chaîne de requête, le cas échéant, dans la demande. Si la demande n'inclut pas de chaîne de requête, l'objet d'événement inclut quand-même `querystring` avec une valeur vide. Pour plus d’informations sur les chaînes de requête, consultez [Mise en cache de contenu basée sur les paramètres de chaîne de requête](QueryStringParameters.md). **`uri` (lecture/écriture)** Chemin d'accès relatif de l'objet demandé. Si votre fonction Lambda modifie la valeur `uri`, notez ce qui suit : + La nouvelle valeur `uri` doit commencer par une barre oblique (/). + Lorsqu'une fonction modifie la valeur `uri`, cela change l'objet que l'utilisateur demande. + Lorsqu'une fonction modifie la valeur `uri`, cela *ne modifie pas* le comportement de cache pour la demande ou l'origine vers laquelle la demande est envoyée. **`body` (lecture/écriture)** Corps de la requête HTTP. La structure `body` peut contenir les champs suivants : **`inputTruncated` (lecture seule)** Indicateur booléen qui indique si le corps a été tronqué par Lambda@Edge. Pour plus d’informations, consultez [Restrictions relatives au corps de la requête avec l'option Inclure le corps](lambda-at-edge-function-restrictions.md#lambda-at-edge-restrictions-request-body). **`action` (lecture/écriture)** L'action que vous avez l'intention de prendre avec le corps. Les options pour l'`action`sont les suivantes : + `read-only:` Il s'agit de l'option par défaut. Au moment de renvoyer la réponse à partir de la fonction Lambda, si `action` est en lecture seule, Lambda@Edge ignore les modifications apportée à `encoding` ou à `data`. + `replace:` À préciser lorsque vous souhaitez remplacer le corps envoyé à l'origine. **`encoding` (lecture/écriture)** L'encodage pour le corps. Lorsque Lambda@Edge expose le corps à la fonction Lambda, il convertit d'abord le corps en base64-encoding. Si vous choisissez `replace` comme `action` pour remplacer le corps, vous pouvez choisir d'utiliser l'encodage `base64` (option par défaut) ou `text`. Si vous précisez `encoding` comme `base64`, mais que le corps n'est pas valide base64, CloudFront renvoie une erreur. **`data` (lecture/écriture)** Le contenu du corps de requête. **`origin` (lecture/écriture) (événements d'origine uniquement)** Origine vers laquelle envoyer la demande. La structure `origin` doit contenir *une unique origine*, qui peut être une origine personnalisée ou une origine Amazon S3. Selon le type d’origine que vous spécifiez (origine personnalisée ou origine Amazon S3), vous devez indiquer les champs suivants dans votre demande : **`customHeaders` (lecture/écriture) (origines personnalisées et Amazon S3)** (Facultatif) Vous pouvez inclure des en-têtes personnalisés dans la demande en spécifiant un nom et une valeur d’en-tête pour chacun d’eux. Vous ne pouvez pas ajouter des en-têtes non autorisés et un en-tête portant le même nom ne peut pas être présent dans `Records.cf.request.headers`. Les [notes sur les en-têtes de demande](#request-event-fields-request-headers) s'appliquent également aux en-têtes personnalisés. 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). **`domainName` (lecture/écriture) (origines personnalisées et Amazon S3)** Nom de domaine de l’origine. Le nom de domaine ne peut pas être vide. + **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 un signe deux-points (:) et ne peut pas être une adresse IP. Le nom du domaine peut contenir jusqu’à 253 caractères. + **Pour les origines Amazon 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. **`path` (lecture/écriture) (origines personnalisées et Amazon S3)** 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/`). Pour les origines personnalisées uniquement, le chemin doit être codé par URL et avoir une longueur maximale de 255 caractères. **`keepaliveTimeout` (lecture/écriture) (origines personnalisées uniquement)** Combien de temps, en secondes, cela CloudFront devrait essayer de maintenir la connexion à l'origine après avoir reçu le dernier paquet de la réponse. La valeur doit être un nombre compris entre 1 et 120 inclus. **`port` (lecture/écriture) (origines personnalisées uniquement)** Le port auquel vous CloudFront devez vous connecter à votre point d'origine personnalisé. Il doit s'agir du port 80, du port 443 ou d'un port compris entre 1 024 et 65 535. **`protocol` (lecture/écriture) (origines personnalisées uniquement)** Protocole de connexion à utiliser CloudFront lors de la connexion à votre point d'origine. La valeur peut être `http` ou `https`. **`readTimeout` (lecture/écriture) (origines personnalisées et Amazon S3)** Combien de temps, en secondes, CloudFront doit attendre une réponse après avoir envoyé une demande à votre origine. Cela spécifie également la durée pendant laquelle CloudFront doit attendre après avoir reçu un paquet d'une réponse et avant de recevoir le paquet suivant. La valeur doit être un nombre compris entre 1 et 120 inclus. Si vous avez besoin d’un quota plus élevé, consultez [Délai de réponse par origine](cloudfront-limits.md#limits-web-distributions). **`responseCompletionTimeout` (lecture/écriture) (origines personnalisées et Amazon S3)** 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`. En définissant cette valeur sur 0, vous effacez toute valeur précédemment définie et rétablissez la valeur par défaut. Vous pouvez également obtenir le même résultat en supprimant le champ `responseCompletionTimeout` de la demande d’événement. **`sslProtocols` (lecture/écriture) (origines personnalisées uniquement)** SSL/TLS Protocole minimal à CloudFront utiliser lors de l'établissement d'une connexion HTTPS avec votre point d'origine. Il peut s'agir des valeurs suivantes : `TLSv1.2`, `TLSv1.1`, `TLSv1` ou `SSLv3`. **`authMethod` (lecture/écriture) (origines Amazon S3 uniquement)** Si vous utilisez une [identité d'accès à l'origine (OAI)](private-content-restricting-access-to-s3.md#private-content-restricting-access-to-s3-oai), définissez ce champ sur `origin-access-identity`. Si vous n'utilisez pas d'OAI, configurez-le sur `none`. Si vous définissez `authMethod` sur `origin-access-identity`, il existe plusieurs exigences : + Vous devez spécifier le paramètre `region` (voir le champ suivant). + Vous devez utiliser la même identité d'accès à l'origine lorsque vous changez l'origine Amazon S3 de la demande. + Vous ne pouvez pas utiliser d'identité d'accès à l'origine lorsque vous remplacez l'origine personnalisée de la demande par une origine Amazon S3. Ce champ ne prend pas en charge le [contrôle d'accès à l'origine (OAC)](private-content-restricting-access-to-s3.md). **`region` (lecture/écriture) (origines Amazon S3 uniquement)** La AWS région de votre compartiment Amazon S3. Cette option n'est requise que lorsque vous définissez `authMethod` sur `origin-access-identity`. ## Événements de réponse Les rubriques suivantes présentent la structure de l'objet qui est CloudFront transmis à une fonction Lambda pour les événements de [réponse du visualiseur et de l'origine](lambda-cloudfront-trigger-events.md). Après les exemples, vous trouverez la liste de tous les champs possibles dans les événements de réponse d'utilisateur et d'origine. **Topics** + [Exemple de réponse de l'origine](#lambda-event-structure-response-origin) + [Exemple de réponse de l'utilisateur](#lambda-event-structure-response-viewer) + [Champs d'événement de réponse](#response-event-fields) ### Exemple de réponse de l'origine L'exemple suivant montre un objet d'événement de réponse de l'origine. ``` { "Records": [ { "cf": { "config": { "distributionDomainName": "d111111abcdef8.cloudfront.net", "distributionId": "EDFDVBD6EXAMPLE", "eventType": "origin-response", "requestId": "4TyzHTaYWb1GX1qTfsHhEqV6HUDd_BzoBZnwfnvQc_1oF26ClkoUSEQ==" }, "request": { "clientIp": "203.0.113.178", "headers": { "x-forwarded-for": [ { "key": "X-Forwarded-For", "value": "203.0.113.178" } ], "user-agent": [ { "key": "User-Agent", "value": "Amazon CloudFront" } ], "via": [ { "key": "Via", "value": "2.0 8f22423015641505b8c857a37450d6c0.cloudfront.net (CloudFront)" } ], "host": [ { "key": "Host", "value": "example.org" } ], "cache-control": [ { "key": "Cache-Control", "value": "no-cache" } ] }, "method": "GET", "origin": { "custom": { "customHeaders": {}, "domainName": "example.org", "keepaliveTimeout": 5, "path": "", "port": 443, "protocol": "https", "readTimeout": 30, "responseCompletionTimeout": 30, "sslProtocols": [ "TLSv1", "TLSv1.1", "TLSv1.2" ] } }, "querystring": "", "uri": "/" }, "response": { "headers": { "access-control-allow-credentials": [ { "key": "Access-Control-Allow-Credentials", "value": "true" } ], "access-control-allow-origin": [ { "key": "Access-Control-Allow-Origin", "value": "*" } ], "date": [ { "key": "Date", "value": "Mon, 13 Jan 2020 20:12:38 GMT" } ], "referrer-policy": [ { "key": "Referrer-Policy", "value": "no-referrer-when-downgrade" } ], "server": [ { "key": "Server", "value": "ExampleCustomOriginServer" } ], "x-content-type-options": [ { "key": "X-Content-Type-Options", "value": "nosniff" } ], "x-frame-options": [ { "key": "X-Frame-Options", "value": "DENY" } ], "x-xss-protection": [ { "key": "X-XSS-Protection", "value": "1; mode=block" } ], "content-type": [ { "key": "Content-Type", "value": "text/html; charset=utf-8" } ], "content-length": [ { "key": "Content-Length", "value": "9593" } ] }, "status": "200", "statusDescription": "OK" } } } ] } ``` ### Exemple de réponse de l'utilisateur L'exemple suivant montre un objet d'événement de réponse de l'utilisateur. ``` { "Records": [ { "cf": { "config": { "distributionDomainName": "d111111abcdef8.cloudfront.net", "distributionId": "EDFDVBD6EXAMPLE", "eventType": "viewer-response", "requestId": "4TyzHTaYWb1GX1qTfsHhEqV6HUDd_BzoBZnwfnvQc_1oF26ClkoUSEQ==" }, "request": { "clientIp": "203.0.113.178", "headers": { "host": [ { "key": "Host", "value": "d111111abcdef8.cloudfront.net" } ], "user-agent": [ { "key": "User-Agent", "value": "curl/7.66.0" } ], "accept": [ { "key": "accept", "value": "*/*" } ] }, "method": "GET", "querystring": "", "uri": "/" }, "response": { "headers": { "access-control-allow-credentials": [ { "key": "Access-Control-Allow-Credentials", "value": "true" } ], "access-control-allow-origin": [ { "key": "Access-Control-Allow-Origin", "value": "*" } ], "date": [ { "key": "Date", "value": "Mon, 13 Jan 2020 20:14:56 GMT" } ], "referrer-policy": [ { "key": "Referrer-Policy", "value": "no-referrer-when-downgrade" } ], "server": [ { "key": "Server", "value": "ExampleCustomOriginServer" } ], "x-content-type-options": [ { "key": "X-Content-Type-Options", "value": "nosniff" } ], "x-frame-options": [ { "key": "X-Frame-Options", "value": "DENY" } ], "x-xss-protection": [ { "key": "X-XSS-Protection", "value": "1; mode=block" } ], "age": [ { "key": "Age", "value": "2402" } ], "content-type": [ { "key": "Content-Type", "value": "text/html; charset=utf-8" } ], "content-length": [ { "key": "Content-Length", "value": "9593" } ] }, "status": "200", "statusDescription": "OK" } } } ] } ``` ### Champs d'événement de réponse Les données d'objet d'événement de réponse sont contenues dans trois sous-objets : `config` (`Records.cf.config`), `request` (`Records.cf.request`) et `response` (`Records.cf.response`). Pour plus d’informations sur les champs de l’objet de demande, consultez [Champs de l'objet de demande](#request-event-fields-request). Les listes suivantes décrivent les champs figurant dans les sous-objets `config` et `response`. #### Champs de l’objet config La liste suivante décrit les champs figurant dans l’objet `config` (`Records.cf.config`). **`distributionDomainName` (lecture seule)** Nom de domaine de la distribution qui est associée à la réponse. **`distributionID` (lecture seule)** ID de la distribution qui est associée à la réponse. **`eventType` (lecture seule)** Type de déclencheur associé à la réponse : `origin-response` ou `viewer-response`. **`requestId` (lecture seule)** Chaîne cryptée qui identifie de manière unique la viewer-to-CloudFront demande à laquelle cette réponse est associée. La `requestId` valeur apparaît également dans les journaux CloudFront d'accès sous la forme`x-edge-request-id`. Pour plus d’informations, consultez [Journaux d'accès (journaux standard)](AccessLogs.md) et [Champs du fichier journal](standard-logs-reference.md#BasicDistributionFileFormat). #### Champs de l'objet de réponse La liste suivante décrit les champs figurant dans l’objet `response` (`Records.cf.response`). Pour obtenir des informations sur l’utilisation d’une fonction Lambda@Edge pour générer une réponse HTTP, consultez [Génération de réponses HTTP dans les déclencheurs de demande](lambda-generating-http-responses.md#lambda-generating-http-responses-in-requests). **`headers` (lecture/écriture)** En-têtes de la réponse. Remarques : + Les clés figurant dans l’objet `headers` sont les versions en minuscules des noms d’en-têtes HTTP standard. L'utilisation des minuscules vous permet d'accéder aux valeurs des en-têtes sans tenir compte de la casse. + Chaque objet d’en-tête (par exemple, `headers["content-type"]` ou `headers["content-length"]`) est un tableau de paires clé-valeur. Pour un en-tête donné, le tableau contient une paire clé-valeur pour chaque valeur de la réponse. + `key` contient le nom sensible à la casse de l’en-tête tel qu’il apparaît dans la réponse HTTP ; par exemple, `Content-Type`, `Content-Length`, `Cookie`, etc. + `value` contient la valeur d'en-tête telle qu'elle apparaît dans la réponse HTTP. + Lorsque votre fonction Lambda ajoute ou modifie des en-têtes de réponse et que vous n'incluez pas le champ `key` d'en-tête, Lambda@Edge insère automatiquement une clé (`key`) d'en-tête en utilisant le nom d'en-tête que vous fournissez. Quelle que soit la manière dont vous avez formaté le nom d'en-tête, la clé d'en-tête qui est insérée automatiquement est formatée avec une majuscule initiale pour chaque partie, séparée par des tirets (-). Par exemple, vous pouvez ajouter un en-tête comme le suivant, sans clé (`key`) d’en-tête : ``` "content-type": [ { "value": "text/html;charset=UTF-8" } ] ``` Dans cet exemple, Lambda@Edge insère automatiquement `"key": "Content-Type"`. Pour plus d’informations sur les restrictions applicables à l’utilisation d’en-têtes, consultez [Restrictions sur les fonctions périphériques](edge-functions-restrictions.md). **`status`** Code de statut HTTP de la réponse. **`statusDescription`** Description de l’état HTTP de la réponse. # Utilisation des demandes et des réponses Pour utiliser les demandes et réponses Lambda@Edge, consultez les rubriques suivantes : **Topics** + [Utilisation des fonctions Lambda@Edge avec le basculement d’origine](#lambda-and-origin-failover) + [Génération de réponses HTTP dans les déclencheurs de demande](#lambda-generating-http-responses-in-requests) + [Mise à jour des réponses HTTP dans des déclencheurs de réponse de l’origine](#lambda-updating-http-responses) + [Accès au corps de requête en choisissant l’option Inclure le corps](#lambda-include-body-access) ## Utilisation des fonctions Lambda@Edge avec le basculement d’origine Vous pouvez utiliser les fonctions Lambda @Edge avec des CloudFront distributions que vous avez configurées avec des groupes d'origine, par exemple, pour le basculement d'origine que vous configurez afin de garantir une haute disponibilité. Pour utiliser une fonction Lambda avec un groupe d'origine, spécifiez la fonction dans une requête d'origine ou un déclencheur de réponse de l'origine pour un groupe d'origine lorsque vous créez le comportement de cache. Pour plus d’informations, consultez les ressources suivantes : + **Création d’un groupe d’origines :** [Création d’un groupe d’origine](high_availability_origin_failover.md#concept_origin_groups.creating) + **Comment fonctionne le basculement d'origine avec Lambda@Edge:** [Utilisation du basculement d'origine avec les fonctions Lambda@Edge](high_availability_origin_failover.md#concept_origin_groups.lambda) ## Génération de réponses HTTP dans les déclencheurs de demande Lorsque CloudFront vous recevez une demande, vous pouvez utiliser une fonction Lambda pour générer une réponse HTTP qui est CloudFront renvoyée directement au visualiseur sans transmettre la réponse à l'origine. La génération de réponses HTTP réduit la charge sur le serveur d'origine, et aussi généralement la latence pour l'utilisateur. Les scénarios courants pour générer des réponses HTTP sont les suivants : + Renvoi d'une petite page web à l'utilisateur + Renvoi d'un code de statut HTTP 301 ou 302 pour rediriger l'utilisateur vers une autre page web + Renvoi d'un code de statut HTTP 401 lorsque l'utilisateur ne s'est pas authentifié Une fonction Lambda@Edge peut générer une réponse HTTP lorsque les événements CloudFront suivants se produisent : **Événements de demande utilisateur** Lorsqu'une fonction est déclenchée par un événement de demande du spectateur, CloudFront renvoie la réponse au visualiseur sans la mettre en cache. **Événements de demande à l'origine** Lorsqu'une fonction est déclenchée par un événement de demande d' CloudFront origine, recherche dans le cache périphérique une réponse précédemment générée par la fonction. + Si la réponse se trouve dans le cache, la fonction n'est pas exécutée et CloudFront renvoie la réponse mise en cache au visualiseur. + Si la réponse ne se trouve pas dans le cache, la fonction est exécutée et CloudFront retourne la réponse à l'utilisateur et la met dans le cache. Pour voir un exemple de code permettant de générer des réponses HTTP, consultez [Exemples de fonctions Lambda@Edge](lambda-examples.md). Vous pouvez également remplacer les réponses HTTP dans les déclencheurs de réponse. Pour plus d’informations, consultez [Mise à jour des réponses HTTP dans des déclencheurs de réponse de l’origine](#lambda-updating-http-responses). ### Modèle de programmation Cette section décrit le modèle de programmation permettant d'utiliser Lambda@Edge pour générer des réponses HTTP. **Topics** + [Objet Réponse](#lambda-generating-http-responses-object) + [Erreurs](#lambda-generating-http-responses-errors) + [Champs obligatoires](#lambda-generating-http-responses-required-fields) #### Objet Réponse La réponse que vous renvoyez en tant que paramètre `result` de la méthode `callback` doit avoir la structure suivante (notez que seul le champ `status` est requis). ``` const response = { body: 'content', bodyEncoding: 'text' | 'base64', headers: { 'header name in lowercase': [{ key: 'header name in standard case', value: 'header value' }], ... }, status: 'HTTP status code (string)', statusDescription: 'status description' }; ``` L'objet de réponse peut inclure les valeurs suivantes : **`body`** Le corps, le cas échéant, que vous CloudFront souhaitez renvoyer dans la réponse générée. **`bodyEncoding`** Encodage de la valeur que vous avez spécifiée dans `body`. Les seuls encodages valides sont `text` et `base64`. Si vous incluez `body` dans l'`response`objet mais que vous l'omettez`bodyEncoding`, CloudFront traite le corps comme du texte. Si vous spécifiez `bodyEncoding` comme `base64`, mais que le corps n'est pas un base64 valide, CloudFront renvoie une erreur. **`headers`** En-têtes que vous CloudFront souhaitez renvoyer dans la réponse générée. Notez ce qui suit : + Les clés figurant dans l’objet `headers` sont les versions en minuscules des noms d’en-têtes HTTP standard. L'utilisation des minuscules vous permet d'accéder aux valeurs des en-têtes sans tenir compte de la casse. + Chaque en-tête (par exemple, `headers["accept"]` ou `headers["host"]`) est un tableau de paires clé-valeur. Pour un en-tête donné, le tableau contient une paire clé-valeur pour chaque valeur de la réponse générée. + `key` (facultatif) est le nom de l'en-tête sensible à la casse tel qu'il s'affiche dans une demande HTTP, par exemple, `accept` ou `host`. + Indiquez `value` comme valeur d'en-tête. + Si vous n'incluez pas la partie clé d'en-tête de la paire clé-valeur, Lambda@Edge insère automatiquement une clé d'en-tête à l'aide du nom d'en-tête que vous fournissez. Quelle que soit la manière dont vous avez formaté le nom d'en-tête, la clé d'en-tête qui est insérée est formatée automatiquement avec une majuscule initiale pour les différentes parties séparées par des tirets (-). Par exemple, vous pouvez ajouter un en-tête comme suit, sans clé d'en-tête : `'content-type': [{ value: 'text/html;charset=UTF-8' }]` Dans cet exemple, Lambda@Edge crée la clé d'en-tête suivante : `Content-Type`. Pour plus d’informations sur les restrictions applicables à l’utilisation d’en-têtes, consultez [Restrictions sur les fonctions périphériques](edge-functions-restrictions.md). **`status`** Le code d'état HTTP . Fournissez le code d'état sous forme de chaîne. CloudFront utilise le code d'état fourni pour les opérations suivantes : + Renvoi dans la réponse + Cache dans le cache CloudFront périphérique, lorsque la réponse a été générée par une fonction déclenchée par un événement de demande d'origine + Connectez-vous CloudFront [Journaux d'accès (journaux standard)](AccessLogs.md) Si la valeur `status` n'est pas comprise entre 200 et 599, CloudFront renvoie une erreur à l'utilisateur. **`statusDescription`** Description que vous souhaitez CloudFront renvoyer dans la réponse, pour accompagner le code d'état HTTP. Vous n'avez pas besoin d'utiliser de descriptions standard, telles que `OK` pour un code de statut HTTP 200. #### Erreurs Voici des erreurs possibles pour les réponses HTTP générées. **La réponse contient un corps et un code de statut HTTP 204 (Pas de contenu)** Lorsqu'une fonction est déclenchée par une demande d'affichage, CloudFront renvoie un code d'état HTTP 502 (Bad Gateway) au visualiseur lorsque les deux conditions suivantes sont vraies : + La valeur du code `status` est 204 (Pas de contenu) + La réponse inclut une valeur pour `body` Cela vient du fait que Lambda@Edge impose la restriction facultative incluse dans la RFC 2616, qui stipule qu'une réponse `HTTP 204` n'a pas besoin d'inclure de corps de message. **Restrictions concernant la taille de la réponse générée** La taille maximale d'une réponse générée par une fonction Lambda dépend de l'événement qui a déclenché la fonction : + **Événements de demande utilisateur** – 40 Ko + **Événements de demande à l'origine ** – 1 Mo Si la réponse est supérieure à la taille autorisée, CloudFront renvoie un code d'état HTTP 502 (Bad Gateway) au visualiseur. #### Champs obligatoires Le champ `status` est obligatoire. Tous les autres champs sont facultatifs. ## Mise à jour des réponses HTTP dans des déclencheurs de réponse de l’origine Lorsque CloudFront vous recevez une réponse HTTP du serveur d'origine, si un déclencheur de réponse d'origine est associé au comportement du cache, vous pouvez modifier la réponse HTTP pour remplacer ce qui a été renvoyé par l'origine. Les scénarios courants pour mettre à jour des réponses HTTP sont les suivants : + Modification du statut sur HTTP 200 et création d'un contenu de corps statique à renvoyer à l'utilisateur lorsqu'une origine renvoie un code de statut d'erreur (4xx ou 5xx). Pour un exemple de code, consultez [Exemple : utilisation d’un déclencheur de réponse de l’origine pour mettre à jour le code de statut d’erreur sur 200](lambda-examples.md#lambda-examples-custom-error-static-body). + Modification du statut pour définir un code de statut HTTP 301 ou HTTP 302, afin de rediriger l'utilisateur vers un autre site web lorsqu'une origine renvoie un code de statut d'erreur (4xx ou 5xx). Pour un exemple de code, consultez [Exemple : utilisation d’un déclencheur de réponse de l’origine pour mettre à jour le code de statut d’erreur sur 302](lambda-examples.md#lambda-examples-custom-error-new-site). **Note** La fonction doit renvoyer une valeur d'état comprise entre `200` et `599` (inclus), sinon elle CloudFront renvoie une erreur au visualiseur. Vous pouvez également remplacer les réponses HTTP dans les événements de requête utilisateur et à l'origine. Pour de plus amples informations, veuillez consulter [Génération de réponses HTTP dans les déclencheurs de demande](#lambda-generating-http-responses-in-requests). Lorsque vous utilisez la réponse HTTP, Lambda@Edge n'expose pas le corps renvoyé par le serveur d'origine au déclencheur de réponse de l'origine. Vous pouvez générer un corps de contenu statique en lui attribuant la valeur souhaitée, ou supprimer le corps à l'intérieur de la fonction en définissant une valeur vide. Si vous n'actualisez pas le champ du corps dans votre fonction, le corps d'origine renvoyé par le serveur d'origine est renvoyé à l'utilisateur. ## Accès au corps de requête en choisissant l’option Inclure le corps Vous pouvez décider que Lambda@Edge expose le corps dans une demande pour des méthodes HTTP accessibles en écriture (POST, PUT, DELETE, etc.) afin que vous puissiez y accéder dans vos fonctions Lambda. Vous pouvez choisir un accès en lecture seule ou vous pouvez préciser que vous remplacerez le corps. Pour activer cette option, choisissez **Include Body (Inclure corps)** lorsque vous créez un déclencheur CloudFront pour votre fonction qui correspond à un pour un événement de demande utilisateur ou de demande d'origine. Pour plus d’informations, consultez [Ajout de déclencheurs pour une fonction Lambda@Edge](lambda-edge-add-triggers.md), ou pour en savoir plus sur l’utilisation de **Include Body (Inclure le corps)** avec votre fonction, consultez [Structure d'événement Lambda@Edge](lambda-event-structure.md). Les scénarios lorsque vous êtes susceptibles de vouloir utiliser cette fonction incluent les éléments suivants : + Traitement des formulaires Web, comme « Contactez-nous », sans renvoyer les données saisies par le client aux serveurs d'origine. + Collecte des données de balise web envoyées par les navigateurs des utilisateurs et traitement de ces données en périphérie. Pour un exemple de code, consultez [Exemples de fonctions Lambda@Edge](lambda-examples.md). **Note** Si le corps de la demande est grand, Lambda@Edge le tronque. Pour plus d’informations sur la taille maximale et la troncature, consultez [Restrictions relatives au corps de la requête avec l'option Inclure le corps](lambda-at-edge-function-restrictions.md#lambda-at-edge-restrictions-request-body). # Exemples de fonctions Lambda@Edge Consultez les exemples suivants pour utiliser les fonctions Lambda avec Amazon. CloudFront **Note** Si vous choisissez l’environnement d’exécution Node.js 18 ou une version ultérieure pour votre fonction Lambda@Edge, un fichier `index.mjs` est créé automatiquement. Pour utiliser les exemples de code suivants, renommez plutôt le fichier `index.mjs` en `index.js`. **Topics** + [Exemples généraux](#lambda-examples-general-examples) + [Génération de réponses : exemples](#lambda-examples-generated-response-examples) + [Chaînes de requête - exemples](#lambda-examples-query-string-examples) + [Personnalisation de contenu à l'aide des en-têtes Pays ou Type d'appareil – exemples](#lambda-examples-redirecting-examples) + [Sélection d'origine dynamique basée sur le contenu – exemples](#lambda-examples-content-based-routing-examples) + [Mise à jour des statuts d’erreur : exemples](#lambda-examples-update-error-status-examples) + [Accès au corps de requête - exemples](#lambda-examples-access-request-body-examples) ## Exemples généraux Les exemples suivants montrent les méthodes courantes d'utilisation de Lambda @Edge dans. CloudFront **Topics** + [Exemple : A/B test](#lambda-examples-a-b-testing) + [Exemple : remplacement d’un en-tête de réponse](#lambda-examples-overriding-response-header) ### Exemple : A/B test Vous pouvez utiliser l'exemple suivant pour tester deux versions différentes d'une image sans créer de redirections ni modifier l'URL. Cet exemple lit les cookies dans la demande de l'utilisateur et modifie l'URL de la demande en conséquence. Si le spectateur n'envoie pas de cookie avec l'une des valeurs attendues, l'exemple assigne de manière aléatoire le spectateur à l' URLsune des valeurs. ------ #### [ Node.js ] ``` 'use strict'; exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; const headers = request.headers; if (request.uri !== '/experiment-pixel.jpg') { // do not process if this is not an A-B test request callback(null, request); return; } const cookieExperimentA = 'X-Experiment-Name=A'; const cookieExperimentB = 'X-Experiment-Name=B'; const pathExperimentA = '/experiment-group/control-pixel.jpg'; const pathExperimentB = '/experiment-group/treatment-pixel.jpg'; /* * Lambda at the Edge headers are array objects. * * Client may send multiple Cookie headers, i.e.: * > GET /viewerRes/test HTTP/1.1 * > User-Agent: curl/7.18.1 (x86_64-unknown-linux-gnu) libcurl/7.18.1 OpenSSL/1.0.1u zlib/1.2.3 * > Cookie: First=1; Second=2 * > Cookie: ClientCode=abc * > Host: example.com * * You can access the first Cookie header at headers["cookie"][0].value * and the second at headers["cookie"][1].value. * * Header values are not parsed. In the example above, * headers["cookie"][0].value is equal to "First=1; Second=2" */ let experimentUri; if (headers.cookie) { for (let i = 0; i < headers.cookie.length; i++) { if (headers.cookie[i].value.indexOf(cookieExperimentA) >= 0) { console.log('Experiment A cookie found'); experimentUri = pathExperimentA; break; } else if (headers.cookie[i].value.indexOf(cookieExperimentB) >= 0) { console.log('Experiment B cookie found'); experimentUri = pathExperimentB; break; } } } if (!experimentUri) { console.log('Experiment cookie has not been found. Throwing dice...'); if (Math.random() < 0.75) { experimentUri = pathExperimentA; } else { experimentUri = pathExperimentB; } } request.uri = experimentUri; console.log(`Request uri set to "${request.uri}"`); callback(null, request); }; ``` ------ #### [ Python ] ``` import json import random def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] headers = request['headers'] if request['uri'] != '/experiment-pixel.jpg': # Not an A/B Test return request cookieExperimentA, cookieExperimentB = 'X-Experiment-Name=A', 'X-Experiment-Name=B' pathExperimentA, pathExperimentB = '/experiment-group/control-pixel.jpg', '/experiment-group/treatment-pixel.jpg' ''' Lambda at the Edge headers are array objects. Client may send multiple cookie headers. For example: > GET /viewerRes/test HTTP/1.1 > User-Agent: curl/7.18.1 (x86_64-unknown-linux-gnu) libcurl/7.18.1 OpenSSL/1.0.1u zlib/1.2.3 > Cookie: First=1; Second=2 > Cookie: ClientCode=abc > Host: example.com You can access the first Cookie header at headers["cookie"][0].value and the second at headers["cookie"][1].value. Header values are not parsed. In the example above, headers["cookie"][0].value is equal to "First=1; Second=2" ''' experimentUri = "" for cookie in headers.get('cookie', []): if cookieExperimentA in cookie['value']: print("Experiment A cookie found") experimentUri = pathExperimentA break elif cookieExperimentB in cookie['value']: print("Experiment B cookie found") experimentUri = pathExperimentB break if not experimentUri: print("Experiment cookie has not been found. Throwing dice...") if random.random() < 0.75: experimentUri = pathExperimentA else: experimentUri = pathExperimentB request['uri'] = experimentUri print(f"Request uri set to {experimentUri}") return request ``` ------ ### Exemple : remplacement d’un en-tête de réponse L'exemple suivant montre comment changer la valeur d'un en-tête de réponse en fonction de la valeur d'un autre en-tête. ------ #### [ Node.js ] ``` export const handler = async (event) => { const response = event.Records[0].cf.response; const headers = response.headers; const headerNameSrc = 'X-Amz-Meta-Last-Modified'; const headerNameDst = 'Last-Modified'; if (headers[headerNameSrc.toLowerCase()]) { headers[headerNameDst.toLowerCase()] = [{ key: headerNameDst, value: headers[headerNameSrc.toLowerCase()][0].value, }]; console.log(`Response header "${headerNameDst}" was set to ` + `"${headers[headerNameDst.toLowerCase()][0].value}"`); } return response; }; ``` ------ #### [ Python ] ``` import json def lambda_handler(event, context): response = event['Records'][0]['cf']['response'] headers = response['headers'] header_name_src = 'X-Amz-Meta-Last-Modified' header_name_dst = 'Last-Modified' if headers.get(header_name_src.lower()): headers[header_name_dst.lower()] = [{ 'key': header_name_dst, 'value': headers[header_name_src.lower()][0]['value'] }] print(f'Response header "{header_name_dst}" was set to ' f'"{headers[header_name_dst.lower()][0]["value"]}"') return response ``` ------ ## Génération de réponses : exemples Les exemples suivants illustrent l’utilisation de Lambda@Edge pour générer des réponses. **Topics** + [Exemple : traitement de contenu statique (réponse générée)](#lambda-examples-static-web-server) + [Exemple : génération d’une redirection HTTP (réponse générée)](#lambda-examples-http-redirect) ### Exemple : traitement de contenu statique (réponse générée) L'exemple suivant montre comment utiliser une fonction Lambda pour traiter le contenu statique d'un site web, ce qui réduit la charge sur le serveur d'origine et réduit la latence globale. **Note** Vous pouvez générer des réponses HTTP pour les événements de requête utilisateur ou de requête à l'origine. Pour de plus amples informations, veuillez consulter [Génération de réponses HTTP dans les déclencheurs de demande](lambda-generating-http-responses.md#lambda-generating-http-responses-in-requests). Vous pouvez également remplacer ou supprimer le corps de la réponse HTTP dans les événements de réponse de l’origine. Pour de plus amples informations, veuillez consulter [Mise à jour des réponses HTTP dans des déclencheurs de réponse de l’origine](lambda-generating-http-responses.md#lambda-updating-http-responses). ------ #### [ Node.js ] ``` 'use strict'; const content = ` <\!DOCTYPE html>Hello from Lambda@Edge!
`; exports.handler = (event, context, callback) => { /* * Generate HTTP OK response using 200 status code with HTML body. */ const response = { status: '200', statusDescription: 'OK', headers: { 'cache-control': [{ key: 'Cache-Control', value: 'max-age=100' }], 'content-type': [{ key: 'Content-Type', value: 'text/html' }] }, body: content, }; callback(null, response); }; ``` ------ #### [ Python ] ``` import json CONTENT = """ <\!DOCTYPE html>Hello from Lambda@Edge!
""" def lambda_handler(event, context): # Generate HTTP OK response using 200 status code with HTML body. response = { 'status': '200', 'statusDescription': 'OK', 'headers': { 'cache-control': [ { 'key': 'Cache-Control', 'value': 'max-age=100' } ], "content-type": [ { 'key': 'Content-Type', 'value': 'text/html' } ] }, 'body': CONTENT } return response ``` ------ ### Exemple : génération d’une redirection HTTP (réponse générée) L'exemple suivant montre comment générer une redirection HTTP. **Note** Vous pouvez générer des réponses HTTP pour les événements de requête utilisateur ou de requête à l'origine. Pour de plus amples informations, veuillez consulter [Génération de réponses HTTP dans les déclencheurs de demande](lambda-generating-http-responses.md#lambda-generating-http-responses-in-requests). ------ #### [ Node.js ] ``` 'use strict'; exports.handler = (event, context, callback) => { /* * Generate HTTP redirect response with 302 status code and Location header. */ const response = { status: '302', statusDescription: 'Found', headers: { location: [{ key: 'Location', value: 'https://docs.aws.amazon.com/lambda/latest/dg/lambda-edge.html', }], }, }; callback(null, response); }; ``` ------ #### [ Python ] ``` def lambda_handler(event, context): # Generate HTTP redirect response with 302 status code and Location header. response = { 'status': '302', 'statusDescription': 'Found', 'headers': { 'location': [{ 'key': 'Location', 'value': 'https://docs.aws.amazon.com/lambda/latest/dg/lambda-edge.html' }] } } return response ``` ------ ## Chaînes de requête - exemples Les exemples suivants montrent comment utiliser Lambda@Edge avec des chaînes de requête. **Topics** + [Exemple : ajout d’un en-tête basé sur un paramètre de chaîne de requête](#lambda-examples-header-based-on-query-string) + [Exemple : normalisation des paramètres de chaîne de requête pour améliorer le taux d’accès au cache](#lambda-examples-normalize-query-string-parameters) + [Exemple : redirection des utilisateurs non authentifiés vers une page de connexion](#lambda-examples-redirect-to-signin-page) ### Exemple : ajout d’un en-tête basé sur un paramètre de chaîne de requête L'exemple suivant montre comment obtenir la paire clé-valeur d'un paramètre de chaîne de requête, puis ajouter un en-tête en fonction de ces valeurs. ------ #### [ Node.js ] ``` 'use strict'; const querystring = require('querystring'); exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; /* When a request contains a query string key-value pair but the origin server * expects the value in a header, you can use this Lambda function to * convert the key-value pair to a header. Here's what the function does: * 1. Parses the query string and gets the key-value pair. * 2. Adds a header to the request using the key-value pair that the function got in step 1. */ /* Parse request querystring to get javascript object */ const params = querystring.parse(request.querystring); /* Move auth param from querystring to headers */ const headerName = 'Auth-Header'; request.headers[headerName.toLowerCase()] = [{ key: headerName, value: params.auth }]; delete params.auth; /* Update request querystring */ request.querystring = querystring.stringify(params); callback(null, request); }; ``` ------ #### [ Python ] ``` from urllib.parse import parse_qs, urlencode def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] ''' When a request contains a query string key-value pair but the origin server expects the value in a header, you can use this Lambda function to convert the key-value pair to a header. Here's what the function does: 1. Parses the query string and gets the key-value pair. 2. Adds a header to the request using the key-value pair that the function got in step 1. ''' # Parse request querystring to get dictionary/json params = {k : v[0] for k, v in parse_qs(request['querystring']).items()} # Move auth param from querystring to headers headerName = 'Auth-Header' request['headers'][headerName.lower()] = [{'key': headerName, 'value': params['auth']}] del params['auth'] # Update request querystring request['querystring'] = urlencode(params) return request ``` ------ ### Exemple : normalisation des paramètres de chaîne de requête pour améliorer le taux d’accès au cache L'exemple suivant montre comment améliorer le taux de réussite de votre cache en apportant les modifications suivantes aux chaînes de requête avant de CloudFront transférer les demandes à votre origine : + Classez par ordre alphabétique les paires clé-valeur selon le nom du paramètre. + Modifiez la casse des paires clé-valeur en minuscules. Pour de plus amples informations, veuillez consulter [Mise en cache de contenu basée sur les paramètres de chaîne de requête](QueryStringParameters.md). ------ #### [ Node.js ] ``` 'use strict'; const querystring = require('querystring'); exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; /* When you configure a distribution to forward query strings to the origin and * to cache based on an allowlist of query string parameters, we recommend * the following to improve the cache-hit ratio: * - Always list parameters in the same order. * - Use the same case for parameter names and values. * * This function normalizes query strings so that parameter names and values * are lowercase and parameter names are in alphabetical order. * * For more information, see: * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/QueryStringParameters.html */ console.log('Query String: ', request.querystring); /* Parse request query string to get javascript object */ const params = querystring.parse(request.querystring.toLowerCase()); const sortedParams = {}; /* Sort param keys */ Object.keys(params).sort().forEach(key => { sortedParams[key] = params[key]; }); /* Update request querystring with normalized */ request.querystring = querystring.stringify(sortedParams); callback(null, request); }; ``` ------ #### [ Python ] ``` from urllib.parse import parse_qs, urlencode def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] ''' When you configure a distribution to forward query strings to the origin and to cache based on an allowlist of query string parameters, we recommend the following to improve the cache-hit ratio: Always list parameters in the same order. - Use the same case for parameter names and values. This function normalizes query strings so that parameter names and values are lowercase and parameter names are in alphabetical order. For more information, see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/QueryStringParameters.html ''' print("Query string: ", request["querystring"]) # Parse request query string to get js object params = {k : v[0] for k, v in parse_qs(request['querystring'].lower()).items()} # Sort param keys sortedParams = sorted(params.items(), key=lambda x: x[0]) # Update request querystring with normalized request['querystring'] = urlencode(sortedParams) return request ``` ------ ### Exemple : redirection des utilisateurs non authentifiés vers une page de connexion L'exemple suivant montre comment rediriger des utilisateurs vers une page de connexion s'ils n'ont pas saisi leurs informations d'identification. ------ #### [ Node.js ] ``` 'use strict'; function parseCookies(headers) { const parsedCookie = {}; if (headers.cookie) { headers.cookie[0].value.split(';').forEach((cookie) => { if (cookie) { const parts = cookie.split('='); parsedCookie[parts[0].trim()] = parts[1].trim(); } }); } return parsedCookie; } exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; const headers = request.headers; /* Check for session-id in request cookie in viewer-request event, * if session-id is absent, redirect the user to sign in page with original * request sent as redirect_url in query params. */ /* Check for session-id in cookie, if present then proceed with request */ const parsedCookies = parseCookies(headers); if (parsedCookies && parsedCookies['session-id']) { callback(null, request); return; } /* URI encode the original request to be sent as redirect_url in query params */ const encodedRedirectUrl = encodeURIComponent(`https://${headers.host[0].value}${request.uri}?${request.querystring}`); const response = { status: '302', statusDescription: 'Found', headers: { location: [{ key: 'Location', value: `https://www.example.com/signin?redirect_url=${encodedRedirectUrl}`, }], }, }; callback(null, response); }; ``` ------ #### [ Python ] ``` import urllib def parseCookies(headers): parsedCookie = {} if headers.get('cookie'): for cookie in headers['cookie'][0]['value'].split(';'): if cookie: parts = cookie.split('=') parsedCookie[parts[0].strip()] = parts[1].strip() return parsedCookie def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] headers = request['headers'] ''' Check for session-id in request cookie in viewer-request event, if session-id is absent, redirect the user to sign in page with original request sent as redirect_url in query params. ''' # Check for session-id in cookie, if present, then proceed with request parsedCookies = parseCookies(headers) if parsedCookies and parsedCookies['session-id']: return request # URI encode the original request to be sent as redirect_url in query params redirectUrl = "https://%s%s?%s" % (headers['host'][0]['value'], request['uri'], request['querystring']) encodedRedirectUrl = urllib.parse.quote_plus(redirectUrl.encode('utf-8')) response = { 'status': '302', 'statusDescription': 'Found', 'headers': { 'location': [{ 'key': 'Location', 'value': 'https://www.example.com/signin?redirect_url=%s' % encodedRedirectUrl }] } } return response ``` ------ ## Personnalisation de contenu à l'aide des en-têtes Pays ou Type d'appareil – exemples Les exemples suivants illustrent une méthode d’utilisation de Lambda@Edge pour personnaliser le comportement en fonction de l’emplacement ou du type d’appareil utilisé par l’utilisateur. **Topics** + [Exemple : redirection de demandes utilisateur vers une URL spécifique à un pays](#lambda-examples-redirect-based-on-country) + [Exemple : gestion de différentes versions d’un objet en fonction de l’appareil](#lambda-examples-vary-on-device-type) ### Exemple : redirection de demandes utilisateur vers une URL spécifique à un pays L'exemple suivant montre comment générer une réponse de redirection HTTP avec une URL propre à un pays et renvoyer la réponse à l'utilisateur. Ceci s'avère utile lorsque vous souhaitez fournir des réponses propres à un pays. Exemples : + Si vous avez des sous-domaines propres à un pays, comme us.example.com et tw.example.com, vous pouvez générer une réponse de redirection lorsqu'un utilisateur demande example.com. + Si vous diffusez une vidéo, mais que vous ne disposez pas de droits pour diffuser le contenu dans un pays spécifique, vous pouvez rediriger les utilisateurs de ce pays vers une page qui explique pourquoi ils ne peuvent regarder la vidéo. Remarques : + Vous devez configurer votre distribution pour être mise en cache en fonction de l'en-tête `CloudFront-Viewer-Country`. Pour de plus amples informations, veuillez consulter [Mise en cache basée sur des en-têtes de demande sélectionnés](DownloadDistValuesCacheBehavior.md#DownloadDistValuesForwardHeaders). + CloudFront ajoute l'`CloudFront-Viewer-Country`en-tête après l'événement de demande du spectateur. Pour utiliser cet exemple, vous devez créer un déclencheur pour l’événement de demande à l’origine. ------ #### [ Node.js ] ``` 'use strict'; /* This is an origin request function */ exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; const headers = request.headers; /* * Based on the value of the CloudFront-Viewer-Country header, generate an * HTTP status code 302 (Redirect) response, and return a country-specific * URL in the Location header. * NOTE: 1. You must configure your distribution to cache based on the * CloudFront-Viewer-Country header. For more information, see * https://docs.aws.amazon.com/console/cloudfront/cache-on-selected-headers * 2. CloudFront adds the CloudFront-Viewer-Country header after the viewer * request event. To use this example, you must create a trigger for the * origin request event. */ let url = 'https://example.com/'; if (headers['cloudfront-viewer-country']) { const countryCode = headers['cloudfront-viewer-country'][0].value; if (countryCode === 'TW') { url = 'https://tw.example.com/'; } else if (countryCode === 'US') { url = 'https://us.example.com/'; } } const response = { status: '302', statusDescription: 'Found', headers: { location: [{ key: 'Location', value: url, }], }, }; callback(null, response); }; ``` ------ #### [ Python ] ``` # This is an origin request function def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] headers = request['headers'] ''' Based on the value of the CloudFront-Viewer-Country header, generate an HTTP status code 302 (Redirect) response, and return a country-specific URL in the Location header. NOTE: 1. You must configure your distribution to cache based on the CloudFront-Viewer-Country header. For more information, see https://docs.aws.amazon.com/console/cloudfront/cache-on-selected-headers 2. CloudFront adds the CloudFront-Viewer-Country header after the viewer request event. To use this example, you must create a trigger for the origin request event. ''' url = 'https://example.com/' viewerCountry = headers.get('cloudfront-viewer-country') if viewerCountry: countryCode = viewerCountry[0]['value'] if countryCode == 'TW': url = 'https://tw.example.com/' elif countryCode == 'US': url = 'https://us.example.com/' response = { 'status': '302', 'statusDescription': 'Found', 'headers': { 'location': [{ 'key': 'Location', 'value': url }] } } return response ``` ------ ### Exemple : gestion de différentes versions d’un objet en fonction de l’appareil L'exemple suivant montre comment servir différentes versions d'un objet en fonction du type d'appareil employé par l'utilisateur, par exemple, un appareil mobile ou une tablette. Remarques : + Vous devez configurer votre distribution pour être mise en cache en fonction des en-têtes `CloudFront-Is-*-Viewer`. Pour de plus amples informations, veuillez consulter [Mise en cache basée sur des en-têtes de demande sélectionnés](DownloadDistValuesCacheBehavior.md#DownloadDistValuesForwardHeaders). + CloudFront ajoute les `CloudFront-Is-*-Viewer` en-têtes après l'événement de demande du spectateur. Pour utiliser cet exemple, vous devez créer un déclencheur pour l’événement de demande à l’origine. ------ #### [ Node.js ] ``` 'use strict'; /* This is an origin request function */ exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; const headers = request.headers; /* * Serve different versions of an object based on the device type. * NOTE: 1. You must configure your distribution to cache based on the * CloudFront-Is-*-Viewer headers. For more information, see * the following documentation: * https://docs.aws.amazon.com/console/cloudfront/cache-on-selected-headers * https://docs.aws.amazon.com/console/cloudfront/cache-on-device-type * 2. CloudFront adds the CloudFront-Is-*-Viewer headers after the viewer * request event. To use this example, you must create a trigger for the * origin request event. */ const desktopPath = '/desktop'; const mobilePath = '/mobile'; const tabletPath = '/tablet'; const smarttvPath = '/smarttv'; if (headers['cloudfront-is-desktop-viewer'] && headers['cloudfront-is-desktop-viewer'][0].value === 'true') { request.uri = desktopPath + request.uri; } else if (headers['cloudfront-is-mobile-viewer'] && headers['cloudfront-is-mobile-viewer'][0].value === 'true') { request.uri = mobilePath + request.uri; } else if (headers['cloudfront-is-tablet-viewer'] && headers['cloudfront-is-tablet-viewer'][0].value === 'true') { request.uri = tabletPath + request.uri; } else if (headers['cloudfront-is-smarttv-viewer'] && headers['cloudfront-is-smarttv-viewer'][0].value === 'true') { request.uri = smarttvPath + request.uri; } console.log(`Request uri set to "${request.uri}"`); callback(null, request); }; ``` ------ #### [ Python ] ``` # This is an origin request function def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] headers = request['headers'] ''' Serve different versions of an object based on the device type. NOTE: 1. You must configure your distribution to cache based on the CloudFront-Is-*-Viewer headers. For more information, see the following documentation: https://docs.aws.amazon.com/console/cloudfront/cache-on-selected-headers https://docs.aws.amazon.com/console/cloudfront/cache-on-device-type 2. CloudFront adds the CloudFront-Is-*-Viewer headers after the viewer request event. To use this example, you must create a trigger for the origin request event. ''' desktopPath = '/desktop'; mobilePath = '/mobile'; tabletPath = '/tablet'; smarttvPath = '/smarttv'; if 'cloudfront-is-desktop-viewer' in headers and headers['cloudfront-is-desktop-viewer'][0]['value'] == 'true': request['uri'] = desktopPath + request['uri'] elif 'cloudfront-is-mobile-viewer' in headers and headers['cloudfront-is-mobile-viewer'][0]['value'] == 'true': request['uri'] = mobilePath + request['uri'] elif 'cloudfront-is-tablet-viewer' in headers and headers['cloudfront-is-tablet-viewer'][0]['value'] == 'true': request['uri'] = tabletPath + request['uri'] elif 'cloudfront-is-smarttv-viewer' in headers and headers['cloudfront-is-smarttv-viewer'][0]['value'] == 'true': request['uri'] = smarttvPath + request['uri'] print("Request uri set to %s" % request['uri']) return request ``` ------ ## Sélection d'origine dynamique basée sur le contenu – exemples Les exemples suivants illustrent une méthode d’utilisation de Lambda@Edge pour acheminer vers différentes origines en fonction des informations contenues dans la demande. **Topics** + [Exemple : utilisation d’un déclencheur de demande à l’origine pour passer d’une origine personnalisée à une origine Amazon S3](#lambda-examples-content-based-S3-origin-based-on-query) + [Exemple : utilisation d’un déclencheur de demande à l’origine pour modifier la région de l’origine Amazon S3](#lambda-examples-content-based-S3-origin-request-trigger) + [Exemple : utilisation d’un déclencheur de demande à l’origine pour passer d’une origine Amazon S3 à une origine personnalisée](#lambda-examples-content-based-custom-origin-request-trigger) + [Exemple : utilisation d’un déclencheur de demande à l’origine pour transférer progressivement le trafic d’un compartiment Amazon S3 à un autre](#lambda-examples-content-based-gradual-traffic-transfer) + [Exemple : utilisation d’un déclencheur de demande à l’origine pour modifier le nom de domaine de l’origine en fonction de l’en-tête du pays](#lambda-examples-content-based-geo-header) ### Exemple : utilisation d’un déclencheur de demande à l’origine pour passer d’une origine personnalisée à une origine Amazon S3 Cette fonction explique comment un déclencheur de demande à l'origine peut être utilisé pour passer d'une origine personnalisée à une origine Amazon S3 à partir de laquelle le contenu est récupéré en fonction des propriétés de la demande. ------ #### [ Node.js ] ``` 'use strict'; const querystring = require('querystring'); exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; /** * Reads query string to check if S3 origin should be used, and * if true, sets S3 origin properties. */ const params = querystring.parse(request.querystring); if (params['useS3Origin']) { if (params['useS3Origin'] === 'true') { const s3DomainName = 'amzn-s3-demo-bucket.s3.amazonaws.com'; /* Set S3 origin fields */ request.origin = { s3: { domainName: s3DomainName, region: '', authMethod: 'origin-access-identity', path: '', customHeaders: {} } }; request.headers['host'] = [{ key: 'host', value: s3DomainName}]; } } callback(null, request); }; ``` ------ #### [ Python ] ``` from urllib.parse import parse_qs def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] ''' Reads query string to check if S3 origin should be used, and if true, sets S3 origin properties ''' params = {k: v[0] for k, v in parse_qs(request['querystring']).items()} if params.get('useS3Origin') == 'true': s3DomainName = 'amzn-s3-demo-bucket.s3.amazonaws.com' # Set S3 origin fields request['origin'] = { 's3': { 'domainName': s3DomainName, 'region': '', 'authMethod': 'origin-access-identity', 'path': '', 'customHeaders': {} } } request['headers']['host'] = [{'key': 'host', 'value': s3DomainName}] return request ``` ------ ### Exemple : utilisation d’un déclencheur de demande à l’origine pour modifier la région de l’origine Amazon S3 Cette fonction explique comment un déclencheur de demande à l'origine peut être utilisé pour modifier l'origine Amazon S3 à partir de laquelle le contenu est récupéré en fonction des propriétés de la demande. Dans cet exemple, nous utilisons la valeur de l'en-tête `CloudFront-Viewer-Country` pour mettre à jour le nom de domaine de compartiment S3 en spécifiant un compartiment dans une région plus proche de l'utilisateur. Cela peut être utile à plusieurs égards : + Cela réduit la latence lorsque la région spécifiée est plus proche du pays de l'utilisateur. + Il est possible de contrôler les données en s'assurant qu'elles sont distribuées depuis une origine qui se trouve dans le pays de provenance de la demande. Pour utiliser cet exemple, vous devez procéder comme suit : + Vous devez configurer votre distribution à mettre en cache en fonction de l'en-tête `CloudFront-Viewer-Country`. Pour de plus amples informations, veuillez consulter [Mise en cache basée sur des en-têtes de demande sélectionnés](DownloadDistValuesCacheBehavior.md#DownloadDistValuesForwardHeaders). + Créez un déclencheur pour cette fonction dans l'événement de demande d'origine. CloudFrontajoute l'`CloudFront-Viewer-Country`en-tête après l'événement de demande du visualiseur. Pour utiliser cet exemple, vous devez vous assurer que la fonction s'exécute pour une demande d'origine. **Note** L’exemple de code suivant utilise la même identité d’accès d’origine (OAI) pour tous les compartiments S3 que vous utilisez comme origine. Pour plus d’informations, consultez [Identité d’accès d’origine](private-content-restricting-access-to-s3.md#private-content-restricting-access-to-s3-oai). ------ #### [ Node.js ] ``` 'use strict'; exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; /** * This blueprint demonstrates how an origin-request trigger can be used to * change the origin from which the content is fetched, based on request properties. * In this example, we use the value of the CloudFront-Viewer-Country header * to update the S3 bucket domain name to a bucket in a Region that is closer to * the viewer. * * This can be useful in several ways: * 1) Reduces latencies when the Region specified is nearer to the viewer's * country. * 2) Provides data sovereignty by making sure that data is served from an * origin that's in the same country that the request came from. * * NOTE: 1. You must configure your distribution to cache based on the * CloudFront-Viewer-Country header. For more information, see * https://docs.aws.amazon.com/console/cloudfront/cache-on-selected-headers * 2. CloudFront adds the CloudFront-Viewer-Country header after the viewer * request event. To use this example, you must create a trigger for the * origin request event. */ const countryToRegion = { 'DE': 'eu-central-1', 'IE': 'eu-west-1', 'GB': 'eu-west-2', 'FR': 'eu-west-3', 'JP': 'ap-northeast-1', 'IN': 'ap-south-1' }; if (request.headers['cloudfront-viewer-country']) { const countryCode = request.headers['cloudfront-viewer-country'][0].value; const region = countryToRegion[countryCode]; /** * If the viewer's country is not in the list you specify, the request * goes to the default S3 bucket you've configured. */ if (region) { /** * If you've set up OAI, the bucket policy in the destination bucket * should allow the OAI GetObject operation, as configured by default * for an S3 origin with OAI. Another requirement with OAI is to provide * the Region so it can be used for the SIGV4 signature. Otherwise, the * Region is not required. */ request.origin.s3.region = region; const domainName = `amzn-s3-demo-bucket-in-${region}.s3.${region}.amazonaws.com`; request.origin.s3.domainName = domainName; request.headers['host'] = [{ key: 'host', value: domainName }]; } } callback(null, request); }; ``` ------ #### [ Python ] ``` def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] ''' This blueprint demonstrates how an origin-request trigger can be used to change the origin from which the content is fetched, based on request properties. In this example, we use the value of the CloudFront-Viewer-Country header to update the S3 bucket domain name to a bucket in a Region that is closer to the viewer. This can be useful in several ways: 1) Reduces latencies when the Region specified is nearer to the viewer's country. 2) Provides data sovereignty by making sure that data is served from an origin that's in the same country that the request came from. NOTE: 1. You must configure your distribution to cache based on the CloudFront-Viewer-Country header. For more information, see https://docs.aws.amazon.com/console/cloudfront/cache-on-selected-headers 2. CloudFront adds the CloudFront-Viewer-Country header after the viewer request event. To use this example, you must create a trigger for the origin request event. ''' countryToRegion = { 'DE': 'eu-central-1', 'IE': 'eu-west-1', 'GB': 'eu-west-2', 'FR': 'eu-west-3', 'JP': 'ap-northeast-1', 'IN': 'ap-south-1' } viewerCountry = request['headers'].get('cloudfront-viewer-country') if viewerCountry: countryCode = viewerCountry[0]['value'] region = countryToRegion.get(countryCode) # If the viewer's country in not in the list you specify, the request # goes to the default S3 bucket you've configured if region: ''' If you've set up OAI, the bucket policy in the destination bucket should allow the OAI GetObject operation, as configured by default for an S3 origin with OAI. Another requirement with OAI is to provide the Region so it can be used for the SIGV4 signature. Otherwise, the Region is not required. ''' request['origin']['s3']['region'] = region domainName = 'amzn-s3-demo-bucket-in-{0}.s3.{0}.amazonaws.com'.format(region) request['origin']['s3']['domainName'] = domainName request['headers']['host'] = [{'key': 'host', 'value': domainName}] return request ``` ------ ### Exemple : utilisation d’un déclencheur de demande à l’origine pour passer d’une origine Amazon S3 à une origine personnalisée Cette fonction explique comment un déclencheur de demande à l'origine peut être utilisé pour modifier l'origine personnalisée à partir de laquelle le contenu est récupéré, en fonction des propriétés de la demande. ------ #### [ Node.js ] ``` 'use strict'; const querystring = require('querystring'); exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; /** * Reads query string to check if custom origin should be used, and * if true, sets custom origin properties. */ const params = querystring.parse(request.querystring); if (params['useCustomOrigin']) { if (params['useCustomOrigin'] === 'true') { /* Set custom origin fields*/ request.origin = { custom: { domainName: 'www.example.com', port: 443, protocol: 'https', path: '', sslProtocols: ['TLSv1', 'TLSv1.1'], readTimeout: 5, keepaliveTimeout: 5, customHeaders: {} } }; request.headers['host'] = [{ key: 'host', value: 'www.example.com'}]; } } callback(null, request); }; ``` ------ #### [ Python ] ``` from urllib.parse import parse_qs def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] # Reads query string to check if custom origin should be used, and # if true, sets custom origin properties params = {k: v[0] for k, v in parse_qs(request['querystring']).items()} if params.get('useCustomOrigin') == 'true': # Set custom origin fields request['origin'] = { 'custom': { 'domainName': 'www.example.com', 'port': 443, 'protocol': 'https', 'path': '', 'sslProtocols': ['TLSv1', 'TLSv1.1'], 'readTimeout': 5, 'keepaliveTimeout': 5, 'customHeaders': {} } } request['headers']['host'] = [{'key': 'host', 'value': 'www.example.com'}] return request ``` ------ ### Exemple : utilisation d’un déclencheur de demande à l’origine pour transférer progressivement le trafic d’un compartiment Amazon S3 à un autre Cette fonction explique comment vous pouvez transférer progressivement le trafic d’un compartiment Amazon S3 à un autre de manière contrôlée. ------ #### [ Node.js ] ``` 'use strict'; function getRandomInt(min, max) { /* Random number is inclusive of min and max*/ return Math.floor(Math.random() * (max - min + 1)) + min; } exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; const BLUE_TRAFFIC_PERCENTAGE = 80; /** * This Lambda function demonstrates how to gradually transfer traffic from * one S3 bucket to another in a controlled way. * We define a variable BLUE_TRAFFIC_PERCENTAGE which can take values from * 1 to 100. If the generated randomNumber less than or equal to BLUE_TRAFFIC_PERCENTAGE, traffic * is re-directed to blue-bucket. If not, the default bucket that we've configured * is used. */ const randomNumber = getRandomInt(1, 100); if (randomNumber <= BLUE_TRAFFIC_PERCENTAGE) { const domainName = 'blue-bucket.s3.amazonaws.com'; request.origin.s3.domainName = domainName; request.headers['host'] = [{ key: 'host', value: domainName}]; } callback(null, request); }; ``` ------ #### [ Python ] ``` import math import random def getRandomInt(min, max): # Random number is inclusive of min and max return math.floor(random.random() * (max - min + 1)) + min def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] BLUE_TRAFFIC_PERCENTAGE = 80 ''' This Lambda function demonstrates how to gradually transfer traffic from one S3 bucket to another in a controlled way. We define a variable BLUE_TRAFFIC_PERCENTAGE which can take values from 1 to 100. If the generated randomNumber less than or equal to BLUE_TRAFFIC_PERCENTAGE, traffic is re-directed to blue-bucket. If not, the default bucket that we've configured is used. ''' randomNumber = getRandomInt(1, 100) if randomNumber <= BLUE_TRAFFIC_PERCENTAGE: domainName = 'blue-bucket.s3.amazonaws.com' request['origin']['s3']['domainName'] = domainName request['headers']['host'] = [{'key': 'host', 'value': domainName}] return request ``` ------ ### Exemple : utilisation d’un déclencheur de demande à l’origine pour modifier le nom de domaine de l’origine en fonction de l’en-tête du pays Cette fonction explique comment vous pouvez modifier le nom de domaine de l'origine en fonction de l'en-tête `CloudFront-Viewer-Country` afin que le contenu soit transmis depuis une origine plus proche du pays de l'utilisateur. La mise en œuvre de cette fonctionnalité pour votre distribution peut avoir les avantages suivants : + Réduction de la latence lorsque la région spécifiée est plus proche du pays de l'utilisateur + Assurance de la souveraineté des données en veillant à ce que les données soient distribuées depuis une origine qui se trouve dans le pays d'où vient la demande Notez que pour activer cette fonctionnalité, vous devez configurer votre distribution pour qu'elle soit mise en cache en fonction de l'en-tête `CloudFront-Viewer-Country`. Pour de plus amples informations, veuillez consulter [Mise en cache basée sur des en-têtes de demande sélectionnés](DownloadDistValuesCacheBehavior.md#DownloadDistValuesForwardHeaders). ------ #### [ Node.js ] ``` 'use strict'; exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; if (request.headers['cloudfront-viewer-country']) { const countryCode = request.headers['cloudfront-viewer-country'][0].value; if (countryCode === 'GB' || countryCode === 'DE' || countryCode === 'IE' ) { const domainName = 'eu.example.com'; request.origin.custom.domainName = domainName; request.headers['host'] = [{key: 'host', value: domainName}]; } } callback(null, request); }; ``` ------ #### [ Python ] ``` def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] viewerCountry = request['headers'].get('cloudfront-viewer-country') if viewerCountry: countryCode = viewerCountry[0]['value'] if countryCode == 'GB' or countryCode == 'DE' or countryCode == 'IE': domainName = 'eu.example.com' request['origin']['custom']['domainName'] = domainName request['headers']['host'] = [{'key': 'host', 'value': domainName}] return request ``` ------ ## Mise à jour des statuts d’erreur : exemples Les exemples suivants fournissent des conseils sur l’utilisation de Lambda@Edge pour modifier le statut d’erreur qui est renvoyé aux utilisateurs. **Topics** + [Exemple : utilisation d’un déclencheur de réponse de l’origine pour mettre à jour le code de statut d’erreur sur 200](#lambda-examples-custom-error-static-body) + [Exemple : utilisation d’un déclencheur de réponse de l’origine pour mettre à jour le code de statut d’erreur sur 302](#lambda-examples-custom-error-new-site) ### Exemple : utilisation d’un déclencheur de réponse de l’origine pour mettre à jour le code de statut d’erreur sur 200 Cette fonction explique comment vous pouvez mettre à jour le statut de la réponse sur 200 et générer un contenu de corps statique à renvoyer à l'utilisateur dans le scénario suivant : + La fonction est déclenchée dans une réponse de l'origine. + Le statut de la réponse du serveur d’origine est un code de statut d’erreur (4xx ou 5xx). ------ #### [ Node.js ] ``` 'use strict'; exports.handler = (event, context, callback) => { const response = event.Records[0].cf.response; /** * This function updates the response status to 200 and generates static * body content to return to the viewer in the following scenario: * 1. The function is triggered in an origin response * 2. The response status from the origin server is an error status code (4xx or 5xx) */ if (response.status >= 400 && response.status <= 599) { response.status = 200; response.statusDescription = 'OK'; response.body = 'Body generation example'; } callback(null, response); }; ``` ------ #### [ Python ] ``` def lambda_handler(event, context): response = event['Records'][0]['cf']['response'] ''' This function updates the response status to 200 and generates static body content to return to the viewer in the following scenario: 1. The function is triggered in an origin response 2. The response status from the origin server is an error status code (4xx or 5xx) ''' if int(response['status']) >= 400 and int(response['status']) <= 599: response['status'] = 200 response['statusDescription'] = 'OK' response['body'] = 'Body generation example' return response ``` ------ ### Exemple : utilisation d’un déclencheur de réponse de l’origine pour mettre à jour le code de statut d’erreur sur 302 Cette fonction explique comment vous pouvez mettre à jour le code de statut HTTP sur 302 pour rediriger le trafic vers un autre chemin (comportement de cache) qui possède une autre origine configurée. Remarques : + La fonction est déclenchée dans une réponse de l'origine. + Le statut de la réponse du serveur d’origine est un code de statut d’erreur (4xx ou 5xx). ------ #### [ Node.js ] ``` 'use strict'; exports.handler = (event, context, callback) => { const response = event.Records[0].cf.response; const request = event.Records[0].cf.request; /** * This function updates the HTTP status code in the response to 302, to redirect to another * path (cache behavior) that has a different origin configured. Note the following: * 1. The function is triggered in an origin response * 2. The response status from the origin server is an error status code (4xx or 5xx) */ if (response.status >= 400 && response.status <= 599) { const redirect_path = `/plan-b/path?${request.querystring}`; response.status = 302; response.statusDescription = 'Found'; /* Drop the body, as it is not required for redirects */ response.body = ''; response.headers['location'] = [{ key: 'Location', value: redirect_path }]; } callback(null, response); }; ``` ------ #### [ Python ] ``` def lambda_handler(event, context): response = event['Records'][0]['cf']['response'] request = event['Records'][0]['cf']['request'] ''' This function updates the HTTP status code in the response to 302, to redirect to another path (cache behavior) that has a different origin configured. Note the following: 1. The function is triggered in an origin response 2. The response status from the origin server is an error status code (4xx or 5xx) ''' if int(response['status']) >= 400 and int(response['status']) <= 599: redirect_path = '/plan-b/path?%s' % request['querystring'] response['status'] = 302 response['statusDescription'] = 'Found' # Drop the body as it is not required for redirects response['body'] = '' response['headers']['location'] = [{'key': 'Location', 'value': redirect_path}] return response ``` ------ ## Accès au corps de requête - exemples Les exemples suivants illustrent l’utilisation de Lambda@Edge pour utiliser des demandes POST. **Note** Pour utiliser ces exemples, vous devez activer l'option *Inclure le corps* dans l'association de fonction Lambda de la distribution. Elle n'est pas activée par défaut. Pour activer ce paramètre dans la CloudFront console, cochez la case **Inclure le corps** dans l'association de **fonctions Lambda**. Pour activer ce paramètre dans l' CloudFront API ou avec CloudFormation, définissez le `IncludeBody` champ sur `true` in`LambdaFunctionAssociation`. **Topics** + [Exemple : utilisation d’un déclencheur de demande pour lire un formulaire HTML](#lambda-examples-access-request-body-examples-read) + [Exemple : utilisation d’un déclencheur de demande pour modifier un formulaire HTML](#lambda-examples-access-request-body-examples-replace) ### Exemple : utilisation d’un déclencheur de demande pour lire un formulaire HTML Cette fonction montre comment vous pouvez traiter le corps d'une requête POST générée par un formulaire HTML (formulaire web), tel que « Contactez-nous ». Par exemple, vous pouvez avoir un formulaire HTML comme le suivant : ``` ``` Pour l'exemple de fonction qui suit, la fonction doit être déclenchée dans une requête d'utilisateur CloudFront ou une requête d'origine. ------ #### [ Node.js ] ``` 'use strict'; const querystring = require('querystring'); /** * This function demonstrates how you can read the body of a POST request * generated by an HTML form (web form). The function is triggered in a * CloudFront viewer request or origin request event type. */ exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; if (request.method === 'POST') { /* HTTP body is always passed as base64-encoded string. Decode it. */ const body = Buffer.from(request.body.data, 'base64').toString(); /* HTML forms send the data in query string format. Parse it. */ const params = querystring.parse(body); /* For demonstration purposes, we only log the form fields here. * You can put your custom logic here. For example, you can store the * fields in a database, such as Amazon DynamoDB, and generate a response * right from your Lambda@Edge function. */ for (let param in params) { console.log(`For "${param}" user submitted "${params[param]}".\n`); } } return callback(null, request); }; ``` ------ #### [ Python ] ``` import base64 from urllib.parse import parse_qs ''' Say there is a POST request body generated by an HTML such as: ''' ''' This function demonstrates how you can read the body of a POST request generated by an HTML form (web form). The function is triggered in a CloudFront viewer request or origin request event type. ''' def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] if request['method'] == 'POST': # HTTP body is always passed as base64-encoded string. Decode it body = base64.b64decode(request['body']['data']) # HTML forms send the data in query string format. Parse it params = {k: v[0] for k, v in parse_qs(body).items()} ''' For demonstration purposes, we only log the form fields here. You can put your custom logic here. For example, you can store the fields in a database, such as Amazon DynamoDB, and generate a response right from your Lambda@Edge function. ''' for key, value in params.items(): print("For %s use submitted %s" % (key, value)) return request ``` ------ ### Exemple : utilisation d’un déclencheur de demande pour modifier un formulaire HTML Cette fonction montre comment vous pouvez modifier le corps d'une requête POST générée par un formulaire HTML (formulaire web). La fonction est déclenchée dans une demande de CloudFront visualisation ou une demande d'origine. ------ #### [ Node.js ] ``` 'use strict'; const querystring = require('querystring'); exports.handler = (event, context, callback) => { var request = event.Records[0].cf.request; if (request.method === 'POST') { /* Request body is being replaced. To do this, update the following /* three fields: * 1) body.action to 'replace' * 2) body.encoding to the encoding of the new data. * * Set to one of the following values: * * text - denotes that the generated body is in text format. * Lambda@Edge will propagate this as is. * base64 - denotes that the generated body is base64 encoded. * Lambda@Edge will base64 decode the data before sending * it to the origin. * 3) body.data to the new body. */ request.body.action = 'replace'; request.body.encoding = 'text'; request.body.data = getUpdatedBody(request); } callback(null, request); }; function getUpdatedBody(request) { /* HTTP body is always passed as base64-encoded string. Decode it. */ const body = Buffer.from(request.body.data, 'base64').toString(); /* HTML forms send data in query string format. Parse it. */ const params = querystring.parse(body); /* For demonstration purposes, we're adding one more param. * * You can put your custom logic here. For example, you can truncate long * bodies from malicious requests. */ params['new-param-name'] = 'new-param-value'; return querystring.stringify(params); } ``` ------ #### [ Python ] ``` import base64 from urllib.parse import parse_qs, urlencode def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] if request['method'] == 'POST': ''' Request body is being replaced. To do this, update the following three fields: 1) body.action to 'replace' 2) body.encoding to the encoding of the new data. Set to one of the following values: text - denotes that the generated body is in text format. Lambda@Edge will propagate this as is. base64 - denotes that the generated body is base64 encoded. Lambda@Edge will base64 decode the data before sending it to the origin. 3) body.data to the new body. ''' request['body']['action'] = 'replace' request['body']['encoding'] = 'text' request['body']['data'] = getUpdatedBody(request) return request def getUpdatedBody(request): # HTTP body is always passed as base64-encoded string. Decode it body = base64.b64decode(request['body']['data']) # HTML forms send data in query string format. Parse it params = {k: v[0] for k, v in parse_qs(body).items()} # For demonstration purposes, we're adding one more param # You can put your custom logic here. For example, you can truncate long # bodies from malicious requests params['new-param-name'] = 'new-param-value' return urlencode(params) ``` ------ # Restrictions sur les fonctions périphériques Les rubriques suivantes décrivent les restrictions qui s'appliquent aux CloudFront fonctions et à Lambda @Edge. Certaines restrictions s'appliquent à toutes les fonctions Edge, tandis que d'autres s'appliquent uniquement à CloudFront Functions ou à Lambda @Edge. Chaque rubrique fournit des informations détaillées sur les limites et les contraintes que vous devez prendre en compte lorsque vous développez et déployez des fonctions de périphérie avec CloudFront. La compréhension de ces restrictions vous permet de garantir que vos fonctions en périphérie fonctionnent comme prévu et respectent les fonctionnalités prises en charge. **Topics** + [Restrictions sur toutes les fonctions périphériques](edge-function-restrictions-all.md) + [Restrictions relatives aux CloudFront fonctions](cloudfront-function-restrictions.md) + [Restrictions sur Lambda@Edge](lambda-at-edge-function-restrictions.md) Pour plus d'informations sur les quotas (anciennement appelés limites), consultez [Quotas relatifs aux CloudFront fonctions](cloudfront-limits.md#limits-functions) et [Quotas sur Lambda@Edge](cloudfront-limits.md#limits-lambda-at-edge). # Restrictions sur toutes les fonctions périphériques Les restrictions suivantes s'appliquent à toutes les fonctions Edge, à la fois à CloudFront Functions et à Lambda @Edge. **Topics** + [Compte AWS propriété](#function-restrictions-account-ownership) + [Combinaison de CloudFront fonctions avec Lambda @Edge](#function-restrictions-combining-functions) + [Codes d'état HTTP](#function-restrictions-status-codes) + [En-têtes HTTP](#function-restrictions-headers) + [Chaînes de requête](#function-restrictions-query-strings) + [URI](#function-restrictions-uri) + [Encodage de l’URI, de la chaîne de requête et des en-têtes](#function-restrictions-encoding) + [Microsoft Smooth Streaming](#function-restrictions-microsoft-smooth-streaming) + [Identification](#function-restrictions-tagging) ## Compte AWS propriété Pour associer une fonction de périphérie à une CloudFront distribution, la fonction et la distribution doivent appartenir à la même entité Compte AWS. ## Combinaison de CloudFront fonctions avec Lambda @Edge Pour un comportement de cache donné, les restrictions suivantes s'appliquent : + Chaque type d'événement (requête de l'utilisateur, requête de l'origine, réponse de l'origine et réponse de l'utilisateur) ne peut posséder qu'une association de fonctions périphériques. + Vous ne pouvez pas combiner CloudFront Functions et Lambda @Edge dans les événements du visualiseur (demande du visualiseur et réponse du visualiseur). Toutes les autres combinaisons de fonctions périphériques sont autorisées. Le tableau suivant explique les combinaisons autorisées. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonCloudFront/latest/DeveloperGuide/edge-function-restrictions-all.html) ## Codes d'état HTTP CloudFront n'invoque pas les fonctions Edge pour les événements de réponse du spectateur lorsque l'origine renvoie le code d'état HTTP 400 ou supérieur. Pour les événements de réponse d'origine, les fonctions Lambda@Edge sont appelées pour *toutes* les réponses d'origine, notamment lorsque l'origine renvoie un code de statut HTTP supérieur ou supérieur à 400. Pour plus d’informations, consultez [Mise à jour des réponses HTTP dans des déclencheurs de réponse de l’origine](lambda-generating-http-responses.md#lambda-updating-http-responses). ## En-têtes HTTP Certains en-têtes HTTP ne sont pas autorisés, ce qui signifie qu'ils ne sont pas exposés aux fonctions de périphérie et que les fonctions ne peuvent pas les ajouter. Les autres en-têtes sont en lecture seule, ce qui signifie que les fonctions peuvent les lire, sans pouvoir les ajouter, les modifier ou le supprimer. **Topics** + [En-têtes non autorisés](#function-restrictions-disallowed-headers) + [En-têtes en lecture seule](#function-restrictions-read-only-headers) ### En-têtes non autorisés Les en-têtes HTTP suivants ne sont pas exposés aux fonctions périphériques, et les fonctions ne peuvent pas les ajouter. Si votre fonction ajoute l'un de ces en-têtes, la CloudFront validation échoue et CloudFront renvoie le code d'état HTTP 502 (Bad Gateway) au visualiseur. + `Connection` + `Expect` + `Keep-Alive` + `Proxy-Authenticate` + `Proxy-Authorization` + `Proxy-Connection` + `Trailer` + `Upgrade` + `X-Accel-Buffering` + `X-Accel-Charset` + `X-Accel-Limit-Rate` + `X-Accel-Redirect` + `X-Amz-Cf-*` + `X-Amzn-Auth` + `X-Amzn-Cf-Billing` + `X-Amzn-Cf-Id` + `X-Amzn-Cf-Xff` + `X-Amzn-Errortype` + `X-Amzn-Fle-Profile` + `X-Amzn-Header-Count` + `X-Amzn-Header-Order` + `X-Amzn-Lambda-Integration-Tag` + `X-Amzn-RequestId` + `X-Cache` + `X-Edge-*` + `X-Forwarded-Proto` + `X-Real-IP` ### En-têtes en lecture seule Les en-têtes suivants sont en lecture seule. Votre fonction peut les lire et les utiliser comme entrée de la logique de la fonction, mais elle ne peut pas modifier les valeurs. Si votre fonction ajoute ou modifie un en-tête en lecture seule, la demande échoue à la CloudFront validation et CloudFront renvoie le code d'état HTTP 502 (Bad Gateway) au visualiseur. #### En-têtes en lecture seule pour les événements de demande de l'utilisateur Les en-têtes suivants sont en lecture seule dans les événements de demande de l'utilisateur. + `CDN-Loop` + `Content-Length` + `Host` + `Transfer-Encoding` + `Via` #### En-têtes en lecture seule dans les événements de demande d'origine (Lambda@Edge uniquement) Les en-têtes suivants sont en lecture seule dans les événements de demande d'origine, qui n'existent que dans Lambda@Edge. + `Accept-Encoding` + `CDN-Loop` + `Content-Length` + `If-Modified-Since` + `If-None-Match` + `If-Range` + `If-Unmodified-Since` + `Transfer-Encoding` + `Via` #### En-têtes en lecture seule dans les événements de réponse d'origine (Lambda@Edge uniquement) Les en-têtes suivants sont en lecture seule dans les événements de réponse d'origine, qui n'existent que dans Lambda@Edge. + `Transfer-Encoding` + `Via` #### En-têtes en lecture seule dans les événements de réponse de l'utilisateur Les en-têtes suivants sont en lecture seule dans les événements de réponse du visualiseur pour Functions CloudFront et Lambda @Edge. + `Warning` + `Via` Les en-têtes suivants sont en lecture seule dans les événements de réponse d'utilisateur pour Lambda@Edge. + `Content-Length` + `Content-Encoding` + `Transfer-Encoding` ## Chaînes de requête Les restrictions suivantes s'appliquent aux fonctions qui lisent, mettent à jour ou créent une chaîne de requête dans un URI de demande. + (Lambda@Edge uniquement) Pour accéder à la chaîne de requête dans une fonction de demande de l'origine ou de réponse de l'origine, votre stratégie de cache ou stratégie de demande de l'origine doit être définie sur **Toutes** pour **Chaînes de requête**. + Une fonction peut créer ou mettre à jour une chaîne de requête pour les événements de demande de l'utilisateur et de demande de l'origine (les événements de demande de l'origine n'existent que dans Lambda@Edge). + Une fonction peut lire une chaîne de requête, mais ne peut pas en créer ou en mettre à jour, pour les événements de réponse de l'origine et de réponse de l'utilisateur (les événements de réponse de l'origine n'existent que dans Lambda@Edge). + Si une fonction crée ou met à jour une chaîne de requête, les restrictions suivantes s'appliquent : + La chaîne de requête mise à jour ne peut pas inclure des espaces, des caractères de contrôle ou l'identificateur de fragment (`#`). + La taille totale de l’URI, comprenant la chaîne de requête, doit être inférieure à 8 192 caractères. + Nous vous recommandons d'utiliser l'encodage de pourcentage pour l'URI et la chaîne de requête. Pour de plus amples informations, veuillez consulter [Encodage de l’URI, de la chaîne de requête et des en-têtes](#function-restrictions-encoding). ## URI Si une fonction modifie l'URI pour une demande, cela ne modifie pas le comportement du cache pour la demande ou l'origine vers laquelle la demande est transférée. La taille totale de l’URI, comprenant la chaîne de requête, doit être inférieure à 8 192 caractères. ## Encodage de l’URI, de la chaîne de requête et des en-têtes Les valeurs de l’URI, de la chaîne de requête et des en-têtes transmises aux fonctions de périphérie sont encodées en UTF-8. Votre fonction doit utiliser l’encodage UTF-8 pour les valeurs d’URI, de chaîne de requête et de l’en-tête qu’elle renvoie. L'encodage de pourcentage est compatible avec l'encodage UTF-8. La liste suivante explique comment CloudFront gère le codage de l'URI, de la chaîne de requête et des en-têtes : + Lorsque les valeurs de la requête sont codées en UTF-8, CloudFront elles sont transmises à votre fonction sans les modifier. + Lorsque les valeurs de la demande sont [codées ISO-8859-1](https://en.wikipedia.org/wiki/ISO/IEC_8859-1), CloudFront convertit les valeurs en codage UTF-8 avant de les transmettre à votre fonction. + Lorsque les valeurs de la demande sont codées à l'aide d'un autre codage de caractères, CloudFront suppose qu'elles sont codées ISO-8859-1 et essaie de les convertir de l'ISO-8859-1 en UTF-8. **Important** Les caractères convertis peuvent résulter d'une interprétation inexacte des valeurs de la demande de l'origine. Cela peut conduire votre fonction ou votre origine à produire un résultat indésirable. Les valeurs de l'URI, de la chaîne de requête et des en-têtes CloudFront transmis à votre origine dépendent de la modification des valeurs par une fonction : + Si une fonction ne modifie pas l'URI, la chaîne de requête ou l'en-tête, elle CloudFront transmet les valeurs qu'elle a reçues dans la demande à votre origine. + Si une fonction modifie l'URI, la chaîne de requête ou l'en-tête, elle CloudFront transmet les valeurs codées en UTF-8. ## Microsoft Smooth Streaming Vous ne pouvez pas utiliser les fonctions de périphérie avec une CloudFront distribution que vous utilisez pour diffuser des fichiers multimédia que vous avez transcodés au format Microsoft Smooth Streaming. ## Identification Vous ne pouvez pas ajouter de balises aux fonctions de périphérie. Pour plus d'informations sur le balisage CloudFront, consultez[Étiquetage d’une distribution](tagging.md). # Restrictions relatives aux CloudFront fonctions Les restrictions suivantes s'appliquent uniquement aux CloudFront fonctions. **Contents** + [Journaux](#cloudfront-function-restrictions-logs) + [Corps de la demande](#cloudfront-function-restrictions-request-body) + [Utilisation d'informations d'identification temporaires avec l' CloudFront KeyValueStore API](#regional-endpoint-for-key-value-store) + [Environnement d’exécution](#cloudfront-function-runtime-restrictions) + [Utilisation du calcul](#cloudfront-function-restrictions-compute-utilization) Pour en savoir plus sur les quotas (anciennement appelés limites), consultez [Quotas relatifs aux CloudFront fonctions](cloudfront-limits.md#limits-functions). ## Journaux Les journaux de CloudFront fonctions dans Functions sont tronqués à 10 Ko. ## Corps de la demande CloudFront Les fonctions ne peuvent pas accéder au corps de la requête HTTP. ## Utilisation d'informations d'identification temporaires avec l' CloudFront KeyValueStore API Vous pouvez utiliser AWS Security Token Service (AWS STS) pour générer des informations de sécurité temporaires (également appelées *jetons de session*). Les jetons de session vous permettent d'assumer temporairement un rôle Gestion des identités et des accès AWS (IAM) afin de pouvoir y accéder Services AWS. Pour appeler l'[CloudFront KeyValueStore API](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_Operations_Amazon_CloudFront_KeyValueStore.html), utilisez un point de terminaison *régional* AWS STS pour renvoyer un jeton de session *version 2*. Si vous utilisez le point de terminaison *global* pour AWS STS (`sts.amazonaws.com`), il AWS STS générera un jeton de session *version 1*, qui n'est pas pris en charge par Signature Version 4A (SigV4A). Par conséquent, vous recevrez une erreur d’authentification. Pour appeler l' CloudFront KeyValueStore API, vous pouvez utiliser les options suivantes : **AWS CLI et AWS SDKs** Vous pouvez configurer le AWS CLI ou un AWS SDK pour utiliser les points de AWS STS terminaison régionaux. Pour plus d’informations, consultez [Points de terminaison AWS STS régionalisés](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sts-regionalized-endpoints.html) dans le *Guide de référence des kits SDK et outils AWS *. Pour plus d'informations sur les AWS STS points de terminaison disponibles, consultez la section [Régions et points de terminaison](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html#id_credentials_region-endpoints) dans le guide de l'utilisateur *IAM*. **SAML** Vous pouvez configurer SAML pour utiliser des points de AWS STS terminaison régionaux. Pour plus d’informations, consultez l’article de blog [Comment utiliser des points de terminaison SAML régionaux pour le basculement](https://aws.amazon.com/blogs/security/how-to-use-regional-saml-endpoints-for-failover/). **API `SetSecurityTokenServicePreferences`** Au lieu d'utiliser un point de AWS STS terminaison régional, vous pouvez configurer le point de terminaison global AWS STS pour renvoyer les jetons de session de version 2. Pour ce faire, utilisez l'opération [SetSecurityTokenServicePreferences](https://docs.aws.amazon.com/IAM/latest/APIReference/API_SetSecurityTokenServicePreferences.html)API pour configurer votre Compte AWS. **Example Exemple : commande de la CLI IAM** ``` aws iam set-security-token-service-preferences --global-endpoint-token-version v2Token ``` Nous vous recommandons d'utiliser les points de terminaison AWS STS régionaux au lieu de cette option. Les points de terminaison régionaux offrent une meilleure disponibilité et des scénarios de basculement. **Fournisseur d’identité personnalisé** Si vous utilisez un fournisseur d’identité personnalisé qui assure la fédération et assume le rôle, utilisez l’une des options précédentes pour le système de fournisseur d’identité parent chargé de générer le jeton de session. ## Environnement d’exécution L'environnement d'exécution CloudFront Functions ne prend pas en charge l'évaluation dynamique du code et restreint l'accès au réseau, au système de fichiers, aux variables d'environnement et aux minuteries. Pour de plus amples informations, veuillez consulter [Fonctions limitées](functions-javascript-runtime-10.md#writing-functions-javascript-features-restricted-features). **Note** Pour être utilisée CloudFront KeyValueStore, votre CloudFront fonction doit utiliser le [JavaScript runtime 2.0](functions-javascript-runtime-20.md). ## Utilisation du calcul CloudFront Le temps d'exécution des fonctions est limité, mesuré en termes d'*utilisation du calcul*. L'utilisation du calcul est un nombre compris entre 0 et 100 qui indique la durée d'exécution de la fonction en pourcentage de la durée maximale autorisée. Par exemple, une utilisation du calcul de 35 signifie que la durée d'exécution de la fonction représente 35 % du temps maximum autorisé. Lorsque vous [testez une fonction](test-function.md), la valeur d'utilisation du calcul figure dans la sortie de l'événement test. Pour les fonctions de production, vous pouvez consulter la [métrique d'utilisation du calcul](viewing-cloudfront-metrics.md#monitoring-console.cloudfront-functions) sur la [page Surveillance de la CloudFront console](https://console.aws.amazon.com/cloudfront/v4/home?#/monitoring) ou dans CloudWatch. # Restrictions sur Lambda@Edge Les restrictions suivantes s'appliquent uniquement à Lambda@Edge. **Contents** + [Résolution DNS](#lambda-at-edge-restrictions-dns) + [Codes d’état HTTP](#lambda-at-edge-restrictions-status-codes) + [Version de la fonction Lambda](#lambda-at-edge-restrictions-version) + [Région Lambda](#lambda-at-edge-restrictions-region) + [Autorisations de rôle Lambda](#lambda-at-edge-restrictions-role-permissions) + [Fonctionnalités de Lambda](#lambda-at-edge-restrictions-features) + [Environnements d'exécution pris en charge](#lambda-at-edge-restrictions-runtime) + [CloudFront en-têtes](#lambda-at-edge-restrictions-cloudfront-headers) + [Restrictions relatives au corps de la requête avec l'option Inclure le corps](#lambda-at-edge-restrictions-request-body) + [Délai de réponse et délai d’attente des connexions actives (origines personnalisées uniquement)](#timeout-for-lambda-edge-functions) Pour obtenir des informations sur les quotas , consultez [Quotas sur Lambda@Edge](cloudfront-limits.md#limits-lambda-at-edge). ## Résolution DNS CloudFront effectue une résolution DNS sur le nom de domaine d'origine *avant* d'exécuter la fonction Lambda @Edge de votre demande d'origine. Si le service DNS de votre domaine rencontre des problèmes et ne CloudFront parvient pas à résoudre le nom de domaine pour obtenir l'adresse IP, votre fonction Lambda @Edge ne sera pas invoquée. CloudFrontrenverra un [code d'état HTTP 502 (Bad Gateway)](http-502-bad-gateway.md) au client. Pour de plus amples informations, veuillez consulter [Erreur DNS (`NonS3OriginDnsError`)](http-502-bad-gateway.md#http-502-dns-error). Si la logique de votre fonction modifie le nom de domaine d'origine, elle CloudFront effectuera une autre résolution DNS sur le nom de domaine mis à jour une fois l'exécution de la fonction terminée. Pour plus d’informations sur la gestion du basculement DNS, consultez [Configuration du basculement DNS](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring.html) dans le *Guide du développeur Amazon Route 53*. ## Codes d’état HTTP Les fonctions Lambda @Edge pour les événements de réponse du spectateur ne peuvent pas modifier le code d'état HTTP de la réponse, que la réponse provienne de l'origine ou du CloudFront cache. ## Version de la fonction Lambda Vous devez utiliser une version numérotée de la fonction Lambda, et non `$LATEST` ou des alias. ## Région Lambda La fonction Lambda doit résider dans la région USA Est (Virginie du Nord). ## Autorisations de rôle Lambda Le rôle d'exécution IAM associé à la fonction Lambda doit autoriser les principaux de service `lambda.amazonaws.com` et `edgelambda.amazonaws.com` à endosser le rôle. Pour de plus amples informations, veuillez consulter [Définition des autorisations et rôles IAM pour Lambda@Edge](lambda-edge-permissions.md). ## Fonctionnalités de Lambda Les fonctionnalités Lambda suivantes ne sont pas prises en charge par Lambda@Edge : + [Configurations de gestion de l’environnement d’exécution Lambda](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-update.html#runtime-management-controls) autres que **Auto** (par défaut) + Configuration de votre fonction Lambda pour accéder à des ressources au sein de votre VPC + [files d'attente de lettres mortes de la fonction Lambda](https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#dlq) + [Variables d’environnement Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html) (à l’exception des variables d’environnement réservées, qui sont automatiquement prises en charge) + Fonctions Lambda avec la [Gestion des dépendances AWS Lambda à l’aide de couches](https://docs.aws.amazon.com/lambda/latest/dg/chapter-layers.html) + [Utilisation de AWS X-Ray](https://docs.aws.amazon.com/lambda/latest/dg/lambda-x-ray.html) + Simultanéité allouée Lambda **Note** Les fonctions Lambda@Edge partagent les mêmes capacités de [simultanéité régionale](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html) que toutes les fonctions Lambda. Pour de plus amples informations, veuillez consulter [Quotas sur Lambda@Edge](cloudfront-limits.md#limits-lambda-at-edge). + [Création d'une fonction Lambda à l'aide d'une image de conteneur](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html) + [Fonctions Lambda utilisant l'architecture arm64](https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html) + Fonctions Lambda avec plus de 512 Mo de stockage éphémère + Utilisation d’une [clé gérée par le client pour votre package de déploiement .zip](https://docs.aws.amazon.com/lambda/latest/dg/encrypt-zip-package.html) ## Environnements d'exécution pris en charge Lambda@Edge prend en charge les dernières versions des environnements d’exécution Node.js et Python. Pour obtenir la liste des versions prises en charge et leurs futures dates d’obsolescence, consultez [Environnements d’exécution pris en charge](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtimes-supported) dans le *Guide du développeur AWS Lambda *. **Astuce** À titre de bonne pratique, privilégiez les versions les plus récentes des environnements d’exécution fournis afin de bénéficier des améliorations de performance et des nouvelles fonctionnalités. Vous ne pouvez pas créer ni mettre à jour de fonctions avec des versions obsolètes de Node.js. Vous ne pouvez associer les fonctions existantes à ces versions qu'à des CloudFront distributions. Les fonctions avec ces versions qui sont associées aux distributions continueront de s’exécuter. Toutefois, nous vous recommandons de déplacer votre fonction vers des versions plus récentes de Node.js. Pour plus d'informations, consultez la [politique de dépréciation des environnements d'exécution](https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html) dans le *guide du AWS Lambda développeur* et le [calendrier de publication de Node.js](https://github.com/nodejs/Release#release-schedule) sur. GitHub ## CloudFront en-têtes Les fonctions Lambda @Edge peuvent lire, modifier, supprimer ou ajouter n'importe lequel des CloudFront en-têtes répertoriés dans. [Ajouter des en-têtes de CloudFront demande](adding-cloudfront-headers.md) **Remarques** Si vous CloudFront souhaitez ajouter ces en-têtes, vous devez les configurer CloudFront pour les ajouter à l'aide d'une politique de [cache ou d'une politique](controlling-the-cache-key.md) de [demande d'origine](controlling-origin-requests.md). CloudFront ajoute les en-têtes *après* l'événement de demande de visualisation, ce qui signifie que les en-têtes ne sont pas disponibles pour les fonctions Lambda @Edge dans une demande de visualisation. Les en-têtes ne sont disponibles que pour les fonctions Lambda@Edge dans une demande d’origine et une réponse d’origine. Si la demande du lecteur inclut des en-têtes portant ces noms et que vous avez configuré pour ajouter ces en-têtes CloudFront à l'aide d'une politique de [cache ou d'une politique](controlling-the-cache-key.md) [de demande d'origine](controlling-origin-requests.md), les valeurs d'en-tête CloudFront figurant dans la demande du lecteur sont alors remplacées. Les fonctions orientées vers le spectateur voient la valeur d'en-tête de la demande du lecteur, tandis que les fonctions orientées vers l'origine voient la valeur d'en-tête ajoutée. CloudFront Si une fonction de demande d'affichage ajoute l'`CloudFront-Viewer-Country`en-tête, elle échoue à la validation et CloudFront renvoie le code d'état HTTP 502 (Bad Gateway) au visualiseur. ## Restrictions relatives au corps de la requête avec l'option Inclure le corps Lorsque vous choisissez l’option **Inclure le corps** pour exposer le corps de la demande à votre fonction Lambda@Edge, les informations et les limites de taille suivantes s’appliquent aux parties du corps qui sont exposées ou remplacées. + CloudFront base64 code toujours le corps de la requête avant de l'exposer à Lambda @Edge. + Si le corps de la requête est volumineux, CloudFront tronquez-le avant de l'exposer à Lambda @Edge, comme suit : + Pour les événements de requête d'utilisateur, le corps est tronqué à 40 Ko. + Pour les événements de requête de l'origine, le corps est tronqué à 1 Mo. + Si vous accédez au corps de la demande en lecture seule, CloudFront envoie le corps de la demande d'origine complet à l'origine. + Si votre fonction Lambda@Edge remplace le corps de la demande, les limites de taille suivantes s’appliquent au corps que la fonction renvoie : + Si la fonction Lambda@Edge renvoie le corps en texte brut : + Pour les événements de demande utilisateur, la limite de taille du corps est fixée à 40 Ko. + Pour les événements de demande à l’origine, la limite de taille du corps est fixée à 1 Mo. + Si la fonction Lambda@Edge renvoie le corps en tant que texte codé base64 : + Pour les événements de demande utilisateur, la limite de taille du corps est fixée à 53,2 Ko. + Pour les événements de demande à l’origine, la limite de taille du corps est fixée à 1,33 Mo. **Note** Si votre fonction Lambda@Edge renvoie un corps qui dépasse ces limites, votre demande échouera avec un code de statut HTTP 502 ([Erreur de validation Lambda](http-502-bad-gateway.md#http-502-lambda-validation-error)). Nous vous recommandons de mettre à jour votre fonction Lambda@Edge afin que le corps ne dépasse pas ces limites. ## Délai de réponse et délai d’attente des connexions actives (origines personnalisées uniquement) Si vous utilisez des fonctions Lambda@Edge pour définir le délai de réponse ou le délai d’attente des connexions actives pour les origines de votre distribution, assurez-vous de définir une valeur que votre origine est capable de prendre en charge. Pour de plus amples informations, veuillez consulter [Quotas de délai de réponse et d’attente des connexions actives](DownloadDistValuesOrigin.md#response-keep-alive-timeout-quota).