Here is your custom content.
" } } } ``` ## Objeto de evento de ejemplo En el siguiente ejemplo se muestra un objeto `event` completo. Este es un ejemplo de invocación para una distribución estándar y no para una distribución de varios inquilinos. Para distribuciones de varios inquilinos, se utiliza el campo `endpoint` en lugar de `distributionDomainName`. El valor de `endpoint` es el nombre de dominio de CloudFront (por ejemplo, d111111abcdef8.cloudfront.net) del grupo de conexiones asociado al evento. **nota** El objeto `event` es la entrada a su función. Su función devuelve solo el objeto `request` o `response`, no el objeto `event` completo. ``` { "version": "1.0", "context": { "distributionDomainName": "d111111abcdef8.cloudfront.net", "distributionId": "EDFDVBD6EXAMPLE", "eventType": "viewer-response", "requestId": "EXAMPLEntjQpEXAMPLE_SG5Z-EXAMPLEPmPfEXAMPLEu3EqEXAMPLE==" }, "viewer": {"ip": "198.51.100.11"}, "request": { "method": "GET", "uri": "/media/index.mpd", "querystring": { "ID": {"value": "42"}, "Exp": {"value": "1619740800"}, "TTL": {"value": "1440"}, "NoValue": {"value": ""}, "querymv": { "value": "val1", "multiValue": [ {"value": "val1"}, {"value": "val2,val3"} ] } }, "headers": { "host": {"value": "video.example.com"}, "user-agent": {"value": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0"}, "accept": { "value": "application/json", "multiValue": [ {"value": "application/json"}, {"value": "application/xml"}, {"value": "text/html"} ] }, "accept-language": {"value": "en-GB,en;q=0.5"}, "accept-encoding": {"value": "gzip, deflate, br"}, "origin": {"value": "https://website.example.com"}, "referer": {"value": "https://website.example.com/videos/12345678?action=play"}, "cloudfront-viewer-country": {"value": "GB"} }, "cookies": { "Cookie1": {"value": "value1"}, "Cookie2": {"value": "value2"}, "cookie_consent": {"value": "true"}, "cookiemv": { "value": "value3", "multiValue": [ {"value": "value3"}, {"value": "value4"} ] } } }, "response": { "statusCode": 200, "statusDescription": "OK", "headers": { "date": {"value": "Mon, 04 Apr 2021 18:57:56 GMT"}, "server": {"value": "gunicorn/19.9.0"}, "access-control-allow-origin": {"value": "*"}, "access-control-allow-credentials": {"value": "true"}, "content-type": {"value": "application/json"}, "content-length": {"value": "701"} }, "cookies": { "ID": { "value": "id1234", "attributes": "Expires=Wed, 05 Apr 2021 07:28:00 GMT" }, "Cookie1": { "value": "val1", "attributes": "Secure; Path=/; Domain=example.com; Expires=Wed, 05 Apr 2021 07:28:00 GMT", "multiValue": [ { "value": "val1", "attributes": "Secure; Path=/; Domain=example.com; Expires=Wed, 05 Apr 2021 07:28:00 GMT" }, { "value": "val2", "attributes": "Path=/cat; Domain=example.com; Expires=Wed, 10 Jan 2021 07:28:00 GMT" } ] } } } } ``` # Características del tiempo de ejecución de JavaScript para CloudFront Functions El entorno de tiempo de ejecución JavaScript de CloudFront Functions es compatible con la [versión 5.1 de ECMAScript (ES)](https://www.ecma-international.org/ecma-262/5.1/) y también admite algunas características de las versiones 6 a 12 de ES. Para obtener las características más actualizadas, le recomendamos que utilice el tiempo de ejecución 2.0 de JavaScript. Las características del tiempo de ejecución 2.0 de JavaScript presentan los siguientes cambios en comparación con la versión 1.0: + Están disponibles los métodos del módulo de búfer + No están disponibles los siguientes métodos de prototipos de cadenas no estándares: + `String.prototype.bytesFrom()` + `String.prototype.fromBytes()` + `String.prototype.fromUTF8()` + `String.prototype.toBytes()` + `String.prototype.toUTF8()` + El módulo criptográfico presenta los siguientes cambios: + `hash.digest()`: el tipo de retorno se cambia a `Buffer` si no se proporciona ninguna codificación + `hmac.digest()`: el tipo de retorno se cambia a `Buffer` si no se proporciona ninguna codificación + Para obtener más información sobre nuevas características adicionales, consulte [Características del tiempo de ejecución 2.0 de JavaScript para CloudFront Functions](functions-javascript-runtime-20.md). **Topics** + [Características del tiempo de ejecución 1.0 de JavaScript](functions-javascript-runtime-10.md) + [Características del tiempo de ejecución 2.0 de JavaScript](functions-javascript-runtime-20.md) # Características del tiempo de ejecución 1.0 de JavaScript para CloudFront Functions El entorno de tiempo de ejecución JavaScript de CloudFront Functions es compatible con [la versión 5.1 de ECMAScript (ES)](https://262.ecma-international.org/5.1/) y también admite algunas características de las versiones 6 a 9 de ES. También proporciona algunos métodos no estándar que no forman parte de las especificaciones de ES. En los siguientes temas se mencionan todas las características de lenguaje admitidas. **Topics** + [Características principales](#writing-functions-javascript-features-core) + [Objetos primitivos](#writing-functions-javascript-features-primitive-objects) + [Objetos integrados](#writing-functions-javascript-features-builtin-objects) + [Tipos de error](#writing-functions-javascript-features-error-types) + [Globals](#writing-functions-javascript-features-globals) + [Módulos integrados](#writing-functions-javascript-features-builtin-modules) + [Características restringidas](#writing-functions-javascript-features-restricted-features) ## Características principales Se admiten las siguientes características principales de ES. **Types** Se admiten todos los tipos de ES 5.1. Esto incluye valores booleanos, números, cadenas, objetos, matrices, funciones, constructores de funciones y expresiones regulares. **Operadores** Se admiten todos los operadores de ES 5.1. Se admite el operador de exponenciación ES 7 (`**`). **Instrucciones** No se admiten las instrucciones `const` ni `let`. Se admiten las siguientes instrucciones de ES 5.1: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `return` + `switch` + `throw` + `try` + `var` + `while` + Instrucciones etiquetadas **Literales** Se admiten literales de plantilla de ES 6: cadenas de líneas múltiples, interpolación de expresiones y plantillas de anidamiento. **Funciones** Se admiten todas las características de función de ES 5.1. Se admiten las funciones flecha de ES 6 así como la sintaxis del parámetro rest de ES 6. **Unicode** El texto de origen y los literales de cadena pueden contener caracteres codificados en Unicode. También se admiten secuencias de escape de punto de código Unicode de seis caracteres (por ejemplo, `\uXXXX`). **Modo estricto** Las funciones operan en modo estricto de forma predeterminada, por lo que no necesita agregar una instrucción `use strict` en su código de función. Esto no se puede cambiar. ## Objetos primitivos Se admiten los siguientes objetos primitivos de ES. **Objeto** Se admiten los siguientes métodos de ES 5.1 en objetos: + `create` (sin lista de propiedades) + `defineProperties` + `defineProperty` + `freeze` + `getOwnPropertyDescriptor` + `getOwnPropertyNames` + `getPrototypeOf` + `hasOwnProperty` + `isExtensible` + `isFrozen` + `prototype.isPrototypeOf` + `isSealed` + `keys` + `preventExtensions` + `prototype.propertyIsEnumerable` + `seal` + `prototype.toString` + `prototype.valueOf` Se admiten los siguientes métodos de ES 6 en objetos: + `assign` + `is` + `prototype.setPrototypeOf` Se admiten los siguientes métodos de ES 8 en objetos: + `entries` + `values` **Cadena** Se admiten los siguientes métodos de ES 5.1 en cadenas: + `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` Se admiten los siguientes métodos de ES 6 en cadenas: + `fromCodePoint` + `prototype.codePointAt` + `prototype.endsWith` + `prototype.includes` + `prototype.repeat` + `prototype.startsWith` Se admiten los siguientes métodos de ES 8 en cadenas: + `prototype.padStart` + `prototype.padEnd` Se admiten los siguientes métodos de ES 9 en cadenas: + `prototype.trimStart` + `prototype.trimEnd` Se admiten los siguientes métodos no estándar en cadenas: + `prototype.bytesFrom(array | string, encoding)` Crea una cadena de bytes a partir de una matriz de octetos o una cadena codificada. Las opciones de codificación de cadenas son `hex`, `base64` y `base64url`. + `prototype.fromBytes(start[, end])` Crea una cadena Unicode a partir de una cadena de bytes donde cada byte se reemplaza con el punto de código Unicode correspondiente. + `prototype.fromUTF8(start[, end])` Crea una cadena Unicode a partir de una cadena de bytes codificada en UTF-8. Si la codificación es incorrecta, devuelve `null`. + `prototype.toBytes(start[, end])` Crea una cadena de bytes a partir de una cadena Unicode. Todos los caracteres deben estar comprendidos en el rango [0-255]. De lo contrario, devuelve `null`. + `prototype.toUTF8(start[, end])` Crea una cadena de bytes codificada en UTF-8 a partir de una cadena Unicode. **Número** Se admiten todos los métodos de ES 5.1 en números. Se admiten los siguientes métodos de ES 6 en números: + `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` ## Objetos integrados Se admiten los siguientes objetos integrados de ES. **Math** Se admiten todos los métodos matemáticos de ES 5.1. En el entorno de tiempo de ejecución de CloudFront Functions, la implementación de `Math.random()` utiliza `arc4random` de OpenBSD predefinido con la marca de tiempo de cuándo se ejecuta la función. Se admiten los siguientes métodos matemáticos de ES 6: + `acosh` + `asinh` + `atanh` + `cbrt` + `clz32` + `cosh` + `expm1` + `fround` + `hypot` + `imul` + `log10` + `log1p` + `log2` + `sign` + `sinh` + `tanh` + `trunc` + `E` + `LN10` + `LN2` + `LOG10E` + `LOG2E` + `PI` + `SQRT1_2` + `SQRT2` **Fecha** Se admiten todas las características `Date` de ES 5.1. Por razones de seguridad, `Date` siempre devuelve el mismo valor (la hora de inicio de la función) durante la vida útil de la ejecución de una sola función. Para obtener más información, consulte [Características restringidas](#writing-functions-javascript-features-restricted-features). **Función** Se admiten los métodos `apply`, `bind` y `call`. Los constructores de funciones no son compatibles. **Expresiones regulares** Se admiten todas las características de expresión regular de ES 5.1. El lenguaje de expresión regular es compatible con Perl. Se admiten grupos de captura con nombre de ES 9. **JSON** Se admiten todas las características JSON de ES 5.1, incluidas `parse` y `stringify`. **Matriz** Se admiten los siguientes métodos de ES 5.1 en matrices: + `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` Se admiten los siguientes métodos de ES 6 en matrices: + `of` + `prototype.copyWithin` + `prototype.fill` + `prototype.find` + `prototype.findIndex` Se admiten los siguientes métodos de ES 7 en matrices: + `prototype.includes` **Matrices con tipo** Se admiten las siguientes matrices con tipo de ES 6: + `Int8Array` + `Uint8Array` + `Uint8ClampedArray` + `Int16Array` + `Uint16Array` + `Int32Array` + `Uint32Array` + `Float32Array` + `Float64Array` + `prototype.copyWithin` + `prototype.fill` + `prototype.join` + `prototype.set` + `prototype.slice` + `prototype.subarray` + `prototype.toString` **ArrayBuffer** Se admiten los siguientes métodos en `ArrayBuffer`: + `prototype.isView` + `prototype.slice` **Promesa** Se admiten los siguientes métodos en promesas: + `reject` + `resolve` + `prototype.catch` + `prototype.finally` + `prototype.then` **Cripto** El módulo criptográfico proporciona ayudantes de código de autenticación de mensajes (HMAC) estándar hashing y basado en hash. Puede cargar el módulo mediante `require('crypto')`. El módulo expone los siguientes métodos que se comportan exactamente como sus homólogos Node.js: + `createHash(algorithm)` + `hash.update(data)` + `hash.digest([encoding])` + `createHmac(algorithm, secret key)` + `hmac.update(data)` + `hmac.digest([encoding])` Para obtener más información, consulte [Cripto (hash y HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) en la sección módulos integrados. **Consola** Este es un objeto ayudante para la depuración. Solo admite el método `log()` para registrar mensajes de registro. CloudFront Functions no admite la sintaxis con comas, como `console.log('a', 'b')`. En su lugar, utilice el formato `console.log('a' + ' ' + 'b')`. ## Tipos de error Se admiten los siguientes objetos de error: + `Error` + `EvalError` + `InternalError` + `MemoryError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Globals Se admite el objeto `globalThis`. Se admiten las siguientes características globales de ES 5.1: + `decodeURI` + `decodeURIComponent` + `encodeURI` + `encodeURIComponent` + `isFinite` + `isNaN` + `parseFloat` + `parseInt` Se admiten las siguientes constantes globales: + `NaN` + `Infinity` + `undefined` ## Módulos integrados Se admiten los siguientes módulos integrados: **Topics** + [Cripto (hash y HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) + [Cadena de consulta](#writing-functions-javascript-features-builtin-modules-query-string) ### Cripto (hash y HMAC) El módulo criptográfico (`crypto`) proporciona ayudantes de código de autenticación de mensajes basado en hash (HMAC) y hashing estándar. Puede cargar el módulo mediante `require('crypto')`. El módulo proporciona los siguientes métodos que se comportan exactamente como sus homólogos Node.js. **Métodos de hashing** `crypto.createHash(algorithm)` Crea y devuelve un objeto hash que puede utilizar para generar resúmenes hash mediante el algoritmo dado: `md5`, `sha1` o `sha256`. `hash.update(data)` Actualiza el contenido hash con los dado `data`. `hash.digest([encoding])` Calcula el resumen de todos los datos pasados con `hash.update()`. La codificación puede ser `hex`, `base64` o `base64url`. **Métodos HMAC** `crypto.createHmac(algorithm, secret key)` Crea y devuelve un objeto HMAC que utiliza el `algorithm` y `secret key` dados. El algoritmo puede ser `md5`, `sha1` o `sha256`. `hmac.update(data)` Actualiza el contenido de HMAC con los dado `data`. `hmac.digest([encoding])` Calcula el resumen de todos los datos pasados con `hmac.update()`. La codificación puede ser `hex`, `base64` o `base64url`. ### Cadena de consulta **nota** El objeto [ de evento de CloudFront Functions ](functions-event-structure.md) analiza automáticamente las cadenas de consulta de URL. Eso significa que en la mayoría de los casos no necesita usar este módulo. El módulo de cadena de consulta (`querystring`) proporciona métodos para analizar y dar formato a las cadenas de consulta de URL. Puede cargar el módulo mediante `require('querystring')`. El módulo proporciona los siguientes métodos. `querystring.escape(string)` La URL codifica la `string` dada y devuelve una cadena de consulta escapada. El método es utilizado por `querystring.stringify()` y no debe utilizarse directamente. `querystring.parse(string[, separator[, equal[, options]]])` Analiza una cadena de consulta (`string`) y devuelve un objeto. El parámetro `separator` es una subcadena para delimitar pares de claves y valores en la cadena de consulta. De forma predeterminada, es `&`. El parámetro `equal` es una subcadena para delimitar claves y valores en la cadena de consulta. De forma predeterminada, es `=`. El parámetro `options` es un objeto con las siguientes claves: `decodeURIComponent function` Una función para decodificar caracteres codificados por porcentaje en la cadena de consulta. De forma predeterminada, es `querystring.unescape()`. `maxKeys number` El número máximo de claves que se analizan. De forma predeterminada, es `1000`. Utilice un valor de `0` para eliminar las limitaciones del recuento de claves. De forma predeterminada, se supone que los caracteres codificados con porcentaje dentro de la cadena de consulta utilizan la codificación UTF-8. Las secuencias UTF-8 no válidas se reemplazan por el carácter de reemplazo `U+FFFD`. Por ejemplo, para la siguiente cadena de consulta: ``` 'name=value&abc=xyz&abc=123' ``` El valor de retorno de `querystring.parse()` es: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` es un alias de `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serializa un `object` y devuelve una cadena de consulta. El parámetro `separator` es una subcadena para delimitar pares de claves y valores en la cadena de consulta. De forma predeterminada, es `&`. El parámetro `equal` es una subcadena para delimitar claves y valores en la cadena de consulta. De forma predeterminada, es `=`. El parámetro `options` es un objeto con las siguientes claves: `encodeURIComponent function` La función que se va a utilizar para convertir caracteres no seguros de URL a codificación porcentual en la cadena de consulta. De forma predeterminada, es `querystring.escape()`. De forma predeterminada, los caracteres que requieren codificación porcentual dentro de la cadena de consulta se codifican como UTF-8. Para utilizar una codificación diferente, especifique la opción `encodeURIComponent`. Por ejemplo, el siguiente código: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` El valor de retorno es: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` es un alias de `querystring.stringify()`. `querystring.unescape(string)` Decodifica caracteres codificados con porcentaje de URL en la `string` dada y devuelve una cadena de consulta sin escapar. Este método es utilizado por `querystring.parse()` y no debe utilizarse directamente. ## Características restringidas Las siguientes características de lenguaje JavaScript no se admiten o están restringidas debido a cuestiones de seguridad. **Evaluación dinámica de código** No se admite la evaluación dinámica de código. Si se intenta, los constructores `eval()` y `Function` arrojan un error. Por ejemplo, `const sum = new Function('a', 'b', 'return a + b')` arroja un error. **Temporizadores** No se admiten las funciones `setTimeout()`, `setImmediate()` y `clearTimeout()`. No hay nada para posponer o producir dentro de una ejecución de función. La función debe ejecutarse de manera sincrónica hasta finalizar. **Fecha y marcas temporales** Por razones de seguridad, no hay acceso a temporizadores de alta resolución. Todos los métodos `Date` para consultar la hora actual siempre devuelven el mismo valor durante la vida útil de una sola función ejecutada. La marca temporal devuelta es la hora en que la función comenzó a ejecutarse. Por eso, no puede medir el tiempo transcurrido en la función. **Acceso al sistema de archivos** No hay acceso al sistema de archivos. Por ejemplo, no hay ningún módulo `fs` para el acceso al sistema de archivos como lo hay en Node.js. **Acceso al proceso** No hay acceso al proceso. Por ejemplo, no hay ningún objeto global `process` para procesar el acceso a la información como lo hay en Node.js. **Variables de entorno** No hay acceso a las variables de entorno. En su lugar, puede utilizar CloudFront KeyValueStore para crear un almacén de datos centralizado de pares clave-valor para las CloudFront Functions. CloudFront KeyValueStore habilita las actualizaciones dinámicas de los datos de configuración sin necesidad de implementar cambios en el código. Debe utilizar el [tiempo de ejecución de JavaScript 2.0](functions-javascript-runtime-20.md) para utilizar CloudFront KeyValueStore. Para obtener más información, consulte [Amazon CloudFront KeyValueStore](kvs-with-functions.md). **Acceso a la red** No se admiten las llamadas de red. Por ejemplo, no se admite XHR, HTTP (S) ni socket. # Características del tiempo de ejecución 2.0 de JavaScript para CloudFront Functions El entorno de tiempo de ejecución JavaScript de CloudFront Functions es compatible con la [versión 5.1 de ECMAScript (ES)](https://262.ecma-international.org/5.1/) y también admite algunas características de las versiones 6 a 12 de ES. También proporciona algunos métodos no estándar que no forman parte de las especificaciones de ES. En los siguientes temas se enumeran todas las características admitidas en este tiempo de ejecución. **Topics** + [Características principales](#writing-functions-javascript-features-core-20) + [Objetos primitivos](#writing-functions-javascript-features-primitive-objects-20) + [Objetos integrados](#writing-functions-javascript-features-builtin-objects-20) + [Tipos de error](#writing-functions-javascript-features-error-types-20) + [Globals](#writing-functions-javascript-features-globals-20) + [Módulos integrados](#writing-functions-javascript-features-builtin-modules-20) + [Características restringidas](#writing-functions-javascript-features-restricted-features-20) ## Características principales Se admiten las siguientes características principales de ES. **Types** Se admiten todos los tipos de ES 5.1. Esto incluye valores booleanos, números, cadenas, objetos, matrices, funciones y expresiones regulares. **Operadores** Se admiten todos los operadores de ES 5.1. Se admite el operador de exponenciación ES 7 (`**`). **Instrucciones** Se admiten las siguientes instrucciones de ES 5.1: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `label` + `return` + `switch` + `throw` + `try` + `var` + `while` Se admiten las siguientes instrucciones de ES 6: + `const` + `let` Se admiten las siguientes instrucciones de ES 8: + `async` + `await` El tiempo de ejecución 2.0 de JavaScript admite `async`, `await`, `const` y `let`. `await` solo se puede usar dentro de funciones `async`. No se admiten argumentos ni cierres de `async`. **Literales** Se admiten literales de plantilla de ES 6: cadenas de líneas múltiples, interpolación de expresiones y plantillas de anidamiento. **Funciones** Se admiten todas las características de función de ES 5.1. Se admiten las funciones flecha de ES 6 así como la sintaxis del parámetro rest de ES 6. **Unicode** El texto de origen y los literales de cadena pueden contener caracteres codificados en Unicode. También se admiten secuencias de escape de punto de código Unicode de seis caracteres (por ejemplo, `\uXXXX`). **Modo estricto** Las funciones operan en modo estricto de forma predeterminada, por lo que no necesita agregar una instrucción `use strict` en su código de función. Esto no se puede cambiar. ## Objetos primitivos Se admiten los siguientes objetos primitivos de ES. **Objeto** Se admiten los siguientes métodos de ES 5.1 en objetos: + `Object.create()` (sin lista de propiedades) + `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()` Se admiten los siguientes métodos de ES 6 en objetos: + `Object.assign()` Se admiten los siguientes métodos de ES 8 en objetos: + `Object.entries()` + `Object.values()` Se admiten los siguientes métodos prototipo de ES 5.1 en objetos: + `Object.prototype.hasOwnProperty()` + `Object.prototype.isPrototypeOf()` + `Object.prototype.propertyIsEnumerable()` + `Object.prototype.toString()` + `Object.prototype.valueOf()` Se admiten los siguientes métodos prototipo de ES 6 en objetos: + `Object.prototype.is()` + `Object.prototype.setPrototypeOf()` **Cadena** Se admiten los siguientes métodos de ES 5.1 en cadenas: + `String.fromCharCode()` Se admiten los siguientes métodos de ES 6 en cadenas: + `String.fromCodePoint()` Se admiten los siguientes métodos prototipo de ES 5.1 en cadenas: + `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()` Se admiten los siguientes métodos prototipo de ES 6 en cadenas: + `String.prototype.codePointAt()` + `String.prototype.endsWith()` + `String.prototype.includes()` + `String.prototype.repeat()` + `String.prototype.startsWith()` Se admiten los siguientes métodos prototipo de ES 8 en cadenas: + `String.prototype.padStart()` + `String.prototype.padEnd()` Se admiten los siguientes métodos prototipo de ES 9 en cadenas: + `String.prototype.trimStart()` + `String.prototype.trimEnd()` Se admiten los siguientes métodos prototipo de ES 12 en cadenas: + `String.prototype.replaceAll()` **nota** `String.prototype.replaceAll()` es una novedad en el tiempo de ejecución 2.0 de JavaScript. **Número** Se admiten TODOS los números de ES 5. Se admiten las siguientes propiedades de ES 6 en números: + `Number.EPSILON` + `Number.MAX_SAFE_INTEGER` + `Number.MIN_SAFE_INTEGER` + `Number.MAX_VALUE` + `Number.MIN_VALUE` + `Number.NaN` + `Number.NEGATIVE_INFINITY` + `Number.POSITIVE_INFINITY` Se admiten los siguientes métodos de ES 6 en números: + `Number.isFinite()` + `Number.isInteger()` + `Number.isNaN()` + `Number.isSafeInteger()` + `Number.parseInt()` + `Number.parseFloat()` Se admiten los siguientes métodos prototipo de ES 5.1 en números: + `Number.prototype.toExponential()` + `Number.prototype.toFixed()` + `Number.prototype.toPrecision()` Se admiten los separadores numéricos ES 12. Los separadores numéricos ES 12 son nuevos en el tiempo de ejecución 2.0 de JavaScript. ## Objetos integrados Se admiten los siguientes objetos integrados de ES. **Math** Se admiten todos los métodos matemáticos de ES 5.1. En el entorno de tiempo de ejecución de CloudFront Functions, la implementación de `Math.random()` utiliza `arc4random` de OpenBSD predefinido con la marca de tiempo de cuándo se ejecuta la función. Se admiten las siguientes propiedades matemáticas de ES 6: + `Math.E` + `Math.LN10` + `Math.LN2` + `Math.LOG10E` + `Math.LOG2E` + `Math.PI` + `Math.SQRT1_2` + `Math.SQRT2` Se admiten los siguientes métodos matemáticos de ES 6: + `Math.abs()` + `Math.acos()` + `Math.acosh()` + `Math.asin()` + `Math.asinh()` + `Math.atan()` + `Math.atan2()` + `Math.atanh()` + `Math.cbrt()` + `Math.ceil()` + `Math.clz32()` + `Math.cos()` + `Math.cosh()` + `Math.exp()` + `Math.expm1()` + `Math.floor()` + `Math.fround()` + `Math.hypot()` + `Math.imul()` + `Math.log()` + `Math.log1p()` + `Math.log2()` + `Math.log10()` + `Math.max()` + `Math.min()` + `Math.pow()` + `Math.random()` + `Math.round()` + `Math.sign()` + `Math.sinh()` + `Math.sin()` + `Math.sqrt()` + `Math.tan()` + `Math.tanh()` + `Math.trunc()` **Fecha** Se admiten todas las características `Date` de ES 5.1. Por razones de seguridad, `Date` siempre devuelve el mismo valor (la hora de inicio de la función) durante la vida útil de la ejecución de una sola función. Para obtener más información, consulte [Características restringidas](functions-javascript-runtime-10.md#writing-functions-javascript-features-restricted-features). **Función** Se admiten los siguientes métodos prototipo de ES 5.1: + `Function.prototype.apply()` + `Function.prototype.bind()` + `Function.prototype.call()` Los constructores de funciones no son compatibles. **Expresiones regulares** Se admiten todas las características de expresión regular de ES 5.1. El lenguaje de expresión regular es compatible con Perl. Se admiten las siguientes características de acceso prototipo de ES 5.1: + `RegExp.prototype.global` + `RegExp.prototype.ignoreCase` + `RegExp.protoype.multiline` + `RegExp.protoype.source` + `RegExp.prototype.sticky` + `RegExp.prototype.flags` **nota** `RegExp.prototype.sticky` y `RegExp.prototype.flags` son novedades en el tiempo de ejecución 2.0 de JavaScript. Se admiten los siguientes métodos prototipo de ES 5.1: + `RegExp.prototype.exec()` + `RegExp.prototype.test()` + `RegExp.prototype.toString()` + `RegExp.prototype[@@replace]()` + `RegExp.prototype[@@split]()` **nota** `RegExp.prototype[@@split]()` es una novedad en el tiempo de ejecución 2.0 de JavaScript. Se admiten las siguientes propiedades de instancia de ES 5.1: + `lastIndex` Se admiten grupos de captura con nombre de ES 9. **JSON** Se admiten los siguientes métodos matemáticos de ES 5.1: + `JSON.parse()` + `JSON.stringify()` **Matriz** Se admiten los siguientes métodos de ES 5.1 en matrices: + `Array.isArray()` Se admiten los siguientes métodos de ES 6 en matrices: + `Array.of()` Se admiten los siguientes métodos prototipo de ES 5.1: + `Array.prototype.concat()` + `Array.prototype.every()` + `Array.prototype.filter()` + `Array.prototype.forEach()` + `Array.prototype.indexOf()` + `Array.prototype.join()` + `Array.prototype.lastIndexOf()` + `Array.prototype.map()` + `Array.prototype.pop()` + `Array.prototype.push()` + `Array.prototype.reduce()` + `Array.prototype.reduceRight()` + `Array.prototype.reverse()` + `Array.prototype.shift()` + `Array.prototype.slice()` + `Array.prototype.some()` + `Array.prototype.sort()` + `Array.prototype.splice()` + `Array.prototype.unshift()` Se admiten los siguientes métodos prototipo de ES 6 + `Array.prototype.copyWithin()` + `Array.prototype.fill()` + `Array.prototype.find()` + `Array.prototype.findIndex()` Se admiten los siguientes métodos prototipo de ES 7: + `Array.prototype.includes()` **Matrices con tipo** Se admiten los siguientes constructores de matrices con tipo de ES 6: + `Float32Array` + `Float64Array` + `Int8Array` + `Int16Array` + `Int32Array` + `Uint8Array` + `Uint8ClampedArray` + `Uint16Array` + `Uint32Array` Se admiten los siguientes métodos matemáticos de ES 6: + `TypedArray.from()` + `TypedArray.of()` **nota** `TypedArray.from()` y `TypedArray.of()` son novedades en el tiempo de ejecución 2.0 de JavaScript. Se admiten los siguientes métodos prototipo de ES 6: + `TypedArray.prototype.copyWithin()` + `TypedArray.prototype.every()` + `TypedArray.prototype.fill()` + `TypedArray.prototype.filter()` + `TypedArray.prototype.find()` + `TypedArray.prototype.findIndex()` + `TypedArray.prototype.forEach()` + `TypedArray.prototype.includes()` + `TypedArray.prototype.indexOf()` + `TypedArray.prototype.join()` + `TypedArray.prototype.lastIndexOf()` + `TypedArray.prototype.map()` + `TypedArray.prototype.reduce()` + `TypedArray.prototype.reduceRight()` + `TypedArray.prototype.reverse()` + `TypedArray.prototype.some()` + `TypedArray.prototype.set()` + `TypedArray.prototype.slice()` + `TypedArray.prototype.sort()` + `TypedArray.prototype.subarray()` + `TypedArray.prototype.toString()` **nota** `TypedArray.prototype.every()`, `TypedArray.prototype.fill()`, `TypedArray.prototype.filter()`, `TypedArray.prototype.find()`, `TypedArray.prototype.findIndex()`, `TypedArray.prototype.forEach()`, `TypedArray.prototype.includes()`, `TypedArray.prototype.indexOf()`, `TypedArray.prototype.join()`, `TypedArray.prototype.lastIndexOf()`,`TypedArray.prototype.map()`, `TypedArray.prototype.reduce()`, `TypedArray.prototype.reduceRight()`, `TypedArray.prototype.reverse()` y `TypedArray.prototype.some()` son novedades en el tiempo de ejecución 2.0 de JavaScript. **ArrayBuffer** Se admiten los siguientes métodos de ES 6 en ArrayBuffer: + `isView()` Se admiten los siguientes métodos prototipo de ES 6 en ArrayBuffer: + `ArrayBuffer.prototype.slice()` **Promesa** Se admiten los siguientes métodos de ES 6 en promesas: + `Promise.all()` + `Promise.allSettled()` + `Promise.any()` + `Promise.reject()` + `Promise.resolve()` + `Promise.race()` **nota** `Promise.all()`, `Promise.allSettled()`, `Promise.any()` y `Promise.race()` son novedades en el tiempo de ejecución 2.0 de JavaScript. Se admiten los siguientes métodos prototipos de ES 6 en promesas: + `Promise.prototype.catch()` + `Promise.prototype.finally()` + `Promise.prototype.then()` **DataView** Se admiten los siguientes métodos prototipo de ES 6: + `DataView.prototype.getFloat32()` + `DataView.prototype.getFloat64()` + `DataView.prototype.getInt16()` + `DataView.prototype.getInt32()` + `DataView.prototype.getInt8()` + `DataView.prototype.getUint16()` + `DataView.prototype.getUint32()` + `DataView.prototype.getUint8()` + `DataView.prototype.setFloat32()` + `DataView.prototype.setFloat64()` + `DataView.prototype.setInt16()` + `DataView.prototype.setInt32()` + `DataView.prototype.setInt8()` + `DataView.prototype.setUint16()` + `DataView.prototype.setUint32()` + `DataView.prototype.setUint8()` **nota** Todos los métodos prototipo de DataView ES 6 son nuevos en el tiempo de ejecución 2.0 de JavaScript. **Símbolo** Se admiten los siguientes métodos matemáticos de ES 6: + `Symbol.for()` + `Symbol.keyfor()` **nota** Todos los métodos de ES 6 de símbolos son nuevos en el tiempo de ejecución 2.0 de JavaScript. **Descodificador de texto** Se admiten los siguientes métodos prototipo: + `TextDecoder.prototype.decode()` Se admiten las siguientes propiedades de acceso prototipo: + `TextDecoder.prototype.encoding` + `TextDecoder.prototype.fatal` + `TextDecoder.prototype.ignoreBOM` **Codificador de texto** Se admiten los siguientes métodos prototipo: + `TextEncoder.prototype.encode()` + `TextEncoder.prototype.encodeInto()` ## Tipos de error Se admiten los siguientes objetos de error: + `Error` + `EvalError` + `InternalError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Globals Se admite el objeto `globalThis`. Se admiten las siguientes características globales de ES 5.1: + `decodeURI()` + `decodeURIComponent()` + `encodeURI()` + `encodeURIComponent()` + `isFinite()` + `isNaN()` + `parseFloat()` + `parseInt()` Se admiten las siguientes características globales de ES 6: + `atob()` + `btoa()` **nota** `atob()` y `btoa()` son novedades en el tiempo de ejecución 2.0 de JavaScript. Se admiten las siguientes constantes globales: + `NaN` + `Infinity` + `undefined` + `arguments` ## Módulos integrados Se admiten los siguientes módulos integrados: **Topics** + [Búfer](#writing-functions-javascript-features-builtin-modules-buffer-20) + [Cadena de consulta](#writing-functions-javascript-features-builtin-modules-query-string-20) + [Cripto](#writing-functions-javascript-features-builtin-modules-crypto-20) ### Búfer El módulo proporciona los siguientes métodos: + `Buffer.alloc(size[, fill[, encoding]])` Asignación de un `Buffer`. + `size`: tamaño del búfer. Introduzca un número entero. + `fill`: opcional. Introduzca una cadena, `Buffer`, Uint8Array o entero. El valor predeterminado es `0`. + `encoding`: opcional. Si `fill` es una cadena, introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `Buffer.allocUnsafe(size)` Asigne un valor no inicializado `Buffer`. + `size`: introduzca un número entero. + `Buffer.byteLength(value[, encoding])` Devuelve la longitud de un valor, en bytes. + `value`: una cadena, `Buffer`, TypedArray, Dataview o Arraybuffer. + `encoding`: opcional. Si `value` es una cadena, introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `Buffer.compare(buffer1, buffer2)` Compare dos `Buffer` para ayudar a ordenar las matrices. Devuelve `0` si son iguales, `-1` si `buffer1` aparece primero o `1` si `buffer2` aparece primero. + `buffer1`: introduzca un `Buffer`. + `buffer2`: introduzca un `Buffer` diferente. + `Buffer.concat(list[, totalLength])` Concatenar varios `Buffer`. Devuelve `0` si no hay ninguno. Devuelve hasta `totalLength`. + `list`: introduzca una lista de `Buffer`. Tenga en cuenta que esto se truncará a `totalLength`. + `totalLength`: opcional. Introduzca un número entero sin signo. Utilice la suma de las instancias de `Buffer` de la lista si está en blanco. + `Buffer.from(array)` Cree un `Buffer` a partir de una matriz. + `array`: introduzca una matriz de bytes de `0` a `255`. + `Buffer.from(arrayBuffer, byteOffset[, length]))` Cree una vista desde `arrayBuffer`, empezando por el desfase `byteOffset` con la longitud `length`. + `arrayBuffer`: introduzca una matriz de `Buffer`. + `byteOffset`: introduzca un número entero. + `length`: opcional. Introduzca un número entero. + `Buffer.from(buffer)` Cree una copia del `Buffer`. + `buffer`: introduzca un `Buffer`. + `Buffer.from(object[, offsetOrEncoding[, length]])` Cree un `Buffer` a partir de un objeto. Devuelve `Buffer.from(object.valueOf(), offsetOrEncoding, length)` si `valueOf()` no es igual al objeto. + `object`: introduzca un objeto. + `offsetOrEncoding`: opcional. Introduzca un número entero o una cadena de codificación. + `length`: opcional. Introduzca un número entero. + `Buffer.from(string[, encoding])` Cree un `Buffer` a partir de una cadena. + `string`: introduzca una cadena. + `encoding`: opcional. Introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `Buffer.isBuffer(object)` Compruebe si `object` es un búfer. Devuelve `true` o `false`. + `object`: introduzca un objeto. + `Buffer.isEncoding(encoding)` Compruebe si `encoding` es compatible. Devuelve `true` o `false`. + `encoding`: opcional. Introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. El módulo proporciona los siguientes métodos de prototipo de búfer. + `Buffer.prototype.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])` Compare `Buffer` con el objetivo. Devuelve `0` si son iguales, `1` si `buffer` aparece primero o `-1` si `target` aparece primero. + `target`: introduzca un `Buffer`. + `targetStart`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `targetEnd`: opcional. Introduzca un número entero. El valor predeterminado es la longitud del `target`. + `sourceStart`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `sourceEnd`: opcional. Introduzca un número entero. El valor predeterminado es la longitud del `Buffer`. + `Buffer.prototype.copy(target[, targetStart[, sourceStart[, sourceEnd]]])` Copie el búfer a `target`. + `target`: introduzca un `Buffer` o una `Uint8Array`. + `targetStart`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `sourceStart`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `sourceEnd`: opcional. Introduzca un número entero. El valor predeterminado es la longitud del `Buffer`. + `Buffer.prototype.equals(otherBuffer)` Compare `Buffer` con `otherBuffer`. Devuelve `true` o `false`. + `otherBuffer`: introduzca una cadena. + `Buffer.prototype.fill(value[, offset[, end][, encoding])` Rellene `Buffer` con `value`. + `value`: introduzca una cadena, un `Buffer` o un número entero. + `offset`: opcional. Introduzca un número entero. + `end`: opcional. Introduzca un número entero. + `encoding`: opcional. Introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `Buffer.prototype.includes(value[, byteOffset][, encoding])` Busque `value` en `Buffer`. Devuelve `true` o `false`. + `value`: introduzca una cadena, `Buffer`, `Uint8Array` o un número entero. + `byteOffset`: opcional. Introduzca un número entero. + `encoding`: opcional. Introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `Buffer.prototype.indexOf(value[, byteOffset][, encoding])` Busque el primer `value` en el `Buffer`. Devuelve `index` si se encuentra; devuelve `-1` si no se encuentra. + `value`: introduzca una cadena, `Buffer`, Unit8Array o un número entero comprendido entre 0 y 255. + `byteOffset`: opcional. Introduzca un número entero. + `encoding`: opcional. Introduzca una de las siguientes opciones si `value` es una cadena: `utf8`, `hex`, `base64`, `base64url`. El valor predeterminado es `utf8`. + `Buffer.prototype.lastIndexOf(value[, byteOffset][, encoding])` Busque el último `value` en el `Buffer`. Devuelve `index` si se encuentra; devuelve `-1` si no se encuentra. + `value`: introduzca una cadena, `Buffer`, Unit8Array o un número entero comprendido entre 0 y 255. + `byteOffset`: opcional. Introduzca un número entero. + `encoding`: opcional. Introduzca una de las siguientes opciones si `value` es una cadena: `utf8`, `hex`, `base64`, `base64url`. El valor predeterminado es `utf8`. + `Buffer.prototype.readInt8(offset)` Lea `Int8` en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readIntBE(offset, byteLength)` Lea el `Int` como big-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `byteLength`: opcional. Introduzca un número entero comprendido entre `1` y `6`. + `Buffer.prototype.readInt16BE(offset)` Lea el `Int16` como big-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readInt32BE(offset)` Lea el `Int32` como big-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readIntLE(offset, byteLength)` Lea el `Int` como little-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.readInt16LE(offset)` Lea el `Int16` como little-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readInt32LE(offset)` Lea el `Int32` como little-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readUInt8(offset)` Lea `UInt8` en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readUIntBE(offset, byteLength)` Lea el `UInt` como big-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.readUInt16BE(offset)` Lea el `UInt16` como big-endian en `offset` desde `Buffer`. + + `offset`: introduzca un número entero. + `Buffer.prototype.readUInt32BE(offset)` Lea el `UInt32` como big-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readUIntLE(offset, byteLength)` Lea el `UInt` como little-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.readUInt16LE(offset)` Lea el `UInt16` como little-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readUInt32LE(offset)` Lea el `UInt32` como little-endian en `offset` desde `Buffer`. + `offset`: introduzca un número entero. + `Buffer.prototype.readDoubleBE([offset])` Lea un doble de 64 bits como big-endian en `offset` desde `Buffer`. + `offset`: opcional. Introduzca un número entero. + `Buffer.prototype.readDoubleLE([offset])` Lea un doble de 64 bits como little-endian en `offset` desde `Buffer`. + `offset`: opcional. Introduzca un número entero. + `Buffer.prototype.readFloatBE([offset])` Lea un flotante de 32 bits como big-endian en `offset` desde `Buffer`. + `offset`: opcional. Introduzca un número entero. + `Buffer.prototype.readFloatLE([offset])` Lea un flotante de 32 bits como little-endian en `offset` desde `Buffer`. + `offset`: opcional. Introduzca un número entero. + `Buffer.prototype.subarray([start[, end]])` Devuelve una copia de `Buffer` desplazada y recortada con un nuevo `start` y `end`. + `start`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `end`: opcional. Introduzca un número entero. El valor predeterminado es la longitud del búfer. + `Buffer.prototype.swap16()` Cambie el orden de los bytes de la matriz del `Buffer`, tratándolo como una matriz de números de 16 bits. La longitud de `Buffer` debe ser divisible entre 2 o recibirá un error. + `Buffer.prototype.swap32()` Cambie el orden de los bytes de la matriz del `Buffer`, tratándolo como una matriz de números de 32 bits. La longitud de `Buffer` debe ser divisible entre 4 o recibirá un error. + `Buffer.prototype.swap64()` Cambie el orden de los bytes de la matriz del `Buffer`, tratándolo como una matriz de números de 64 bits. La longitud de `Buffer` debe ser divisible entre 8 o recibirá un error. + `Buffer.prototype.toJSON()` Devuelve `Buffer` como JSON. + `Buffer.prototype.toString([encoding[, start[, end]]])` Convierte `Buffer`, de `start` a `end`, en una cadena codificada. + `encoding`: opcional. Introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `start`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `end`: opcional. Introduzca un número entero. El valor predeterminado es la longitud del búfer. + `Buffer.prototype.write(string[, offset[, length]][, encoding])` Escribe codificada la `string` en el `Buffer` si hay espacio, o una `string` truncada si no hay suficiente espacio. + `string`: introduzca una cadena. + `offset`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `length`: opcional. Introduzca un número entero. El valor predeterminado es la longitud de la cadena. + `encoding`: opcional. Si lo desea, introduzca una de las siguientes opciones: `utf8`, `hex`, `base64` o `base64url`. El valor predeterminado es `utf8`. + `Buffer.prototype.writeInt8(value, offset, byteLength)` Escriba el `Int8` `value` de la `byteLength` en `offset` en `Buffer`. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeIntBE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeInt16BE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeInt32BE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeIntLE(offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `offset`: introduzca un número entero. + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeInt16LE(offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `offset`: introduzca un número entero. + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeInt32LE(offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `offset`: introduzca un número entero. + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUInt8(value, offset, byteLength)` Escriba el `UInt8` `value` de la `byteLength` en `offset` en `Buffer`. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUIntBE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUInt16BE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUInt32BE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUIntLE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUInt16LE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeUInt32LE(value, offset, byteLength)` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `value`: introduzca un número entero. + `offset`: introduzca un número entero + `byteLength`: introduzca un número entero entre `1` y `6`. + `Buffer.prototype.writeDoubleBE(value, [offset])` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `Buffer.prototype.writeDoubleLE(value, [offset])` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `value`: introduzca un número entero. + `offset`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `Buffer.prototype.writeFloatBE(value, [offset])` Escriba un `value` en `offset` para el `Buffer`, usando big-endian. + `value`: introduzca un número entero. + `offset`: opcional. Introduzca un número entero. El valor predeterminado es 0. + `Buffer.prototype.writeFloatLE(value, [offset])` Escriba un `value` en `offset` para el `Buffer`, usando little-endian. + `value`: introduzca un número entero. + `offset`: opcional. Introduzca un número entero. El valor predeterminado es 0. Se admiten los siguientes métodos de instancia: + `buffer[index]` Obtenga y establezca el octeto (byte) en `index` en `Buffer`. + Obtenga un número de `0` a `255`. O establezca un número de `0` a `255`. Se admiten las siguientes propiedades de instancia: + `buffer` Obtenga el objeto `ArrayBuffer` para el búfer. + `byteOffset` Obtenga el `byteOffset` del objeto `Arraybuffer` del búfer. + `length` Obtenga el recuento de bytes del búfer. **nota** Todos los métodos del módulo del búfer son nuevos en el tiempo de ejecución 2.0 de JavaScript. ### Cadena de consulta **nota** El objeto [ de evento de CloudFront Functions ](functions-event-structure.md) analiza automáticamente las cadenas de consulta de URL. Eso significa que en la mayoría de los casos no necesita usar este módulo. El módulo de cadena de consulta (`querystring`) proporciona métodos para analizar y dar formato a las cadenas de consulta de URL. Puede cargar el módulo mediante `require('querystring')`. El módulo proporciona los siguientes métodos. `querystring.escape(string)` La URL codifica la `string` dada y devuelve una cadena de consulta escapada. El método es utilizado por `querystring.stringify()` y no debe utilizarse directamente. `querystring.parse(string[, separator[, equal[, options]]])` Analiza una cadena de consulta (`string`) y devuelve un objeto. El parámetro `separator` es una subcadena para delimitar pares de claves y valores en la cadena de consulta. De forma predeterminada, es `&`. El parámetro `equal` es una subcadena para delimitar claves y valores en la cadena de consulta. De forma predeterminada, es `=`. El parámetro `options` es un objeto con las siguientes claves: `decodeURIComponent function` Una función para decodificar caracteres codificados por porcentaje en la cadena de consulta. De forma predeterminada, es `querystring.unescape()`. `maxKeys number` El número máximo de claves que se analizan. De forma predeterminada, es `1000`. Utilice un valor de `0` para eliminar las limitaciones del recuento de claves. De forma predeterminada, se supone que los caracteres codificados con porcentaje dentro de la cadena de consulta utilizan la codificación UTF-8. Las secuencias UTF-8 no válidas se reemplazan por el carácter de reemplazo `U+FFFD`. Por ejemplo, para la siguiente cadena de consulta: ``` 'name=value&abc=xyz&abc=123' ``` El valor de retorno de `querystring.parse()` es: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` es un alias de `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serializa un `object` y devuelve una cadena de consulta. El parámetro `separator` es una subcadena para delimitar pares de claves y valores en la cadena de consulta. De forma predeterminada, es `&`. El parámetro `equal` es una subcadena para delimitar claves y valores en la cadena de consulta. De forma predeterminada, es `=`. El parámetro `options` es un objeto con las siguientes claves: `encodeURIComponent function` La función que se va a utilizar para convertir caracteres no seguros de URL a codificación porcentual en la cadena de consulta. De forma predeterminada, es `querystring.escape()`. De forma predeterminada, los caracteres que requieren codificación porcentual dentro de la cadena de consulta se codifican como UTF-8. Para utilizar una codificación diferente, especifique la opción `encodeURIComponent`. Por ejemplo, el siguiente código: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` El valor de retorno es: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` es un alias de `querystring.stringify()`. `querystring.unescape(string)` Decodifica caracteres codificados con porcentaje de URL en la `string` dada y devuelve una cadena de consulta sin escapar. Este método es utilizado por `querystring.parse()` y no debe utilizarse directamente. ### Cripto El módulo criptográfico (`crypto`) proporciona ayudantes de código de autenticación de mensajes basado en hash (HMAC) y hashing estándar. Puede cargar el módulo mediante `require('crypto')`. **Métodos de hashing** `crypto.createHash(algorithm)` Crea y devuelve un objeto hash que puede utilizar para generar resúmenes hash mediante el algoritmo dado: `md5`, `sha1` o `sha256`. `hash.update(data)` Actualiza el contenido hash con los dado `data`. `hash.digest([encoding])` Calcula el resumen de todos los datos pasados con `hash.update()`. La codificación puede ser `hex`, `base64` o `base64url`. **Métodos HMAC** `crypto.createHmac(algorithm, secret key)` Crea y devuelve un objeto HMAC que utiliza el `algorithm` y `secret key` dados. El algoritmo puede ser `md5`, `sha1` o `sha256`. `hmac.update(data)` Actualiza el contenido de HMAC con los dado `data`. `hmac.digest([encoding])` Calcula el resumen de todos los datos pasados con `hmac.update()`. La codificación puede ser `hex`, `base64` o `base64url`. ## Características restringidas Las siguientes características de lenguaje JavaScript no se admiten o están restringidas debido a cuestiones de seguridad. **Evaluación dinámica de código** No se admite la evaluación dinámica de código. Si se intenta, los constructores `eval()` y `Function` arrojan un error. Por ejemplo, `const sum = new Function('a', 'b', 'return a + b')` arroja un error. **Temporizadores** No se admiten las funciones `setTimeout()`, `setImmediate()` y `clearTimeout()`. No hay nada para posponer o producir dentro de una ejecución de función. La función debe ejecutarse de manera sincrónica hasta finalizar. **Fecha y marcas temporales** Por razones de seguridad, no hay acceso a temporizadores de alta resolución. Todos los métodos `Date` para consultar la hora actual siempre devuelven el mismo valor durante la vida útil de una sola función ejecutada. La marca temporal devuelta es la hora en que la función comenzó a ejecutarse. Por eso, no puede medir el tiempo transcurrido en la función. **Acceso al sistema de archivos** No hay acceso al sistema de archivos. Por ejemplo, no hay ningún módulo `fs` para el acceso al sistema de archivos como lo hay en Node.js. **Acceso al proceso** No hay acceso al proceso. Por ejemplo, no hay ningún objeto global `process` para procesar el acceso a la información como lo hay en Node.js. **Variables de entorno** No hay acceso a las variables de entorno. En su lugar, puede utilizar CloudFront KeyValueStore para crear un almacén de datos centralizado de pares clave-valor para las CloudFront Functions. CloudFront KeyValueStore habilita las actualizaciones dinámicas de los datos de configuración sin necesidad de implementar cambios en el código. Para obtener más información, consulte [Amazon CloudFront KeyValueStore](kvs-with-functions.md). **Acceso a la red** No se admiten las llamadas de red. Por ejemplo, no se admite XHR, HTTP (S) ni socket. # Métodos auxiliares para almacenes de clave-valor **nota** Las llamadas de métodos auxiliares del almacén de valores de claves desde CloudFront Functions no desencadenan un evento de datos de AWS CloudTrail. Estos eventos no se registran en el historial de eventos de CloudTrail. Para obtener más información, consulte [Registro de llamadas a la API de Amazon CloudFront con AWS CloudTrail](logging_using_cloudtrail.md). Esta sección se aplica si utiliza el [Almacén de clave-valor de CloudFront](kvs-with-functions.md) para incluir claves-valores en la función que cree. CloudFront Functions tiene un módulo que proporciona tres métodos auxiliares para leer valores del almacén de clave-valor. Para utilizar este módulo en el código de la función, asegúrese de haber [asociado un almacén de clave-valor](kvs-with-functions-associate.md) a la función. A continuación, incluya las siguientes instrucciones en las primeras líneas del código de la función: ``` import cf from 'cloudfront'; const kvsHandle = cf.kvs(); ``` ## `get()`Método de Utilice este método para devolver el valor de clave del nombre de clave que especifique. **Solicitud** ``` get("key", options); ``` + `key`: el nombre de la clave cuyo valor desea recuperar + `options`: hay una opción, `format`. Garantiza que la función analice correctamente los datos. Valores posibles: + `string`: (predeterminado) codificado en UTF8 + `json` + `bytes`: búfer de datos binarios sin procesar **Ejemplo de solicitud** ``` const value = await kvsHandle.get("myFunctionKey", { format: "string"}); ``` **Respuesta** La respuesta es una `promise` que se resuelve en un valor en el formato solicitado mediante el uso de `options`. De forma predeterminada, el valor se devuelve como una cadena. ### Gestión de errores El método `get()` devolverá un error cuando la clave que ha solicitado no exista en el almacén de clave-valor asociado. Para administrar este caso de uso, puede agregar un bloque `try` y `catch` al código. **aviso** El uso de combinadores de promesas (por ejemplo, `Promise.all`, `Promise.any`) y métodos de cadena de promesas (por ejemplo, `then` y `catch`) puede requerir un uso elevado de la memoria de la función. Si la función supera la cuota de [memoria máxima de la función](cloudfront-limits.md#limits-functions), no se ejecutará. Para evitar este error, le recomendamos que utilice la sintaxis `await` de forma secuencial o en bucles para solicitar varios valores. **Ejemplo** ``` var value1 = await kvs.get('key1'); var value2 = await kvs.get('key2'); ``` Actualmente, el uso de combinadores de promesas para obtener varios valores no mejorará el rendimiento, como en el siguiente ejemplo. ``` var values = await Promise.all([kvs.get('key1'), kvs.get('key2'),]); ``` ## `exists()`Método de Utilice este método para identificar si la clave existe o no en el almacén de clave-valor. **Solicitud** ``` exists("key"); ``` **Ejemplo de solicitud** ``` const exist = await kvsHandle.exists("myFunctionkey"); ``` **Respuesta** La respuesta es una `promise` que devuelve un valor booleano (`true` o `false`). Este valor especifica si la clave existe o no en el almacén de clave-valor. ## `meta()`Método de Utilice este método para devolver metadatos sobre el almacén de clave-valor. **Solicitud** ``` meta(); ``` **Ejemplo de solicitud** ``` const meta = await kvsHandle.meta(); ``` **Respuesta** La respuesta es una `promise` que se resuelve en un objeto con las siguientes propiedades: + `creationDateTime`: la fecha y hora en formato ISO 8601 de creación del almacén de clave-valor. + `lastUpdatedDateTime`: la fecha y hora en formato ISO 8601 de última sincronización del almacén de clave-valor desde el origen. El valor no incluye el tiempo de propagación hasta la periferia. + `keyCount`: el número total de claves del KVS tras la última sincronización desde el origen. **Ejemplo de respuesta** ``` {keyCount:3,creationDateTime:2023-11-30T23:07:55.765Z,lastUpdatedDateTime:2023-12-15T03:57:52.411Z} ``` # Métodos auxiliares para la modificación del origen Esta sección se aplica si actualiza o cambia dinámicamente el origen utilizado en la solicitud dentro del código de CloudFront Functions. Solo puede actualizar el origen cuando el *espectador solicite* CloudFront Functions. CloudFront Functions tiene un módulo que proporciona métodos auxiliares para actualizar o cambiar el origen de forma dinámica. Para usar este módulo, cree una función de CloudFront con tiempo de ejecución 2.0 de JavaScript e incluya la siguiente instrucción en la primera línea del código de la función: ``` import cf from 'cloudfront'; ``` Para obtener más información, consulte [Características del tiempo de ejecución 2.0 de JavaScript para CloudFront Functions](functions-javascript-runtime-20.md). **nota** Las páginas de la API de pruebas y la consola de pruebas no comprueban si se ha producido una modificación del origen. Sin embargo, las pruebas garantizan que el código de la función se ejecute sin errores. ## Elección entre CloudFront Functions y Lambda@Edge Puede actualizar sus orígenes mediante CloudFront Functions o Lambda@Edge. Cuando se utiliza CloudFront Functions para actualizar los orígenes, se utiliza el desencadenador de eventos de *solicitud del espectador*, lo que significa que esta lógica se ejecutará en todas las solicitudes cuando se utilice esta función. Cuando se utiliza Lambda@Edge, las funciones de actualización del origen se encuentran en el desencadenador de eventos de *solicitud de origen*, lo que significa que esta lógica solo se ejecuta cuando se pierde memoria caché. La elección depende en gran medida de la carga de trabajo y del uso actual de CloudFront Functions y Lambda@Edge en sus distribuciones. Las siguientes consideraciones pueden ayudarlo a decidir si debe utilizar CloudFront Functions o Lambda@Edge para actualizar sus orígenes. CloudFront Functions es más útil en las siguientes situaciones: + Cuando sus solicitudes son dinámicas (es decir, no se pueden almacenar en caché) y siempre van al origen. CloudFront Functions ofrece un mejor rendimiento y un coste total más bajo. + Si tiene una función de CloudFront de solicitud de espectador existente que se ejecutará en cada solicitud, puede añadir la lógica de actualización del origen a la función existente. Para usar CloudFront Functions para actualizar los orígenes, consulte los métodos auxiliares en los temas siguientes. Lambda@Edge es más útil en las siguientes situaciones: + Cuando tiene contenido que se puede almacenar en caché con gran frecuencia, Lambda@Edge puede ser más rentable, ya que solo se ejecuta cuando se pierde memoria caché, mientras que CloudFront Functions se ejecuta en todas las solicitudes. + Si tiene una función de Lambda@Edge de solicitud de origen existente, puede añadir la lógica de actualización del origen a la función existente. + Cuando la lógica de actualización de origen requiere obtener datos de orígenes de datos de terceros, como Amazon DynamoDB o Amazon S3. Para obtener más información sobre Lambda@Edge, consulte [Personalización en la periferia con Lambda@Edge](lambda-at-the-edge.md). ## Método updateRequestOrigin() Use el método `updateRequestOrigin()` para actualizar la configuración de origen de una solicitud. Puede usar este método para actualizar las propiedades de origen existentes para los orígenes que ya están definidos en su distribución o para definir un nuevo origen para la solicitud. Para ello, especifique las propiedades que desea cambiar. **importante** Cualquier configuración que no especifique en `updateRequestOrigin()` heredará la *misma configuración* de la configuración del origen existente. El origen establecido por el método `updateRequestOrigin()` puede ser cualquier punto de conexión HTTP y no es necesario que sea un origen existente en la distribución de CloudFront. **Notas** Si está actualizando un origen que forma parte de un grupo de origen, solo se actualiza el *origen principal* del grupo de origen. El origen secundario no cambia. Cualquier código de respuesta del origen modificado que coincida con los criterios de conmutación por error desencadenará una conmutación por error al origen secundario. Si va a cambiar el tipo de origen y tiene habilitado el OAC, asegúrese de que el tipo de origen en `originAccessControlConfig` coincida con el nuevo tipo de origen. No puede usar el método `updateRequestOrigin()` para actualizar los [orígenes de la VPC](private-content-vpc-origins.md). Se producirá un error en la solicitud. **Solicitud** ``` updateRequestOrigin({origin properties}) ``` Las `origin properties` pueden incluir lo siguiente: **domainName (opcional)** El nombre de dominio del origen. Si no se proporciona, se utiliza en su lugar el nombre de dominio del origen asignado. **Para orígenes personalizados** Especifique un nombre de dominio DNS, como `www.example.com`. El nombre de dominio no puede incluir dos puntos (`:`) ni puede ser una dirección IP. El nombre de dominio puede tener una longitud de hasta 253 caracteres. **Para orígenes de S3** Especifique el nombre de dominio DNS del bucket de Amazon S3, como `amzn-s3-demo-bucket.s3.eu-west-1.amazonaws.com`. El nombre puede tener una longitud de hasta 128 caracteres y debe escribirse en letras minúsculas. **hostHeader (opcional, para orígenes personalizados que no sean de S3)** El encabezado del host que se utilizará al realizar la solicitud al origen. Si no se proporciona, se utiliza el valor del parámetro domainName. Si no se proporciona ningún parámetro de encabezado de host ni de nombre de dominio, se utiliza el nombre de dominio del origen asignado o el encabezado de host de la solicitud entrante si la política de reenvío al origen (FTO) incluye el host. El encabezado del host no puede incluir dos puntos (`:`) ni puede ser una dirección IP. El encabezado del host puede tener una longitud de hasta 253 caracteres. **originPath (opcional)** La ruta de directorio del servidor donde la solicitud debería encontrar el contenido. La ruta debe comenzar con una barra diagonal (/), pero no debe terminar con una. Por ejemplo, no debería terminar con `example-path/`. Si no se proporciona, se utiliza la ruta de origen del origen asignado. **Para orígenes personalizados** La ruta debe estar codificada en URL y tener una longitud máxima de 255 caracteres. **customHeaders (opcional)** Si desea incluir encabezados personalizados con la solicitud, especifique un nombre de encabezado y un par de valores para cada uno de ellos. El formato es diferente al de los encabezados de solicitud y respuesta de la estructura de eventos. Use la siguiente sintaxis de pares clave-valor: ``` {"key1": "value1", "key2": "value2", ...} ``` No puede agregar encabezados que no estén permitidos y un encabezado con el mismo nombre tampoco puede estar presente en la solicitud entrante `headers`. El nombre del encabezado debe estar en minúsculas en el código de la función. Cuando CloudFront Functions convierte el objeto de evento de nuevo en una solicitud HTTP, la primera letra de cada palabra en los nombres de encabezados se escribe en mayúsculas, y las palabras se separan con guiones. Por ejemplo, si el código de la función agrega un encabezado llamado `example-header-name`, CloudFront lo convierte en `Example-Header-Name` en la solicitud HTTP. Para obtener más información, consulte [Encabezados personalizados que CloudFront no puede agregar a solicitudes de origen](add-origin-custom-headers.md#add-origin-custom-headers-denylist) y [Restricciones en funciones de borde](edge-functions-restrictions.md). Si no se proporciona, se utilizará cualquier encabezado personalizado del origen asignado. **connectionAttempts (opcional)** El número de veces que CloudFront intenta conectarse al origen. El valor mínimo es 1 y el máximo, 3. Si no se proporciona, se utilizarán los intentos de conexión del origen asignado. **originShield (opcional)** Esto habilita o actualiza Origin Shield de CloudFront. El uso de Origin Shield puede ayudar a reducir la carga en el origen. Para obtener más información, consulte [Uso de Amazon CloudFront Origin Shield](origin-shield.md). Si no se proporciona, se utiliza la configuración de Origin Shield del origen asignado. **enabled (obligatorio)** Expresión booleana para activar o desactivar Origin Shield. Acepta un valor `true` o `false`. **region (obligatorio cuando está habilitado)** La Región de AWS para Origin Shield. Especifique la Región de AWS que tiene la latencia más baja en su origen. Use el código de la región, no el nombre de la región. Por ejemplo, use `us-east-2` para especificar la región Este de EE. UU. (Ohio). Cuando habilite Origin Shield de CloudFront, debe especificar la Región de AWS para Origin Shield. Para ver una lista de las Regiones de AWS disponibles y ayudarlo a elegir la mejor región para su origen, consulte [Elección de la región de AWS para Origin Shield](origin-shield.md#choose-origin-shield-region). **originAccessControlConfig (opcional)** El identificador único de un control de acceso de origen (OAC) para este origen. Esto solo se usa cuando el origen admite un OAC de CloudFront, como Amazon S3, las URL de funciones de Lambda, MediaStore y MediaPackage V2. Si no se proporciona, se utiliza la configuración de OAC del origen asignado. Esto no admite la identidad de acceso de origen (OAI) heredada. Para obtener más información, consulte [Restricción del acceso a un origen de AWS](private-content-restricting-access-to-origin.md). **enabled (obligatorio)** Expresión booleana para activar o desactivar OAC. Acepta un valor `true` o `false`. **signingBehavior (obligatorio cuando está habilitado)** Especifica qué solicitudes firma CloudFront (agrega información de autenticación). Especifique `always` para el caso de uso más común. Para obtener más información, consulte [Configuración avanzada para el control de acceso de origen](private-content-restricting-access-to-s3.md#oac-advanced-settings-s3). Este campo puede tener uno de los siguientes valores: + `always`: CloudFront firma todas las solicitudes de origen y sobrescribe el encabezado `Authorization` de la solicitud del lector, si existe. + `never`: CloudFront no firma ninguna solicitud de origen. Este valor desactiva el control de acceso de origen para el origen. + `no-override`: si la solicitud del espectador no contiene el encabezado `Authorization`, CloudFront firma la solicitud de origen. Si la solicitud del espectador contiene el encabezado `Authorization`, CloudFront no firma la solicitud de origen y, en cambio, pasa el encabezado `Authorization` de la solicitud del espectador. **aviso** Para pasar el encabezado `Authorization` de la solicitud del espectador, debe agregarlo a una política de solicitud de origen para todos los comportamientos de caché que utilizan los orígenes asociados a este control de acceso de origen. Para obtener más información, consulte [Control de las solicitudes de origen con una política](controlling-origin-requests.md). **signingProtocol (obligatorio cuando está habilitado)** El protocolo de firma del OAC, que determina cómo CloudFront firma (autentica) las solicitudes. El único valor válido es `sigv4`. **originType (obligatorio cuando está habilitado)** El tipo de origen de este OAC. Los valores válidos son `s3`, `mediapackagev2`, `mediastore` y `lambda`. **timeouts (opcional)** Tiempos de espera en los que puede especificar durante cuánto tiempo CloudFront debe intentar esperar a que los orígenes respondan o envíen datos. Si no se proporciona, se utiliza la configuración de tiempo de espera del origen asignado. A menos que se especifique lo contrario, estos tiempos de espera son compatibles tanto con orígenes personalizados como con orígenes de Amazon S3. **readTimeout (opcional)** `readTimeout` se aplica a los dos valores siguientes: + Tiempo (en segundos) que CloudFront espera una respuesta después de enviar una solicitud al origen. + Tiempo (en segundos) que CloudFront espera después de recibir el paquete de una respuesta desde el origen y antes de recibir el paquete siguiente. El tiempo de espera mínimo es 1 segundo; el máximo es 120 segundos. Para obtener más información, consulte [Tiempo de espera de respuesta](DownloadDistValuesOrigin.md#DownloadDistValuesOriginResponseTimeout). **responseCompletionTimeout (opcional)** El tiempo (en segundos) que una solicitud de CloudFront al origen puede permanecer abierta y esperar una respuesta. Si en ese tiempo no se recibe la respuesta completa del origen, CloudFront finaliza la conexión. El valor de `responseCompletionTimeout` debe ser igual o mayor que el valor para `readTimeout`. Para obtener más información, consulte [Tiempo de espera de finalización de la respuesta](DownloadDistValuesOrigin.md#response-completion-timeout). **keepAliveTimeout (opcional)** Este tiempo de espera solo se aplica a los orígenes personalizados, no a los orígenes de Amazon S3. (Las configuraciones de origen S3 omitirán esta configuración). `keepAliveTimeout` especifica el tiempo que CloudFront debería intentar mantener la conexión con el origen después de recibir el último paquete de la respuesta. El tiempo de espera mínimo es 1 segundo; el máximo es 120 segundos. Para obtener más información, consulte [Tiempo de espera de keep-alive (solo orígenes personalizados y de VPC)](DownloadDistValuesOrigin.md#DownloadDistValuesOriginKeepaliveTimeout). **connectionTimeout (opcional)** Número de segundos que espera CloudFront al intentar establecer una conexión con el origen. El tiempo de espera mínimo es 1 segundo; el máximo es 10 segundos. Para obtener más información, consulte [Tiempo de espera de conexión](DownloadDistValuesOrigin.md#origin-connection-timeout). **customOriginConfig (opcional)** Se utiliza `customOriginConfig` para especificar la configuración de conexión para los orígenes que *no* son un bucket de Amazon S3. Hay una excepción: puede especificar esta configuración si el bucket de S3 está configurado con alojamiento de sitios web estáticos. (Otros tipos de configuraciones de bucket de S3 ignorarán esta configuración). Si no se proporciona `customOriginConfig`, se utiliza la configuración del origen asignado. **port (obligatorio)** El puerto HTTP que CloudFront utiliza para conectarse al origen. Especifique el puerto HTTP que escucha el origen. **protocol (obligatorio)** Especifica el protocolo (HTTP o HTTPS) que CloudFront utiliza para conectarse al origen. Los valores válidos son los siguientes: + `http`: CloudFront utiliza siempre HTTP para conectarse al origen + `https`: CloudFront utiliza siempre HTTPS para conectarse al origen **sslProtocols (obligatorio)** Una lista que especifica el protocolo SSL/TLS mínimo que CloudFront utiliza al conectarse a su origen a través de HTTPS. Los valores válidos son `SSLv3`, `TLSv1`, `TLSv1.1` y `TLSv1.2`. Para obtener más información, consulte [Protocolo SSL mínimo del origen](DownloadDistValuesOrigin.md#DownloadDistValuesOriginSSLProtocols). **ipAddressType (opcional)** Especifica el tipo de dirección IP que CloudFront utiliza para conectarse al origen. Los valores válidos son `ipv4`, `ipv6` y `dualstack`. Los cambios de `ipAddressType` solo se admiten cuando también se está cambiando la propiedad de `domainName`. **sni (opcional, para orígenes personalizados que no sean de S3)** La indicación de nombre de servidor (SNI) es una extensión del protocolo seguridad de la capa de transporte (TLS) mediante el cual un cliente indica el nombre de host al que intenta conectarse al inicio del proceso de establecimiento de comunicación de TLS. Este valor debe coincidir con un nombre común de un certificado TLS del servidor de origen. De lo contrario, el servidor de origen puede generar un error. Si no se proporciona, se utiliza el valor del parámetro `hostHeader`. Si no se proporciona el encabezado del host, se utiliza el valor del parámetro `domainName`. Si no se proporciona ningún parámetro de encabezado de host ni de nombre de dominio, se utiliza el nombre de dominio del origen asignado o el encabezado de host de la solicitud entrante si la política de reenvío al origen (FTO) incluye el host. La SNI no puede incluir dos puntos (`:`) ni puede ser una dirección IP. La SNI puede tener hasta 253 caracteres. **allowedCertificateNames (opcional, para orígenes personalizados que no sean de S3)** Puede incluir una lista de nombres de certificados válidos que CloudFront utilizará para validar la coincidencia del dominio con el certificado TLS del servidor de origen durante el establecimiento de comunicación de TLS con el servidor de origen. Este campo espera una matriz de nombres de dominio válidos y puede incluir dominios comodín, como `*.example.com`. Puede especificar hasta 20 nombres de certificado permitidos. Cada nombre de certificado puede tener hasta 64 caracteres. **Example : actualización al origen de la solicitud de Amazon S3** El siguiente ejemplo cambia el origen de la solicitud del espectador a un bucket de S3, activa el OAC y restablece los encabezados personalizados enviados al origen. ``` 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 : actualización al origen de la solicitud del equilibrador de carga de aplicación** El siguiente ejemplo cambia el origen de la solicitud del espectador a un origen de equilibrador de carga de aplicación y establece un encabezado personalizado y tiempos de espera. ``` 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 : actualización al origen con Origin Shield activado** En el siguiente ejemplo, el origen de la distribución tiene Origin Shield activado. El código de función actualiza solo el nombre de dominio utilizado para el origen y omite todos los demás parámetros opcionales. En este caso, Origin Shield seguirá utilizándose con el nombre de dominio del origen modificado porque los parámetros de Origin Shield no se actualizaron. ``` cf.updateRequestOrigin({ "domainName" : "www.example.com" }); ``` **Example - Actualización del encabezado del host, la SNI y los nombres de los certificados permitidos** En la mayoría de los casos de uso, no necesitará usar este tipo de modificación en las solicitudes que se dirijan al origen. Estos parámetros no deberían usarse a menos que entienda el impacto de cambiar estos valores. En el siguiente ejemplo, se cambia al origen el nombre de dominio, el encabezado del host, la SNI y los certificados permitidos en la solicitud. ``` cf.updateRequestOrigin({ "domainName": "www.example.com", "hostHeader": "test.example.com", "sni": "test.example.net", "allowedCertificateNames": ["*.example.com", "*.example.net"], }); ``` ## Método selectRequestOriginById() Utilice `selectRequestOriginById()` para actualizar un origen existente mediante la selección un origen diferente que ya esté configurado en la distribución. Este método utiliza toda la configuración definida por el origen actualizado. Este método solo acepta orígenes que ya estén definidos en la misma distribución utilizada al ejecutar la función. Se hace referencia a los orígenes por el ID de origen, que es el nombre del origen que se ha definido al configurar el origen. Si tiene un origen de VPC configurado en la distribución, puede utilizar este método para actualizar el origen al origen de VPC. Para obtener más información, consulte [Restricción del acceso con orígenes de la VPC](private-content-vpc-origins.md). **Notas** La función `selectRequestOriginById()` no puede seleccionar un origen que tenga habilitado TLS mutua (origen). Si se intenta seleccionar un origen habilitado de TLS mutua (origen) mediante esta función, se producirá un error de validación. Si su caso de uso requiere una selección de origen dinámica con TLS mutua (origen), utilice `updateRequestOrigin()` en su lugar, asegurándose de que todos los orígenes de destino utilicen el mismo certificado de cliente. **Solicitud** ``` cf.selectRequestOriginById(origin_id, {origin_overrides}) ``` En el ejemplo anterior, `origin_id` es una cadena que apunta al nombre de un origen en la distribución que está ejecutando la función. El parámetro `origin_overrides ` puede contener lo siguiente: **hostHeader (opcional, para orígenes personalizados que no sean de S3)** El encabezado del host que se utilizará al realizar la solicitud al origen. Si no se proporciona, se utiliza el valor del parámetro `domainName`. Si no se proporciona ningún parámetro de encabezado de host ni de nombre de dominio, se utiliza el nombre de dominio del origen asignado o el encabezado de host de la solicitud entrante si la política de reenvío al origen (FTO) incluye el host. El encabezado del host no puede incluir dos puntos (`:`) ni puede ser una dirección IP. El encabezado del host puede tener una longitud de hasta 253 caracteres. **sni (opcional, para orígenes personalizados que no sean de S3)** La indicación de nombre de servidor (SNI) es una extensión del protocolo seguridad de la capa de transporte (TLS) mediante el cual un cliente indica el nombre de host al que intenta conectarse al inicio del proceso de establecimiento de comunicación de TLS. Este valor debe coincidir con un nombre común de un certificado TLS del servidor de origen. De lo contrario, el servidor de origen puede generar un error. Si no se proporciona, se utiliza el valor del parámetro `hostHeader`. Si no se proporciona el encabezado del host, se utiliza el valor del parámetro `domainName`. Si no se proporciona ningún parámetro de encabezado de host ni de nombre de dominio, se utiliza el nombre de dominio del origen asignado o el encabezado de host de la solicitud entrante si la política de reenvío al origen (FTO) incluye el host. La SNI no puede incluir dos puntos (`:`) ni puede ser una dirección IP. La SNI puede tener hasta 253 caracteres. **allowedCertificateNames (opcional, para orígenes personalizados que no sean de S3)** Puede incluir una lista de nombres de certificados válidos que CloudFront utilizará para validar la coincidencia del dominio con el certificado TLS del servidor de origen durante el establecimiento de comunicación de TLS con el servidor de origen. Este campo espera una matriz de nombres de dominio válidos y puede incluir dominios comodín, como `*.example.com`. Puede especificar hasta 20 nombres de certificado permitidos. Cada nombre de certificado puede tener hasta 64 caracteres. **Solicitud** ``` selectRequestOriginById(origin_id) ``` En el ejemplo anterior, `origin_id` es una cadena que apunta al nombre de un origen en la distribución que está ejecutando la función. **Example : selección del origen de solicitud de Amazon S3** El siguiente ejemplo selecciona el origen denominado `amzn-s3-demo-bucket-in-us-east-1` de la lista de orígenes asociados a la distribución y aplica los ajustes de configuración del origen `amzn-s3-demo-bucket-in-us-east-1` a la solicitud. ``` cf.selectRequestOriginById("amzn-s3-demo-bucket-in-us-east-1"); ``` **Example : selección del origen de la solicitud del equilibrador de carga de aplicación** El siguiente ejemplo selecciona un origen del equilibrador de carga de aplicación denominado `myALB-prod` de la lista de orígenes asociada a la distribución y aplica los ajustes de configuración de `myALB-prod` a la solicitud. ``` cf.selectRequestOriginById("myALB-prod"); ``` **Example - Selección del origen de la solicitud del equilibrador de carga de aplicación e invalidación del encabezado del host** Como en el ejemplo anterior, el siguiente ejemplo selecciona un origen del equilibrador de carga de aplicación denominado `myALB-prod` de la lista de orígenes asociada a la distribución y aplica los ajustes de configuración de `myALB-prod` a la solicitud. Sin embargo, este ejemplo invalida el valor del encabezado del host mediante `origin_overrides`. ``` cf.overrideRequestOrigin("myALB-prod",{ "hostHeader" : "test.example.com" }); ``` ## Método createRequestOriginGroup() Utilice `createRequestOriginGroup()` para definir dos orígenes que se utilizarán como [grupo de orígenes](high_availability_origin_failover.md#concept_origin_groups.creating) para la conmutación por error en escenarios que requieren alta disponibilidad. Un grupo de orígenes incluye dos orígenes (uno principal y otro secundario) y un criterio de conmutación por error especificado. Cree un grupo de origen para admitir la conmutación por error de origen en CloudFront. Cuando cree o actualice un grupo de orígenes mediante este método, puede especificar el grupo de orígenes en lugar de un único origen. CloudFront realizará la conmutación por error del origen principal al secundario, mediante los criterios de conmutación por error. Si tiene un origen de VPC configurado en la distribución, puede utilizar este método para crear un grupo de orígenes utilizando un origen de VPC. Para obtener más información, consulte [Restricción del acceso con orígenes de la VPC](private-content-vpc-origins.md). **Notas** La función `createRequestOriginGroup()` no admite la creación de grupos de orígenes que incluyan orígenes habilitados de TLS mutua (origen). Los grupos de origen con orígenes de TLS mutua (origen) no se pueden crear dinámicamente mediante CloudFront Functions. Si necesita capacidades de conmutación por error de origen con TLS mutua (origen), configure los grupos de origen directamente en la configuración de distribución de CloudFront, en lugar de crearlos de forma dinámica en funciones. ### Solicitud ``` createRequestOriginGroup({origin_group_properties}) ``` En el ejemplo anterior, el archivo `origin_group_properties` contiene lo siguiente: **originIds (obligatorio)** Matriz de `origin_ids`, donde `origin_id` es una cadena que apunta al nombre de un origen en la distribución que ejecuta la función. Debe proporcionar dos orígenes como parte de la matriz. El primer origen de la lista es el origen principal y el segundo sirve como segundo origen a efectos de conmutación por error. **originOverrides (opcional)** Se pueden sobrescribir algunos ajustes avanzados mediante el parámetro `{origin_overrides}`. Las `origin overrides` pueden incluir lo siguiente: **hostHeader (opcional, para orígenes personalizados que no sean de S3)** El encabezado del host que se utilizará al realizar la solicitud al origen. Si no se proporciona, se utiliza el valor del parámetro `domainName`. Si no se proporciona ningún parámetro de encabezado de host ni de nombre de dominio, se utiliza el nombre de dominio del origen asignado o el encabezado de host de la solicitud entrante si la política de reenvío al origen (FTO) incluye el host. El encabezado del host no puede incluir dos puntos (`:`) ni puede ser una dirección IP. El encabezado del host puede tener una longitud de hasta 253 caracteres. **sni (opcional, para orígenes personalizados que no sean de S3)** La indicación de nombre de servidor (SNI) es una extensión del protocolo seguridad de la capa de transporte (TLS) mediante el cual un cliente indica el nombre de host al que intenta conectarse al inicio del proceso de establecimiento de comunicación de TLS. Este valor debe coincidir con un nombre común de un certificado TLS del servidor de origen, de lo contrario, el servidor de origen puede generar un error. Si no se proporciona, se utiliza el valor del parámetro `hostHeader`. Si no se proporciona el encabezado del host, se utiliza el valor del parámetro `domainName`. Si no se proporciona ningún parámetro de encabezado de host ni de nombre de dominio, se utiliza el nombre de dominio del origen asignado o el encabezado de host de la solicitud entrante si la política de reenvío al origen (FTO) incluye el host. La SNI no puede incluir dos puntos (`:`) ni puede ser una dirección IP. La SNI puede tener hasta 253 caracteres. **allowedCertificateNames (opcional, para orígenes personalizados que no sean de S3)** Puede incluir una lista de nombres de certificados válidos que CloudFront utilizará para validar la coincidencia del dominio con el certificado TLS del servidor de origen durante el establecimiento de comunicación de TLS con el servidor de origen. Este campo espera una matriz de nombres de dominio válidos y puede incluir dominios comodín, como `*.example.com`. Puede especificar hasta 20 nombres de certificado permitidos. Cada nombre de certificado puede tener hasta 64 caracteres. **selectionCriteria (opcional)** Seleccione si desea utilizar los criterios de conmutación por error del origen `default` o utilizar la lógica de conmutación por error basada en `media-quality-score`. Los valores válidos son los siguientes: + `default` utiliza los criterios de conmutación por error basados en los códigos de estado que se especifican en `failoverCriteria`. Si no configura `selectionCriteria` en la función, se utilizará `default`. + `media-quality-score` se utiliza cuando se emplea la capacidad de enrutamiento con reconocimiento multimedia. **failoverCriteria (obligatorio)** Una matriz de códigos de estado que, cuando se devuelven desde el origen principal, desencadenarán que CloudFront conmute por error al origen secundario. Si sobrescribe un grupo de orígenes existente, esta matriz sobrescribirá todos los códigos de estado de conmutación por error establecidos en la configuración original del grupo de orígenes. Cuando utilice `media-quality-score` `selectionCriteria`, CloudFront intentará enrutar las solicitudes basándose en la puntuación de calidad de los medios. Si el origen seleccionado devuelve un código de error establecido en esta matriz, CloudFront realizará la conmutación por error al otro origen. **Example : creación del grupo de orígenes de solicitudes** En el siguiente ejemplo se crea un grupo de orígenes para una solicitud mediante los ID de origen. Estos ID de origen proceden de la configuración del grupo de orígenes para la distribución utilizada para ejecutar esta función. Si lo desea, puede usar `originOverrides` para invalidar las configuraciones del grupo de origen para `sni`, `hostHeader` y `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étodos auxiliares para las propiedades de CloudFront SaaS Manager Utilice las siguientes funciones auxiliares de CloudFront SaaS Manager para recuperar los valores de las distribuciones de varios inquilinos en la función que cree. Para utilizar los ejemplos de esta página, primero debe crear una función de CloudFront utilizando el tiempo de ejecución 2.0 de JavaScript. Para obtener más información, [Características del tiempo de ejecución 2.0 de JavaScript para CloudFront Functions](functions-javascript-runtime-20.md). **Topics** + [Grupos de conexiones](#connection-groups-helper-function) + [Inquilinos de distribución](#distribution-tenants-helper-functions) ## Grupos de conexiones El grupo de conexiones que está asociado a los inquilinos de distribución tiene un nombre de dominio. Para obtener este valor, utilice el campo `endpoint` del subobjeto `context` del objeto de evento. **Solicitud** ``` const value = event.context.endpoint; ``` **Respuesta** La respuesta es una `string` que contiene el nombre de dominio del grupo de conexiones, como d111111abcdef8.cloudfront.net. El campo `endpoint` solo aparece cuando se invoca la función para una distribución de varios inquilinos con un grupo de conexiones asociado. Para obtener más información, consulte [Objeto Context (Contexto)](functions-event-structure.md#functions-event-structure-context). ## Inquilinos de distribución CloudFront Functions tiene un módulo que proporciona acceso a valores específicos de inquilinos de distribución. Para usar este módulo, incluya la siguiente instrucción en la primera línea del código de la función: ``` import cf from 'cloudfront'; ``` Puede usar los siguientes ejemplos solo en la función `handler`, ya sea directamente o mediante cualquier función de llamada anidada. ### `distributionTenant.id`Campo de Utilice este campo para obtener el valor del ID del inquilino de distribución. **Solicitud** ``` const value = cf.distributionTenant.id; ``` **Respuesta** La respuesta es una `string` que contiene el ID del inquilino de distribución, por ejemplo, `dt_1a2b3c4d5e6f7`. **Gestión de errores** Si se invoca la función para una distribución estándar, al especificar el campo `distributionTenant.id` se devolverá el error de tipo `distributionTenant module is not available`. Para gestionar este caso de uso, puede agregar un bloque `try` y `catch` al código. ### `distributionTenant.parameters.get()`Método de Utilice este método para devolver el valor de los nombres de parámetro de inquilino de distribución que especifique. ``` distributionTenant.parameters.get("key"); ``` `key`: el nombre del parámetro del inquilino de distribución cuyo valor desea obtener. **Solicitud ** ``` const value = distributionTenant.parameters.get("key"); ``` **Respuesta** La respuesta es una `string` que contiene el valor del parámetro del inquilino de distribución. Por ejemplo, si el nombre de la clave es `TenantPath`, entonces el valor de este parámetro podría ser `tenant1`. **Gestión de errores** Es posible que reciba los errores siguientes: + Si se invoca la función para una distribución estándar, el método `distributionTenant.parameters.get()` devolverá el error de tipo `distributionTenant module is not available`. + El error `DistributionTenantParameterKeyNotFound` se devuelve cuando el parámetro de inquilino de distribución que especificó no existe. Para administrar estos casos de uso, puede agregar un bloque `try` y `catch` al código. # Utilice async y await Las funciones de tiempo de ejecución 2.0 de JavaScript de CloudFront Functions proporcionan una sintaxis `async` y `await` para gestionar los objetos `Promise`. Las promesas representan resultados retrasados a los que se puede acceder mediante la palabra clave `await` en las funciones marcadas como `async`. Varias funciones nuevas de WebCrypto utilizan promesas. Para obtener más información sobre los objetos `Promise`, consulte [Promesa](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise). **nota** Debe usar el tiempo de ejecución de JavaScript 2.0 para las siguientes muestras de código. `await` solo se puede usar dentro de funciones `async`. No se admiten argumentos ni cierres de `async`. ``` 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; } ``` El siguiente ejemplo de código JavaScript muestra cómo ver las promesas con el método en cadena `then`. Se puede utilizar `catch` para ver los errores. **aviso** El uso de combinadores de promesas (por ejemplo, `Promise.all`, `Promise.any`) y métodos de cadena de promesas (por ejemplo, `then` y `catch`) puede requerir un uso elevado de la memoria de la función. Si la función supera la cuota de [memoria máxima de la función](cloudfront-limits.md#limits-functions), no se ejecutará. Para evitar este error, recomendamos que utilice la sintaxis `await` en lugar de los métodos `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; } ``` # Compatibilidad con CWT para CloudFront Functions En esta sección, se proporcionan detalles sobre la compatibilidad con los tókenes web CBOR (CWT) en las CloudFront Functions, lo que permite la autenticación y la autorización seguras basadas en tókenes en las ubicaciones periféricas de CloudFront. Esta compatibilidad se proporciona como un módulo, al que se puede acceder desde CloudFront Functions. Para usar este módulo, cree una función de CloudFront con tiempo de ejecución 2.0 de JavaScript e incluya la siguiente instrucción en la primera línea del código de la función: ``` import cf from 'cloudfront'; ``` Los métodos asociados a este módulo son accesibles mediante (donde \$1 es un comodín que representa las diferentes funciones presentes en el módulo): ``` cf.cwt.* ``` Para obtener más información, consulte [Características del tiempo de ejecución 2.0 de JavaScript para CloudFront Functions](functions-javascript-runtime-20.md). Actualmente, el módulo solo admite la estructura MAC0 con el algoritmo HS256 (HMAC-SHA256) con un límite de 1 KB para el tamaño máximo del token. ## Estructura de token En esta sección se describe la estructura de token que espera el módulo de CWT. El módulo espera que el token esté correctamente etiquetado y sea identificable (por ejemplo, COSE MAC0). Además, en cuanto a la estructura del token, el módulo sigue los estándares establecidos por [Firma y cifrado de objetos CBOR (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 utiliza la estructura 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 etiqueta de CWT es opcional a la hora de generar los tókenes. Sin embargo, se requiere la etiqueta de estructura COSE. ## método validateToken() La función decodifica y valida un token de CWT con la clave especificada. Si la validación es exitosa, devuelve el token de CWT decodificado. De lo contrario, emite un error. Tenga en cuenta que esta función no valida el conjunto de reclamaciones. ### Solicitud ``` cf.cwt.validateToken(token, handlerContext{key}) ```Parameters **token (obligatorio)** Token codificado para la validación. Debe ser un búfer de JavaScript. **handlerContext (obligatorio)** Un objeto de JavaScript que almacena el contexto de la llamada a validateToken. Por el momento, solo se admite la propiedad de la clave. **clave (obligatorio)** Clave secreta para el cálculo del resumen del mensaje. Se puede proporcionar como cadena o búfer de JavaScript. ### Respuesta Cuando el método `validateToken()` devuelve un token validado correctamente, la respuesta de la función es un `CWTObject` en el siguiente formato. Una vez decodificadas, todas las claves de reclamación se representan como cadenas. ``` CWTObject { protectedHeaders, unprotectedHeaders, payload } ``` ### Ejemplo: Validación del token con el identificador enviado como parte del token En este ejemplo, se muestra la validación del token de CWT, en la que se extrae el identificador del encabezado. A continuación, el identificador pasa a KeyValueStore de CloudFront Functions para obtener la clave secreta utilizada para validar el token. ``` import cf from 'cloudfront' const CwtClaims = { iss: 1, aud: 3, exp: 4 } async function handler(event) { try { let request = event.request; let encodedToken = request.headers['x-cwt-token'].value; let kid = request.headers['x-cwt-kid'].value; // Retrieve the secret key from the kvs let secretKey = await cf.kvs().get(kid); // Now you can use the secretKey to decode & validate the token. let tokenBuffer = Buffer.from(encodedToken, 'base64url'); let handlerContext = { key: secretKey, } try { let cwtObj = cf.cwt.validateToken(tokenBuffer, handlerContext); // Check if token is expired const currentTime = Math.floor(Date.now() / 1000); // Current time in seconds if (cwtObj[CwtClaims.exp] && cwtObj[CwtClaims.exp] < currentTime) { return { statusCode: 401, statusDescription: 'Token expired' }; } } catch (error) { return { statusCode: 401, statusDescription: 'Invalid token' }; } } catch (error) { return { statusCode: 402, statusDescription: 'Token processing failed' }; } return request; } ``` ## método generateToken() Esta función genera un nuevo token de CWT mediante la carga útil y la configuración de contexto proporcionados. ### Solicitud ``` cf.cwt.generateToken(generatorContext, payload) ```Parameters **generatorContext (obligatorio)** Se trata de un objeto de JavaScript que se utiliza como contexto para generar el token y contiene los siguientes pares de valores clave: **cwTag (opcional)** Este valor es un booleano que, si `true` lo especifica, `cwtTag` se debe agregar. **coseTag (obligatorio)** Especifica el tipo de etiqueta de COSE. Actualmente, solo admite `MAC0`. **clave (obligatorio)** Clave secreta para el cálculo del resumen del mensaje. Este valor puede ser una cadena o JavaScript `Buffer`. **carga útil (obligatorio)** Carga útil del token para la codificación. La carga útil debe estar en formato `CWTObject`. ### Respuesta Devuelve un búfer de JavaScript que contiene el token codificado. **Example : genera un token de 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 : actualice el token según alguna lógica** ``` 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étodos de ayuda generales Esta página proporciona métodos de ayuda adicionales en CloudFront Functions. Para usar estos métodos, cree una función de CloudFront con tiempo de ejecución 2.0 de JavaScript. ``` import cf from 'cloudfront'; ``` Para obtener más información, consulte [Características del tiempo de ejecución 2.0 de JavaScript para CloudFront Functions](functions-javascript-runtime-20.md). ## `edgeLocation`Metadatos de Este método requiere el uso del modulo `cloudfront`. **nota** Solo puede utilizar este método para las funciones de solicitud del espectador. Para las funciones de respuesta del espectador, este método está vacío. Utilice este objeto de JavaScript para obtener el código del aeropuerto de ubicación periférica, la región de [Caché periférica regional](HowCloudFrontWorks.md#CloudFrontRegionaledgecaches) prevista o la dirección IP del servidor de CloudFront utilizada para gestionar la solicitud. Estos metadatos solo están disponibles cuando el espectador solicita desencadenar el evento. ``` cf.edgeLocation = { name: SEA serverIp: 1.2.3.4 region: us-west-2 } ``` El objeto `cf.edgeLocation` puede incluir lo siguiente: **name** El [código IATA](https://en.wikipedia.org/wiki/IATA_airport_code) de tres letras de la ubicación periférica que gestionó la solicitud. **serverIp** Dirección IPv4 o IPv6 del servidor que gestionó la solicitud. **region** La caché periférica regional (REC) de CloudFront que se *espera* que utilice la solicitud en caso de falta de memoria caché. Este valor no se actualiza en caso de que el REC esperado no esté disponible y se utilice un REC de copia de seguridad para la solicitud. Esto no incluye la ubicación de Origin Shield que se utilice, excepto en los casos en que el REC principal y el Origin Shield estén en la misma ubicación. **nota** CloudFront Functions no se invoca por segunda vez cuando CloudFront está configurado para usar la conmutación por error de origen. Para obtener más información, consulte [Optimización de alta disponibilidad con conmutación por error de origen de CloudFront](high_availability_origin_failover.md). ## `rawQueryString()`Método de Este método no requiere el módulo `cloudFront`. Utilice el método `rawQueryString()` para recuperar la cadena de consulta no analizada y no modificada como una cadena. **Solicitud** ``` function handler(event) { var request = event.request; const qs = request.rawQueryString(); } ``` **Respuesta** Devuelve la cadena de consulta completa de la solicitud entrante como un valor de cadena sin `?` al principio. + Si no hay una cadena de consulta, pero `?` está presente, la función devuelve una cadena vacía. + Si no hay una cadena de consulta y `?` no está presente, la función devuelve `undefined`. **Caso 1: se devuelve la cadena de consulta completa (sin `?` al principio)** URL de solicitud entrante: `https://example.com/page?name=John&age=25&city=Boston` `rawQueryString()` devuelve: `"name=John&age=25&city=Boston"` **Caso 2: se devuelve una cadena vacía (cuando `?` está presente pero sin parámetros)** URL de solicitud entrante: `https://example.com/page?` `rawQueryString()` devuelve: `""` **Caso 3: se devuelve `undefined` (sin cadena de consulta ni `?`)** URL de solicitud entrante: `https://example.com/page` `rawQueryString()` devuelve: `undefined` # Creación de funciones La función se crea en dos etapas: 1. Crear el código de función como JavaScript. Puede utilizar el ejemplo predeterminado de la consola de CloudFront o escribir el suyo propio. Para obtener más información, consulte los temas siguientes: + [Escritura de código de función](writing-function-code.md) + [Estructura de eventos de CloudFront Functions](functions-event-structure.md) + [Ejemplos de CloudFront Functions para CloudFront](service_code_examples_cloudfront_functions_examples.md) 1. Utilice CloudFront para crear la función e incluir el código. El código existe dentro de la función (no como referencia). ------ #### [ Console ] **Para crear una función** 1. Inicie sesión en la consola de CloudFront en [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) y elija la página **Funciones**. 1. Seleccione **Creación de función**. 1. Introduzca un nombre de función que sea único en la Cuenta de AWS, elija la versión de Java Script y, a continuación, elija **Continuar**. Aparece la página de detalles de la nueva función. **nota** Para utilizar [pares clave-valor](kvs-with-functions.md) en la función, debe elegir tiempo de ejecución 2.0 de Java Script. 1. En la sección **Código de función**, seleccione la pestaña **Compilación** e introduzca el código de función. El código de ejemplo que se incluye en la pestaña **Compilación** ilustra la sintaxis básica del código de la función. 1. Elija **Guardar cambios**. 1. Si el código de la función utiliza pares clave-valor, debe asociar un almacén de clave-valor. Puede asociar el almacén de clave-valor cuando crea en primer lugar la función. O bien, puede asociarlo más adelante, [actualizando la función](update-function.md). Para asociar un almacén clave-valor ahora, siga estos pasos: + Vaya a la sección **Asociar KeyValueStore** y elija **Asociar KeyValueStore existente**. + Seleccione el almacén de clave-valor que contiene los pares clave-valor de la función y, a continuación, elija **Asociar KeyValueStore**. CloudFront asocia inmediatamente el almacén a la función. No necesita guardar la función. ------ #### [ CLI ] Si utiliza la CLI, normalmente crea primero el código de la función en un archivo y, a continuación, crea la función con la AWS CLI. **Para crear una función** 1. Cree el código de la función en un archivo y guárdelo en un directorio al que se pueda conectar el equipo. 1. Ejecute el comando como se muestra en el ejemplo. En este ejemplo, se utiliza la notación `fileb://` para transmitir el archivo. También incluye saltos de línea para que el comando sea más legible. ``` 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 ``` **Notas** `Runtime`: la versión de Java Script. Para utilizar [pares clave-valor](kvs-with-functions.md) en la función, debe especificar la versión 2.0. `KeyValueStoreAssociations`: si la función usa pares clave-valor, puede asociar el almacén de clave-valor en la creación inicial de la función. O bien, puede asociarlo más adelante, utilizando `update-function`. La `Quantity` siempre es `1`, porque cada función solo puede tener asociado un almacén de clave-valor. Si el comando se ejecuta correctamente, verá un resultado parecido al siguiente. ``` 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 mayor parte de la información se repite desde la solicitud. CloudFront agrega el resto de información. **Notas** `ETag`: este valor cambia cada vez que se modifica el almacén de clave-valor. Utilice este valor y el nombre de la función para hacer referencia a la función en el futuro. Asegúrese de utilizar siempre la `ETag` actual. `FunctionARN`: el ARN de la función CloudFront. 111122223333: la Cuenta de AWS. `Stage`: la fase de la función (`LIVE` o `DEVELOPMENT`). `Status`: el estado de la función (`PUBLISHED` o `UNPUBLISHED`). ------ Después de crear la función, se agrega a la fase `DEVELOPMENT`. Le recomendamos que [pruebe la función](test-function.md) antes de [publicarla](publish-function.md). Tras publicar la función, la función cambia a la fase `LIVE`. # Prueba de funciones Antes de implementar función en la etapa activa (producción), puede probarla para verificar que funciona según lo previsto. Para probar una función, especifica un *objeto de evento* que representa una solicitud o respuesta HTTP que su distribución de CloudFront podría recibir en producción. CloudFront Functions realiza lo siguiente: 1. Ejecuta la función con el objeto de evento proporcionado como entrada. 1. Devuelve el resultado de la función (el objeto de evento modificado) junto con los registros de función o mensajes de error y la *utilización de cómputo*de la función. Para obtener más información acerca del uso de cómputo, consulte [Descripción del uso de cómputo](#compute-utilization). **nota** Al probar una función, CloudFront solo la valida en función de los errores de ejecución de la función. CloudFront no valida si la solicitud se tramitará correctamente una vez publicada. Por ejemplo, si su función elimina un encabezado obligatorio, la prueba se realizará correctamente porque no hay ningún problema con el código. Sin embargo, si publica la función y la asocia a una distribución, la función fallará cuando se realice una solicitud a través de CloudFront. **Contents** + [Configuración del objeto del evento](#test-function-create-event) + [Prueba de la función](#test-function-step-test) + [Descripción del uso de cómputo](#compute-utilization) ## Configuración del objeto del evento Antes de probar una función, debe configurar el objeto de evento con el cual la probará. Hay varias opciones para hacerlo. **Opción 1: Configurar un objeto de evento sin guardarlo** Puede configurar un objeto de evento en el editor visual de la consola de CloudFront y no guardarlo. Puede usar este objeto de evento para probar la función desde la consola de CloudFront, aunque no esté guardado. **Opción 2: Crear un objeto de evento en el editor visual** Puede configurar un objeto de evento en el editor visual de la consola de CloudFront y no guardarlo. Puede crear 10 objetos de eventos para cada función para, por ejemplo, probar diferentes entradas posibles. Al crear el objeto de evento de esta manera, puede usarlo para probar la función en la consola de CloudFront. No puede usarlo para probar la función mediante una API o un SDK de AWS. **Opción 3: Crear un objeto de evento mediante un editor de texto** Puede usar un editor de texto para crear un objeto de evento a mano en formato JSON. Para obtener información sobre la estructura de un objeto de evento, consulte [Estructura de evento](functions-event-structure.md). Puede usar este objeto de evento para probar la función mediante la CLI. Sin embargo, no se puede utilizar para probar la función en la consola de CloudFront. **Para crear un objeto de evento (opción 1 o 2)** 1. Inicie sesión en la consola de CloudFront en [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) y elija la página **Funciones**. Elija la función que desea probar. 1. En la página de detalles de la función, seleccione la pestaña **Probar**. 1. En **Tipo de evento**, elija una de las siguientes opciones: + Elija **Solicitud del lector** si la función modifica una solicitud HTTP o genera una respuesta basada en la solicitud. Aparece la sección **Solicitud**. + O bien, seleccione **Respuesta del lector**. Aparecen las secciones **Solicitud** y **Respuesta**. 1. Complete los campos que desee incluir en el evento. Puede elegir **Editar JSON** para ver el JSON sin procesar. 1. (Opcional) Para guardar el evento, elija **Guardar** y, en **Save test event**, introduzca un nombre y, a continuación, seleccione **Guardar**. También puede elegir **Editar JSON**, copiar el JSON sin procesar y guardarlo en su propio archivo, fuera de CloudFront. **Para crear un objeto de evento (opción 3)** Cree el objeto de evento mediante un editor de texto. Guarde el archivo en un directorio al que se pueda conectar su equipo. Asegúrese de seguir estas directrices: + Omita los campos `distributionDomainName`, `distributionId` y `requestId`. + Los nombres de encabezados, cookies y cadenas de consulta deben estar en minúsculas. Una opción para crear un objeto de evento de esta manera es crear una muestra mediante el editor visual. Puede estar seguro de que la muestra tiene el formato correcto. A continuación, puede copiar el JSON sin procesar, pegarlo en un editor de texto y guardar el archivo. Para obtener más información sobre la estructura de un evento, consulte [Estructura de evento](functions-event-structure.md). ## Prueba de la función Puede probar una función en la consola de CloudFront o con la AWS Command Line Interface (AWS CLI). ------ #### [ Console ] **Para probar la función** 1. Inicie sesión en la consola de CloudFront en [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) y elija la página **Funciones**. 1. Elija la función que desea probar. 1. Elija la pestaña **Prueba**. 1. Asegúrese de que se muestre el evento correcto. Si desea cambiar desde el evento que se muestra actualmente, elija otro evento en el campo **Seleccionar evento de prueba**. 1. Seleccione **Probar función**. La consola muestra el resultado de la función, incluidos los registros de funciones y el uso del cómputo. ------ #### [ CLI ] Puede probar una función mediante el comando **aws cloudfront test-function**. **Para probar la función** 1. Abra una ventana de línea de comandos. 1. Ejecute el siguiente comando desde el directorio que contiene el archivo especificado. En este ejemplo, se utiliza la notación `fileb://` para transmitir el archivo del objeto de evento. También incluye saltos de línea para que el comando sea más legible. ``` aws cloudfront test-function \ --name MaxAge \ --if-match ETVABCEXAMPLE \ --event-object fileb://event-maxage-test01.json \ --stage DEVELOPMENT ``` **Notas** Se hace referencia a la función por su nombre y por la ETag (en el parámetro `if-match`). Se hace referencia al objeto de evento por su ubicación en el sistema de archivos. El estado puede ser `DEVELOPMENT` o `LIVE`. Si el comando se ejecuta correctamente, verá un resultado parecido al siguiente. ``` 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 ``` ------ **Notas** `FunctionExecutionLogs` contiene una lista de líneas de registro que la función escribió en instrucciones `console.log()` (si las hay). `ComputeUtilization` contiene información sobre la ejecución de la función. Consulte [Descripción del uso de cómputo](#compute-utilization). `FunctionOutput` contiene el objeto de evento que devolvió la función. ## Descripción del uso de cómputo **Utilización de cómputo** es la cantidad de tiempo que la función tardó en ejecutarse como un porcentaje del tiempo máximo permitido. Por ejemplo, un valor de 35 significa que la función se completó en el 35 % del tiempo máximo permitido. Si una función supera continuamente el tiempo máximo permitido, CloudFront la limita. En la siguiente lista se explica la probabilidad de que una función se limite en función del valor de utilización de cómputo. **Valor de utilización de cómputo:** + **1 – 50** – la función está cómodamente por debajo del tiempo máximo permitido y debe ejecutarse sin limitación. + **51 – 70** – la función se acerca al tiempo máximo permitido. Considere optimizar el código de la función. + **71 – 100** – la función está muy cerca o supera el tiempo máximo permitido. Es probable que CloudFront limite esta función si la asocia a una distribución. # Actualización de funciones Puede actualizar una función en cualquier momento. Los cambios se realizan únicamente en la versión de la función que se encuentra en la etapa `DEVELOPMENT`. Para copiar los cambios de la etapa `DEVELOPMENT` a `LIVE`, debe [publicar la función](publish-function.md). Puede actualizar el código de una función en la consola de CloudFront o con la AWS Command Line Interface (AWS CLI). ------ #### [ Console ] **Actualización del código de la función** 1. Inicie sesión en la consola de CloudFront en [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) y elija la página **Funciones**. Elija la función que desea actualizar. 1. Elija **Editar** y realice los siguientes cambios: + Actualice todos los campos de la sección **Detalles**. + Cambie o elimine el almacén de clave-valor asociado. Para obtener más información sobre los almacenes de clave-valor, consulte [Amazon CloudFront KeyValueStore](kvs-with-functions.md). + Cambie el código de la función. Seleccione la pestaña **Compilación**, realice los cambios y, a continuación, seleccione **Guardar cambios** para guardar los cambios en el código. ------ #### [ CLI ] **Para actualizar el código de la función** 1. Abra una ventana de línea de comandos. 1. Ejecute el siguiente comando. En este ejemplo, se utiliza la notación `fileb://` para transmitir el archivo. También incluye saltos de línea para que el comando sea más legible. ``` 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 ``` **Notas** Puede identificar la función por su nombre y ETag (en el parámetro `if-match`). Asegúrese de utilizar siempre la ETag actual. Puede obtener este valor de la operación de la API [DescribeFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeFunction.html). Debe incluir el `function-code`, incluso aunque no desee cambiarlo. Tenga cuidado con la `function-config`. Debe transmitir todo lo que quiera conservar en la configuración. En concreto, gestione el almacén de clave-valor de la siguiente manera: Para retener la asociación de almacenes de clave-valor existentes (si existen), especifique el nombre del almacén *existente*. Para cambiar la asociación, especifique el nombre del *nuevo* almacén de clave-valor. Para eliminar la asociación, omita el parámetro `KeyValueStoreAssociations`. Si el comando se ejecuta correctamente, verá un resultado parecido al siguiente. ``` 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 mayor parte de la información se repite desde la solicitud. CloudFront agrega el resto de información. **Notas** `ETag`: este valor cambia cada vez que se modifica el almacén de clave-valor. `FunctionARN`: el ARN de la función CloudFront. `Stage`: la fase de la función (`LIVE` o `DEVELOPMENT`). `Status`: el estado de la función (`PUBLISHED` o `UNPUBLISHED`). # Publicación de funciones Al publicar la función, se copia la función de la fase `DEVELOPMENT` a la fase `LIVE`. Si no hay ningún comportamiento de la caché asociado a la función, publicarla permite asociarla a un comportamiento de la caché. Solo se pueden asociar comportamientos de la caché a funciones que se encuentran en la etapa `LIVE`. **importante** Antes de la publicación, le recomendamos que [pruebe la función](test-function.md). Después de publicar la función, todos los comportamientos de la caché asociados a la función comienzan automáticamente a usar la copia recién publicada, tan pronto como las distribuciones terminen de implementarse. Puede publicar una función en la consola de CloudFront o con la AWS CLI. ------ #### [ Console ] **Publicación de una función** 1. Inicie sesión en la consola de CloudFront en [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) y elija la página **Funciones**. 1. Elija la función que desea actualizar. 1. Elija la pestaña **Publicar** y, a continuación, elija **Publicar**. Si la función ya está asociada a uno o varios comportamientos de la caché, elija **Publish and update**. 1. (Opcional) Para ver las distribuciones asociadas a la función, seleccione **Associated CloudFront distributions (Distribuciones de CloudFront asociadas)** a fin de expandir esa sección. Cuando se guarda correctamente, aparece un banner en la parte superior de la página que dice ***Function name* published successfully**. También puede seleccionar la pestaña **Compilación** y, a continuación, **Activa** para ver la versión activa del código de función. ------ #### [ CLI ] **Publicación de una función** 1. Abra una ventana de línea de comandos. 1. Ejecute el siguiente comando de la **aws cloudfront publish-function**. En el ejemplo, se proporcionan saltos de línea para que el ejemplo sea más legible. ``` aws cloudfront publish-function \ --name MaxAge \ --if-match ETVXYZEXAMPLE ``` Si el comando se ejecuta correctamente, verá un resultado parecido al siguiente. ``` 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 ``` ------ # Asociación de funciones con distribuciones Para utilizar una función con una distribución, asocie la función a uno o varios comportamientos de caché en la distribución. Puede asociar una función a varios comportamientos de la caché en varias distribuciones. Puede asociar una función con cualquiera de los siguientes elementos: + Un comportamiento de la caché existente + Un nuevo comportamiento de la caché en una distribución existente + Un nuevo comportamiento de la caché en una distribución nueva. Cuando asocia una función a un comportamiento de la caché, debe selecciona un *tipo de evento*. El tipo de evento determina cuándo CloudFront ejecuta la función. Puede elegir los siguientes tipos de evento: + **Solicitud del lector**: la función se ejecuta cuando CloudFront recibe una solicitud de un lector. + **Viewer Response (Respuesta al lector)**: la función se ejecuta antes de que CloudFront devuelva una respuesta al lector. No se pueden utilizar tipos de eventos orientados al origen (*solicitud de origen* y *respuesta de origen*) con CloudFront Functions. En su lugar, puede utilizar Lambda@Edge. Para obtener más información, consulte [Eventos de CloudFront que pueden desencadenar una función de Lambda@Edge](lambda-cloudfront-trigger-events.md). **nota** Antes de asociar una función, debe [publicarla](publish-function.md) en la etapa `LIVE`. Puede asociar una función a una distribución en la consola de CloudFront o con la AWS Command Line Interface (AWS CLI). En el siguiente procedimiento, se muestra cómo asociar una función a un comportamiento existente de la caché. ------ #### [ Console ] **Asociación de una función a un comportamiento existente de la caché** 1. Inicie sesión en la consola de CloudFront en [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) y elija la página **Funciones**. 1. Elija la función que desee asociar. 1. En la página **Función**, seleccione la pestaña **Publicar**. 1. Elija la **función Publicar**. 1. Elija **Add association**. En el cuadro de diálogo que aparece, elija una distribución, un tipo de evento o un comportamiento de caché. Para el tipo de evento, seleccione cuándo desea que se ejecute esta función: + **Solicitud del lector**: ejecute la función cada vez que CloudFront reciba una solicitud. + **Respuesta al lector**: ejecute la función cada vez que CloudFront devuelve una respuesta. 1. Para guardar la configuración, elija **Agregar asociación**. CloudFront asocia la distribución a la función. Espere unos minutos para que la distribución asociada termine de implementarse. Puede seleccionar **Ver distribución** en la página de detalles de la función para comprobar el progreso. ------ #### [ CLI ] **Asociación de una función a un comportamiento existente de la caché** 1. Abra una ventana de línea de comandos. 1. Introduzca el siguiente comando para guardar la configuración de la distribución cuyo comportamiento de la caché desea asociar a una función. Este comando guarda la configuración de distribución en un archivo llamado `dist-config.yaml`. Para utilizar este comando, haga lo siguiente: + Reemplace *`DistributionID`* por el ID de la distribución. + Ejecute el comando en una línea. En el ejemplo, se proporcionan saltos de línea para que el ejemplo sea más legible. ``` aws cloudfront get-distribution-config \ --id DistributionID \ --output yaml > dist-config.yaml ``` Si el comando se ejecuta correctamente, la AWS CLI no devuelve ninguna salida. 1. Abra el archivo llamado `dist-config.yaml` que ha creado. Edite el archivo para realizar los siguientes cambios. 1. Cambie el nombre del campo `ETag` a `IfMatch`, pero no cambie el valor del campo. 1. En el comportamiento de la caché, busque el objeto llamado `FunctionAssociations`. Actualice este objeto para agregar una asociación de función. La sintaxis YAML para una asociación de función se parece al siguiente ejemplo. + En el siguiente ejemplo, se muestra un tipo de evento de solicitud del lector (disparador). Para utilizar un tipo de evento de respuesta al lector, reemplace `viewer-request` por `viewer-response`. + Reemplace *`arn:aws:cloudfront::111122223333:function/ExampleFunction`* por el nombre de recurso de Amazon (ARN) de la función que está asociando a este comportamiento de la caché. Para obtener el ARN de la función, puede usar el comando **aws cloudfront list-functions**. ``` FunctionAssociations: Items: - EventType: viewer-request FunctionARN: arn:aws:cloudfront::111122223333:function/ExampleFunction Quantity: 1 ``` 1. Después de realizar estos cambios, guarde el archivo. 1. Utilice el siguiente comando para actualizar la distribución y agregue la asociación de función. Para utilizar este comando, haga lo siguiente: + Reemplace *`DistributionID`* por el ID de la distribución. + Ejecute el comando en una línea. En el ejemplo, se proporcionan saltos de línea para que el ejemplo sea más legible. ``` aws cloudfront update-distribution \ --id DistributionID \ --cli-input-yaml file://dist-config.yaml ``` Cuando el comando se realiza correctamente verá una salida como la siguiente, que describe la distribución que se acaba de actualizar con la asociación de función. La siguiente salida de ejemplo se trunca para que sea más legible. ``` 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 ``` ------ El `Status` de la distribución cambia a `InProgress` mientras la distribución se vuelve a implementar. Cuando la nueva configuración de distribución llega a una ubicación periférica de CloudFront, esa ubicación periférica comienza a utilizar la función asociada. Cuando la distribución esté completamente implementada, `Status` volverá a `Deployed`. Esto indica que la CloudFront Function asociada está activa en todas las ubicaciones periféricas de CloudFront en todo el mundo. Esto normalmente dura unos minutos. # Amazon CloudFront KeyValueStore CloudFront KeyValueStore es un almacén de datos clave-valor seguro, global y de baja latencia que permite el acceso de lectura desde [CloudFront Functions](cloudfront-functions.md), lo que permite una lógica personalizable avanzada en las ubicaciones periféricas de CloudFront. Con CloudFront KeyValueStore, puede actualizar el código de la función y los datos asociados a una función de forma independiente. Esta separación simplifica el código de la función y facilita la actualización de los datos sin necesidad de implementar cambios en el código. **nota** Para usar CloudFront KeyValueStore, la función de CloudFront debe usar el [tiempo de ejecución 2.0 de JavaScript](functions-javascript-runtime-20.md). A continuación, se muestra el procedimiento general para usar pares clave-valor: + Cree almacenes de clave-valor y llénelos con un conjunto de pares clave-valor. Puede agregar los almacenes de clave-valor a un bucket de Amazon S3 o introducirlos manualmente. + Asocie los almacenes de clave-valor a la función de CloudFront. + En el código de la función, utilice el nombre de la clave para recuperar el valor asociado a la clave o para evaluar si existe una clave. Para obtener más información sobre el uso de pares clave-valor en el código de la función y sobre los métodos auxiliares, consulte [Métodos auxiliares para almacenes de clave-valor](functions-custom-methods.md). ## Casos de uso Puede utilizar pares clave-valor para los siguientes ejemplos: + **Reescrituras o redirecciones de URL**: el par clave-valor puede contener las URL reescritas o las URL redirigidas. + **Pruebas A/B y marcadores de características**: puede crear una función para realizar experimentos asignando un porcentaje del tráfico a una versión específica del sitio web. + **Autorización de acceso**: puede implementar el control de acceso para permitir o denegar las solicitudes en función de los criterios que haya definido y de los datos almacenados en un almacén de clave-valor. ## Formatos de valores compatibles Puede almacenar el valor en un par clave-valor en cualquiera de los siguientes formatos: + Cadena + Cadena codificada en bytes + JSON ## Seguridad La función de CloudFront y todos los datos de los almacenes de clave-valor se gestionan de forma segura, de la siguiente manera: + CloudFront cifra cada almacén de clave-valor en reposo y durante el tránsito (al leer o escribir en los almacenes de clave-valor) cuando llame a las operaciones de la API [CloudFront KeyValueStore](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_Operations_Amazon_CloudFront_KeyValueStore.html). + Cuando se ejecuta la función, CloudFront descifra cada par clave-valor de la memoria en las ubicaciones periféricas de CloudFront. Para comenzar a utilizar CloudFront KeyValueStore, consulte los siguientes temas. **Topics** + [Casos de uso](#key-value-store-use-cases) + [Formatos de valores compatibles](#key-value-store-supported-formats) + [Seguridad](#key-value-store-security) + [Trabajo con un almacén de clave-valor](kvs-with-functions-kvs.md) + [Trabajo con datos de clave-valor](kvs-with-functions-kvp.md) + Para obtener más información sobre la introducción a CloudFront KeyValueStore, consulte la entrada de blog de AWS [Introducing Amazon CloudFront KeyValueStore](https://aws.amazon.com/blogs/aws/introducing-amazon-cloudfront-keyvaluestore-a-low-latency-datastore-for-cloudfront-functions/). # Trabajo con un almacén de clave-valor Debe crear un almacén de clave-valor para almacenar los pares clave-valor que desee utilizar en CloudFront Functions. Una vez que cree los almacenes de clave-valor y los pares clave-valor agregados, puede usar las claves-valores en el código de la función de CloudFront. Para comenzar, consulte los siguientes temas: **Topics** + [Creación de un almacén de clave-valor](kvs-with-functions-create.md) + [Asociación de un almacén de clave-valor a una función](kvs-with-functions-associate.md) + [Actualización de un almacén de clave-valor](kvs-with-functions-edit.md) + [Obtención de una referencia a un almacén de clave-valor](kvs-with-functions-get-reference.md) + [Eliminación de un almacén de clave-valor](kvs-with-functions-delete.md) + [Formato de archivo para pares clave-valor](kvs-with-functions-create-s3-kvp.md) **nota** El tiempo de ejecución 2.0 de JavaScript incluye algunos métodos auxiliares para trabajar con claves-valor en el código de la función. Para obtener más información, consulte [Métodos auxiliares para almacenes de clave-valor](functions-custom-methods.md). # Creación de un almacén de clave-valor Puede crear un almacén de clave-valor y los pares clave-valor al mismo tiempo. Puede crear también un almacén de clave-valor vacío ahora y luego agregar pares clave-valor. **nota** Si especifica el origen de datos de un bucket de Amazon S3, debe tener los permisos `s3:GetObject` y `s3:GetBucketLocation` de ese bucket. Si no tiene estos permisos, CloudFront no podrá crear correctamente el almacén de clave-valor. Decida si quiere agregar pares clave-valor al mismo tiempo cuando crea el almacén de clave-valor. Puede importar los pares clave-valor mediante la consola de CloudFront, la API de CloudFront o los AWS SDK. Sin embargo, solo puede importar el archivo de pares clave-valor cuando *inicialmente* crea el almacén de clave-valor. Para crear un archivo de pares clave-valor, consulte [Formato de archivo para pares clave-valor](kvs-with-functions-create-s3-kvp.md). ------ #### [ Console ] **Creación de un almacén de clave-valor** 1. Inicie sesión en Consola de administración de AWS y abra la página **Funciones** en la consola de CloudFront en [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Elija la pestaña **KeyValueStores** y, a continuación, elija **Crear KeyValueStore**. 1. Introduzca un nombre y una descripción opcional para el almacén de clave-valor. 1. Complete **URI de S3**: + Si tiene un archivo de pares clave-valor, ingrese la ruta al bucket de Amazon S3 donde ha almacenado el archivo. + Deje este campo en blanco si piensa ingresar los pares clave-valor manualmente. 1. Seleccione **Crear**. El almacén de clave-valor ya existe. Aparece la página de detalles del nuevo almacén de clave-valor. La información de la página incluye el ID y el ARN del almacén de clave-valor. + El ID es una cadena aleatoria de caracteres que es única en la Cuenta de AWS. + El ARN tiene la siguiente sintaxis: *Cuenta de AWS*`:key-value-store/`*el ID del almacén de clave-valor* 1. Consulte la sección de **Pares clave-valor**. Si ha importado un archivo, en esta sección se muestran algunos pares clave-valor. Se puede hacer lo siguiente: + Si ha importado un archivo, también puede agregar más valores manualmente. + Si no ha importado un archivo desde un bucket de Amazon S3 y desea agregar pares clave-valor ahora, puede completar el siguiente paso. + Puede omitir este paso y agregar los pares clave-valor más adelante. 1. Para agregar los pares ahora: 1. Elija **Agregar pares clave-valor**. 1. Seleccione **Agregar par** e introduzca un nombre y un valor. Repita este paso para agregar más pares. 1. Cuando haya terminado, elija **Guardar cambios** para guardar todos los pares clave-valor del almacén de clave-valor. En el cuadro de diálogo que aparece, elija **Listo**. 1. Para asociar ahora el almacén de clave-valor a una función, complete la sección **Funciones asociadas**. Para obtener más información, consulte [Creación de funciones](create-function.md) o [Actualización de funciones](update-function.md). También puede asociar la función más adelante, ya sea desde esta página de detalles del almacén de clave-valor o desde la página de detalles de la función. ------ #### [ AWS CLI ] **Creación de un almacén de clave-valor** + Ejecute el siguiente comando para crear un almacén clave-valor e importar los pares clave-valor de un bucket de 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 ``` **Respuesta** ``` { "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 ] **Creación de un almacén de clave-valor** 1. Utilice la operación [CreateKeyValueStore de CloudFront](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_CreateKeyValueStore.html). La operación requiere varios parámetros: + Un `name` del almacén de clave-valor. + Un parámetro `comment` que incluye un comentario. + Un parámetro `import-source` que permite importar pares clave-valor desde un archivo almacenado en un bucket de Amazon S3. Solo podrá importar desde un archivo cuando cree por primera vez el almacén clave-valor. Para obtener información sobre la estructura de archivos, consulte [Formato de archivo para pares clave-valor](kvs-with-functions-create-s3-kvp.md). La respuesta de la operación incluye la siguiente información: + Los valores transferidos en la solicitud, incluido el nombre que asignó. + Datos como la hora de creación. + Una `ETag` (por ejemplo, `ETVABCEXAMPLE`), el ARN que incluye el nombre del almacén de clave-valor (por ejemplo, `arn:aws:cloudfront::123456789012:key-value-store/keyvaluestore1`). Utilizará alguna combinación de la `ETag`, el ARN y el nombre para trabajar con el almacén de clave-valor mediante programación. ------ ## Estados del almacén de clave-valor Al crear un almacén de clave-valor, el almacén de datos puede tener los siguientes valores de estado. **** | Valor | Descripción | | --- | --- | | **Aprovisionando** | Se ha creado el almacén de clave-valor y CloudFront está procesando el origen de datos que usted ha especificado. | | **Ready** | Se ha creado el almacén de clave-valor y CloudFront ha procesado correctamente el origen de datos que usted ha especificado. | | **Error al importar** | CloudFront no ha podido procesar el origen de datos que usted ha especificado. Este estado puede aparecer si el formato de archivo no es válido o si supera el límite de tamaño. Para obtener más información, consulte [Formato de archivo para pares clave-valor](kvs-with-functions-create-s3-kvp.md). | # Asociación de un almacén de clave-valor a una función Después de crear el almacén de clave-valor, puede actualizar la función para asociarla al almacén de clave-valor. Debe realizar esta asociación para utilizar los pares clave-valor de ese almacén en esa función. Se aplican las siguientes reglas: + Una función solo puede tener un almacén de clave-valor + Puede asociar el mismo almacén de clave-valor a varias funciones ------ #### [ Console ] **Asociación de un almacén de clave-valor a una función** 1. Inicie sesión en la consola de CloudFront en [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) y elija la página **Funciones**. 1. Elija el nombre de la función. 1. Vaya a la sección **Asociar KeyValueStore** y elija **Asociar KeyValueStore existente**. 1. Seleccione el almacén de clave-valor que contiene los pares clave-valor de la función y, a continuación, elija **Asociar KeyValueStore**. CloudFront asocia inmediatamente el almacén a la función. No necesita guardar la función. 1. Para especificar un almacén de clave-valor diferente, elija **Actualizar KeyValueStore asociado**, seleccione otro nombre de almacén de clave-valor y, a continuación, elija **Asociar KeyValueStore**. Para obtener más información, consulte [Actualización de funciones](update-function.md). ------ #### [ AWS CLI ] **Asociación de un almacén de clave-valor a una función** + Ejecute el siguiente comando para actualizar la función `MaxAge` y asociar un recurso de almacén de clave-valor. ``` 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 ``` + Para asociar un almacén de clave-valor a una función, especifique el parámetro `KeyValueStoreAssociations` y el ARN del almacén de clave-valor. + Para cambiar la asociación, especifique otro ARN de almacén de clave-valor. + Para eliminar la asociación, quite el parámetro `KeyValueStoreAssociations`. Para obtener más información, consulte [Actualización de funciones](update-function.md). ------ #### [ API ] **Asociación de un almacén de clave-valor a una función** + Utilice la operación de la API [UpdateFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateFunction.html). Para obtener más información, consulte [Actualización de funciones](update-function.md). ------ **Notas** Si modifica un almacén de clave-valor sin cambiar los pares clave-valor o si solo modifica los pares clave-valor sin cambiar el almacén de clave-valor, no necesita volver a asociarlo. Tampoco necesita volver a publicar la función. Sin embargo, le recomendamos que pruebe la función para comprobar que funciona según lo previsto. Para obtener más información, consulte [Prueba de funciones](test-function.md). Puede ver todas las funciones que utilizan determinados almacenes de clave-valor. En la consola de CloudFront, elija la página de detalles del almacén de clave-valor. # Actualización de un almacén de clave-valor Al actualizar un almacén de clave-valor, puede cambiar los pares clave-valor o cambiar la asociación entre el almacén de clave-valor y la función. ------ #### [ Console ] **Actualización de un almacén de clave-valor** 1. Inicie sesión en Consola de administración de AWS y abra la página **Funciones** en la consola de CloudFront en [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Elija la pestaña **KeyValueStores**. 1. Seleccione el almacén de clave-valor que desee actualizar. + Para actualizar los pares clave-valor, elija **Editar** en la sección **Pares clave-valor**. Puede agregar o eliminar cualquier par clave-valor. También puede cambiar el valor de un par clave-valor existente. Cuando haya finalizado, elija **Save changes** (Guardar cambios). + Para actualizar la asociación de este almacén de clave-valor, elija **Ir a las funciones**. Para obtener más información, consulte [Asociación de un almacén de clave-valor a una función](kvs-with-functions-associate.md). ------ #### [ AWS CLI ] **Actualización de un almacén de clave-valor** 1. **Cambiar los pares clave-valor**: puede agregar más pares clave-valor, eliminar uno o varios pares clave-valor y cambiar el valor de un par clave-valor existente. Para obtener más información, consulte [Trabajo con datos de clave-valor](kvs-with-functions-kvp.md). 1. **Cambiar la asociación de funciones para el almacén de clave-valor**: para actualizar la asociación de funciones para el almacén de clave-valor, consulte [Asociación de un almacén de clave-valor a una función](kvs-with-functions-associate.md). **sugerencia** Necesitará el ARN del almacén de clave-valor. Para obtener más información, consulte [Obtención de una referencia a un almacén de clave-valor](kvs-with-functions-get-reference.md). ------ #### [ API ] **Actualización de un almacén de clave-valor** 1. **Cambiar los pares clave-valor**: puede agregar más pares clave-valor, eliminar uno o varios pares clave-valor y cambiar el valor de un par clave-valor existente. Para obtener más información, consulte [Trabajo con datos de clave-valor](kvs-with-functions-kvp.md). 1. **Cambiar la asociación de funciones para el almacén de clave-valor**: para actualizar la asociación de funciones para el almacén de clave-valor, utilice la operación de la API [UpdateFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateFunction.html). Para obtener más información, consulte [Actualización de funciones](update-function.md). **sugerencia** Necesitará el ARN del almacén de clave-valor. Para obtener más información, consulte [Obtención de una referencia a un almacén de clave-valor](kvs-with-functions-get-reference.md). ------ # Obtención de una referencia a un almacén de clave-valor Para trabajar con los almacenes de clave-valor mediante programación, necesita la `ETag` y el nombre del almacén de clave-valor. Para obtener ambos valores, puede usar la AWS Command Line Interface (AWS CLI) o la API de CloudFront. ------ #### [ AWS CLI ] **Obtención de la referencia del almacén de clave-valor** 1. Para obtener una lista de almacenes de clave-valor, ejecute el siguiente comando. Busque el nombre del almacén de clave-valor que desea modificar. ``` aws cloudfront list-key-value-stores ``` 1. A partir de la respuesta, busque el nombre del almacén de clave-valor que desee. **Respuesta** ``` { "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. Ejecute el siguiente comando para devolver la `ETag` para el almacén de clave-valor especificado. ``` aws cloudfront describe-key-value-store \ --name=keyvaluestore1 ``` **Respuesta** ``` { "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 ] **Obtención de la referencia del almacén de clave-valor** 1. Utilice la operación de la API [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html) para obtener una lista de almacenes de clave-valor. Busque el nombre del almacén de clave-valor que desee cambiar. 1. Utilice la operación de la API [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeKeyValueStore.html) y especifique el nombre del almacén de clave-valor que devolvió en el paso anterior. ------ La respuesta incluye un UUID, el ARN del almacén de clave-valor y la `ETag` del almacén de clave-valor. + Una `ETag`, como `E3UN6WX5RRO2AG` + El UUID es de 128 bits, como `8aa76c93-3198-462c-aaf6-example` + El ARN incluye el número de Cuenta de AWS, el `key-value-store` constante y el UUID, como en el siguiente ejemplo: `arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example` Para obtener más información acerca de la operación `DescribeKeyValueStore`, consulte [Acerca de CloudFront KeyValueStore](kvs-with-functions-kvp.md#kvs-with-functions-api-describe). # Eliminación de un almacén de clave-valor Puede eliminar el almacén de clave-valor mediante la consola de Amazon CloudFront o la API. ------ #### [ Console ] **Eliminación de un almacén de clave-valor** 1. Inicie sesión en Consola de administración de AWS y abra la página **Funciones** en la consola de CloudFront en [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Elija el nombre de la función. 1. En la sección **KeyValueStore asociado**, compruebe si hay un almacén de clave-valor asociado a la función. Si es así, elimine la asociación eligiendo **Desasociar KeyValueStore** y, a continuación, elija **Eliminar asociación**. 1. En el panel de navegación, elija la página **Funciones** y, a continuación, elija la pestaña **KeyValueStores**. 1. Seleccione el almacén de clave-valor que desea eliminar y, a continuación, elija **Eliminar**. ------ #### [ AWS CLI ] **Eliminación de un almacén de clave-valor** 1. Obtenga la `ETag` y el nombre de los almacenes de clave-valor. Para obtener más información, consulte [Obtención de una referencia a un almacén de clave-valor](kvs-with-functions-get-reference.md). 1. Compruebe si los almacenes de clave-valor están asociados a una función. Si lo está, elimine la asociación. Para obtener más información sobre los dos pasos, consulte [Actualización de funciones](update-function.md). 1. Cuando tenga el nombre y la `ETag` del almacén de clave-valor y ya no esté asociado a una función, podrá eliminarlo. Ejecute el siguiente comando para eliminar el almacén de clave-valor especificado. ``` aws cloudfront delete-key-value-store \ --name=keyvaluestore1 \ --if-match=E3UN6WX5RRO2AG ``` ------ #### [ API ] **Eliminación de un almacén de clave-valor** 1. Obtenga la `ETag` y el nombre de los almacenes de clave-valor. Para obtener más información, consulte [Obtención de una referencia a un almacén de clave-valor](kvs-with-functions-get-reference.md). 1. Compruebe si los almacenes de clave-valor están asociados a una función. Si lo está, elimine la asociación. Para obtener más información sobre los dos pasos, consulte [Actualización de funciones](update-function.md). 1. Para eliminar el almacén de clave-valor, utilice la operación de la API [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DeleteKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DeleteKeyValueStore.html) de CloudFront. ------ # Formato de archivo para pares clave-valor Al crear un archivo codificado con UTF-8, utilice el siguiente formato JSON: ``` { "data":[ { "key":"key1", "value":"value" }, { "key":"key2", "value":"value" } ] } ``` El archivo no puede incluir claves duplicadas. Si especificó un archivo no válido en el bucket de Amazon S3, puede actualizar el archivo para eliminar cualquier duplicado y, a continuación, intentar crear de nuevo el almacén de clave-valor. Para obtener más información, consulte [Creación de un almacén de clave-valor](kvs-with-functions-create.md). **nota** El archivo de su origen de datos y sus pares clave-valor tienen los siguientes límites: Tamaño del archivo: 5 MB Tamaño de la clave: 512 caracteres Tamaño del valor: 1024 caracteres # Trabajo con datos de clave-valor Este tema describe cómo agregar pares clave-valor a un almacén de clave-valor existente. Para incluir pares clave-valor al crear inicialmente los almacenes de clave-valor, consulte [Creación de un almacén de clave-valor](kvs-with-functions-create.md). **Topics** + [Uso de pares clave-valor (consola)](#kvs-with-functions-kvp-using-console) + [Acerca de CloudFront KeyValueStore](#kvs-with-functions-api-describe) + [Uso de pares clave-valor (AWS CLI)](#work-with-kvs-cli-keys) + [Uso de pares clave-valor (API)](#kvs-with-functions-kvp-using-api) ## Uso de pares clave-valor (consola) Puede utilizar la consola de CloudFront para trabajar con los pares clave-valor. **Trabajo con pares clave-valor** 1. Inicie sesión en Consola de administración de AWS y abra la página **Funciones** en la consola de CloudFront en [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Elija la pestaña **KeyValueStores**. 1. Seleccione el almacén de clave-valor que desee cambiar. 1. En la sección **Pares clave-valor**, elija **Editar**. 1. Puede agregar un par clave-valor, eliminar cualquier par clave-valor o cambiar el valor de un par clave-valor existente. 1. Cuando haya finalizado, elija **Save changes** (Guardar cambios). ## Acerca de CloudFront KeyValueStore **sugerencia** La API KeyValueStore de CloudFront es un servicio global que utiliza Signature Version 4A (SigV4A) para la autenticación. Utilizar credenciales temporales con SigV4A requiere tokens de sesión de la versión 2. Para obtener más información, consulte [Uso de credenciales temporales con la API KeyValueStore de CloudFront](cloudfront-function-restrictions.md#regional-endpoint-for-key-value-store). Si utiliza la AWS Command Line Interface (AWS CLI) o el código propio para llamar a la API KeyValueStore de CloudFront, consulte las secciones siguientes. Cuando trabaja con un almacén de clave-valor y sus pares clave-valor, el servicio al que llame depende del caso de uso: + Para trabajar con pares clave-valor en un almacén de clave-valor *existente*, utilice el servicio KeyValueStore de CloudFront. + Para incluir pares clave-valor en el almacén de clave-valor al crear *inicialmente* el almacén de clave-valor, utilice el servicio de CloudFront. Tanto la API de CloudFront como la API de CloudFront KeyValueStore tienen una operación `DescribeKeyValueStore`. Las llama por diferentes motivos. Para entender las diferencias, consulte la siguiente tabla. | | API de CloudFront DescribeKeyValueStore | API de CloudFront KeyValueStore DescribeKeyValueStore | | --- | --- | --- | | Datos sobre el almacén de clave-valor | Devuelve datos, como el estado y la fecha en que se modificó por última vez el propio almacén de clave-valor. | Devuelve datos sobre el *contenido* del recurso de almacenamiento: los pares clave-valor del almacén y el tamaño del contenido. | | Datos que identifican el almacén de clave-valor | Devuelve una `ETag`, el UUID y el ARN del almacén de clave-valor. | Devuelve una `ETag` y el ARN del almacén de clave-valor. | **Notas** Cada operación DescribeKeyValueStore devuelve una `ETag` *diferente*. Las `ETags` no son intercambiables. Al llamar a una operación de la API para completar una acción, debe especificar la `ETag` de la API correspondiente. Por ejemplo, en la operación [DeleteKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DeleteKey.html) de KeyValueStore de CloudFront, especifique la `ETag` que devolvió de la operación [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html) de KeyValueStore de CloudFront. Cuando invoca CloudFront Functions mediante CloudFront KeyValueStore, los valores del almacén de valores clave no se actualizan ni cambian durante la invocación de la función. Las actualizaciones se procesan entre las invocaciones de una función. ## Uso de pares clave-valor (AWS CLI) Puede ejecutar los siguientes comandos de la AWS Command Line Interface para KeyValueStore de CloudFront. **Contents** + [Enumeración de pares clave-valor](#kvs-cli-list-keys) + [Obtención de pares clave-valor](#kvs-cli-get-keys) + [Descripción de un almacén de clave-valor](#kvs-cli-describe-keys) + [Creación de un par clave-valor](#kvs-cli-create-keys) + [Eliminación de un par clave-valor](#kvs-cli-delete-keys) + [Actualización de pares clave-valor](#kvs-cli-update-key) ### Enumeración de pares clave-valor Para enumerar los pares clave-valor del almacén de clave-valor, ejecute el siguiente comando. ``` aws cloudfront-keyvaluestore list-keys \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Respuesta** ``` { "Items": [ { "Key": "key1", "Value": "value1" } ] } ``` ### Obtención de pares clave-valor Para obtener un par clave-valor del almacén de clave-valor, ejecute el siguiente comando. ``` aws cloudfront-keyvaluestore get-key \ --key=key1 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Respuesta** ``` { "Key": "key1", "Value": "value1", "ItemCount": 1, "TotalSizeInBytes": 11 } ``` ### Descripción de un almacén de clave-valor Para describir un almacén de clave-valor, ejecute el siguiente comando. ``` aws cloudfront-keyvaluestore describe-key-value-store \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Respuesta** ``` { "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" } ``` ### Creación de un par clave-valor Para crear un par clave-valor en el almacén de clave-valor, ejecute el siguiente comando. ``` 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 ``` **Respuesta** ``` { "ETag": "KV13V1IB3VIYZZH", "ItemCount": 3, "TotalSizeInBytes": 31 } ``` ### Eliminación de un par clave-valor Para eliminar un par clave-valor, ejecute el siguiente comando. ``` aws cloudfront-keyvaluestore delete-key \ --if-match=KV13V1IB3VIYZZH \ --key=key1 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Output** ``` { "ETag": "KV1VC38T7YXB528", "ItemCount": 2, "TotalSizeInBytes": 22 } ``` ### Actualización de pares clave-valor Puede utilizar el comando `update-keys` para actualizar más de un par clave-valor. Por ejemplo, para eliminar un par clave-valor existente y crear otro, ejecute el siguiente comando. ``` 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"}]' ``` **Respuesta** ``` { "ETag": "KV3AEGXETSR30VB", "ItemCount": 3, "TotalSizeInBytes": 28 } ``` ## Uso de pares clave-valor (API) Siga esta sección para trabajar con los pares clave-valor mediante programación. **Contents** + [Obtención de una referencia a un almacén de clave-valor](#kvs-with-functions-api-ref) + [Cambio de los pares clave-valor en un almacén de clave-valor](#kvs-with-functions-api-actions) + [Código de ejemplo para CloudFront KeyValueStore](#example-code-key-value-store) ### Obtención de una referencia a un almacén de clave-valor Cuando utilice la API KeyValueStore de CloudFront para llamar a una operación de escritura, debe especificar el ARN y la `ETag` del almacén de clave-valor. Para obtener estos datos, haga lo siguiente: **Obtención de una referencia a un almacén de clave-valor** 1. Utilice la operación de la API [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html) para obtener una lista de almacenes de clave-valor. Busque el almacén de clave-valor que desee cambiar. 1. Utilice la [operación de la API CloudFrontKeyValueStore DescribeKeyValueStore](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html) y especifique el almacén de clave-valor del paso anterior. La respuesta incluye el ARN y la `ETag` del almacén de clave-valor. + El ARN incluye el número de Cuenta de AWS, el `key-value-store` constante y el UUID, como en el siguiente ejemplo: `arn:aws:cloudfront::123456789012:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111` + Una `ETag` como la del siguiente ejemplo: `ETVABCEXAMPLE2` ### Cambio de los pares clave-valor en un almacén de clave-valor Puede especificar el almacén de clave-valor que contiene el par clave-valor que desea actualizar. Consulte las siguientes operaciones de la API de CloudFront KeyValueStore: + [CloudFrontKeyValueStore DeleteKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DeleteKey.html): elimina un par clave-valor + [CloudFrontKeyValueStore GetKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_GetKey.html): devuelve un par clave-valor + [CloudFrontKeyValueStore ListKeys](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_ListKeys.html): devuelve una lista de pares clave-valor + [CloudFrontKeyValueStore PutKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_PutKey.html): puede realizar las siguientes tareas: + Cree un par clave-valor en un almacén de clave-valor especificando un nombre y un valor de clave nuevos. + Establezca un valor diferente en un par clave-valor existente especificando un nombre de clave existente y un valor de clave nuevo. + [CloudFrontKeyValueStore UpdateKeys](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_UpdateKeys.html): puede realizar una o más de las siguientes acciones en una operación de todo o nada: + Eliminación de uno o varios pares clave-valor + Creación de uno o varios pares clave-valor nuevos + Establecimiento de un valor diferente en uno o varios pares clave-valor existentes ### Código de ejemplo para CloudFront KeyValueStore **Example** En el siguiente código, se muestra cómo llamar a la operación de la API `DescribeKeyValueStore` de un almacén de clave-valor. ``` 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); } })(); ```