Here is your custom content.
" } } } ``` ## Exemplo de objeto de evento O exemplo a seguir mostra um objeto `event` completo. Este é um exemplo de invocação para uma distribuição padrão, e não para uma distribuição multilocatário. Para distribuições multilocatário, é usado o campo `endpoint`, em vez de `distributionDomainName`. O valor de `endpoint` é o nome de domínio do CloudFront (por exemplo, d111111abcdef8.cloudfront.net) do grupo de conexões associado ao evento. **nota** O objeto `event` é a entrada para sua função. Sua função retorna apenas o objeto `request` ou `response`, não o 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" } ] } } } } ``` # Recursos de tempo de execução JavaScript para funções do CloudFront O ambiente de runtime do JavaScript do CloudFront Functions é compatível com o [ECMAScript (ES) versão 5.1](https://www.ecma-international.org/ecma-262/5.1/) e também é compatível com alguns recursos das versões 6 a 12 do ES. Para ter os recursos mais atualizados, recomendamos usar o JavaScript runtime 2.0. Os recursos do JavaScript runtime 2.0 têm as seguintes alterações em comparação com o 1.0: + Os métodos do módulo de buffer estão disponíveis. + Os seguintes métodos de protótipo de string não padrão não estão disponíveis: + `String.prototype.bytesFrom()` + `String.prototype.fromBytes()` + `String.prototype.fromUTF8()` + `String.prototype.toBytes()` + `String.prototype.toUTF8()` + O módulo criptográfico tem as seguintes alterações: + `hash.digest()`: o tipo de retorno será alterado para `Buffer` se nenhuma codificação for fornecida. + `hmac.digest()`: o tipo de retorno será alterado para `Buffer` se nenhuma codificação for fornecida. + Para ter mais informações sobre novos recursos adicionais, consulte [Recursos de runtime 2.0 do JavaScript para CloudFront Functions](functions-javascript-runtime-20.md). **Topics** + [Recursos de runtime 1.0 do JavaScript](functions-javascript-runtime-10.md) + [Recursos de runtime 2.0 do JavaScript](functions-javascript-runtime-20.md) # Recursos de runtime 1.0 do JavaScript para CloudFront Functions O ambiente de runtime do JavaScript do CloudFront Functions é compatível com o [ECMAScript (ES) versão 5.1](https://262.ecma-international.org/5.1/) e também é compatível com alguns recursos das versões ES 6 a 9. Ele também fornece alguns métodos não padronizados que não fazem parte das especificações ES. Os tópicos a seguir listam todos os recursos de idioma compatíveis. **Topics** + [Recursos principais](#writing-functions-javascript-features-core) + [Objetos primitivos](#writing-functions-javascript-features-primitive-objects) + [Objetos integrados](#writing-functions-javascript-features-builtin-objects) + [Tipos de erro](#writing-functions-javascript-features-error-types) + [Variáveis globais](#writing-functions-javascript-features-globals) + [Módulos integrados](#writing-functions-javascript-features-builtin-modules) + [Recursos restritos](#writing-functions-javascript-features-restricted-features) ## Recursos principais Os seguintes recursos principais do ES são compatíveis. **Tipos** Todos os tipos ES 5.1 são compatíveis. Isso inclui valores booleanos, números, cadeias de caracteres, objetos, matrizes, funções, construtores de funções e expressões regulares. **Operadores** Todos os operadores ES 5.1 são compatíveis. O operador de exponenciação ES 7 (`**`) é compatível. **Declarações** As instruções `const` e `let` não são compatíveis. As seguintes instruções ES 5.1 são compatíveis: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `return` + `switch` + `throw` + `try` + `var` + `while` + Instruções rotuladas **Literais** Os literais de modelo ES 6 são compatíveis: cadeias de várias linhas, interpolação de expressão e modelos de aninhamento. **Funções** Todos os recursos de função ES 5.1 são compatíveis. As funções de seta ES 6 são compatíveis, assim como a sintaxe de parâmetro de descanso ES 6. **Unicode** Texto de origem e literais de cadeias de caracteres podem conter caracteres codificados em Unicode. Sequências de escape de ponto de código Unicode de seis caracteres (por exemplo, `\uXXXX`) também são compatíveis. **Modo estrito** As funções operam no modo estrito por padrão, então você não precisa adicionar uma instrução `use strict` ao seu código de função. Elas não podem ser alteradas. ## Objetos primitivos Os seguintes objetos primitivos de ES são compatíveis. **Objeto** Os seguintes métodos ES 5.1 em objetos são compatíveis: + `create` (sem lista de propriedades) + `defineProperties` + `defineProperty` + `freeze` + `getOwnPropertyDescriptor` + `getOwnPropertyNames` + `getPrototypeOf` + `hasOwnProperty` + `isExtensible` + `isFrozen` + `prototype.isPrototypeOf` + `isSealed` + `keys` + `preventExtensions` + `prototype.propertyIsEnumerable` + `seal` + `prototype.toString` + `prototype.valueOf` Os seguintes métodos ES 6 em objetos são compatíveis: + `assign` + `is` + `prototype.setPrototypeOf` Os seguintes métodos ES 8 em objetos são compatíveis: + `entries` + `values` **String** Os seguintes métodos ES 5.1 em cadeias de caracteres são compatíveis: + `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` Os seguintes métodos ES 6 em cadeias de caracteres são compatíveis: + `fromCodePoint` + `prototype.codePointAt` + `prototype.endsWith` + `prototype.includes` + `prototype.repeat` + `prototype.startsWith` Os seguintes métodos ES 8 em cadeias de caracteres são compatíveis: + `prototype.padStart` + `prototype.padEnd` Os seguintes métodos ES 9 em cadeias de caracteres são compatíveis: + `prototype.trimStart` + `prototype.trimEnd` Os seguintes métodos não padronizados em cadeias de caracteres são compatíveis: + `prototype.bytesFrom(array | string, encoding)` Cria uma cadeia de caracteres de bytes de uma matriz de octetos ou uma cadeia de caracteres codificada. As opções de codificação de cadeia de caracteres são `hex`, `base64` e `base64url`. + `prototype.fromBytes(start[, end])` Cria uma cadeia de caracteres Unicode de uma cadeia de caracteres de bytes em que cada byte é substituído pelo ponto de código Unicode correspondente. + `prototype.fromUTF8(start[, end])` Cria uma cadeia de caracteres Unicode de uma cadeia de caracteres de bytes codificada UTF-8. Se a codificação estiver incorreta, ela retorna `null`. + `prototype.toBytes(start[, end])` Cria uma cadeia de caracteres de bytes de uma cadeia de caracteres Unicode. Todos os caracteres devem estar no intervalo de [0.255]. Se não, ele retorna `null`. + `prototype.toUTF8(start[, end])` Cria uma cadeia de caracteres de bytes codificada UTF-8 de uma cadeia de caracteres Unicode. **telefone** Todos os métodos ES 5.1 em números são compatíveis. Os seguintes métodos ES 6 em números são compatíveis: + `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 Os seguintes objetos integrados do ES são compatíveis. **Matemática** Todos os métodos matemáticos ES 5.1 são compatíveis. No ambiente de tempo de execução do CloudFront Functions, a implementação `Math.random()` usa o OpenBSD `arc4random` propagado com o carimbo de data/hora de quando a função é executada. Os seguintes métodos matemáticos ES 6 são compatíveis: + `acosh` + `asinh` + `atanh` + `cbrt` + `clz32` + `cosh` + `expm1` + `fround` + `hypot` + `imul` + `log10` + `log1p` + `log2` + `sign` + `sinh` + `tanh` + `trunc` + `E` + `LN10` + `LN2` + `LOG10E` + `LOG2E` + `PI` + `SQRT1_2` + `SQRT2` **Data** Todos os recursos `Date` do ES 5.1 são compatíveis. Por razões de segurança, `Date` sempre retorna o mesmo valor, que seria o horário de início da função, durante o tempo de vida de uma única execução de função. Para obter mais informações, consulte [Recursos restritos](#writing-functions-javascript-features-restricted-features). **Função** Os métodos `apply`, `bind` e `call` são compatíveis. Os construtores de função não são compatíveis. **Expressões regulares** Todos os recursos de expressão regular ES 5.1 são compatíveis. A linguagem de expressão regular é compatível com Perl. Os grupos de captura nomeados ES 9 são compatíveis. **JSON** Todos os recursos JSON ES 5.1 são compatíveis, incluindo `parse` e `stringify`. **Array** Os seguintes métodos ES 5.1 em matrizes são compatíveis: + `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` Os seguintes métodos ES 6 em matrizes são compatíveis: + `of` + `prototype.copyWithin` + `prototype.fill` + `prototype.find` + `prototype.findIndex` Os seguintes métodos ES 7 em matrizes são compatíveis: + `prototype.includes` **Matrizes digitadas** As seguintes matrizes ES 6 digitadas são compatíveis: + `Int8Array` + `Uint8Array` + `Uint8ClampedArray` + `Int16Array` + `Uint16Array` + `Int32Array` + `Uint32Array` + `Float32Array` + `Float64Array` + `prototype.copyWithin` + `prototype.fill` + `prototype.join` + `prototype.set` + `prototype.slice` + `prototype.subarray` + `prototype.toString` **ArrayBuffer** Os seguintes métodos em `ArrayBuffer` são compatíveis: + `prototype.isView` + `prototype.slice` **Promessa** Os seguintes métodos em promises são compatíveis: + `reject` + `resolve` + `prototype.catch` + `prototype.finally` + `prototype.then` **Criptografia** O módulo criptográfico fornece auxiliares de código de autenticação de mensagens (HMAC) padrão e hash. Você pode carregar o módulo usando `require('crypto')`. O módulo expõe os seguintes métodos que se comportam exatamente como suas contrapartes Node.js: + `createHash(algorithm)` + `hash.update(data)` + `hash.digest([encoding])` + `createHmac(algorithm, secret key)` + `hmac.update(data)` + `hmac.digest([encoding])` Para mais informações, consulte [Criptográficos (hash e HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) na seção de módulos integrados. **Console** Este é um objeto auxiliar para depuração. Ele só é compatível com o método `log()` para gravar mensagens de log. O CloudFront Functions não é compatível com sintaxe de vírgula, como `console.log('a', 'b')`. Em vez disso, use o formato `console.log('a' + ' ' + 'b')`. ## Tipos de erro Os seguintes objetos de erro são compatíveis: + `Error` + `EvalError` + `InternalError` + `MemoryError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Variáveis globais O objeto `globalThis` é compatível. As seguintes funções globais do ES 5.1 são compatíveis: + `decodeURI` + `decodeURIComponent` + `encodeURI` + `encodeURIComponent` + `isFinite` + `isNaN` + `parseFloat` + `parseInt` As seguintes restrições globais são válidas: + `NaN` + `Infinity` + `undefined` ## Módulos integrados Os seguintes módulos integrados são compatíveis: **Topics** + [Criptográficos (hash e HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) + [String de consulta](#writing-functions-javascript-features-builtin-modules-query-string) ### Criptográficos (hash e HMAC) O módulo criptográfico (`crypto`) fornece auxiliares de código de autenticação de mensagens (HMAC) padrão e hash. Você pode carregar o módulo usando `require('crypto')`. O módulo fornece os seguintes métodos que se comportam exatamente como suas contrapartes Node.js. **Métodos de hash** `crypto.createHash(algorithm)` Cria e retorna um objeto hash que você pode usar para gerar resumos de hash usando o algoritmo fornecido: `md5`, `sha1` ou `sha256`. `hash.update(data)` Atualiza o conteúdo de hash com os fornecido `data`. `hash.digest([encoding])` Calcula o resumo de todos os dados passados usando `hash.update()`. A codificação pode ser `hex`, `base64` ou `base64url`. **Métodos de HMAC** `crypto.createHmac(algorithm, secret key)` Cria e retorna um objeto HMAC que usa o `algorithm` e a `secret key` fornecidos. O algoritmo pode ser `md5`, `sha1` ou `sha256`. `hmac.update(data)` Atualiza o conteúdo HMAC com os fornecido `data`. `hmac.digest([encoding])` Calcula o resumo de todos os dados passados usando `hmac.update()`. A codificação pode ser `hex`, `base64` ou `base64url`. ### String de consulta **nota** O [objeto de evento CloudFront Functions](functions-event-structure.md) analisa automaticamente as cadeias de consulta de URL para você. Isso significa que na maioria dos casos você não precisa usar este módulo. O módulo cadeia de consulta (`querystring`) fornece métodos para analisar e formatar cadeias de consulta de URL. Você pode carregar o módulo usando `require('querystring')`. O módulo fornece os seguintes métodos: `querystring.escape(string)` O URL codifica a `string` fornecida, retornando uma cadeia de consulta escapada. O método é usado por `querystring.stringify()` e não deve ser usado diretamente. `querystring.parse(string[, separator[, equal[, options]]])` Analisa uma cadeia de consulta (`string`) e retorna um objeto. O parâmetro `separator` é uma substring para delimitar pares de chaves e valores na cadeia de consulta. O padrão é `&`. O parâmetro `equal` é uma substring para delimitar chaves e valores na cadeia de consulta. O padrão é `=`. O parâmetro `options` é um objeto com as seguintes chaves: `decodeURIComponent function` Uma função para decodificar caracteres codificados por percentual na cadeia de consulta. O padrão é `querystring.unescape()`. `maxKeys number` O número máximo de chaves a serem analisadas. O padrão é `1000`. Use um valor de `0` para remover as limitações para as chaves de contagem. Por padrão, os caracteres codificados por percentual dentro da cadeia de consulta são assumidos para usar a codificação UTF-8. Sequências UTF-8 inválidas são substituídas pelo caractere de substituição `U+FFFD`. Por exemplo, para a seguinte cadeia de consulta: ``` 'name=value&abc=xyz&abc=123' ``` O valor de retorno de `querystring.parse()` é: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` é um alias para `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serializa um `object` e retorna uma cadeia de consulta. O parâmetro `separator` é uma substring para delimitar pares de chaves e valores na cadeia de consulta. O padrão é `&`. O parâmetro `equal` é uma substring para delimitar chaves e valores na cadeia de consulta. O padrão é `=`. O parâmetro `options` é um objeto com as seguintes chaves: `encodeURIComponent function` A função a ser usada para converter caracteres URL-inseguros para codificação percentual na cadeia de consulta. O padrão é `querystring.escape()`. Por padrão, os caracteres que exigem percentual de codificação dentro da cadeia de consulta são codificados como UTF-8. Para usar uma codificação diferente, especifique a opção `encodeURIComponent`. Por exemplo, para o seguinte código: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` O valor de retorno é: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` é um alias para `querystring.stringify()`. `querystring.unescape(string)` Decodifica caracteres codificados por porcentagem de URL na `string` fornecida, retornando uma cadeia de consulta sem escapamento. Esse método é usado por `querystring.parse()` e não deve ser usado diretamente. ## Recursos restritos Os seguintes recursos de linguagem JavaScript não são compatíveis ou são restritos devido a preocupações de segurança. **Avaliação dinâmica do código** A avaliação dinâmica do código não é compatível. Ambos os construtores `eval()` e `Function` lançam um erro se forem tentados. Por exemplo, `const sum = new Function('a', 'b', 'return a + b')` lança um erro. **Temporizadores ** As funções `setTimeout()`, `setImmediate()` e `clearTimeout()` não são compatíveis. Não há provisão para adiar ou renderizar dentro de uma execução de função. Sua função deve ser executada de forma síncrona até a conclusão. **Data e carimbos de data/hora** Por razões de segurança, não há acesso a temporizadores de alta resolução. Todos os métodos `Date` para consultar a hora atual sempre retornam o mesmo valor durante o tempo de vida de uma única execução de função. O carimbo de data/hora retornado é o momento em que a função começou a ser executada. Consequentemente, você não pode medir o tempo decorrido em sua função. **Acesso ao sistema de arquivos** Não há acesso ao sistema de arquivos. Por exemplo, não há módulo `fs` para acesso ao sistema de arquivos como no Node.js. **Acesso a processos** Não há acesso a processos. Por exemplo, não há um objeto global `process` para processar o acesso às informações como no Node.js. **Variáveis de ambiente** Não há acesso às variáveis de ambiente. Em vez disso, é possível usar o KeyValueStore do CloudFront para criar um datastore centralizado de pares de chave-valor para o CloudFront Functions. O KeyValueStore do CloudFront permite atualizações dinâmicas nos dados de configuração sem a necessidade de implantar alterações no código. É necessário usar o [JavaScript runtime 2.0](functions-javascript-runtime-20.md) para usar o KeyValueStore do CloudFront. Para obter mais informações, consulte [Amazon CloudFront KeyValueStore](kvs-with-functions.md). **Acesso à rede** Não há suporte para chamadas de rede. Por exemplo, XHR, HTTP (S) e socket não são compatíveis. # Recursos de runtime 2.0 do JavaScript para CloudFront Functions O ambiente de runtime do JavaScript do CloudFront Functions é compatível com o [ECMAScript (ES) versão 5.1](https://262.ecma-international.org/5.1/) e também é compatível com alguns recursos das versões 6 a 12 do ES. Ele também fornece alguns métodos não padronizados que não fazem parte das especificações ES. Os tópicos a seguir listam todos os recursos compatíveis nesse runtime. **Topics** + [Recursos principais](#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 erro](#writing-functions-javascript-features-error-types-20) + [Variáveis globais](#writing-functions-javascript-features-globals-20) + [Módulos integrados](#writing-functions-javascript-features-builtin-modules-20) + [Recursos restritos](#writing-functions-javascript-features-restricted-features-20) ## Recursos principais Os seguintes recursos principais do ES são compatíveis. **Tipos** Todos os tipos ES 5.1 são compatíveis. Isso inclui valores boolianos, números, strings, objetos, matrizes, funções e expressões regulares. **Operadores** Todos os operadores ES 5.1 são compatíveis. O operador de exponenciação ES 7 (`**`) é compatível. **Declarações** As seguintes instruções ES 5.1 são compatíveis: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `label` + `return` + `switch` + `throw` + `try` + `var` + `while` As seguintes instruções do ES 6 são compatíveis: + `const` + `let` As seguintes instruções do ES 8 são compatíveis: + `async` + `await` `async`, `await`, `const` e `let` são compatíveis com o runtime 2.0 do JavaScript. `await` pode ser usado apenas dentro de funções `async`. Encerramentos e argumentos `async` não são compatíveis. **Literais** Os literais de modelo ES 6 são compatíveis: cadeias de várias linhas, interpolação de expressão e modelos de aninhamento. **Funções** Todos os recursos de função ES 5.1 são compatíveis. As funções de seta ES 6 são compatíveis, assim como a sintaxe de parâmetro de descanso ES 6. **Unicode** Texto de origem e literais de cadeias de caracteres podem conter caracteres codificados em Unicode. Sequências de escape de ponto de código Unicode de seis caracteres (por exemplo, `\uXXXX`) também são compatíveis. **Modo estrito** As funções operam no modo estrito por padrão, então você não precisa adicionar uma instrução `use strict` ao seu código de função. Elas não podem ser alteradas. ## Objetos primitivos Os seguintes objetos primitivos de ES são compatíveis. **Objeto** Os seguintes métodos ES 5.1 em objetos são compatíveis: + `Object.create()` (sem lista de propriedades) + `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()` Os seguintes métodos ES 6 em objetos são compatíveis: + `Object.assign()` Os seguintes métodos ES 8 em objetos são compatíveis: + `Object.entries()` + `Object.values()` Os seguintes métodos de protótipo do ES 5.1 em objetos são compatíveis: + `Object.prototype.hasOwnProperty()` + `Object.prototype.isPrototypeOf()` + `Object.prototype.propertyIsEnumerable()` + `Object.prototype.toString()` + `Object.prototype.valueOf()` Os seguintes métodos de protótipo do ES 6 em objetos são compatíveis: + `Object.prototype.is()` + `Object.prototype.setPrototypeOf()` **String** Os seguintes métodos ES 5.1 em cadeias de caracteres são compatíveis: + `String.fromCharCode()` Os seguintes métodos ES 6 em cadeias de caracteres são compatíveis: + `String.fromCodePoint()` Os seguintes métodos de protótipo do ES 5.1 em strings são compatíveis: + `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()` Os seguintes métodos de protótipo do ES 6 em strings são compatíveis: + `String.prototype.codePointAt()` + `String.prototype.endsWith()` + `String.prototype.includes()` + `String.prototype.repeat()` + `String.prototype.startsWith()` Os seguintes métodos de protótipo do ES 8 em strings são compatíveis: + `String.prototype.padStart()` + `String.prototype.padEnd()` Os seguintes métodos de protótipo do ES 9 em strings são compatíveis: + `String.prototype.trimStart()` + `String.prototype.trimEnd()` Os seguintes métodos de protótipo do ES 12 em strings são compatíveis: + `String.prototype.replaceAll()` **nota** `String.prototype.replaceAll()` é um recurso novo no runtime 2.0 do JavaScript. **Número** Todos os números do ES 5 são compatíveis. As seguintes propriedades do ES 6 em números são compatíveis: + `Number.EPSILON` + `Number.MAX_SAFE_INTEGER` + `Number.MIN_SAFE_INTEGER` + `Number.MAX_VALUE` + `Number.MIN_VALUE` + `Number.NaN` + `Number.NEGATIVE_INFINITY` + `Number.POSITIVE_INFINITY` Os seguintes métodos ES 6 em números são compatíveis: + `Number.isFinite()` + `Number.isInteger()` + `Number.isNaN()` + `Number.isSafeInteger()` + `Number.parseInt()` + `Number.parseFloat()` Os seguintes métodos de protótipo do ES 5.1 em números são compatíveis: + `Number.prototype.toExponential()` + `Number.prototype.toFixed()` + `Number.prototype.toPrecision()` Separadores numéricos ES 12 são compatíveis. Os separadores numéricos ES 12 são novos no runtime 2.0 do JavaScript. ## Objetos integrados Os seguintes objetos integrados do ES são compatíveis. **Matemática** Todos os métodos matemáticos ES 5.1 são compatíveis. No ambiente de tempo de execução do CloudFront Functions, a implementação `Math.random()` usa o OpenBSD `arc4random` propagado com o carimbo de data/hora de quando a função é executada. As seguintes propriedades matemáticas do ES 6 são compatíveis: + `Math.E` + `Math.LN10` + `Math.LN2` + `Math.LOG10E` + `Math.LOG2E` + `Math.PI` + `Math.SQRT1_2` + `Math.SQRT2` Os seguintes métodos matemáticos ES 6 são compatíveis: + `Math.abs()` + `Math.acos()` + `Math.acosh()` + `Math.asin()` + `Math.asinh()` + `Math.atan()` + `Math.atan2()` + `Math.atanh()` + `Math.cbrt()` + `Math.ceil()` + `Math.clz32()` + `Math.cos()` + `Math.cosh()` + `Math.exp()` + `Math.expm1()` + `Math.floor()` + `Math.fround()` + `Math.hypot()` + `Math.imul()` + `Math.log()` + `Math.log1p()` + `Math.log2()` + `Math.log10()` + `Math.max()` + `Math.min()` + `Math.pow()` + `Math.random()` + `Math.round()` + `Math.sign()` + `Math.sinh()` + `Math.sin()` + `Math.sqrt()` + `Math.tan()` + `Math.tanh()` + `Math.trunc()` **Data** Todos os recursos `Date` do ES 5.1 são compatíveis. Por razões de segurança, `Date` sempre retorna o mesmo valor, que seria o horário de início da função, durante o tempo de vida de uma única execução de função. Para obter mais informações, consulte [Recursos restritos](functions-javascript-runtime-10.md#writing-functions-javascript-features-restricted-features). **Função** Os seguintes métodos de protótipo do ES 5.1 são compatíveis: + `Function.prototype.apply()` + `Function.prototype.bind()` + `Function.prototype.call()` Os construtores de função não são compatíveis. **Expressões regulares** Todos os recursos de expressão regular ES 5.1 são compatíveis. A linguagem de expressão regular é compatível com Perl. As seguintes propriedades do acessador de protótipos do ES 5.1 são compatíveis: + `RegExp.prototype.global` + `RegExp.prototype.ignoreCase` + `RegExp.protoype.multiline` + `RegExp.protoype.source` + `RegExp.prototype.sticky` + `RegExp.prototype.flags` **nota** `RegExp.prototype.sticky` e `RegExp.prototype.flags` são recursos novos no runtime 2.0 do JavaScript. Os seguintes métodos de protótipo do ES 5.1 são compatíveis: + `RegExp.prototype.exec()` + `RegExp.prototype.test()` + `RegExp.prototype.toString()` + `RegExp.prototype[@@replace]()` + `RegExp.prototype[@@split]()` **nota** `RegExp.prototype[@@split]()` é um recurso novo no runtime 2.0 do JavaScript. As seguintes propriedades de instância do ES 5.1 são compatíveis: + `lastIndex` Os grupos de captura nomeados ES 9 são compatíveis. **JSON** Os seguintes métodos do ES 5.1 são compatíveis: + `JSON.parse()` + `JSON.stringify()` **Array** Os seguintes métodos ES 5.1 em matrizes são compatíveis: + `Array.isArray()` Os seguintes métodos ES 6 em matrizes são compatíveis: + `Array.of()` Os seguintes métodos de protótipo do ES 5.1 são compatíveis: + `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()` Os seguintes métodos de protótipo do ES 6 são compatíveis + `Array.prototype.copyWithin()` + `Array.prototype.fill()` + `Array.prototype.find()` + `Array.prototype.findIndex()` Os seguintes métodos de protótipo do ES 7 são compatíveis: + `Array.prototype.includes()` **Matrizes digitadas** Os seguintes construtores de matriz de tipo do ES 6 são compatíveis: + `Float32Array` + `Float64Array` + `Int8Array` + `Int16Array` + `Int32Array` + `Uint8Array` + `Uint8ClampedArray` + `Uint16Array` + `Uint32Array` Os seguintes métodos do ES 6 são compatíveis: + `TypedArray.from()` + `TypedArray.of()` **nota** `TypedArray.from()` e `TypedArray.of()` são recursos novos no runtime 2.0 do JavaScript. Os seguintes métodos de protótipo do ES 6 são compatíveis + `TypedArray.prototype.copyWithin()` + `TypedArray.prototype.every()` + `TypedArray.prototype.fill()` + `TypedArray.prototype.filter()` + `TypedArray.prototype.find()` + `TypedArray.prototype.findIndex()` + `TypedArray.prototype.forEach()` + `TypedArray.prototype.includes()` + `TypedArray.prototype.indexOf()` + `TypedArray.prototype.join()` + `TypedArray.prototype.lastIndexOf()` + `TypedArray.prototype.map()` + `TypedArray.prototype.reduce()` + `TypedArray.prototype.reduceRight()` + `TypedArray.prototype.reverse()` + `TypedArray.prototype.some()` + `TypedArray.prototype.set()` + `TypedArray.prototype.slice()` + `TypedArray.prototype.sort()` + `TypedArray.prototype.subarray()` + `TypedArray.prototype.toString()` **nota** `TypedArray.prototype.every()`, `TypedArray.prototype.fill()`, `TypedArray.prototype.filter()`, `TypedArray.prototype.find()`, `TypedArray.prototype.findIndex()`, `TypedArray.prototype.forEach()`, `TypedArray.prototype.includes()`, `TypedArray.prototype.indexOf()`, `TypedArray.prototype.join()`, `TypedArray.prototype.lastIndexOf()`, `TypedArray.prototype.map()`, `TypedArray.prototype.reduce()`, `TypedArray.prototype.reduceRight()`, `TypedArray.prototype.reverse()` e `TypedArray.prototype.some()` são recursos novos no runtime 2.0 do JavaScript. **ArrayBuffer** Os seguintes métodos do ES 6 em ArrayBuffer são compatíveis: + `isView()` Os seguintes métodos de protótipo do ES 6 em ArrayBuffer são compatíveis: + `ArrayBuffer.prototype.slice()` **Promessa** Os seguintes métodos do ES 6 em promises são compatíveis: + `Promise.all()` + `Promise.allSettled()` + `Promise.any()` + `Promise.reject()` + `Promise.resolve()` + `Promise.race()` **nota** `Promise.all()`, `Promise.allSettled()`, `Promise.any()` e `Promise.race()` são recursos novos no runtime 2.0 do JavaScript. Os seguintes métodos de protótipo do ES 6 em promises são compatíveis: + `Promise.prototype.catch()` + `Promise.prototype.finally()` + `Promise.prototype.then()` **DataView** Os seguintes métodos de protótipo do ES 6 são compatíveis: + `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 os métodos de protótipo do Dataview ES 6 são novos no runtime 2.0 do JavaScript. **Símbolo** Os seguintes métodos do ES 6 são compatíveis: + `Symbol.for()` + `Symbol.keyfor()` **nota** Todos os métodos do Symbol ES 6 são novos no runtime 2.0 do JavaScript. **Decodificador de texto** Os seguintes métodos de protótipo são compatíveis: + `TextDecoder.prototype.decode()` As seguintes propriedades do acessador de protótipos são compatíveis: + `TextDecoder.prototype.encoding` + `TextDecoder.prototype.fatal` + `TextDecoder.prototype.ignoreBOM` **Codificador de texto** Os seguintes métodos de protótipo são compatíveis: + `TextEncoder.prototype.encode()` + `TextEncoder.prototype.encodeInto()` ## Tipos de erro Os seguintes objetos de erro são compatíveis: + `Error` + `EvalError` + `InternalError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Variáveis globais O objeto `globalThis` é compatível. As seguintes funções globais do ES 5.1 são compatíveis: + `decodeURI()` + `decodeURIComponent()` + `encodeURI()` + `encodeURIComponent()` + `isFinite()` + `isNaN()` + `parseFloat()` + `parseInt()` As seguintes funções globais do ES 6 são compatíveis: + `atob()` + `btoa()` **nota** `atob()` e `btoa()` são recursos novos no runtime 2.0 do JavaScript. As seguintes restrições globais são válidas: + `NaN` + `Infinity` + `undefined` + `arguments` ## Módulos integrados Os seguintes módulos integrados são compatíveis: **Topics** + [Buffer](#writing-functions-javascript-features-builtin-modules-buffer-20) + [String de consulta](#writing-functions-javascript-features-builtin-modules-query-string-20) + [Criptografia](#writing-functions-javascript-features-builtin-modules-crypto-20) ### Buffer O módulo oferece os seguintes métodos: + `Buffer.alloc(size[, fill[, encoding]])` Aloque um `Buffer`. + `size`: tamanho do buffer. Insira um número inteiro. + `fill`: opcional. Insira uma string, `Buffer`, Uint8Array ou um número inteiro. O padrão é `0`. + `encoding`: opcional. Quando `fill` for uma string, insira uma das seguintes opções: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.allocUnsafe(size)` Aloque um `Buffer` não inicializado. + `size`: insira um número inteiro. + `Buffer.byteLength(value[, encoding])` Exibe o tamanho de um valor, em bytes. + `value`: uma string, `Buffer`, TypedArray, Dataview ou Arraybuffer. + `encoding`: opcional. Quando `value` for uma string, insira uma das seguintes opções: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.compare(buffer1, buffer2)` Compare dois `Buffer`s para ajudar a classificar matrizes. Exibirá `0` se forem iguais, `-1` se `buffer1` vier primeiro ou `1` se `buffer2` vier primeiro. + `buffer1`: insira um `Buffer`. + `buffer2`: insira um `Buffer` diferente. + `Buffer.concat(list[, totalLength])` Concatene vários `Buffer`s. Exibirá `0` se for nenhum. Exibe até `totalLength`. + `list`: insira uma lista de `Buffer`s. Observe que isso será truncado para `totalLength`. + `totalLength`: opcional. Insira um número inteiro não assinado. Use a soma das instâncias de `Buffer` na lista se estiver em branco. + `Buffer.from(array)` Crie um `Buffer` por uma matriz. + `array`: insira uma matriz de bytes de `0` a `255`. + `Buffer.from(arrayBuffer, byteOffset[, length]))` Crie uma visualização de `arrayBuffer` começando pelo deslocamento `byteOffset` com o tamanho `length`. + `arrayBuffer`: insira uma matriz `Buffer`. + `byteOffset`: insira um número inteiro. + `length`: opcional. Insira um número inteiro. + `Buffer.from(buffer)` Crie uma cópia do `Buffer`. + `buffer`: insira um `Buffer`. + `Buffer.from(object[, offsetOrEncoding[, length]])` Crie um `Buffer` por meio de um objeto. Exibirá `Buffer.from(object.valueOf(), offsetOrEncoding, length)` se `valueOf()` não for igual ao objeto. + `object`: insira um objeto. + `offsetOrEncoding`: opcional. Insira um número inteiro ou uma string de codificação. + `length`: opcional. Insira um número inteiro. + `Buffer.from(string[, encoding])` Crie um `Buffer` por meio de uma string. + `string`: insira uma string. + `encoding`: opcional. Insira uma das seguintes opções: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.isBuffer(object)` Confira se `object` é um buffer. Retorna `true` ou `false`. + `object`: insira um objeto. + `Buffer.isEncoding(encoding)` Confira se `encoding` é compatível. Retorna `true` ou `false`. + `encoding`: opcional. Insira uma das seguintes opções: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. O módulo oferece os seguintes métodos de protótipo de buffer: + `Buffer.prototype.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])` Compare `Buffer` com o destino. Exibirá `0` se forem iguais, `1` se `buffer` vier primeiro ou `-1` se `target` vier primeiro. + `target`: insira um `Buffer`. + `targetStart`: opcional. Insira um número inteiro. O padrão é 0. + `targetEnd`: opcional. Insira um número inteiro. O padrão é o tamanho do `target`. + `sourceStart`: opcional. Insira um número inteiro. O padrão é 0. + `sourceEnd`: opcional. Insira um número inteiro. O padrão é o tamanho do `Buffer`. + `Buffer.prototype.copy(target[, targetStart[, sourceStart[, sourceEnd]]])` Copie o buffer em `target`. + `target`: insira um `Buffer` ou uma `Uint8Array`. + `targetStart`: opcional. Insira um número inteiro. O padrão é 0. + `sourceStart`: opcional. Insira um número inteiro. O padrão é 0. + `sourceEnd`: opcional. Insira um número inteiro. O padrão é o tamanho do `Buffer`. + `Buffer.prototype.equals(otherBuffer)` Compare `Buffer` com `otherBuffer`. Retorna `true` ou `false`. + `otherBuffer`: insira uma string. + `Buffer.prototype.fill(value[, offset[, end][, encoding])` Preencha `Buffer` com `value`. + `value`: insira uma string, um `Buffer` ou um número inteiro. + `offset`: opcional. Insira um número inteiro. + `end`: opcional. Insira um número inteiro. + `encoding`: opcional. Insira uma das seguintes opções: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.prototype.includes(value[, byteOffset][, encoding])` Pesquise `value` no `Buffer`. Retorna `true` ou `false`. + `value`: insira uma string, um `Buffer`, uma `Uint8Array` ou um número inteiro. + `byteOffset`: opcional. Insira um número inteiro. + `encoding`: opcional. Insira uma das seguintes opções: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.prototype.indexOf(value[, byteOffset][, encoding])` Procure o primeiro `value` em `Buffer`. Exibirá `index` se for encontrado; exibirá `-1` se não for encontrado. + `value`: insira uma string, `Buffer`, Unit8Array ou um número inteiro de 0 a 255. + `byteOffset`: opcional. Insira um número inteiro. + `encoding`: opcional. Insira uma das seguintes opções se `value` for uma string: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.prototype.lastIndexOf(value[, byteOffset][, encoding])` Procure o último `value` em `Buffer`. Exibirá `index` se for encontrado; exibirá `-1` se não for encontrado. + `value`: insira uma string, `Buffer`, Unit8Array ou um número inteiro de 0 a 255. + `byteOffset`: opcional. Insira um número inteiro. + `encoding`: opcional. Insira uma das seguintes opções se `value` for uma string: `utf8`, `hex`, `base64` e `base64url`. O padrão é `utf8`. + `Buffer.prototype.readInt8(offset)` Leia `Int8` em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readIntBE(offset, byteLength)` Leia `Int` como big-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `byteLength`: opcional. Insira um número inteiro de `1` a `6`. + `Buffer.prototype.readInt16BE(offset)` Leia `Int16` como big-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readInt32BE(offset)` Leia `Int32` como big-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readIntLE(offset, byteLength)` Leia `Int` como little-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.readInt16LE(offset)` Leia `Int16` como little-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readInt32LE(offset)` Leia `Int32` como little-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readUInt8(offset)` Leia `UInt8` em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readUIntBE(offset, byteLength)` Leia `UInt` como big-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.readUInt16BE(offset)` Leia `UInt16` como big-endian em `offset` de `Buffer`. + + `offset`: insira um número inteiro. + `Buffer.prototype.readUInt32BE(offset)` Leia `UInt32` como big-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readUIntLE(offset, byteLength)` Leia `UInt` como little-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.readUInt16LE(offset)` Leia `UInt16` como little-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readUInt32LE(offset)` Leia `UInt32` como little-endian em `offset` de `Buffer`. + `offset`: insira um número inteiro. + `Buffer.prototype.readDoubleBE([offset])` Leia um double de 64 bits como big-endian em `offset` de `Buffer`. + `offset`: opcional. Insira um número inteiro. + `Buffer.prototype.readDoubleLE([offset])` Leia um double de 64 bits como little-endian em `offset` de `Buffer`. + `offset`: opcional. Insira um número inteiro. + `Buffer.prototype.readFloatBE([offset])` Leia um float de 32 bits como big-endian em `offset` de `Buffer`. + `offset`: opcional. Insira um número inteiro. + `Buffer.prototype.readFloatLE([offset])` Leia um float de 32 bits como little-endian em `offset` de `Buffer`. + `offset`: opcional. Insira um número inteiro. + `Buffer.prototype.subarray([start[, end]])` Exibe uma cópia do `Buffer` que está deslocado e recortado com novos `start` e `end`. + `start`: opcional. Insira um número inteiro. O padrão é 0. + `end`: opcional. Insira um número inteiro. O padrão é o tamanho do buffer. + `Buffer.prototype.swap16()` Troque a ordem de bytes da matriz de `Buffer` tratando-a como uma matriz de números de 16 bits. O tamanho do `Buffer` deve ser divisível por 2, ou você receberá um erro. + `Buffer.prototype.swap32()` Troque a ordem de bytes da matriz de `Buffer` tratando-a como uma matriz de números de 32 bits. O tamanho do `Buffer` deve ser divisível por 4, ou você receberá um erro. + `Buffer.prototype.swap64()` Troque a ordem de bytes da matriz de `Buffer` tratando-a como uma matriz de números de 64 bits. O tamanho do `Buffer` deve ser divisível por 8, ou você receberá um erro. + `Buffer.prototype.toJSON()` Exibe `Buffer` como JSON. + `Buffer.prototype.toString([encoding[, start[, end]]])` Converta `Buffer`, de `start` em `end` em string codificada. + `encoding`: opcional. Insira uma das seguintes opções: `utf8`, `hex`, `base64` ou `base64url`. O padrão é `utf8`. + `start`: opcional. Insira um número inteiro. O padrão é 0. + `end`: opcional. Insira um número inteiro. O padrão é o tamanho do buffer. + `Buffer.prototype.write(string[, offset[, length]][, encoding])` Escreva `string` codificado em `Buffer` se houver espaço ou um `string` truncado se não houver espaço suficiente. + `string`: insira uma string. + `offset`: opcional. Insira um número inteiro. O padrão é 0. + `length`: opcional. Insira um número inteiro. O padrão é o tamanho da string. + `encoding`: opcional. Opcionalmente, insira uma das seguintes opções: `utf8`, `hex`, `base64` ou `base64url`. O padrão é `utf8`. + `Buffer.prototype.writeInt8(value, offset, byteLength)` Escreva `Int8` `value` de `byteLength` em `offset` para `Buffer`. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeIntBE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeInt16BE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeInt32BE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeIntLE(offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeInt16LE(offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeInt32LE(offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUInt8(value, offset, byteLength)` Escreva `UInt8` `value` de `byteLength` em `offset` para `Buffer`. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUIntBE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUInt16BE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUInt32BE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUIntLE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUInt16LE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeUInt32LE(value, offset, byteLength)` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `value`: insira um número inteiro. + `offset`: insira um número inteiro. + `byteLength`: insira um número inteiro de `1` a `6`. + `Buffer.prototype.writeDoubleBE(value, [offset])` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: opcional. Insira um número inteiro. O padrão é 0. + `Buffer.prototype.writeDoubleLE(value, [offset])` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `value`: insira um número inteiro. + `offset`: opcional. Insira um número inteiro. O padrão é 0. + `Buffer.prototype.writeFloatBE(value, [offset])` Escreva `value` em `offset` para `Buffer`, usando big-endian. + `value`: insira um número inteiro. + `offset`: opcional. Insira um número inteiro. O padrão é 0. + `Buffer.prototype.writeFloatLE(value, [offset])` Escreva `value` em `offset` para `Buffer`, usando little-endian. + `value`: insira um número inteiro. + `offset`: opcional. Insira um número inteiro. O padrão é 0. Os seguintes métodos de instância são compatíveis: + `buffer[index]` Obtenha e defina o octeto (byte) em `index` em `Buffer`. + Obtenha um número de `0` a `255`. Ou defina um número de `0` a `255`. As seguintes propriedades de instância são compatíveis: + `buffer` Obtenha o objeto `ArrayBuffer` para o buffer. + `byteOffset` Obtenha o `byteOffset` do objeto `Arraybuffer` do buffer. + `length` Obtenha a contagem de bytes do buffer. **nota** Todos os métodos do módulo de buffer são novos no runtime 2.0 do JavaScript. ### String de consulta **nota** O [objeto de evento CloudFront Functions](functions-event-structure.md) analisa automaticamente as cadeias de consulta de URL para você. Isso significa que na maioria dos casos você não precisa usar este módulo. O módulo cadeia de consulta (`querystring`) fornece métodos para analisar e formatar cadeias de consulta de URL. Você pode carregar o módulo usando `require('querystring')`. O módulo fornece os seguintes métodos: `querystring.escape(string)` O URL codifica a `string` fornecida, retornando uma cadeia de consulta escapada. O método é usado por `querystring.stringify()` e não deve ser usado diretamente. `querystring.parse(string[, separator[, equal[, options]]])` Analisa uma cadeia de consulta (`string`) e retorna um objeto. O parâmetro `separator` é uma substring para delimitar pares de chaves e valores na cadeia de consulta. O padrão é `&`. O parâmetro `equal` é uma substring para delimitar chaves e valores na cadeia de consulta. O padrão é `=`. O parâmetro `options` é um objeto com as seguintes chaves: `decodeURIComponent function` Uma função para decodificar caracteres codificados por percentual na cadeia de consulta. O padrão é `querystring.unescape()`. `maxKeys number` O número máximo de chaves a serem analisadas. O padrão é `1000`. Use um valor de `0` para remover as limitações para as chaves de contagem. Por padrão, os caracteres codificados por percentual dentro da cadeia de consulta são assumidos para usar a codificação UTF-8. Sequências UTF-8 inválidas são substituídas pelo caractere de substituição `U+FFFD`. Por exemplo, para a seguinte cadeia de consulta: ``` 'name=value&abc=xyz&abc=123' ``` O valor de retorno de `querystring.parse()` é: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` é um alias para `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serializa um `object` e retorna uma cadeia de consulta. O parâmetro `separator` é uma substring para delimitar pares de chaves e valores na cadeia de consulta. O padrão é `&`. O parâmetro `equal` é uma substring para delimitar chaves e valores na cadeia de consulta. O padrão é `=`. O parâmetro `options` é um objeto com as seguintes chaves: `encodeURIComponent function` A função a ser usada para converter caracteres URL-inseguros para codificação percentual na cadeia de consulta. O padrão é `querystring.escape()`. Por padrão, os caracteres que exigem percentual de codificação dentro da cadeia de consulta são codificados como UTF-8. Para usar uma codificação diferente, especifique a opção `encodeURIComponent`. Por exemplo, para o seguinte código: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` O valor de retorno é: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` é um alias para `querystring.stringify()`. `querystring.unescape(string)` Decodifica caracteres codificados por porcentagem de URL na `string` fornecida, retornando uma cadeia de consulta sem escapamento. Esse método é usado por `querystring.parse()` e não deve ser usado diretamente. ### Criptografia O módulo criptográfico (`crypto`) fornece auxiliares de código de autenticação de mensagens (HMAC) padrão e hash. Você pode carregar o módulo usando `require('crypto')`. **Métodos de hash** `crypto.createHash(algorithm)` Cria e retorna um objeto hash que você pode usar para gerar resumos de hash usando o algoritmo fornecido: `md5`, `sha1` ou `sha256`. `hash.update(data)` Atualiza o conteúdo de hash com os fornecido `data`. `hash.digest([encoding])` Calcula o resumo de todos os dados passados usando `hash.update()`. A codificação pode ser `hex`, `base64` ou `base64url`. **Métodos de HMAC** `crypto.createHmac(algorithm, secret key)` Cria e retorna um objeto HMAC que usa o `algorithm` e a `secret key` fornecidos. O algoritmo pode ser `md5`, `sha1` ou `sha256`. `hmac.update(data)` Atualiza o conteúdo HMAC com os fornecido `data`. `hmac.digest([encoding])` Calcula o resumo de todos os dados passados usando `hmac.update()`. A codificação pode ser `hex`, `base64` ou `base64url`. ## Recursos restritos Os seguintes recursos de linguagem JavaScript não são compatíveis ou são restritos devido a preocupações de segurança. **Avaliação dinâmica do código** A avaliação dinâmica do código não é compatível. Ambos os construtores `eval()` e `Function` lançam um erro se forem tentados. Por exemplo, `const sum = new Function('a', 'b', 'return a + b')` lança um erro. **Temporizadores ** As funções `setTimeout()`, `setImmediate()` e `clearTimeout()` não são compatíveis. Não há provisão para adiar ou renderizar dentro de uma execução de função. Sua função deve ser executada de forma síncrona até a conclusão. **Data e carimbos de data/hora** Por razões de segurança, não há acesso a temporizadores de alta resolução. Todos os métodos `Date` para consultar a hora atual sempre retornam o mesmo valor durante o tempo de vida de uma única execução de função. O carimbo de data/hora retornado é o momento em que a função começou a ser executada. Consequentemente, você não pode medir o tempo decorrido em sua função. **Acesso ao sistema de arquivos** Não há acesso ao sistema de arquivos. Por exemplo, não há módulo `fs` para acesso ao sistema de arquivos como no Node.js. **Acesso a processos** Não há acesso a processos. Por exemplo, não há um objeto global `process` para processar o acesso às informações como no Node.js. **Variáveis de ambiente** Não há acesso às variáveis de ambiente. Em vez disso, é possível usar o KeyValueStore do CloudFront para criar um datastore centralizado de pares de chave-valor para o CloudFront Functions. O KeyValueStore do CloudFront permite atualizações dinâmicas nos dados de configuração sem a necessidade de implantar alterações no código. Para obter mais informações, consulte [Amazon CloudFront KeyValueStore](kvs-with-functions.md). **Acesso à rede** Não há suporte para chamadas de rede. Por exemplo, XHR, HTTP (S) e socket não são compatíveis. # Métodos auxiliares para armazenamentos de chave-valor **nota** As chamadas do método auxiliar de armazenamento de chave-valor do CloudFront Functions não acionam um evento de dados do AWS CloudTrail. Esses eventos não são registrados em log no histórico de eventos do CloudTrail. Para obter mais informações, consulte [Registrar em log chamadas de API do Amazon CloudFront usando o AWS CloudTrail](logging_using_cloudtrail.md). Esta seção se aplicará se você usar o [Armazenamento de chave-valor do CloudFront](kvs-with-functions.md) para incluir chave-valor na função criada. O CloudFront Functions tem um módulo que oferece três métodos auxiliares para ler valores do armazenamento de chave-valor. Para usar esse módulo no código da função, verifique se você [associou um armazenamento de chave-valor](kvs-with-functions-associate.md) à função. Em seguida, inclua as seguintes declarações nas primeiras linhas do código da função: ``` import cf from 'cloudfront'; const kvsHandle = cf.kvs(); ``` ## `get()`Método Use esse método para retornar o valor do nome da chave especificado. **Solicitação** ``` get("key", options); ``` + `key`: o nome da chave cujo valor precisa ser buscado. + `options`: existe uma opção, `format`. Isso garante que a função analise os dados corretamente. Possíveis valores: + `string`: (padrão) codificado em UTF8. + `json` + `bytes`: buffer de dados binários brutos. **Exemplo de solicitação** ``` const value = await kvsHandle.get("myFunctionKey", { format: "string"}); ``` **Resposta** A resposta é uma `promise` que se resolve para um valor no formato solicitado usando `options`. Por padrão, o valor é retornado como uma string. ### Tratamento de erros O método `get()` retornará um erro quando a chave solicitada não existir no armazenamento de chave-valor associado. Para gerenciar esse caso de uso, é possível adicionar um bloco `try` e `catch` ao seu código. **Atenção** O uso de combinadores de promessa (por exemplo, `Promise.all` e `Promise.any`) e métodos de cadeia de promessa (por exemplo, `then` e `catch`) pode exigir alto uso de memória da função. Se sua função exceder a cota [máxima de memória da função](cloudfront-limits.md#limits-functions), ela não será executada. Para evitar esse erro, recomendamos que você use a sintaxe `await` sequencialmente ou em ciclos para solicitar vários valores. **Exemplo** ``` var value1 = await kvs.get('key1'); var value2 = await kvs.get('key2'); ``` No momento, o uso de combinadores de promessas para obter vários valores não melhorará o desempenho, como no exemplo a seguir. ``` var values = await Promise.all([kvs.get('key1'), kvs.get('key2'),]); ``` ## `exists()`Método Use esse método para identificar se a chave existe ou não no armazenamento de chave-valor. **Solicitação** ``` exists("key"); ``` **Exemplo de solicitação** ``` const exist = await kvsHandle.exists("myFunctionkey"); ``` **Resposta** A resposta é uma `promise` que retorna um booleano (`true` ou `false`). Esse valor especifica se a chave existe ou não no armazenamento de chave-valor. ## `meta()`Método Use esse método para retornar metadados sobre o armazenamento de chave-valor. **Solicitação** ``` meta(); ``` **Exemplo de solicitação** ``` const meta = await kvsHandle.meta(); ``` **Resposta** A resposta é uma `promise` que é resolvida em um objeto com as seguintes propriedades: + `creationDateTime`: a data e a hora no formato ISO 8601 em que o armazenamento de chave-valor foi criado. + `lastUpdatedDateTime`: a data e a hora em que o valor da chave armazenado foi sincronizado pela última vez a partir da origem, no formato ISO 8601. O valor não inclui o tempo de propagação até a borda. + `keyCount`: o número total de chaves no KVS após a última sincronização da origem. **Exemplo de resposta** ``` {keyCount:3,creationDateTime:2023-11-30T23:07:55.765Z,lastUpdatedDateTime:2023-12-15T03:57:52.411Z} ``` # Métodos auxiliares para modificação da origem Esta seção se aplica se você atualizar ou alterar dinamicamente a origem usada na solicitação dentro do seu código do CloudFront Functions. Você pode atualizar a origem somente em *solicitações do visualizador* do CloudFront Functions. O CloudFront Functions tem um módulo que oferece métodos auxiliares para atualizar ou alterar dinamicamente a origem. Para usar esse módulo, crie uma função do CloudFront usando o Runtime 2.0 do JavaScript e inclua a seguinte instrução na primeira linha do código da função: ``` import cf from 'cloudfront'; ``` Para obter mais informações, consulte [Recursos de runtime 2.0 do JavaScript para CloudFront Functions](functions-javascript-runtime-20.md). **nota** As páginas da API de teste e do console de teste não verificam se ocorreu uma modificação na origem. No entanto, o teste garante que o código da função seja executado sem erros. ## Escolher entre o CloudFront Functions e o Lambda@Edge Você pode atualizar suas origens usando o CloudFront Functions ou o Lambda@Edge. Ao usar o CloudFront Functions para atualizar as origens, você usa *o acionador de evento de solicitação do visualizador*, o que significa que essa lógica será executada em todas as solicitações quando essa função for usada. Ao usar o Lambda@Edge, os recursos de atualização de origem estão no acionador de evento da *solicitação para a origem*, o que significa que essa lógica só é executada em caso de ausências no cache. Sua escolha depende muito da workload e de qualquer uso existente do CloudFront Functions e do Lambda@Edge em suas distribuições. As considerações a seguir podem ajudar você a decidir se deve usar o CloudFront Functions ou o Lambda@Edge para atualizar suas origens. O CloudFront Functions é mais útil nas seguintes situações: + Quando suas solicitações são dinâmicas (o que significa que não podem ser armazenadas em cache) e sempre vão para a origem. O CloudFront Functions oferece melhor desempenho e menor custo geral. + Quando você já tem uma função do CloudFront de solicitação do visualizador que será executada em todas as solicitações, é possível adicionar a lógica de atualização de origem à função existente. Para usar o CloudFront Functions para atualizar as origens, consulte os métodos auxiliares nos tópicos a seguir. O Lambda@Edge é mais útil nas seguintes situações: + Quando você tem conteúdo altamente armazenável em cache, o Lambda@Edge pode ser mais econômico porque é executado somente em caso de ausências no cache, enquanto o CloudFront Functions é executado em todas as solicitações. + Quando você já tem uma função do Lambda@Edge de solicitação para a origem, é possível adicionar a lógica de atualização de origem à função existente. + Quando sua lógica de atualização de origem exige a busca de dados de fontes de dados de terceiros, como o Amazon DynamoDB ou o Amazon S3. Para ter mais informações sobre o Lambda@Edge, consulte [Personalização na borda com o Lambda@Edge](lambda-at-the-edge.md). ## método updateRequestOrigin() Use o método `updateRequestOrigin()` para atualizar as configurações da origem de uma solicitação. Você pode usar esse método para atualizar as propriedades da origem existente no caso de origens que já estejam definidas na sua distribuição ou para definir uma nova origem para a solicitação. Para isso, especifique as propriedades que você deseja alterar. **Importante** Qualquer configuração que você não especificar no `updateRequestOrigin()` herdará as *mesmas configurações* da configuração da origem existente. A origem definida pelo método `updateRequestOrigin()` pode ser qualquer endpoint HTTP e não precisa ser uma origem existente na sua distribuição do CloudFront. **Observações** Se você estiver atualizando uma origem que faz parte de um grupo de origens, somente a *origem primária* desse grupo será atualizada. A origem secundária permanecerá inalterada. Qualquer código de resposta da origem modificada que corresponda aos critérios de failover acionará um failover para a origem secundária. Se você estiver alterando o tipo de origem e o OAC estiver habilitado, verifique se o tipo de origem em `originAccessControlConfig` corresponde ao novo tipo de origem. Não é possível usar o método `updateRequestOrigin()` para atualizar [origens de VPC](private-content-vpc-origins.md). A solicitação falhará. **Solicitação** ``` updateRequestOrigin({origin properties}) ``` A chave `origin properties` pode conter os seguintes valores: **domainName (opcional)** O nome de domínio da origem. Se isso não for fornecido, será usado o nome de domínio da origem atribuída. **Para origens personalizadas** Especifique um nome de domínio DNS, como `www.example.com`. O nome de domínio não pode incluir dois-pontos (`:`) e não pode ser um endereço IP. O nome de domínio pode ter até 253 caracteres. **Para origens do S3** Especifique o nome de domínio DNS do bucket do Amazon S3, como `amzn-s3-demo-bucket.s3.eu-west-1.amazonaws.com`. O nome pode ter até 128 caracteres e deve ser todo em minúsculas. **hostHeader (opcional, para origens personalizadas não S3)** O cabeçalho do host a ser usado ao fazer a solicitação à origem. Se não for fornecido, será usado o valor do parâmetro domainName. Se nem o cabeçalho do host nem o parâmetro do nome de domínio forem fornecidos, será usado o nome de domínio da origem atribuída ou o cabeçalho do host da solicitação recebida se a política de encaminhamento à origem (FTO) incluir o host. O cabeçalho do host não pode incluir dois-pontos (`:`) e não pode ser um endereço IP. O cabeçalho do host pode ter até 253 caracteres. **originPath (opcional)** O caminho do diretório na origem em que a solicitação deve localizar o conteúdo. O caminho deve começar com uma barra (/), mas não deve terminar com uma. Por exemplo, não deve terminar com `example-path/`. Se isso não for fornecido, será usado o caminho de origem da origem atribuída. **Para origens personalizadas** O caminho deve ser codificado por URL e ter um tamanho máximo de 255 caracteres. **customHeaders (opcional)** Você pode incluir os cabeçalhos personalizados com a solicitação ao especificar o par de nome e valor do cabeçalho para cada cabeçalho personalizado. O formato é diferente do formato dos cabeçalhos de solicitação e resposta na estrutura do evento. Use os seguintes pares de chave/valor: ``` {"key1": "value1", "key2": "value2", ...} ``` Não é possível adicionar cabeçalhos não permitidos e não pode haver um cabeçalho com o mesmo nome em `headers` de solicitação de entrada. O nome do cabeçalho deve estar em letras minúsculas no código da função. Quando o CloudFront Functions converte o objeto de evento novamente em uma solicitação HTTP, a primeira letra de toda palavra em nomes de cabeçalho é grafada em maiúscula e as palavras são separadas por hífen. Por exemplo, se o código da função adicionar um cabeçalho chamado `example-header-name`, o CloudFront o converterá em `Example-Header-Name` na solicitação HTTP. Para obter mais informações, consulte [Cabeçalhos personalizados que o CloudFront não pode adicionar às solicitações da origem](add-origin-custom-headers.md#add-origin-custom-headers-denylist) e [Restrições das funções de borda](edge-functions-restrictions.md). Se isso não for fornecido, quaisquer cabeçalhos personalizados da origem atribuída serão usados. **connectionAttempts (opcional)** O número de vezes que o CloudFront tenta se conectar à origem. O mínimo é 1 e o máximo é 3. Se isso não for fornecido, serão usadas as tentativas de conexão da origem atribuída. **originShield (opcional)** Isso ativa ou atualiza o CloudFront Origin Shield. Usar o Origin Shield pode ajudar a reduzir a carga na sua origem. Para obter mais informações, consulte [Usar o Amazon CloudFront Origin Shield](origin-shield.md). Se isso não for fornecido, serão usadas as configurações do Origin Shield da origem atribuída. **enabled (obrigatório)** Expressão booliana para habilitar ou desabilitar o Origin Shield. Aceita um valor `true` ou `false`. **region (obrigatório quando habilitado)** A Região da AWS para o Origin Shield. Especifique a região da Região da AWS que tem a latência mais baixa para sua origem. Use o código da região, não o nome da região. Por exemplo, especifique a região Leste dos EUA (Ohio) como `us-east-2`. Ao habilitar o CloudFront Origin Shield, você deve especificar a Região da AWS para o Origin Shield. Para obter uma lista das Regiões da AWS disponíveis e ajuda para escolher a melhor região para sua origem, consulte [Escolher a região da AWS para o Origin Shield](origin-shield.md#choose-origin-shield-region). **originAccessControlConfig (opcional)** O identificador exclusivo de um controle de acesso de origem (OAC) para essa origem. Isso só é usado quando a origem é compatível com um OAC do CloudFront, como Amazon S3, URLs de funções do Lambda, MediaStore e MediaPackage V2. Se isso não for fornecido, serão usadas as configurações do OAC da origem atribuída. Nesse caso, não é possível usar a identidade do acesso de origem (OAI) legada. Para obter mais informações, consulte [Restringir o acesso a uma origem da AWS](private-content-restricting-access-to-origin.md). **enabled (obrigatório)** Expressão booliana para habilitar ou desabilitar o OAC. Aceita um valor `true` ou `false`. **signingBehavior (obrigatório quando habilitado)** Especifica quais solicitações o CloudFront assina (adiciona informações de autenticação). Especifique `always` para o caso de uso mais comum. Para obter mais informações, consulte [Configurações avançadas para controle de acesso à origem](private-content-restricting-access-to-s3.md#oac-advanced-settings-s3). Esse campo pode ter um dos seguintes valores: + `always`: o CloudFront assina todas as solicitações de origem, substituindo o cabeçalho `Authorization` da solicitação do visualizador se houver. + `never`: o CloudFront não assina nenhuma solicitação para a origem. Esse valor desativa o controle de acesso de origem. + `no-override`: se a solicitação do visualizador não contiver o cabeçalho `Authorization`, o CloudFront assinará a solicitação para a origem. Se a solicitação do visualizador contiver o cabeçalho `Authorization`, o CloudFront não assinará a solicitação para a origem e, em vez disso, passará adiante o cabeçalho `Authorization` da solicitação do visualizador. **Atenção** Para transmitir o cabeçalho `Authorization` da solicitação do visualizador, você deve adicioná-lo a uma política de solicitação para a origem para todos os comportamentos de cache que usam origens associadas a esse controle de acesso de origem. Para obter mais informações, consulte [Controlar as solicitações de origem com uma política](controlling-origin-requests.md). **signingProtocol (obrigatório quando habilitado)** O protocolo de assinatura do OAC, que determina como o CloudFront assina (autentica) as solicitações. O único valor válido é `sigv4`. **originType (obrigatório quando habilitado)** O tipo de origem desse OAC. Os valores válidos são `s3`, `mediapackagev2`, `mediastore` e `lambda`. **timeouts (opcional)** Tempos limite que você pode especificar para indicar por quanto tempo o CloudFront deve tentar esperar até que as origens respondam ou enviem dados. Se isso não for fornecido, serão usadas as configurações de tempo limite da origem atribuída. A menos que seja especificado, esses tempos limite suportam origens personalizadas e origens do Amazon S3. **readTimeout (opcional)** O `readTimeout` aplica-se a ambos os valores a seguir: + O período (em segundos) que o CloudFront aguarda uma resposta após o encaminhamento de uma solicitação à origem. + O período (em segundos) que o CloudFront aguarda após o recebimento de um pacote de uma resposta da origem e antes do recebimento do próximo pacote. O tempo limite mínimo é de 1 segundo e o máximo é de 120 segundos. Para obter mais informações, consulte [Tempo limite de resposta](DownloadDistValuesOrigin.md#DownloadDistValuesOriginResponseTimeout). **responseCompletionTimeout (opcional)** O tempo (em segundos) em que uma solicitação do CloudFront para a origem pode permanecer aberta e aguardar uma resposta. Se a resposta completa não for recebida da origem até esse momento, o CloudFront encerrará a conexão. O valor para `responseCompletionTimeout` deve ser igual a ou maior que o valor especificado para `readTimeout`. Para obter mais informações, consulte [Tempo limite de conclusão da resposta](DownloadDistValuesOrigin.md#response-completion-timeout). **keepAliveTimeout (opcional)** O tempo limite só se aplica a origens personalizadas, não a origens do Amazon S3. (As configurações de origem do S3 ignorarão essas configurações.) A `keepAliveTimeout` especifica por quanto tempo o CloudFront deve tentar manter a conexão com a origem depois de receber o último pacote da resposta. O tempo limite mínimo é de 1 segundo e o máximo é de 120 segundos. Para obter mais informações, consulte [Tempo limite de keep alive (somente origens de VPC e personalizadas)](DownloadDistValuesOrigin.md#DownloadDistValuesOriginKeepaliveTimeout). **connectionTimeout (opcional)** O número de segundos que o CloudFront aguarda ao tentar estabelecer uma conexão com a origem. O tempo limite mínimo é de 1 segundo e o máximo é de 10 segundos. Para obter mais informações, consulte [Tempo limite da conexão](DownloadDistValuesOrigin.md#origin-connection-timeout). **customOriginConfig (opcional)** Use `customOriginConfig` para especificar configurações de conexão para origens que *não* sejam um bucket do Amazon S3. Há uma exceção: você pode especificar essas configurações se o bucket do S3 estiver configurado com hospedagem de site estático. (Outros tipos de configuração do bucket do S3 ignorarão essas configurações.) Se `customOriginConfig` não for fornecido, serão usadas as configurações da origem atribuída. **port (obrigatório)** A porta HTTP que o CloudFront usa para se conectar à origem. Especifique a porta HTTP que a origem escuta. **protocol (obrigatório)** Especifica o protocolo (HTTP ou HTTPS) que o CloudFront usa para se conectar à origem. Os valores válidos são os seguintes: + `http`: o CloudFront sempre usa HTTP para se conectar à origem. + `https`: o CloudFront sempre usa HTTPS para se conectar à origem. **sslProtocols (obrigatório)** Uma lista que especifica o protocolo SSL/TLS mínimo que o CloudFront usa ao se conectar à sua origem por HTTPS. Os valores válidos são `SSLv3`, `TLSv1`, `TLSv1.1` e `TLSv1.2`. Para obter mais informações, consulte [Protocolo SSL de origem mínimo](DownloadDistValuesOrigin.md#DownloadDistValuesOriginSSLProtocols). **ipAddressType (opcional)** Especifica o tipo de endereço IP que o CloudFront usa para se conectar à origem. Os valores válidos são `ipv4`, `ipv6` e `dualstack`. Só é possível alterar o `ipAddressType` quando a propriedade `domainName` também está sendo alterada. **sni (opcional, para origens personalizadas não S3)** A Indicação de Nome de Servidor (SNI) é uma extensão do protocolo Transport Layer Security (TLS) por meio da qual um cliente indica a qual nome de host está tentando se conectar no início do processo de handshake do TLS. Esse valor deve corresponder a um nome comum em um certificado TLS no servidor de origem. Do contrário, o servidor de origem pode gerar um erro. Se não for fornecido, será usado o valor do parâmetro `hostHeader`. Se o cabeçalho do host não for fornecido, será usado o valor do parâmetro `domainName`. Se nem o cabeçalho do host nem o parâmetro do nome de domínio forem fornecidos, será usado o nome de domínio da origem atribuída ou o cabeçalho do host da solicitação recebida se a política de encaminhamento à origem (FTO) incluir o host. A SNI não pode incluir dois-pontos (`:`) e não pode ser um endereço IP. A SNI pode ter até 253 caracteres. **allowedCertificateNames (opcional, para origens personalizadas não S3)** É possível incluir uma lista de nomes de certificados válidos a serem usados pelo CloudFront para validar a correspondência de domínio do certificado TLS do servidor de origem durante o handshake do TLS com o servidor de origem. Esse campo requer uma matriz de nomes de domínio válidos e pode incluir domínios curinga, como `*.example.com`. É possível especificar até vinte nomes de certificados permitidos. O nome de cada certificado pode ter até 64 caracteres. **Example – Atualização para a origem da solicitação do Amazon S3** O exemplo a seguir altera a origem da solicitação do visualizador para um bucket do S3, habilita o OAC e redefine os cabeçalhos personalizados enviados à origem. ``` 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 – Atualização para a origem da solicitação do Application Load Balancer** O exemplo a seguir altera a origem da solicitação do visualizador para uma origem do Application Load Balancer e define um cabeçalho personalizado e tempos limite. ``` 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 – Atualização para a origem com o Origin Shield habilitado** No exemplo a seguir, a origem na distribuição tem o Origin Shield habilitado. O código da função atualiza somente o nome de domínio usado para a origem e omite todos os outros parâmetros opcionais. Nesse caso, o Origin Shield ainda será usado com o nome de domínio de origem modificado porque os parâmetros do Origin Shield não foram atualizados. ``` cf.updateRequestOrigin({ "domainName" : "www.example.com" }); ``` **Example : atualizar o cabeçalho do host, a SNI e o nome dos certificados permitidos** Na maioria dos casos de uso, não será necessário usar esse tipo de modificação nas solicitações encaminhadas à sua origem. Esses parâmetros não devem ser usados, a menos que você entenda o impacto de alterar esses valores. O exemplo a seguir altera o nome de domínio, o cabeçalho do host, a SNI e os certificados permitidos na solicitação para a origem. ``` cf.updateRequestOrigin({ "domainName": "www.example.com", "hostHeader": "test.example.com", "sni": "test.example.net", "allowedCertificateNames": ["*.example.com", "*.example.net"], }); ``` ## Método selectRequestOriginById() Use `selectRequestOriginById()` para atualizar uma origem existente selecionando uma origem diferente que já esteja configurada na sua distribuição. Esse método usa todas as mesmas configurações definidas pela origem atualizada. Esse método só aceita origens que já estão definidas na mesma distribuição usada ao executar a função. As origens são referidas pelo ID de origem, que é o nome de origem que você definiu ao configurar a origem. Se você tiver uma origem de VPC configurada em sua distribuição, poderá usar esse método para atualizá-la para sua origem de VPC. Para obter mais informações, consulte [Restringe o acesso com origens de VPC.](private-content-vpc-origins.md). **Observações** A função `selectRequestOriginById()` não pode selecionar uma origem que tenha a TLS mútua (origem) habilitada. A tentativa de selecionar uma origem com a TLS mútua (origem) habilitada por meio dessa função gera um erro de validação. Se seu caso de uso exigir seleção dinâmica de origem com TLS mútua (origem), use `updateRequestOrigin()` em vez disso, para garantir que todas as origens de destino usem o mesmo certificado de cliente. **Solicitação** ``` cf.selectRequestOriginById(origin_id, {origin_overrides}) ``` No exemplo anterior, `origin_id` é uma string que aponta para o nome de uma origem na distribuição que está executando a função. O parâmetro `origin_overrides `pode conter o seguinte: **hostHeader (opcional, para origens personalizadas não S3)** O cabeçalho do host a ser usado ao fazer a solicitação à origem. Se não for fornecido, será usado o valor do parâmetro `domainName`. Se nem o cabeçalho do host nem o parâmetro do nome de domínio forem fornecidos, será usado o nome de domínio da origem atribuída ou o cabeçalho do host da solicitação recebida se a política de encaminhamento à origem (FTO) incluir o host. O cabeçalho do host não pode incluir dois-pontos (`:`) e não pode ser um endereço IP. O cabeçalho do host pode ter até 253 caracteres. **sni (opcional, para origens personalizadas não S3)** A Indicação de Nome de Servidor (SNI) é uma extensão do protocolo Transport Layer Security (TLS) por meio da qual um cliente indica a qual nome de host está tentando se conectar no início do processo de handshake do TLS. Esse valor deve corresponder a um nome comum em um certificado TLS no servidor de origem. Do contrário, o servidor de origem pode gerar um erro. Se não for fornecido, será usado o valor do parâmetro `hostHeader`. Se o cabeçalho do host não for fornecido, será usado o valor do parâmetro `domainName`. Se nem o cabeçalho do host nem o parâmetro do nome de domínio forem fornecidos, será usado o nome de domínio da origem atribuída ou o cabeçalho do host da solicitação recebida se a política de encaminhamento à origem (FTO) incluir o host. A SNI não pode incluir dois-pontos (`:`) e não pode ser um endereço IP. A SNI pode ter até 253 caracteres. **allowedCertificateNames (opcional, para origens personalizadas não S3)** É possível incluir uma lista de nomes de certificados válidos a serem usados pelo CloudFront para validar a correspondência de domínio do certificado TLS do servidor de origem durante o handshake do TLS com o servidor de origem. Esse campo requer uma matriz de nomes de domínio válidos e pode incluir domínios curinga, como `*.example.com`. É possível especificar até vinte nomes de certificados permitidos. O nome de cada certificado pode ter até 64 caracteres. **Solicitação** ``` selectRequestOriginById(origin_id) ``` No exemplo anterior, `origin_id` é uma string que aponta para o nome de uma origem na distribuição que está executando a função. **Example – Selecionar a origem da solicitação do Amazon S3** O exemplo a seguir seleciona a origem denominada `amzn-s3-demo-bucket-in-us-east-1` na lista de origens associadas à distribuição e aplica as configurações da origem `amzn-s3-demo-bucket-in-us-east-1` à solicitação. ``` cf.selectRequestOriginById("amzn-s3-demo-bucket-in-us-east-1"); ``` **Example – Selecionar a origem da solicitação do Application Load Balancer** O exemplo a seguir seleciona uma origem do Application Load Balancer denominada `myALB-prod` na lista de origens associadas à distribuição e aplica as configurações de `myALB-prod` à solicitação. ``` cf.selectRequestOriginById("myALB-prod"); ``` **Example : selecionar a origem da solicitação do Application Load Balancer e substituir o cabeçalho do host** Como no exemplo anterior, o exemplo a seguir seleciona uma origem do Application Load Balancer denominada `myALB-prod` na lista de origens associadas à distribuição e aplica as configurações de `myALB-prod` à solicitação. No entanto, este exemplo substitui o valor do cabeçalho do host usando `origin_overrides`. ``` cf.overrideRequestOrigin("myALB-prod",{ "hostHeader" : "test.example.com" }); ``` ## Método createRequestOriginGroup() Use `createRequestOriginGroup()` para definir duas origens a serem usadas como um [grupo de origens](high_availability_origin_failover.md#concept_origin_groups.creating) para failover em cenários que exigem alta disponibilidade. Um grupo de origens inclui duas origens (uma primária e uma secundária) e critérios de failover especificados por você. Você cria um grupo de origem para oferecer suporte ao failover de origem no CloudFront. Ao criar ou atualizar um grupo de origens usando esse método, você pode especificar o grupo de origens em vez de uma única origem. O CloudFront fará o failover da origem primária para a origem secundária usando os critérios de failover. Se você tiver uma origem de VPC configurada em sua distribuição, poderá usar esse método para criar um grupo de origens usando uma origem de VPC. Para obter mais informações, consulte [Restringe o acesso com origens de VPC.](private-content-vpc-origins.md). **Observações** A função `createRequestOriginGroup()` não permite a criação de grupos de origens que incluam origens com a TLS mútua (origem) habilitada. Grupos de origens que incluem origens com TLS mútua (origem) não podem ser criados dinamicamente por meio do CloudFront Functions. Se você precisar de recursos de failover de origem com TLS mútua (origem), configure grupos de origens diretamente nas configurações de distribuição do CloudFront em vez de criá-los dinamicamente em funções. ### Solicitação ``` createRequestOriginGroup({origin_group_properties}) ``` No exemplo anterior, as `origin_group_properties` podem conter o seguinte: **originIds (obrigatório)** Matriz de `origin_ids`, em que o `origin_id` é uma string que aponta para o nome de uma origem na distribuição que executa a função. É necessário fornecer duas origens como parte da matriz. A primeira origem na lista é a primária e a segunda serve como a segunda origem para fins de failover. **originOverrides (opcional)** Algumas configurações avançadas podem ser substituídas usando o parâmetro `{origin_overrides}`. A chave `origin overrides` pode conter os seguintes valores: **hostHeader (opcional, para origens personalizadas não S3)** O cabeçalho do host a ser usado ao fazer a solicitação à origem. Se não for fornecido, será usado o valor do parâmetro `domainName`. Se nem o cabeçalho do host nem o parâmetro do nome de domínio forem fornecidos, será usado o nome de domínio da origem atribuída ou o cabeçalho do host da solicitação recebida se a política de encaminhamento à origem (FTO) incluir o host. O cabeçalho do host não pode incluir dois-pontos (`:`) e não pode ser um endereço IP. O cabeçalho do host pode ter até 253 caracteres. **sni (opcional, para origens personalizadas não S3)** A Indicação de Nome de Servidor (SNI) é uma extensão do protocolo Transport Layer Security (TLS) por meio da qual um cliente indica a qual nome de host está tentando se conectar no início do processo de handshake do TLS. Esse valor deve corresponder a um nome comum em um certificado TLS no servidor de origem. Do contrário, o servidor de origem pode gerar um erro. Se não for fornecido, será usado o valor do parâmetro `hostHeader`. Se o cabeçalho do host não for fornecido, será usado o valor do parâmetro `domainName`. Se nem o cabeçalho do host nem o parâmetro do nome de domínio forem fornecidos, será usado o nome de domínio da origem atribuída ou o cabeçalho do host da solicitação recebida se a política de encaminhamento à origem (FTO) incluir o host. A SNI não pode incluir dois-pontos (`:`) e não pode ser um endereço IP. A SNI pode ter até 253 caracteres. **allowedCertificateNames (opcional, para origens personalizadas não S3)** É possível incluir uma lista de nomes de certificados válidos a serem usados pelo CloudFront para validar a correspondência de domínio do certificado TLS do servidor de origem durante o handshake do TLS com o servidor de origem. Esse campo requer uma matriz de nomes de domínio válidos e pode incluir domínios curinga, como `*.example.com`. É possível especificar até vinte nomes de certificados permitidos. O nome de cada certificado pode ter até 64 caracteres. **selectionCriteria (opcional)** Selecione se deseja usar os critérios de failover da origem `default` ou usar a lógica de failover baseada em `media-quality-score`. Os valores válidos são os seguintes: + `default` usa os critérios de failover com base nos códigos de status especificados nos `failoverCriteria`. Se você não definir `selectionCriteria` na função, a `default` será usada. + `media-quality-score` é usado quando o recurso de roteamento com reconhecimento de mídia está sendo usado. **failoverCriteria (obrigatório)** Uma matriz de códigos de status que, quando retornados da origem primária, acionarão o CloudFront para fazer failover para a origem secundária. Se você sobrescrever um grupo de origens existente, essa matriz substituirá todos os códigos de status de failover definidos na configuração original do grupo de origens. Quando você usar `media-quality-score` como `selectionCriteria`, o CloudFront tentará encaminhar as solicitações com base na pontuação de qualidade de mídia. Se a origem selecionada retornar um código de erro definido nessa matriz, o CloudFront fará failover para a outra origem. **Example : criar grupo de origens para uma solicitação** O exemplo a seguir cria um grupo de origens para uma solicitação usando os IDs de origem. Esses IDs de origem provêm da configuração do grupo de origens da distribuição usada para executar essa função. Opcionalmente, é possível usar `originOverrides` para substituir as configurações de `sni`, `hostHeader` e `allowedCertificateNames` do grupo de origem. ``` 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 propriedades do CloudFront SaaS Manager Use as funções auxiliares do CloudFront SaaS Manager a seguir para recuperar valores referentes às suas distribuições multilocatário na função que você criar. Para usar exemplos nessa página, é necessário criar primeiro uma função do CloudFront usando o runtime 2.0 do JavaScript. Para obter mais informações, [Recursos de runtime 2.0 do JavaScript para CloudFront Functions](functions-javascript-runtime-20.md). **Topics** + [Grupos de conexões](#connection-groups-helper-function) + [Locatários da distribuição](#distribution-tenants-helper-functions) ## Grupos de conexões O grupo de conexões associado aos locatários da distribuição tem um nome de domínio. Para obter esse valor, use o campo `endpoint` do subobjeto `context` do objeto do evento. **Solicitação** ``` const value = event.context.endpoint; ``` **Resposta** A resposta é uma `string` que contém o nome de domínio do grupo de conexões, como d111111abcdef8.cloudfront.net. O campo `endpoint` é exibido somente quando a função é invocada para uma distribuição multilocatário com um grupo de conexões associado. Para obter mais informações, consulte [Objeto de contexto](functions-event-structure.md#functions-event-structure-context). ## Locatários da distribuição O CloudFront Functions tem um módulo que oferece acesso a valores específicos de locatários da distribuição. Para usar esse módulo, inclua a seguinte instrução na primeira linha do código da função: ``` import cf from 'cloudfront'; ``` Você pode usar os exemplos a seguir somente na função `handler`, tanto diretamente quanto por meio de qualquer função de chamada aninhada. ### `distributionTenant.id`Campo Use esse campo para obter o valor do ID do locatário da distribuição. **Solicitação** ``` const value = cf.distributionTenant.id; ``` **Resposta** A resposta é uma `string` que contém o ID do locatário da distribuição, como `dt_1a2b3c4d5e6f7`. **Tratamento de erros** Se a função for invocada para uma distribuição padrão, ao especificar o campo `distributionTenant.id`, o erro de tipo `distributionTenant module is not available` será exibido. Para lidar com esse caso de uso, é possível adicionar um bloco `try` e `catch` ao seu código. ### Método `distributionTenant.parameters.get()` Use esse método para retornar o valor dos nomes de parâmetro de locatários da distribuição que você especificou. ``` distributionTenant.parameters.get("key"); ``` `key`: o nome do parâmetro de locatário da distribuição para o qual você deseja buscar o valor. **Solicitação ** ``` const value = distributionTenant.parameters.get("key"); ``` **Resposta** A resposta é uma `string` que contém o valor do parâmetro do locatário da distribuição. Por exemplo, se o nome da chave for `TenantPath`, o valor desse parâmetro poderá ser `tenant1`. **Tratamento de erros** Você poderá receber os seguintes erros: + Se sua função for invocada para uma distribuição padrão, o método `distributionTenant.parameters.get()` exibirá o erro de tipo `distributionTenant module is not available`. + O erro `DistributionTenantParameterKeyNotFound` é exibido quando o parâmetro do locatário da distribuição que você especificou não existe. Para gerenciar esses casos de uso, é possível adicionar um bloco `try` e `catch` ao código. # Utilizar async e await As funções do JavaScript runtime 2.0 do CloudFront Functions oferecem as sintaxes `async` e `await` para lidar com objetos `Promise`. Promises representam resultados atrasados que podem ser acessados por meio da palavra-chave `await` nas funções marcadas como `async`. Várias novas funções do WebCrypto usam Promises. Para obter mais informações sobre objetos `Promise`, consulte [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise). **nota** É necessário usar o JavaScript runtime 2.0 para os exemplos de código a seguir. `await` pode ser usado apenas dentro de funções `async`. Encerramentos e argumentos `async` não são compatíveis. ``` 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; } ``` O exemplo de código JavaScript a seguir mostra como visualizar Promises com o método de cadeia `then`. É possível usar `catch` para visualizar erros. **Atenção** O uso de combinadores de promessa (por exemplo, `Promise.all` e `Promise.any`) e métodos de cadeia de promessa (por exemplo, `then` e `catch`) pode exigir alto uso de memória da função. Se sua função exceder a cota [máxima de memória da função](cloudfront-limits.md#limits-functions), ela não será executada. Para evitar esse erro, recomendamos usar a sintaxe `await` em vez dos 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; } ``` # Suporte a CWT para o CloudFront Functions Esta seção apresenta detalhes sobre o suporte a CBOR Web Tokens (CWT) no CloudFront Functions, o que permite autenticação e autorização seguras baseadas em tokens nos locais da borda do CloudFront. Esse suporte é fornecido como um módulo, acessível em sua função do CloudFront. Para usar esse módulo, crie uma função do CloudFront usando o Runtime 2.0 do JavaScript e inclua a seguinte instrução na primeira linha do código da função: ``` import cf from 'cloudfront'; ``` Os métodos associados a este módulo podem ser acessados por meio de cf.cwt.\$1 (em que \$1 é um curinga representando as diferentes funções presentes no módulo): ``` cf.cwt.* ``` Para ter mais informações, consulte [Recursos de runtime 2.0 do JavaScript para CloudFront Functions](functions-javascript-runtime-20.md). No momento, o módulo aceita apenas a estrutura MAC0 com o algoritmo HS256 (HMAC-SHA256), com um limite de 1 KB para o tamanho máximo do token. ## Estrutura do tokens Esta seção aborda a estrutura de tokens que é esperada pelo módulo CWT. O módulo espera que o token seja corretamente marcado e identificável (p. ex., COSE MAC0). Além disso, para a estrutura de tokens, o módulo segue os padrões definidos pela [CBOR Object Signing and Encryption (COSE) [RFC 8152](https://datatracker.ietf.org/doc/html/rfc8152)]. ``` ( // CWT Tag (Tag value: 61) --- optional ( // COSE MAC0 Structure Tag (Tag value: 17) --- required [ protectedHeaders, unprotectedHeaders, payload, tag, ] ) ) ``` **Example : CWT usando a estrutura 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 ] ) ) ``` A tag CWT é opcional ao gerar tokens. No entanto, a tag da estrutura COSE é necessária. ## Método validateToken() A função decodifica e valida um CWT usando a chave especificada. Se o comando tiver êxito, ela exibirá um CWT decodificado. Do contrário, gerará um erro. Observe que essa função não valida o conjunto de instruções. ### Solicitação ``` cf.cwt.validateToken(token, handlerContext{key}) ```Parâmetros **token (obrigatório)** Token codificado para validação. Deve ser um buffer em JavaScript. **handlerContext (obrigatório)** Um objeto JavaScript que armazena o contexto para a chamada validateToken. No momento, somente a propriedade key é permitida. **key (obrigatório)** Chave secreta para computação de resumo de mensagens. Pode ser fornecido como uma string ou como um buffer em JavaScript. ### Resposta Quando o método `validateToken()` exibe um token validado com êxito, a resposta da função é um `CWTObject` no formato a seguir. Depois de decodificadas, todas as chaves de solicitação são representadas como strings. ``` CWTObject { protectedHeaders, unprotectedHeaders, payload } ``` ### Exemplo: validar o token com kid enviado como parte do token Este exemplo demonstra a validação de um CWT, em que kid (key ID) é extraído do cabeçalho. Em seguida, o kid é encaminhado ao KeyValueStore do CloudFront Functions para buscar a chave secreta usada para validar o 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() Essa função gera um novo CWT usando a carga útil e as configurações de contexto fornecidas. ### Solicitação ``` cf.cwt.generateToken(generatorContext, payload) ```Parâmetros **generatorContext (obrigatório)** Esse é um objeto JavaScript usado como contexto para gerar o token e contém os seguintes pares de chave-valor: **cwtTag (opcional)** Esse valor é um booliano que, se for `true`, especifica que `cwtTag` deve ser adicionado. **coseTag (obrigatório)** Especifica o tipo de tag COSE. No momento, oferece suporte apenas a `MAC0`. **key (obrigatório)** Chave secreta para computar resumo de mensagens. Esse valor pode ser uma string ou `Buffer` em JavaScript. **payload (obrigatório)** Carga útil do token para codificação. A carga útil deve estar no seguinte formato `CWTObject`. ### Resposta Exibe um buffer em JavaScript contendo o token codificado. **Example : gerar um 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 : atualizar o token com base em alguma 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 auxiliares gerais Esta página apresenta outros métodos auxiliares dentro do CloudFront Functions. Para usar esses métodos, crie uma função do CloudFront usando o Runtime 2.0 do JavaScript. ``` import cf from 'cloudfront'; ``` Para ter mais informações, consulte [Recursos de runtime 2.0 do JavaScript para CloudFront Functions](functions-javascript-runtime-20.md). ## `edgeLocation`Metadados do Esse método requer o uso do módulo `cloudfront`. **nota** Somente é possível usar esse método para funções de solicitação de visualizador. Para funções de resposta ao visualizador, esse método está vazio. Use esse objeto JavaScript para obter o código do aeroporto do local da borda, a região do [cache de borda regional](HowCloudFrontWorks.md#CloudFrontRegionaledgecaches) que deve ser usada ou o endereço IP do servidor do CloudFront usado para processar a solicitação. Esses metadados estão disponíveis somente no acionador de eventos de solicitação de visualizador. ``` cf.edgeLocation = { name: SEA serverIp: 1.2.3.4 region: us-west-2 } ``` O objeto `cf.edgeLocation` contém os seguintes campos: **name** O [código da IATA](https://en.wikipedia.org/wiki/IATA_airport_code) de três letras do local da borda que processou a solicitação. **serverIp** O endereço IPv4 ou IPv6 do servidor que processou a solicitação. **region** O cache de borda regional (REC) do CloudFront que a solicitação deve usar se não houver acerto no cache. Esse valor não é atualizado caso o REC a ser usado não esteja disponível e um REC de backup seja usado para a solicitação. Isso não inclui o local do Origin Shield que está sendo usado, exceto nos casos em que o REC primário e o Origin Shield estão no mesmo local. **nota** O CloudFront Functions não é invocado pela segunda vez quando o CloudFront está configurado para usar o failover de origem. Para ter mais informações, consulte [Otimizar a alta disponibilidade com o failover de origem do CloudFront](high_availability_origin_failover.md). ## Método `rawQueryString()` Esse método não requer o módulo `cloudFront`. Use o método `rawQueryString()` para recuperar a string de consulta não analisada e não alterada como uma string. **Solicitação** ``` function handler(event) { var request = event.request; const qs = request.rawQueryString(); } ``` **Resposta** Exibe a string de consulta completa da solicitação de entrada como um valor de string sem o `?` inicial. + Se não houver uma string de consulta, mas houver um `?`, as funções exibirão uma string vazia. + Se não houver uma string de consulta e houver um `?`, a função exibirá `undefined`. **Caso 1: string de consulta completa exibida (sem o `?` inicial)** URL da solicitação de entrada: `https://example.com/page?name=John&age=25&city=Boston`. `rawQueryString()` exibe: `"name=John&age=25&city=Boston"`. **Caso 2: string vazia exibida (quando há um `?`, mas sem parâmetros)** URL da solicitação de entrada: `https://example.com/page?`. `rawQueryString()` exibe: `""`. **Caso 3: `undefined` exibido (sem string de consulta e nenhum `?`)** URL da solicitação de entrada: `https://example.com/page`. `rawQueryString()` exibe: `undefined`.