Here is your custom content.
" } } } ``` ## Oggetto evento di esempio Di seguito viene illustrato un esempio di oggetto `event` completo. Questo è un esempio di invocazione per una distribuzione standard, non per una distribuzione multi-tenant. Per le distribuzioni multi-tenant, il `endpoint` campo viene utilizzato al posto di The value of è `distributionDomainName` il nome di `endpoint` CloudFront dominio (ad esempio, d111111abcdef8.cloudfront.net) del gruppo di connessione associato all'evento. **Nota** L'oggetto `event` è l'input per la tua funzione. La funzione restituisce solo l'oggetto `request` o `response`, non l'oggetto `event` completo. ``` { "version": "1.0", "context": { "distributionDomainName": "d111111abcdef8.cloudfront.net", "distributionId": "EDFDVBD6EXAMPLE", "eventType": "viewer-response", "requestId": "EXAMPLEntjQpEXAMPLE_SG5Z-EXAMPLEPmPfEXAMPLEu3EqEXAMPLE==" }, "viewer": {"ip": "198.51.100.11"}, "request": { "method": "GET", "uri": "/media/index.mpd", "querystring": { "ID": {"value": "42"}, "Exp": {"value": "1619740800"}, "TTL": {"value": "1440"}, "NoValue": {"value": ""}, "querymv": { "value": "val1", "multiValue": [ {"value": "val1"}, {"value": "val2,val3"} ] } }, "headers": { "host": {"value": "video.example.com"}, "user-agent": {"value": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0"}, "accept": { "value": "application/json", "multiValue": [ {"value": "application/json"}, {"value": "application/xml"}, {"value": "text/html"} ] }, "accept-language": {"value": "en-GB,en;q=0.5"}, "accept-encoding": {"value": "gzip, deflate, br"}, "origin": {"value": "https://website.example.com"}, "referer": {"value": "https://website.example.com/videos/12345678?action=play"}, "cloudfront-viewer-country": {"value": "GB"} }, "cookies": { "Cookie1": {"value": "value1"}, "Cookie2": {"value": "value2"}, "cookie_consent": {"value": "true"}, "cookiemv": { "value": "value3", "multiValue": [ {"value": "value3"}, {"value": "value4"} ] } } }, "response": { "statusCode": 200, "statusDescription": "OK", "headers": { "date": {"value": "Mon, 04 Apr 2021 18:57:56 GMT"}, "server": {"value": "gunicorn/19.9.0"}, "access-control-allow-origin": {"value": "*"}, "access-control-allow-credentials": {"value": "true"}, "content-type": {"value": "application/json"}, "content-length": {"value": "701"} }, "cookies": { "ID": { "value": "id1234", "attributes": "Expires=Wed, 05 Apr 2021 07:28:00 GMT" }, "Cookie1": { "value": "val1", "attributes": "Secure; Path=/; Domain=example.com; Expires=Wed, 05 Apr 2021 07:28:00 GMT", "multiValue": [ { "value": "val1", "attributes": "Secure; Path=/; Domain=example.com; Expires=Wed, 05 Apr 2021 07:28:00 GMT" }, { "value": "val2", "attributes": "Path=/cat; Domain=example.com; Expires=Wed, 10 Jan 2021 07:28:00 GMT" } ] } } } } ``` # JavaScript funzionalità di runtime per CloudFront Functions L'ambiente JavaScript di runtime CloudFront Functions è conforme alla [versione 5.1 ECMAScript (ES)](https://www.ecma-international.org/ecma-262/5.1/) e supporta anche alcune funzionalità delle versioni ES da 6 a 12. Per la maggior parte delle up-to-date funzionalità, si consiglia di utilizzare JavaScript runtime 2.0. Le funzionalità JavaScript di runtime 2.0 presentano le seguenti modifiche rispetto alla versione 1.0: + Sono disponibili metodi del modulo Buffer + Non sono disponibili i seguenti metodi di prototipo per stringhe non standard: + `String.prototype.bytesFrom()` + `String.prototype.fromBytes()` + `String.prototype.fromUTF8()` + `String.prototype.toBytes()` + `String.prototype.toUTF8()` + Il modulo crittografico presenta le seguenti modifiche: + `hash.digest()`: il tipo di restituzione viene modificato in `Buffer` se non viene fornita alcuna codifica + `hmac.digest()`: il tipo di restituzione viene modificato in `Buffer` se non viene fornita alcuna codifica + Per ulteriori informazioni sulle nuove funzionalità aggiuntive, consulta [JavaScript funzionalità di runtime 2.0 per CloudFront Functions](functions-javascript-runtime-20.md). **Topics** + [JavaScript funzionalità di runtime 1.0](functions-javascript-runtime-10.md) + [JavaScript funzionalità di runtime 2.0](functions-javascript-runtime-20.md) # JavaScript Funzionalità di runtime 1.0 per CloudFront Functions L'ambiente JavaScript di runtime di CloudFront Functions è conforme alla [versione 5.1 ECMAScript (ES)](https://262.ecma-international.org/5.1/) e supporta anche alcune funzionalità delle versioni ES da 6 a 9. Fornisce anche alcuni metodi non standard che non fanno parte delle specifiche ES. Negli argomenti seguenti sono elencate tutte le funzionalità linguistiche supportate. **Topics** + [ ## Caratteristiche principali ](#writing-functions-javascript-features-core) + [ ## Oggetti primitivi ](#writing-functions-javascript-features-primitive-objects) + [ ## Oggetti incorporati ](#writing-functions-javascript-features-builtin-objects) + [ ## Tipi di errore ](#writing-functions-javascript-features-error-types) + [ ## Elementi globali ](#writing-functions-javascript-features-globals) + [ ## Moduli incorporati ](#writing-functions-javascript-features-builtin-modules) + [ ## Funzionalità con restrizioni ](#writing-functions-javascript-features-restricted-features) ## Caratteristiche principali Sono supportate le seguenti caratteristiche principali di ES. **Tipi** Sono supportati tutti i tipi ES 5.1. Tra questi vi sono valori booleani, numeri, stringhe, oggetti, matrici, funzioni, costruttori di funzioni ed espressioni regolari. **Operatori** Sono supportati tutti gli operatori ES 5.1. È supportato l'operatore esponenziale ES 7 (`**`). **Dichiarazioni** Le istruzioni `const` e `let` non sono supportate. Sono supportate le seguenti istruzioni ES 5.1: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `return` + `switch` + `throw` + `try` + `var` + `while` + Istruzioni etichettate **Valori letterali** Sono supportati i valori letterali modello ES 6: stringhe multilinea, interpolazione di espressioni e modelli di nidificazione. **Funzioni** Sono supportate tutte le funzioni ES 5.1. Sono supportate le funzioni freccia ES 6 ed è supportata la sintassi del parametro rest ES 6. **Unicode** Il testo di origine e i valori letterali stringa possono contenere caratteri codificati in Unicode. Sono supportate anche sequenze di escape dei punti di codice Unicode di sei caratteri (ad esempio, `\uXXXX`). **Modalità rigorosa** Le funzioni funzionano in modalità rigorosa per impostazione predefinita, quindi non è necessario aggiungere una istruzione `use strict` nel codice funzione. Non possono essere modificate. ## Oggetti primitivi Sono supportati i seguenti oggetti primitivi di ES. **Oggetto** Sono supportati i seguenti metodi ES 5.1 sugli oggetti: + `create` (senza elenco delle proprietà) + `defineProperties` + `defineProperty` + `freeze` + `getOwnPropertyDescriptor` + `getOwnPropertyNames` + `getPrototypeOf` + `hasOwnProperty` + `isExtensible` + `isFrozen` + `prototype.isPrototypeOf` + `isSealed` + `keys` + `preventExtensions` + `prototype.propertyIsEnumerable` + `seal` + `prototype.toString` + `prototype.valueOf` Sono supportati i seguenti metodi ES 6 sugli oggetti: + `assign` + `is` + `prototype.setPrototypeOf` Sono supportati i seguenti metodi ES 8 sugli oggetti: + `entries` + `values` **Stringa** Sono supportati i seguenti metodi ES 5.1 sulle stringhe: + `fromCharCode` + `prototype.charAt` + `prototype.concat` + `prototype.indexOf` + `prototype.lastIndexOf` + `prototype.match` + `prototype.replace` + `prototype.search` + `prototype.slice` + `prototype.split` + `prototype.substr` + `prototype.substring` + `prototype.toLowerCase` + `prototype.trim` + `prototype.toUpperCase` Sono supportati i seguenti metodi ES 6 sulle stringhe: + `fromCodePoint` + `prototype.codePointAt` + `prototype.endsWith` + `prototype.includes` + `prototype.repeat` + `prototype.startsWith` Sono supportati i seguenti metodi ES 8 sulle stringhe: + `prototype.padStart` + `prototype.padEnd` Sono supportati i seguenti metodi ES 9 sulle stringhe: + `prototype.trimStart` + `prototype.trimEnd` Sono supportati i seguenti metodi non standard sulle stringhe: + `prototype.bytesFrom(array | string, encoding)` Crea una stringa di byte da un array di ottetti o da una stringa codificata. Le opzioni di codifica delle stringhe sono `hex`, `base64` e `base64url`. + `prototype.fromBytes(start[, end])` Crea una stringa Unicode da una stringa di byte in cui ogni byte viene sostituito con il corrispondente punto di codice Unicode. + `prototype.fromUTF8(start[, end])` Crea una stringa Unicode da una stringa di byte codificata UTF-8. Se la codifica non è corretta, viene restituito `null`. + `prototype.toBytes(start[, end])` Crea una stringa di byte da una stringa Unicode. Tutti i caratteri devono essere compresi nell'intervallo [0,255]. In caso contrario, restituisce `null`. + `prototype.toUTF8(start[, end])` Crea una stringa di byte codificata UTF-8 da una stringa Unicode. **Numero** Sono supportati tutti i metodi ES 5.1 sui numeri. Sono supportati i seguenti metodi ES 6 sui numeri: + `isFinite` + `isInteger` + `isNaN` + `isSafeInteger` + `parseFloat` + `parseInt` + `prototype.toExponential` + `prototype.toFixed` + `prototype.toPrecision` + `EPSILON` + `MAX_SAFE_INTEGER` + `MAX_VALUE` + `MIN_SAFE_INTEGER` + `MIN_VALUE` + `NEGATIVE_INFINITY` + `NaN` + `POSITIVE_INFINITY` ## Oggetti incorporati Sono supportati i seguenti oggetti incorporati di ES. **Math** Sono supportati tutti i metodi matematici ES 5.1. Nell'ambiente di runtime di CloudFront Functions, l'`Math.random()`implementazione utilizza `arc4random` OpenBSD con il timestamp di quando la funzione viene eseguita. Sono supportati i seguenti metodi matematici ES 6: + `acosh` + `asinh` + `atanh` + `cbrt` + `clz32` + `cosh` + `expm1` + `fround` + `hypot` + `imul` + `log10` + `log1p` + `log2` + `sign` + `sinh` + `tanh` + `trunc` + `E` + `LN10` + `LN2` + `LOG10E` + `LOG2E` + `PI` + `SQRT1_2` + `SQRT2` **Data** Sono supportate tutte le funzioni `Date` ES 5.1. Per motivi di sicurezza, restituisce `Date` sempre lo stesso valore, ovvero l'ora di inizio della funzione, durante la durata di una singola esecuzione di una funzione. Per ulteriori informazioni, consulta [Funzionalità con restrizioni](#writing-functions-javascript-features-restricted-features). **Funzione** Sono supportati i metodi `apply`, `bind` e `call`. I costruttori di funzioni non sono supportati. **Espressioni regolari** Sono supportate tutte le funzioni di espressione regolare ES 5.1. Il linguaggio delle espressioni regolari è compatibile con Perl. Sono supportati i gruppi di acquisizione denominati di ES 9. **JSON** Sono supportate tutte le funzionalità JSON di ES 5.1, incluso `parse` e `stringify`. **Array** Sono supportati i seguenti metodi ES 5.1 sugli array: + `isArray` + `prototype.concat` + `prototype.every` + `prototype.filter` + `prototype.forEach` + `prototype.indexOf` + `prototype.join` + `prototype.lastIndexOf` + `prototype.map` + `prototype.pop` + `prototype.push` + `prototype.reduce` + `prototype.reduceRight` + `prototype.reverse` + `prototype.shift` + `prototype.slice` + `prototype.some` + `prototype.sort` + `prototype.splice` + `prototype.unshift` Sono supportati i seguenti metodi ES 6 sugli array: + `of` + `prototype.copyWithin` + `prototype.fill` + `prototype.find` + `prototype.findIndex` Sono supportati i seguenti metodi ES 7 sugli array: + `prototype.includes` **Array tipizzati** Sono supportati i seguenti array tipizzati ES 6: + `Int8Array` + `Uint8Array` + `Uint8ClampedArray` + `Int16Array` + `Uint16Array` + `Int32Array` + `Uint32Array` + `Float32Array` + `Float64Array` + `prototype.copyWithin` + `prototype.fill` + `prototype.join` + `prototype.set` + `prototype.slice` + `prototype.subarray` + `prototype.toString` **ArrayBuffer** Sono supportati i seguenti metodi su `ArrayBuffer`: + `prototype.isView` + `prototype.slice` **Promessa** Sono supportati i seguenti metodi sulle promesse: + `reject` + `resolve` + `prototype.catch` + `prototype.finally` + `prototype.then` **Crittografia** Il modulo di crittografia fornisce helper standard hash e HMAC (Hash Message Authentication Code). È possibile caricare il modulo usando `require('crypto')`. Il modulo espone i seguenti metodi che si comportano esattamente come le loro controparti Node.js: + `createHash(algorithm)` + `hash.update(data)` + `hash.digest([encoding])` + `createHmac(algorithm, secret key)` + `hmac.update(data)` + `hmac.digest([encoding])` Per ulteriori informazioni, consulta [Crittografia (hash e HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) nella sezione dei moduli incorporati. **Console** Questo è un oggetto helper per il debug. Supporta solo il metodo `log()` per registrare i messaggi di log. CloudFront Le funzioni non supportano la sintassi delle virgole, ad esempio. `console.log('a', 'b')` Utilizzare invece il formato `console.log('a' + ' ' + 'b')`. ## Tipi di errore Sono supportati i seguenti oggetti di errore: + `Error` + `EvalError` + `InternalError` + `MemoryError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Elementi globali L'oggetto `globalThis` è supportato. Sono supportate le seguenti funzioni globali ES 5.1: + `decodeURI` + `decodeURIComponent` + `encodeURI` + `encodeURIComponent` + `isFinite` + `isNaN` + `parseFloat` + `parseInt` Sono supportate le seguenti costanti globali: + `NaN` + `Infinity` + `undefined` ## Moduli incorporati Sono supportati i seguenti moduli incorporati: **Topics** + [ ### Crittografia (hash e HMAC) ](#writing-functions-javascript-features-builtin-modules-crypto) + [ ### Stringa di query ](#writing-functions-javascript-features-builtin-modules-query-string) ### Crittografia (hash e HMAC) Il modulo di crittografia (`crypto`) fornisce helper di hashing standard e HMAC (Hash Message Authentication Code). È possibile caricare il modulo usando `require('crypto')`. Il modulo fornisce i seguenti metodi che si comportano esattamente come le controparti Node.js. **Metodi di hashing** `crypto.createHash(algorithm)` Crea e restituisce un oggetto hash che è possibile utilizzare per generare digest hash utilizzando il dato algoritmo: `md5`, `sha1`, o `sha256`. `hash.update(data)` Aggiorna il contenuto hash con il dato `data`. `hash.digest([encoding])` Calcola il digest di tutti i dati passati tramite `hash.update()`. La codifica può essere `hex`, `base64` o `base64url`. **Metodi HMAC** `crypto.createHmac(algorithm, secret key)` Crea e restituisce un oggetto HMAC che utilizza il dato `algorithm` e `secret key`. L'algoritmo può essere `md5`, `sha1` o `sha256`. `hmac.update(data)` Aggiorna il contenuto HMAC con il dato `data`. `hmac.digest([encoding])` Calcola il digest di tutti i dati passati tramite `hmac.update()`. La codifica può essere `hex`, `base64` o `base64url`. ### Stringa di query **Nota** L'[oggetto evento CloudFront Functions](functions-event-structure.md) analizza automaticamente le stringhe di query URL per voi. Ciò significa che nella maggior parte dei casi non è necessario utilizzare questo modulo. Il modulo stringa di query (`querystring`) fornisce metodi per l'analisi e la formattazione delle stringhe di query URL. È possibile caricare il modulo usando `require('querystring')`. Il modulo fornisce i metodi seguenti: `querystring.escape(string)` URL che codifica il dato `string`, restituendo una stringa di query con escape. Il metodo viene utilizzato da `querystring.stringify()` e non deve essere utilizzato direttamente. `querystring.parse(string[, separator[, equal[, options]]])` Analizza una stringa di query (`string`) e restituisce un oggetto. Il parametro `separator` è una sottostringa per delimitare coppie chiave e valore nella stringa di query. Per impostazione predefinita, tale valore è `&`. Il parametro `equal` è una sottostringa per la delimitazione di chiavi e valori nella stringa di query. Per impostazione predefinita, tale valore è `=`. Il parametro `options` è un oggetto con le seguenti chiavi: `decodeURIComponent function` Un funzione per decodificare i caratteri codificati in percentuale nella stringa di query. Per impostazione predefinita, tale valore è `querystring.unescape()`. `maxKeys number` Il numero massimo di chiavi da analizzare. Per impostazione predefinita, tale valore è `1000`. Utilizza un valore `0` per rimuovere le limitazioni per il conteggio delle chiavi. Per impostazione predefinita, si presuppone che i caratteri con codifica in percentuale all'interno della stringa di query utilizzino la codifica UTF-8. Le sequenze UTF-8 non valide vengono sostituite con il carattere sostitutivo `U+FFFD`. Ad esempio, per la seguente stringa di query: ``` 'name=value&abc=xyz&abc=123' ``` Il valore restituito di `querystring.parse()` è: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` è un alias per `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serializza un `object` e restituisce una stringa di query. Il parametro `separator` è una sottostringa per delimitare coppie chiave e valore nella stringa di query. Per impostazione predefinita, tale valore è `&`. Il parametro `equal` è una sottostringa per la delimitazione di chiavi e valori nella stringa di query. Per impostazione predefinita, tale valore è `=`. Il parametro `options` è un oggetto con le seguenti chiavi: `encodeURIComponent function` La funzione da utilizzare per convertire caratteri non sicuri dell’URL in codifica percentuale nella stringa di query. Per impostazione predefinita, tale valore è `querystring.escape()`. Per impostazione predefinita, i caratteri che richiedono la codifica percentuale all'interno della stringa di query sono codificati come UTF-8. Per utilizzare una codifica diversa, specifica l'opzione `encodeURIComponent`. Ad esempio, per il seguente codice: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` Il valore restituito è: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` è un alias per `querystring.stringify()`. `querystring.unescape(string)` Decodifica i caratteri codificati in percentuale URL nel dato `string`, restituendo una stringa di query senza escape. Questo metodo viene utilizzato da `querystring.parse()` e non deve essere utilizzato direttamente. ## Funzionalità con restrizioni Le seguenti funzionalità JavaScript linguistiche non sono supportate o sono limitate a causa di problemi di sicurezza. **Valutazione dinamica del codice** La valutazione dinamica del codice non è supportata. Entrambi i costruttori `eval()` e `Function` generano un errore se tentato. Ad esempio, `const sum = new Function('a', 'b', 'return a + b')` genera un errore. **Timer** Le funzioni `setTimeout()`, `setImmediate()` e `clearTimeout()` non sono supportate. Non vi è alcuna disposizione per differire o cedere all'interno di un'esecuzione di funzione. La funzione deve essere eseguita in modo sincrono fino al completamento. **Data e timestamp** Per motivi di sicurezza, non è possibile accedere ai timer ad alta risoluzione. Tutti i metodi `Date` per interrogare l'ora corrente restituiscono sempre lo stesso valore durante la durata di una singola esecuzione di funzione. Il timestamp restituito è il momento in cui la funzione ha iniziato l'esecuzione. Di conseguenza, non è possibile misurare il tempo trascorso nella vostra funzione. **Accesso al file system** Nessun accesso al file system. Ad esempio, non esiste un modulo `fs` per l'accesso al file system come invece è presente in Node.js. **Accesso al processo** Non è possibile accedere al processo. Ad esempio, non esiste un oggetto globale `process` per l’elaborazione dell’accesso alle informazioni come in Node.js. **Variabili di ambiente** Non è possibile accedere alle variabili d’ambiente. Puoi invece utilizzarlo CloudFront KeyValueStore per creare un datastore centralizzato di coppie chiave-valore per le tue Funzioni. CloudFront CloudFront KeyValueStore consente aggiornamenti dinamici ai dati di configurazione senza dover implementare modifiche al codice. È necessario utilizzare [JavaScript runtime 2.0](functions-javascript-runtime-20.md) per utilizzare. CloudFront KeyValueStore Per ulteriori informazioni, consulta [Amazon CloudFront KeyValueStore](kvs-with-functions.md). **Accesso alla rete** Non è disponibile alcun supporto per le chiamate di rete. Ad esempio, XHR, HTTP(S) e socket non sono supportati. # JavaScript funzionalità di runtime 2.0 per CloudFront Functions L'ambiente JavaScript di runtime di CloudFront Functions è conforme alla [versione 5.1 ECMAScript (ES)](https://262.ecma-international.org/5.1/) e supporta anche alcune funzionalità delle versioni ES da 6 a 12. Fornisce anche alcuni metodi non standard che non fanno parte delle specifiche ES. Negli argomenti seguenti sono elencate tutte le funzionalità supportate in questo runtime. **Topics** + [ ## Caratteristiche principali ](#writing-functions-javascript-features-core-20) + [ ## Oggetti primitivi ](#writing-functions-javascript-features-primitive-objects-20) + [ ## Oggetti incorporati ](#writing-functions-javascript-features-builtin-objects-20) + [ ## Tipi di errore ](#writing-functions-javascript-features-error-types-20) + [ ## Elementi globali ](#writing-functions-javascript-features-globals-20) + [ ## Moduli incorporati ](#writing-functions-javascript-features-builtin-modules-20) + [ ## Funzionalità con restrizioni ](#writing-functions-javascript-features-restricted-features-20) ## Caratteristiche principali Sono supportate le seguenti caratteristiche principali di ES. **Tipi** Sono supportati tutti i tipi ES 5.1. Tra questi vi sono valori booleani, numeri, stringhe, oggetti, matrici, funzioni ed espressioni regolari. **Operatori** Sono supportati tutti gli operatori ES 5.1. È supportato l'operatore esponenziale ES 7 (`**`). **Dichiarazioni** Sono supportate le seguenti istruzioni ES 5.1: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `label` + `return` + `switch` + `throw` + `try` + `var` + `while` Sono supportate le seguenti istruzioni ES 6: + `const` + `let` Sono supportate le seguenti istruzioni ES 8: + `async` + `await` `async`, `await``const`, e `let` sono supportati nel JavaScript runtime 2.0. `await` può essere utilizzato solo all’interno delle funzioni `async`. Argomenti e chiusure `async` non sono supportati. **Valori letterali** Sono supportati i valori letterali modello ES 6: stringhe multilinea, interpolazione di espressioni e modelli di nidificazione. **Funzioni** Sono supportate tutte le funzioni ES 5.1. Sono supportate le funzioni freccia ES 6 ed è supportata la sintassi del parametro rest ES 6. **Unicode** Il testo di origine e i valori letterali stringa possono contenere caratteri codificati in Unicode. Sono supportate anche sequenze di escape dei punti di codice Unicode di sei caratteri (ad esempio, `\uXXXX`). **Modalità rigorosa** Le funzioni funzionano in modalità rigorosa per impostazione predefinita, quindi non è necessario aggiungere una istruzione `use strict` nel codice funzione. Non possono essere modificate. ## Oggetti primitivi Sono supportati i seguenti oggetti primitivi di ES. **Oggetto** Sono supportati i seguenti metodi ES 5.1 sugli oggetti: + `Object.create()` (senza elenco delle proprietà) + `Object.defineProperties()` + `Object.defineProperty()` + `Object.freeze()` + `Object.getOwnPropertyDescriptor()` + `Object.getOwnPropertyDescriptors()` + `Object.getOwnPropertyNames()` + `Object.getPrototypeOf()` + `Object.isExtensible()` + `Object.isFrozen()` + `Object.isSealed()` + `Object.keys()` + `Object.preventExtensions()` + `Object.seal()` Sono supportati i seguenti metodi ES 6 sugli oggetti: + `Object.assign()` Sono supportati i seguenti metodi ES 8 sugli oggetti: + `Object.entries()` + `Object.values()` Sono supportati i seguenti metodi di prototipo ES 5.1 sugli oggetti: + `Object.prototype.hasOwnProperty()` + `Object.prototype.isPrototypeOf()` + `Object.prototype.propertyIsEnumerable()` + `Object.prototype.toString()` + `Object.prototype.valueOf()` Sono supportati i seguenti metodi di prototipo ES 6 sugli oggetti: + `Object.prototype.is()` + `Object.prototype.setPrototypeOf()` **Stringa** Sono supportati i seguenti metodi ES 5.1 sulle stringhe: + `String.fromCharCode()` Sono supportati i seguenti metodi ES 6 sulle stringhe: + `String.fromCodePoint()` Sono supportati i seguenti metodi di prototipo ES 5.1 sulle stringhe: + `String.prototype.charAt()` + `String.prototype.concat()` + `String.prototype.indexOf()` + `String.prototype.lastIndexOf()` + `String.prototype.match()` + `String.prototype.replace()` + `String.prototype.search()` + `String.prototype.slice()` + `String.prototype.split()` + `String.prototype.substr()` + `String.prototype.substring()` + `String.prototype.toLowerCase()` + `String.prototype.trim()` + `String.prototype.toUpperCase()` Sono supportati i seguenti metodi di prototipo ES 6 sulle stringhe: + `String.prototype.codePointAt()` + `String.prototype.endsWith()` + `String.prototype.includes()` + `String.prototype.repeat()` + `String.prototype.startsWith()` Sono supportati i seguenti metodi di prototipo ES 8 sulle stringhe: + `String.prototype.padStart()` + `String.prototype.padEnd()` Sono supportati i seguenti metodi di prototipo ES 9 sulle stringhe: + `String.prototype.trimStart()` + `String.prototype.trimEnd()` Sono supportati i seguenti metodi di prototipo ES 12 sulle stringhe: + `String.prototype.replaceAll()` **Nota** `String.prototype.replaceAll()`è nuovo nel JavaScript runtime 2.0. **Numero** Sono supportati TUTTI i numeri ES 5. Sono supportate le seguenti proprietà ES 6 sui numeri: + `Number.EPSILON` + `Number.MAX_SAFE_INTEGER` + `Number.MIN_SAFE_INTEGER` + `Number.MAX_VALUE` + `Number.MIN_VALUE` + `Number.NaN` + `Number.NEGATIVE_INFINITY` + `Number.POSITIVE_INFINITY` Sono supportati i seguenti metodi ES 6 sui numeri: + `Number.isFinite()` + `Number.isInteger()` + `Number.isNaN()` + `Number.isSafeInteger()` + `Number.parseInt()` + `Number.parseFloat()` Sono supportati i seguenti metodi di prototipo ES 5.1 sui numeri: + `Number.prototype.toExponential()` + `Number.prototype.toFixed()` + `Number.prototype.toPrecision()` Sono supportati i separatori numerici ES 12. I separatori numerici ES 12 sono nuovi nel JavaScript runtime 2.0. ## Oggetti incorporati Sono supportati i seguenti oggetti incorporati di ES. **Math** Sono supportati tutti i metodi matematici ES 5.1. Nell'ambiente di runtime di CloudFront Functions, l'`Math.random()`implementazione utilizza `arc4random` OpenBSD con il timestamp di quando la funzione viene eseguita. Sono supportate le seguenti proprietà matematiche ES 6: + `Math.E` + `Math.LN10` + `Math.LN2` + `Math.LOG10E` + `Math.LOG2E` + `Math.PI` + `Math.SQRT1_2` + `Math.SQRT2` Sono supportati i seguenti metodi matematici ES 6: + `Math.abs()` + `Math.acos()` + `Math.acosh()` + `Math.asin()` + `Math.asinh()` + `Math.atan()` + `Math.atan2()` + `Math.atanh()` + `Math.cbrt()` + `Math.ceil()` + `Math.clz32()` + `Math.cos()` + `Math.cosh()` + `Math.exp()` + `Math.expm1()` + `Math.floor()` + `Math.fround()` + `Math.hypot()` + `Math.imul()` + `Math.log()` + `Math.log1p()` + `Math.log2()` + `Math.log10()` + `Math.max()` + `Math.min()` + `Math.pow()` + `Math.random()` + `Math.round()` + `Math.sign()` + `Math.sinh()` + `Math.sin()` + `Math.sqrt()` + `Math.tan()` + `Math.tanh()` + `Math.trunc()` **Data** Sono supportate tutte le funzioni `Date` ES 5.1. Per motivi di sicurezza, restituisce `Date` sempre lo stesso valore, ovvero l'ora di inizio della funzione, durante la durata di una singola esecuzione di una funzione. Per ulteriori informazioni, consulta [Funzionalità con restrizioni](functions-javascript-runtime-10.md#writing-functions-javascript-features-restricted-features). **Funzione** Sono supportati i seguenti metodi di prototipo ES 5.1: + `Function.prototype.apply()` + `Function.prototype.bind()` + `Function.prototype.call()` I costruttori di funzioni non sono supportati. **Espressioni regolari** Sono supportate tutte le funzioni di espressione regolare ES 5.1. Il linguaggio delle espressioni regolari è compatibile con Perl. Sono supportate le seguenti proprietà di accessor per prototipo ES 5.1: + `RegExp.prototype.global` + `RegExp.prototype.ignoreCase` + `RegExp.protoype.multiline` + `RegExp.protoype.source` + `RegExp.prototype.sticky` + `RegExp.prototype.flags` **Nota** `RegExp.prototype.sticky`e `RegExp.prototype.flags` sono nuove in runtime 2.0. JavaScript Sono supportati i seguenti metodi di prototipo ES 5.1: + `RegExp.prototype.exec()` + `RegExp.prototype.test()` + `RegExp.prototype.toString()` + `RegExp.prototype[@@replace]()` + `RegExp.prototype[@@split]()` **Nota** `RegExp.prototype[@@split]()`sono nuove nel JavaScript runtime 2.0. Sono supportate le seguenti proprietà di istanza ES 5.1: + `lastIndex` Sono supportati i gruppi di acquisizione denominati di ES 9. **JSON** Sono supportati i seguenti metodi ES 5.1: + `JSON.parse()` + `JSON.stringify()` **Array** Sono supportati i seguenti metodi ES 5.1 sugli array: + `Array.isArray()` Sono supportati i seguenti metodi ES 6 sugli array: + `Array.of()` Sono supportati i seguenti metodi di prototipo ES 5.1: + `Array.prototype.concat()` + `Array.prototype.every()` + `Array.prototype.filter()` + `Array.prototype.forEach()` + `Array.prototype.indexOf()` + `Array.prototype.join()` + `Array.prototype.lastIndexOf()` + `Array.prototype.map()` + `Array.prototype.pop()` + `Array.prototype.push()` + `Array.prototype.reduce()` + `Array.prototype.reduceRight()` + `Array.prototype.reverse()` + `Array.prototype.shift()` + `Array.prototype.slice()` + `Array.prototype.some()` + `Array.prototype.sort()` + `Array.prototype.splice()` + `Array.prototype.unshift()` Sono supportati i seguenti metodi di prototipo ES 6: + `Array.prototype.copyWithin()` + `Array.prototype.fill()` + `Array.prototype.find()` + `Array.prototype.findIndex()` Sono supportati i seguenti metodi di prototipo ES 7: + `Array.prototype.includes()` **Array tipizzati** Sono supportati i seguenti costruttori di array tipizzati ES 6: + `Float32Array` + `Float64Array` + `Int8Array` + `Int16Array` + `Int32Array` + `Uint8Array` + `Uint8ClampedArray` + `Uint16Array` + `Uint32Array` Sono supportati i seguenti metodi ES 6: + `TypedArray.from()` + `TypedArray.of()` **Nota** `TypedArray.from()`e `TypedArray.of()` sono nuove nel JavaScript runtime 2.0. Sono supportati i seguenti metodi di prototipo ES 6: + `TypedArray.prototype.copyWithin()` + `TypedArray.prototype.every()` + `TypedArray.prototype.fill()` + `TypedArray.prototype.filter()` + `TypedArray.prototype.find()` + `TypedArray.prototype.findIndex()` + `TypedArray.prototype.forEach()` + `TypedArray.prototype.includes()` + `TypedArray.prototype.indexOf()` + `TypedArray.prototype.join()` + `TypedArray.prototype.lastIndexOf()` + `TypedArray.prototype.map()` + `TypedArray.prototype.reduce()` + `TypedArray.prototype.reduceRight()` + `TypedArray.prototype.reverse()` + `TypedArray.prototype.some()` + `TypedArray.prototype.set()` + `TypedArray.prototype.slice()` + `TypedArray.prototype.sort()` + `TypedArray.prototype.subarray()` + `TypedArray.prototype.toString()` **Nota** `TypedArray.prototype.every()`,`TypedArray.prototype.fill()`,`TypedArray.prototype.filter()`,`TypedArray.prototype.find()`, `TypedArray.prototype.findIndex()``TypedArray.prototype.forEach()`,`TypedArray.prototype.includes()`,`TypedArray.prototype.indexOf()`,`TypedArray.prototype.join()`,`TypedArray.prototype.lastIndexOf()`,`TypedArray.prototype.map()`,`TypedArray.prototype.reduce()`, `TypedArray.prototype.reduceRight()``TypedArray.prototype.reverse()`, e `TypedArray.prototype.some()` sono nuovi nel JavaScript runtime 2.0. **ArrayBuffer** Sono supportati i seguenti metodi ES 6 su ArrayBuffer : + `isView()` Sono supportati i seguenti metodi prototipali ES 6 su ArrayBuffer : + `ArrayBuffer.prototype.slice()` **Promessa** Sono supportati i seguenti metodi ES 6 sulle promesse: + `Promise.all()` + `Promise.allSettled()` + `Promise.any()` + `Promise.reject()` + `Promise.resolve()` + `Promise.race()` **Nota** `Promise.all()`, `Promise.allSettled()``Promise.any()`, e `Promise.race()` sono nuovi nel JavaScript runtime 2.0. Sono supportati i seguenti metodi di prototipo ES 6 sulle promesse: + `Promise.prototype.catch()` + `Promise.prototype.finally()` + `Promise.prototype.then()` **DataView** Sono supportati i seguenti metodi di prototipo ES 6: + `DataView.prototype.getFloat32()` + `DataView.prototype.getFloat64()` + `DataView.prototype.getInt16()` + `DataView.prototype.getInt32()` + `DataView.prototype.getInt8()` + `DataView.prototype.getUint16()` + `DataView.prototype.getUint32()` + `DataView.prototype.getUint8()` + `DataView.prototype.setFloat32()` + `DataView.prototype.setFloat64()` + `DataView.prototype.setInt16()` + `DataView.prototype.setInt32()` + `DataView.prototype.setInt8()` + `DataView.prototype.setUint16()` + `DataView.prototype.setUint32()` + `DataView.prototype.setUint8()` **Nota** Tutti i metodi prototipali di Dataview ES 6 sono nuovi in JavaScript runtime 2.0. **Symbol** Sono supportati i seguenti metodi ES 6: + `Symbol.for()` + `Symbol.keyfor()` **Nota** Tutti i metodi Symbol ES 6 sono nuovi nel JavaScript runtime 2.0. **TextDecoder** Sono supportati i seguenti metodi di prototipo: + `TextDecoder.prototype.decode()` Sono supportate le seguenti proprietà di accessor per prototipo: + `TextDecoder.prototype.encoding` + `TextDecoder.prototype.fatal` + `TextDecoder.prototype.ignoreBOM` **TextEncoder** Sono supportati i seguenti metodi di prototipo: + `TextEncoder.prototype.encode()` + `TextEncoder.prototype.encodeInto()` **Console** Questo è un oggetto helper per il debug. Supporta solo il metodo `log()` per registrare i messaggi di log. CloudFront Le funzioni non supportano la sintassi delle virgole, ad esempio`console.log('a', 'b')`. Utilizzare invece il formato `console.log('a' + ' ' + 'b')`. ## Tipi di errore Sono supportati i seguenti oggetti di errore: + `Error` + `EvalError` + `InternalError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Elementi globali L'oggetto `globalThis` è supportato. Sono supportate le seguenti funzioni globali ES 5.1: + `decodeURI()` + `decodeURIComponent()` + `encodeURI()` + `encodeURIComponent()` + `isFinite()` + `isNaN()` + `parseFloat()` + `parseInt()` Sono supportate le seguenti funzioni globali ES 6: + `atob()` + `btoa()` **Nota** `atob()`e `btoa()` sono nuovi in JavaScript runtime 2.0. Sono supportate le seguenti costanti globali: + `NaN` + `Infinity` + `undefined` + `arguments` ## Moduli incorporati Sono supportati i seguenti moduli incorporati: **Topics** + [ ### Buffer ](#writing-functions-javascript-features-builtin-modules-buffer-20) + [ ### Stringa di query ](#writing-functions-javascript-features-builtin-modules-query-string-20) + [ ### Crittografia ](#writing-functions-javascript-features-builtin-modules-crypto-20) ### Buffer Il modulo fornisce i metodi seguenti: + `Buffer.alloc(size[, fill[, encoding]])` Alloca un `Buffer`. + `size`: dimensione del buffer. Immetti un numero intero. + `fill`: facoltativo. Immetti una stringa, `Buffer`, Uint8Array o un numero intero. Il valore predefinito è “`0`”. + `encoding`: facoltativo. Quando `fill` è una stringa, immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”. + `Buffer.allocUnsafe(size)` Alloca un `Buffer` non inizializzato. + `size`: immetti un numero intero. + `Buffer.byteLength(value[, encoding])` Restituisce la lunghezza di un valore, in byte. + `value`: Una stringa, `Buffer` TypedArray, Dataview o Arraybuffer. + `encoding`: facoltativo. Quando `value` è una stringa, immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”. + `Buffer.compare(buffer1, buffer2)` Confronta due `Buffer` per semplificare l'ordinamento degli array. Restituisce `0` se sono uguali, `-1` se viene prima `buffer1` o `1` se viene prima `buffer2`. + `buffer1`: immetti un `Buffer`. + `buffer2`: immetti un altro `Buffer`. + `Buffer.concat(list[, totalLength])` Concatena più `Buffer`. Restituisce `0` se non ce ne sono. Restituisce fino a `totalLength`. + `list`: immetti un elenco di `Buffer`. Tieni presente che verrà troncato a `totalLength`. + `totalLength`: facoltativo. Inserisci un numero intero senza segno. Usa la somma delle istanze `Buffer` nell'elenco se vuoto. + `Buffer.from(array)` Crea un `Buffer` da un array. + `array`: immetti un array di byte da `0` a `255`. + `Buffer.from(arrayBuffer, byteOffset[, length]))` Crea una vista da `arrayBuffer`, partendo dall'offset `byteOffset` con lunghezza `length`. + `arrayBuffer`: immetti una matrice `Buffer`. + `byteOffset`: immetti un numero intero. + `length`: facoltativo. Immetti un numero intero. + `Buffer.from(buffer)` Crea una copia del `Buffer`. + `buffer`: immetti un `Buffer`. + `Buffer.from(object[, offsetOrEncoding[, length]])` Crea un `Buffer` da un oggetto. Restituisce `Buffer.from(object.valueOf(), offsetOrEncoding, length)` se `valueOf()` non è uguale all'oggetto. + `object`: immetti un oggetto. + `offsetOrEncoding`: facoltativo. Immetti un numero intero o una stringa di codifica. + `length`: facoltativo. Immetti un numero intero. + `Buffer.from(string[, encoding])` Crea un `Buffer` da una stringa. + `string`: immetti una stringa. + `encoding`: facoltativo. Immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”. + `Buffer.isBuffer(object)` Controlla se `object` è un buffer. Restituisce `true` o `false`. + `object`: immetti un oggetto. + `Buffer.isEncoding(encoding)` Verifica se `encoding` è supportato. Restituisce `true` o `false`. + `encoding`: facoltativo. Immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”. Il modulo fornisce i seguenti metodi di prototipo del buffer: + `Buffer.prototype.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])` Confronta `Buffer` con l'obiettivo. Restituisce `0` se sono uguali, `1` se viene prima `buffer` o `-1` se viene prima `target`. + `target`: immetti un `Buffer`. + `targetStart`: facoltativo. Immetti un numero intero. Il valore predefinito è 0. + `targetEnd`: facoltativo. Immetti un numero intero. Il valore predefinito è la lunghezza di `target`. + `sourceStart`: facoltativo. Immetti un numero intero. Il valore predefinito è 0. + `sourceEnd`: facoltativo. Immetti un numero intero. Il valore predefinito è la lunghezza di `Buffer`. + `Buffer.prototype.copy(target[, targetStart[, sourceStart[, sourceEnd]]])` Copia il buffer su `target`. + `target`: immetti un `Buffer` o `Uint8Array`. + `targetStart`: facoltativo. Immetti un numero intero. Il valore predefinito è 0. + `sourceStart`: facoltativo. Immetti un numero intero. Il valore predefinito è 0. + `sourceEnd`: facoltativo. Immetti un numero intero. Il valore predefinito è la lunghezza di `Buffer`. + `Buffer.prototype.equals(otherBuffer)` Confronta `Buffer` con `otherBuffer`. Restituisce `true` o `false`. + `otherBuffer`: immetti una stringa. + `Buffer.prototype.fill(value[, offset[, end][, encoding])` Compila `Buffer` con `value`. + `value`: immetti una stringa, `Buffer` o un numero intero. + `offset`: facoltativo. Immetti un numero intero. + `end`: facoltativo. Immetti un numero intero. + `encoding`: facoltativo. Immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”. + `Buffer.prototype.includes(value[, byteOffset][, encoding])` Cerca `value` in `Buffer`. Restituisce `true` o `false`. + `value`: immetti una stringa, `Buffer`, `Uint8Array` o un numero intero. + `byteOffset`: facoltativo. Immetti un numero intero. + `encoding`: facoltativo. Immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”. + `Buffer.prototype.indexOf(value[, byteOffset][, encoding])` Cerca il primo `value` in `Buffer`. Restituisce `index` se trovato e `-1` se non trovato. + `value`: immetti una stringa, `Buffer`, Unit8Array o un numero intero compreso tra 0 e 255. + `byteOffset`: facoltativo. Immetti un numero intero. + `encoding`: facoltativo. Se `value` è una stringa, immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”. + `Buffer.prototype.lastIndexOf(value[, byteOffset][, encoding])` Cerca l'ultimo `value` in `Buffer`. Restituisce `index` se trovato e `-1` se non trovato. + `value`: immetti una stringa, `Buffer`, Unit8Array o un numero intero compreso tra 0 e 255. + `byteOffset`: facoltativo. Immetti un numero intero. + `encoding`: facoltativo. Se `value` è una stringa, immetti uno dei seguenti valori: `utf8`, `hex`, `base64`, `base64url`. Il valore predefinito è “`utf8`”. + `Buffer.prototype.readInt8(offset)` Leggi `Int8` in `offset` a partire da `Buffer`. + `offset`: immetti un numero intero. + `Buffer.prototype.readIntBE(offset, byteLength)` Leggi `Int` come big-endian in `offset` da `Buffer`. + `offset`: immetti un numero intero. + `byteLength`: facoltativo. Immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.readInt16BE(offset)` Leggi `Int16` come big-endian in `offset` da `Buffer`. + `offset`: immetti un numero intero. + `Buffer.prototype.readInt32BE(offset)` Leggi `Int32` come big-endian in `offset` da `Buffer`. + `offset`: immetti un numero intero. + `Buffer.prototype.readIntLE(offset, byteLength)` Leggi `Int` come little-endian in `offset` da `Buffer`. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.readInt16LE(offset)` Leggi `Int16` come little-endian in `offset` da `Buffer`. + `offset`: immetti un numero intero. + `Buffer.prototype.readInt32LE(offset)` Leggi `Int32` come little-endian in `offset` da `Buffer`. + `offset`: immetti un numero intero. + `Buffer.prototype.readUInt8(offset)` Leggi `UInt8` in `offset` a partire da `Buffer`. + `offset`: immetti un numero intero. + `Buffer.prototype.readUIntBE(offset, byteLength)` Leggi `UInt` come big-endian in `offset` da `Buffer`. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.readUInt16BE(offset)` Leggi `UInt16` come big-endian in `offset` da `Buffer`. + + `offset`: immetti un numero intero. + `Buffer.prototype.readUInt32BE(offset)` Leggi `UInt32` come big-endian in `offset` da `Buffer`. + `offset`: immetti un numero intero. + `Buffer.prototype.readUIntLE(offset, byteLength)` Leggi `UInt` come little-endian in `offset` da `Buffer`. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.readUInt16LE(offset)` Leggi `UInt16` come little-endian in `offset` da `Buffer`. + `offset`: immetti un numero intero. + `Buffer.prototype.readUInt32LE(offset)` Leggi `UInt32` come little-endian in `offset` da `Buffer`. + `offset`: immetti un numero intero. + `Buffer.prototype.readDoubleBE([offset])` Leggi un file a doppia precisione a 64 bit come big-endian in `offset` da `Buffer`. + `offset`: facoltativo. Immetti un numero intero. + `Buffer.prototype.readDoubleLE([offset])` Leggi un file a doppia precisione a 64 bit come little-endian in `offset` da `Buffer`. + `offset`: facoltativo. Immetti un numero intero. + `Buffer.prototype.readFloatBE([offset])` Leggi un file a virgola mobile a 32 bit come big-endian in `offset` da `Buffer`. + `offset`: facoltativo. Immetti un numero intero. + `Buffer.prototype.readFloatLE([offset])` Leggi un file a virgola mobile a 32 bit come little-endian in `offset` da `Buffer`. + `offset`: facoltativo. Immetti un numero intero. + `Buffer.prototype.subarray([start[, end]])` Restituisce una copia di `Buffer` con offset e ritaglio con nuovi valori per `start` e `end`. + `start`: facoltativo. Immetti un numero intero. Il valore predefinito è 0. + `end`: facoltativo. Immetti un numero intero. Il valore predefinito è la lunghezza del buffer. + `Buffer.prototype.swap16()` Scambia l'ordine dei byte dell'array `Buffer`, trattandolo come un array di numeri a 16 bit. La lunghezza di `Buffer` deve essere divisibile per 2, altrimenti riceverai un errore. + `Buffer.prototype.swap32()` Scambia l'ordine dei byte dell'array `Buffer`, trattandolo come un array di numeri a 32 bit. La lunghezza di `Buffer` deve essere divisibile per 4, altrimenti riceverai un errore. + `Buffer.prototype.swap64()` Scambia l'ordine dei byte dell'array `Buffer`, trattandolo come un array di numeri a 64 bit. La lunghezza di `Buffer` deve essere divisibile per 8, altrimenti riceverai un errore. + `Buffer.prototype.toJSON()` Restituisce `Buffer` come file JSON. + `Buffer.prototype.toString([encoding[, start[, end]]])` Converti `Buffer`, da `start` a `end`, in una stringa codificata. + `encoding`: facoltativo. Immetti uno dei seguenti valori: `utf8`, `hex`, `base64` o `base64url`. Il valore predefinito è “`utf8`”. + `start`: facoltativo. Immetti un numero intero. Il valore predefinito è 0. + `end`: facoltativo. Immetti un numero intero. Il valore predefinito è la lunghezza del buffer. + `Buffer.prototype.write(string[, offset[, length]][, encoding])` Scrivi il valore `string` codificato su `Buffer` se c'è spazio a sufficienza o un valore `string` troncato se non c'è abbastanza spazio. + `string`: immetti una stringa. + `offset`: facoltativo. Immetti un numero intero. Il valore predefinito è 0. + `length`: facoltativo. Immetti un numero intero. Il valore predefinito è la lunghezza della stringa. + `encoding`: facoltativo. Facoltativamente, immetti uno dei seguenti valori: `utf8`, `hex`, `base64` o `base64url`. Il valore predefinito è “`utf8`”. + `Buffer.prototype.writeInt8(value, offset, byteLength)` Scrivi `Int8` `value` di `byteLength` a `offset` su `Buffer`. + `value`: immetti un numero intero. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeIntBE(value, offset, byteLength)` Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian. + `value`: immetti un numero intero. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeInt16BE(value, offset, byteLength)` Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian. + `value`: immetti un numero intero. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeInt32BE(value, offset, byteLength)` Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian. + `value`: immetti un numero intero. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeIntLE(offset, byteLength)` Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeInt16LE(offset, byteLength)` Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeInt32LE(offset, byteLength)` Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeUInt8(value, offset, byteLength)` Scrivi `UInt8` `value` di `byteLength` a `offset` su `Buffer`. + `value`: immetti un numero intero. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeUIntBE(value, offset, byteLength)` Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian. + `value`: immetti un numero intero. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeUInt16BE(value, offset, byteLength)` Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian. + `value`: immetti un numero intero. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeUInt32BE(value, offset, byteLength)` Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian. + `value`: immetti un numero intero. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeUIntLE(value, offset, byteLength)` Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian. + `value`: immetti un numero intero. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeUInt16LE(value, offset, byteLength)` Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian. + `value`: immetti un numero intero. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeUInt32LE(value, offset, byteLength)` Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian. + `value`: immetti un numero intero. + `offset`: immetti un numero intero. + `byteLength`: immetti un numero intero compreso tra `1` e `6`. + `Buffer.prototype.writeDoubleBE(value, [offset])` Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian. + `value`: immetti un numero intero. + `offset`: facoltativo. Immetti un numero intero. Il valore predefinito è 0. + `Buffer.prototype.writeDoubleLE(value, [offset])` Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian. + `value`: immetti un numero intero. + `offset`: facoltativo. Immetti un numero intero. Il valore predefinito è 0. + `Buffer.prototype.writeFloatBE(value, [offset])` Scrivi `value` a `offset` su `Buffer`, usando il metodo big-endian. + `value`: immetti un numero intero. + `offset`: facoltativo. Immetti un numero intero. Il valore predefinito è 0. + `Buffer.prototype.writeFloatLE(value, [offset])` Scrivi `value` a `offset` su `Buffer`, usando il metodo little-endian. + `value`: immetti un numero intero. + `offset`: facoltativo. Immetti un numero intero. Il valore predefinito è 0. Sono supportati i seguenti metodi di istanza: + `buffer[index]` Ottieni e imposta l'ottetto (byte) a `index` in `Buffer`. + Ottieni un numero da `0` a `255`. In alternativa, imposta un numero da `0` a `255`. Sono supportate le seguenti proprietà di istanza: + `buffer` Ottieni l'oggetto `ArrayBuffer` per il buffer. + `byteOffset` Ottieni il valore `byteOffset` per l'oggetto `Arraybuffer` del buffer. + `length` Ottieni il conteggio dei byte del buffer. **Nota** Tutti i metodi del modulo Buffer sono nuovi in runtime 2.0. JavaScript ### Stringa di query **Nota** L'[oggetto evento CloudFront Functions](functions-event-structure.md) analizza automaticamente le stringhe di query URL per voi. Ciò significa che nella maggior parte dei casi non è necessario utilizzare questo modulo. Il modulo stringa di query (`querystring`) fornisce metodi per l'analisi e la formattazione delle stringhe di query URL. È possibile caricare il modulo usando `require('querystring')`. Il modulo fornisce i metodi seguenti: `querystring.escape(string)` URL che codifica il dato `string`, restituendo una stringa di query con escape. Il metodo viene utilizzato da `querystring.stringify()` e non deve essere utilizzato direttamente. `querystring.parse(string[, separator[, equal[, options]]])` Analizza una stringa di query (`string`) e restituisce un oggetto. Il parametro `separator` è una sottostringa per delimitare coppie chiave e valore nella stringa di query. Per impostazione predefinita, tale valore è `&`. Il parametro `equal` è una sottostringa per la delimitazione di chiavi e valori nella stringa di query. Per impostazione predefinita, tale valore è `=`. Il parametro `options` è un oggetto con le seguenti chiavi: `decodeURIComponent function` Un funzione per decodificare i caratteri codificati in percentuale nella stringa di query. Per impostazione predefinita, tale valore è `querystring.unescape()`. `maxKeys number` Il numero massimo di chiavi da analizzare. Per impostazione predefinita, tale valore è `1000`. Utilizza un valore `0` per rimuovere le limitazioni per il conteggio delle chiavi. Per impostazione predefinita, si presuppone che i caratteri con codifica in percentuale all'interno della stringa di query utilizzino la codifica UTF-8. Le sequenze UTF-8 non valide vengono sostituite con il carattere sostitutivo `U+FFFD`. Ad esempio, per la seguente stringa di query: ``` 'name=value&abc=xyz&abc=123' ``` Il valore restituito di `querystring.parse()` è: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` è un alias per `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serializza un `object` e restituisce una stringa di query. Il parametro `separator` è una sottostringa per delimitare coppie chiave e valore nella stringa di query. Per impostazione predefinita, tale valore è `&`. Il parametro `equal` è una sottostringa per la delimitazione di chiavi e valori nella stringa di query. Per impostazione predefinita, tale valore è `=`. Il parametro `options` è un oggetto con le seguenti chiavi: `encodeURIComponent function` La funzione da utilizzare per convertire caratteri non sicuri dell’URL in codifica percentuale nella stringa di query. Per impostazione predefinita, tale valore è `querystring.escape()`. Per impostazione predefinita, i caratteri che richiedono la codifica percentuale all'interno della stringa di query sono codificati come UTF-8. Per utilizzare una codifica diversa, specifica l'opzione `encodeURIComponent`. Ad esempio, per il seguente codice: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` Il valore restituito è: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` è un alias per `querystring.stringify()`. `querystring.unescape(string)` Decodifica i caratteri codificati in percentuale URL nel dato `string`, restituendo una stringa di query senza escape. Questo metodo viene utilizzato da `querystring.parse()` e non deve essere utilizzato direttamente. ### Crittografia Il modulo di crittografia (`crypto`) fornisce helper di hashing standard e HMAC (Hash Message Authentication Code). È possibile caricare il modulo usando `require('crypto')`. **Metodi di hashing** `crypto.createHash(algorithm)` Crea e restituisce un oggetto hash che è possibile utilizzare per generare digest hash utilizzando il dato algoritmo: `md5`, `sha1`, o `sha256`. `hash.update(data)` Aggiorna il contenuto hash con il dato `data`. `hash.digest([encoding])` Calcola il digest di tutti i dati passati tramite `hash.update()`. La codifica può essere `hex`, `base64` o `base64url`. **Metodi HMAC** `crypto.createHmac(algorithm, secret key)` Crea e restituisce un oggetto HMAC che utilizza il dato `algorithm` e `secret key`. L'algoritmo può essere `md5`, `sha1` o `sha256`. `hmac.update(data)` Aggiorna il contenuto HMAC con il dato `data`. `hmac.digest([encoding])` Calcola il digest di tutti i dati passati tramite `hmac.update()`. La codifica può essere `hex`, `base64` o `base64url`. ## Funzionalità con restrizioni Le seguenti funzionalità JavaScript linguistiche non sono supportate o sono limitate a causa di problemi di sicurezza. **Valutazione dinamica del codice** La valutazione dinamica del codice non è supportata. Entrambi i costruttori `eval()` e `Function` generano un errore se tentato. Ad esempio, `const sum = new Function('a', 'b', 'return a + b')` genera un errore. **Timer** Le funzioni `setTimeout()`, `setImmediate()` e `clearTimeout()` non sono supportate. Non vi è alcuna disposizione per differire o cedere all'interno di un'esecuzione di funzione. La funzione deve essere eseguita in modo sincrono fino al completamento. **Data e timestamp** Per motivi di sicurezza, non è possibile accedere ai timer ad alta risoluzione. Tutti i metodi `Date` per interrogare l'ora corrente restituiscono sempre lo stesso valore durante la durata di una singola esecuzione di funzione. Il timestamp restituito è il momento in cui la funzione ha iniziato l'esecuzione. Di conseguenza, non è possibile misurare il tempo trascorso nella vostra funzione. **Accesso al file system** Nessun accesso al file system. Ad esempio, non esiste un modulo `fs` per l'accesso al file system come invece è presente in Node.js. **Accesso al processo** Non è possibile accedere al processo. Ad esempio, non esiste un oggetto globale `process` per l’elaborazione dell’accesso alle informazioni come in Node.js. **Variabili di ambiente** Non è possibile accedere alle variabili d’ambiente. Puoi invece utilizzarlo CloudFront KeyValueStore per creare un datastore centralizzato di coppie chiave-valore per le tue Funzioni. CloudFront CloudFront KeyValueStore consente aggiornamenti dinamici ai dati di configurazione senza dover implementare modifiche al codice. Per ulteriori informazioni, consulta [Amazon CloudFront KeyValueStore](kvs-with-functions.md). **Accesso alla rete** Non è disponibile alcun supporto per le chiamate di rete. Ad esempio, XHR, HTTP(S) e socket non sono supportati. # Metodi helper per archivi di valori delle chiavi **Nota** Le chiamate al metodo di supporto Key Value Store da CloudFront Functions non attivano un evento di AWS CloudTrail dati. Questi eventi non vengono registrati nella cronologia degli CloudTrail eventi. Per ulteriori informazioni, consulta [Registrazione delle chiamate CloudFront API Amazon tramite AWS CloudTrail](logging_using_cloudtrail.md). Questa sezione si applica se utilizzi [CloudFront Key Value Store](kvs-with-functions.md) per includere valori chiave nella funzione che crei. CloudFront Functions ha un modulo che fornisce tre metodi di supporto per leggere i valori dall'archivio di valori chiave. Per utilizzare questo modulo nel codice della funzione, assicurati di aver [associato un archivio di valori delle chiavi](kvs-with-functions-associate.md) alla funzione. Quindi, includi le seguenti istruzioni nelle prime righe del codice della funzione: ``` import cf from 'cloudfront'; const kvsHandle = cf.kvs(); ``` ## Metodo `get()` Utilizza questo metodo per restituire il valore della chiave per il nome chiave specificato. **Richiesta** ``` get("key", options); ``` + `key`: il nome della chiave di cui è necessario recuperare il valore + `options`: è presente un’opzione, `format`. Assicura che la funzione analizzi correttamente i dati. Valori possibili: + `string`: (Predefinito) UTF8 codificato + `json` + `bytes`: buffer di dati binari non elaborati **Esempio di richiesta** ``` const value = await kvsHandle.get("myFunctionKey", { format: "string"}); ``` **Risposta** La risposta è una `promise` che si risolve in un valore nel formato richiesto utilizzando `options`. Per impostazione predefinita, il valore viene restituito come stringa. ### Gestione degli errori Il metodo `get()` restituirà un errore quando la chiave richiesta non esiste nell’archivio di valori delle chiavi associato. Per gestire questo caso d’uso, puoi aggiungere un blocco `catch` e `try` al codice. **avvertimento** L’uso dei combinatori di promesse (ad esempio, `Promise.all`, `Promise.any`) e dei metodi di catena di promesse (ad esempio, `then` e `catch`) può richiedere un elevato utilizzo della memoria delle funzioni. Se la funzione supera la quota [massima di memoria delle funzioni](cloudfront-limits.md#limits-functions), non verrà eseguita. Per evitare questo errore, ti consigliamo di utilizzare la sintassi `await` in modo sequenziale o in loop per richiedere più valori. **Esempio** ``` var value1 = await kvs.get('key1'); var value2 = await kvs.get('key2'); ``` Attualmente, l’uso dei combinatori di promesse per ottenere più valori non migliora le prestazioni, come nell’esempio seguente. ``` var values = await Promise.all([kvs.get('key1'), kvs.get('key2'),]); ``` ## Metodo `exists()` Utilizza questo metodo per verificare se la chiave è presente o meno nell’archivio di valori delle chiavi. **Richiesta** ``` exists("key"); ``` **Esempio di richiesta** ``` const exist = await kvsHandle.exists("myFunctionkey"); ``` **Risposta** La risposta è un `promise` che restituisce un valore booleano (`true` o `false`). Questo valore specifica se la chiave esiste o meno nell’archivio di valori delle chiavi. ## Metodo `meta()` Utilizza questo metodo per restituire i metadati relativi all’archivio di valori delle chiavi. **Richiesta** ``` meta(); ``` **Esempio di richiesta** ``` const meta = await kvsHandle.meta(); ``` **Risposta** La risposta è un valore `promise` che si risolve in un oggetto con le seguenti proprietà: + `creationDateTime`: la data e l'ora di creazione dell'archivio di valori delle chiavi, nel formato ISO 8601. + `lastUpdatedDateTime`: la data e l'ora dell'ultima sincronizzazione dell'archivio di valori delle chiavi, nel formato ISO 8601. Il valore non include il tempo di propagazione verso l'edge. + `keyCount`: il numero totale di chiavi in KVS dopo l'ultima sincronizzazione dalla sorgente. **Esempio di risposta** ``` {keyCount:3,creationDateTime:2023-11-30T23:07:55.765Z,lastUpdatedDateTime:2023-12-15T03:57:52.411Z} ``` # Metodi di assistente di gestione per la modifica dell’origine Questa sezione si applica se aggiorni o modifichi dinamicamente l'origine utilizzata nella richiesta all'interno del codice CloudFront Functions. Puoi aggiornare l'origine solo su *richiesta del visualizzatore* CloudFront Functions. CloudFront Functions dispone di un modulo che fornisce metodi di supporto per aggiornare o modificare dinamicamente l'origine. Per utilizzare questo modulo, create una CloudFront funzione utilizzando JavaScript runtime 2.0 e includete la seguente dichiarazione nella prima riga del codice della funzione: ``` import cf from 'cloudfront'; ``` Per ulteriori informazioni, consulta [JavaScript funzionalità di runtime 2.0 per CloudFront Functions](functions-javascript-runtime-20.md). **Nota** Le pagine della console Esegui test API ed Esegui test non controllano se si è verificata una modifica dell’origine. Tuttavia, il test garantisce che il codice della funzione venga eseguito senza errori. ## Scegli tra CloudFront Functions e Lambda @Edge Puoi aggiornare le tue origini utilizzando CloudFront Functions o Lambda @Edge. Quando si utilizza CloudFront Functions per aggiornare le origini, si utilizza il trigger dell'evento *Viewer Request*, il che significa che questa logica verrà eseguita su ogni richiesta quando viene utilizzata questa funzione. Quando si utilizza Lambda@Edge, le funzionalità di aggiornamento dell’origine si trovano nel trigger dell’evento di *richiesta origine*, il che significa che questa logica viene eseguita solo in caso di perdita della cache. La scelta dipende in gran parte dal carico di lavoro e dall'eventuale utilizzo esistente di CloudFront Functions e Lambda @Edge nelle distribuzioni. Le seguenti considerazioni possono aiutarti a decidere se utilizzare CloudFront Functions o Lambda @Edge per aggiornare le tue origini. CloudFront Functions è particolarmente utile nelle seguenti situazioni: + Quando le tue richieste sono dinamiche (il che significa che non possono essere memorizzate nella cache) e andranno sempre all'origine. CloudFront Functions offre prestazioni migliori e costi complessivi inferiori. + Se disponi già di una CloudFront funzione di richiesta del visualizzatore che verrà eseguita su ogni richiesta, puoi aggiungere la logica di aggiornamento dell'origine alla funzione esistente. Per utilizzare CloudFront Functions per aggiornare le origini, consultate i metodi di supporto nei seguenti argomenti. Lambda@Edge è particolarmente utile nelle seguenti situazioni: + Quando si dispone di contenuti altamente memorizzabili nella cache, Lambda @Edge può essere più efficiente in termini di costi perché viene eseguito solo in caso di errori di cache, mentre Functions viene eseguito su ogni richiesta. CloudFront + Se disponi già di una funzione Lambda@Edge per le richieste origine, puoi aggiungere la logica di aggiornamento dell’origine alla funzione esistente. + Quando la logica di aggiornamento dell’origine richiede il recupero di dati da origini dati di terze parti, come Amazon DynamoDB o Amazon S3. Per ulteriori informazioni su Lambda@Edge, consulta [Personalizzazione al livello di edge con Lambda@Edge](lambda-at-the-edge.md). ## updateRequestOriginmetodo () Utilizza il metodo `updateRequestOrigin()` per aggiornare le impostazioni di origine per una richiesta. Puoi utilizzare questo metodo per aggiornare le proprietà di origine esistenti per le origini già definite nella distribuzione o per definire una nuova origine per la richiesta. A tale scopo, specifica le proprietà che desideri modificare. **Importante** Tutte le impostazioni non specificate in `updateRequestOrigin()` erediteranno le *stesse impostazioni* dalla configurazione dell’origine esistente. L'origine impostata dal `updateRequestOrigin()` metodo può essere qualsiasi endpoint HTTP e non è necessario che sia un'origine esistente all'interno della CloudFront distribuzione. **Note** Se stai aggiornando un’origine che fa parte di un gruppo di origine, viene aggiornata solo l’*origine principale* del gruppo di origine. L’origine secondaria rimane invariata. Qualsiasi codice di risposta proveniente dall’origine modificata che soddisfi i criteri di failover attiverà un failover all’origine secondaria. Se stai modificando il tipo di origine e hai abilitato l’OAC, assicurati che il tipo di origine in `originAccessControlConfig` corrisponda al nuovo tipo di origine. Non puoi utilizzare il metodo `updateRequestOrigin()` per aggiornare [VPC Origins](private-content-vpc-origins.md). La richiesta non andrà a buon fine. **Richiesta** ``` updateRequestOrigin({origin properties}) ``` Le `origin properties` possono contenere i seguenti valori: **domainName (facoltativo)** Il nome di dominio dell'origine. Se non è fornito, viene utilizzato il nome di dominio dell’origine assegnata. **Per origini personalizzate** Specifica un nome di dominio DNS, ad esempio `www.example.com`. Il nome di dominio non può includere i due punti (`:`) e non può essere un indirizzo IP. Il nome di dominio può contenere fino a 253 caratteri. **Per origini S3** Specifica il nome di dominio DNS del bucket Amazon S3, ad esempio `amzn-s3-demo-bucket.s3.eu-west-1.amazonaws.com`. Il nome può contenere fino a 128 caratteri e deve essere tutto in minuscolo. **HostHeader (opzionale, per origini personalizzate non S3)** L'intestazione host da utilizzare quando si effettua la richiesta all'origine. Se questo non viene fornito, viene utilizzato il valore del parametro DomainName. Se non vengono forniti né l'intestazione host né il parametro del nome di dominio, viene utilizzato il nome di dominio dell'origine assegnata o l'intestazione host della richiesta in entrata se la politica di inoltro all'origine (FTO) include l'host. L'intestazione host non può includere i due punti (`:`) e non può essere un indirizzo IP. L'intestazione host può contenere fino a 253 caratteri. **originPath (facoltativo)** Il percorso di directory sul server di origine in cui la richiesta deve trovare il contenuto. Il percorso può iniziare, ma non deve terminare, con una barra (/). Ad esempio, non deve terminare con `example-path/`. Se questo non è fornito, viene utilizzato il percorso di origine dall’origine assegnata. **Per origini personalizzate** Il percorso deve essere codificato URL e avere una lunghezza massima di 255 caratteri. **customHeaders (facoltativo)** Puoi includere intestazioni personalizzate con la richiesta specificando un nome di intestazione e una coppia di valori per ogni intestazione personalizzata. Il formato è diverso da quello delle intestazioni di richiesta e risposta nella struttura dell’evento. Utilizza la seguente sintassi della coppia chiave-valore: ``` {"key1": "value1", "key2": "value2", ...} ``` Non è possibile aggiungere intestazioni non consentite e un’intestazione con lo stesso nome non può essere presente anche nelle `headers` della richiesta in entrata. Il nome dell’intestazione deve essere in minuscolo nel codice della funzione. Quando CloudFront Functions riconverte l'oggetto evento in una richiesta HTTP, la prima lettera di ogni parola nei nomi delle intestazioni viene scritta in maiuscolo e le parole sono separate da un trattino. Ad esempio, se il codice di funzione aggiunge un'intestazione denominata`example-header-name`, la CloudFront converte in nella richiesta HTTP. `Example-Header-Name` Per ulteriori informazioni, consultare [Intestazioni personalizzate che CloudFront non possono essere aggiunte alle richieste di origine](add-origin-custom-headers.md#add-origin-custom-headers-denylist) e [Restrizioni sulle funzioni edge](edge-functions-restrictions.md). Se questo non viene fornito, vengono utilizzate le intestazioni personalizzate dell’origine assegnata. **connectionAttempts (facoltativo)** Il numero di volte che CloudFront tenta di connettersi all'origine. Il valore minimo è 1 e il valore massimo è 3. Se questo non viene fornito, vengono utilizzati i tentativi di connessione dall’origine assegnata. **originShield (facoltativo)** Ciò abilita o aggiorna CloudFront Origin Shield. L'utilizzo di Origin Shield può contribuire a ridurre il carico sulla tua origine. Per ulteriori informazioni, consulta [Usa Amazon CloudFront Origin Shield](origin-shield.md). Se questo non è fornito, vengono utilizzate le impostazioni Origin Shield dall’origine assegnata. **enabled (obbligatorio)** Espressione booleana per abilitare o disabilitare Origin Shield. Accetta un valore `true` o `false`. **region (obbligatorio se abilitato)** The Regione AWS for Origin Shield. Specifica la Regione AWS con la latenza più bassa all'origine. Utilizza il codice della Regione, non il nome della Regione. Ad esempio, utilizza `us-east-2` per specificare la Regione Stati Uniti orientali (Ohio). Quando abiliti CloudFront Origin Shield, devi specificare Regione AWS il nome. Per un elenco delle Regioni AWS disponibili e informazioni sulla scelta della Regione migliore per l’origine, consulta [Scegli la AWS regione per Origin Shield](origin-shield.md#choose-origin-shield-region). **originAccessControlConfig (opzionale)** L’identificativo univoco di un controllo di accesso origine (OAC) per tale origine. Viene utilizzato solo quando l'origine supporta un CloudFront OAC, come Amazon S3, la URLs funzione MediaStore Lambda e V2. MediaPackage Se questo non viene fornito, vengono utilizzate le impostazioni OAC dell’origine assegnata. Questo non supporta l’identità di accesso origine (OAI) legacy. Per ulteriori informazioni, consulta [Limita l'accesso a un' AWS origine](private-content-restricting-access-to-origin.md). **enabled (obbligatorio)** Espressione booleana per abilitare o disabilitare OAC. Accetta un valore `true` o `false`. **signingBehavior (obbligatorio se abilitato)** Speciifica a quali richieste si riferisce (aggiunge le CloudFront informazioni di autenticazione). Specifica `always` per il caso d'uso più comune. Per ulteriori informazioni, consulta [Impostazioni avanzate per il controllo dell'accesso all'origine](private-content-restricting-access-to-s3.md#oac-advanced-settings-s3). Questo campo può avere uno dei seguenti valori: + `always`— CloudFront firma tutte le richieste di origine, sovrascrivendo l'`Authorization`intestazione della richiesta del visualizzatore, se ne esiste una. + `never`— CloudFront non firma alcuna richiesta di origine. Questo valore disattiva il controllo di accesso origine per l’origine. + `no-override`— Se la richiesta del visualizzatore non contiene l'`Authorization`intestazione, CloudFront firma la richiesta di origine. Se la richiesta del visualizzatore contiene l'`Authorization`intestazione, CloudFront non firma la richiesta di origine e trasmette invece l'`Authorization`intestazione della richiesta del visualizzatore. **avvertimento** Per trasmettere l’intestazione `Authorization` dalla richiesta visualizzatore, è necessario aggiungerla a una policy di richiesta origine per tutti i comportamenti cache che utilizzano origini associate a questo controllo di accesso origine. Per ulteriori informazioni, consulta [Controllo delle richieste di origine con una policy](controlling-origin-requests.md). **signingProtocol (richiesto se abilitato)** Il protocollo di firma dell'OAC, che determina il modo in cui CloudFront firma (autentica) le richieste. L’unico valore valido è `sigv4`. **originType (richiesto se abilitato)** Il tipo di origine per questo OAC. I valori validi includono `s3`, `mediapackagev2`, `mediastore` e `lambda`. **timeout (facoltativo)** I timeout che puoi specificare per quanto tempo CloudFront devono cercare di attendere che le origini rispondano o inviino dati. Se questo non viene fornito, vengono utilizzate le impostazioni di timeout dell’origine assegnata. Se non diversamente specificato, questi timeout supportano sia origini personalizzate che origini Amazon S3. **readTimeout (facoltativo)** `readTimeout` si applica a entrambi i seguenti valori: + Quanto tempo (in secondi) CloudFront attende una risposta dopo l'inoltro di una richiesta all'origine. + Quanto tempo (in secondi) CloudFront attende dopo aver ricevuto un pacchetto di risposta dall'origine e prima di ricevere il pacchetto successivo. Il timeout minimo è di 1 secondo e quello massimo è di 120 secondi. Per ulteriori informazioni, consulta [Timeout di risposta](DownloadDistValuesOrigin.md#DownloadDistValuesOriginResponseTimeout). **responseCompletionTimeout (facoltativo)** Il tempo (in secondi) durante il quale una richiesta dall' CloudFront origine può rimanere aperta e attendere una risposta. Se la risposta completa non viene ricevuta dall'origine entro quest'ora, CloudFront termina la connessione. Il valore per `responseCompletionTimeout` deve essere maggiore o uguale al valore per `readTimeout`. Per ulteriori informazioni, consulta [Timeout completamento risposta](DownloadDistValuesOrigin.md#response-completion-timeout). **keepAliveTimeout (facoltativo)** Questo timeout si applica solo alle origini personalizzate, non alle origini Amazon S3. Le configurazioni di origine S3 ignoreranno queste impostazioni. `keepAliveTimeout`Indica per quanto tempo CloudFront deve cercare di mantenere la connessione all'origine dopo aver ricevuto l'ultimo pacchetto della risposta. Il timeout minimo è di 1 secondo e quello massimo è di 120 secondi. Per ulteriori informazioni, consulta [Timeout keep-alive (solo origini personalizzate e VPC)](DownloadDistValuesOrigin.md#DownloadDistValuesOriginKeepaliveTimeout). **connectionTimeout (facoltativo)** Il numero di secondi che CloudFront attendono quando si tenta di stabilire una connessione all'origine. Il timeout minimo è di 1 secondo e quello massimo è di 10 secondi. Per ulteriori informazioni, consulta [Timeout di connessione](DownloadDistValuesOrigin.md#origin-connection-timeout). **customOriginConfig (facoltativo)** Utilizza `customOriginConfig` per specificare le impostazioni di connessione per origini che *non* sono un bucket Amazon S3. C’è un’eccezione: puoi specificare queste impostazioni se il bucket S3 è configurato con hosting di siti web statici. Altri tipi di configurazioni di bucket S3 ignoreranno queste impostazioni. Se `customOriginConfig` non viene fornito, vengono utilizzate le impostazioni dell’origine assegnata. **port (obbligatorio)** La porta HTTP CloudFront utilizzata per connettersi all'origine. La porta HTTP sulla quale l'origine è in ascolto. **protocol (obbligatorio)** Speciifica il protocollo (HTTP o HTTPS) CloudFront utilizzato per connettersi all'origine. I valori validi sono: + `http`— utilizza CloudFront sempre HTTP per connettersi all'origine + `https`— utilizza CloudFront sempre HTTPS per connettersi all'origine **sslProtocols (obbligatorio)** Un elenco che specifica il SSL/TLS protocollo minimo da CloudFront utilizzare per la connessione all'origine tramite HTTPS. I valori validi includono `SSLv3`, `TLSv1`, `TLSv1.1` e `TLSv1.2`. Per ulteriori informazioni, consulta [Protocollo SSL di origine minimo](DownloadDistValuesOrigin.md#DownloadDistValuesOriginSSLProtocols). **ipAddressType (facoltativo)** Speciifica il tipo di indirizzo IP CloudFront utilizzato per la connessione all'origine. I valori validi includono `ipv4`, `ipv6` e `dualstack`. La modifica di `ipAddressType` è supportata solo quando viene modificata anche la proprietà `domainName`. **sni (opzionale, per origini personalizzate non S3)** La Server Name Indication (SNI) è un'estensione del protocollo Transport Layer Security (TLS) con cui un client indica a quale nome host sta tentando di connettersi all'inizio del processo di handshake TLS. Questo valore deve corrispondere a un nome comune su un certificato TLS sul server di origine. In caso contrario, il server di origine potrebbe generare un errore. Se questo non viene fornito, viene utilizzato il valore del `hostHeader` parametro. Se l'intestazione dell'host non viene fornita, viene utilizzato il valore del `domainName` parametro. Se non vengono forniti né l'intestazione host né il parametro del nome di dominio, viene utilizzato il nome di dominio dell'origine assegnata o l'intestazione host della richiesta in entrata se la politica di inoltro all'origine (FTO) include l'host. L'SNI non può includere i due punti (`:`) e non può essere un indirizzo IP. Il codice SNI può contenere fino a 253 caratteri. **allowedCertificateNames (opzionale, per origini personalizzate non S3)** È possibile includere un elenco di nomi di certificati validi da utilizzare per CloudFront convalidare la corrispondenza del dominio con il certificato TLS del server di origine durante l'handshake TLS con il server di origine. Questo campo prevede una matrice di nomi di dominio validi e può includere domini wildcard, come. `*.example.com` È possibile specificare fino a 20 nomi di certificato consentiti. Ogni nome di certificato può contenere fino a 64 caratteri. **Example — Aggiornamento dell’origine richiesta Amazon S3** Nell’esempio seguente viene modificata l’origine della richiesta visualizzatore in un bucket S3, abilitato OAC e ripristinate le intestazioni personalizzate inviate all’origine. ``` cf.updateRequestOrigin({ "domainName" : "amzn-s3-demo-bucket-in-us-east-1.s3.us-east-1.amazonaws.com", "originAccessControlConfig": { "enabled": true, "signingBehavior": "always", "signingProtocol": "sigv4", "originType": "s3" }, // Empty object resets any header configured on the assigned origin "customHeaders": {} }); ``` **Example — Aggiornamento dell’origine richiesta di Application Load Balancer** Nell’esempio seguente viene modificata l’origine della richiesta visualizzatore in un’origine Application Load Balancer e impostata un’intestazione e timeout personalizzati. ``` cf.updateRequestOrigin({ "domainName" : "example-1234567890.us-east-1.elb.amazonaws.com", "timeouts": { "readTimeout": 30, "connectionTimeout": 5 }, "customHeaders": { "x-stage": "production", "x-region": "us-east-1" } }); ``` **Example — Aggiornamento dell’origine con Origin Shield abilitato** Nell’esempio seguente, Origin Shield è abilitato nell’origine della distribuzione. Il codice funzione aggiorna solo il nome di dominio utilizzato per l’origine e omette tutti gli altri parametri opzionali. In questo caso, Origin Shield continuerà a essere utilizzato con il nome di dominio di origine modificato poiché i parametri di Origin Shield non sono stati aggiornati. ``` cf.updateRequestOrigin({ "domainName" : "www.example.com" }); ``` **Example — Aggiorna l'intestazione dell'host, l'SNI e i nomi dei certificati consentiti** Nella maggior parte dei casi d'uso, non è necessario utilizzare questo tipo di modifica per le richieste che arrivano all'origine. Questi parametri non devono essere utilizzati a meno che non si comprenda l'impatto della modifica di questi valori. L'esempio seguente modifica il nome di dominio, l'intestazione dell'host, l'SNI e i certificati consentiti dalla richiesta all'origine. ``` cf.updateRequestOrigin({ "domainName": "www.example.com", "hostHeader": "test.example.com", "sni": "test.example.net", "allowedCertificateNames": ["*.example.com", "*.example.net"], }); ``` ## selectRequestOriginByIdmetodo () Utilizza `selectRequestOriginById()` per aggiornare un’origine esistente selezionando un’origine diversa già configurata nella distribuzione. Questo metodo utilizza tutte le stesse impostazioni definite dall’origine aggiornata. Questo metodo accetta solo origini già definite nella stessa distribuzione utilizzata durante l’esecuzione della funzione. Le origini sono identificate dall’ID origine, ovvero il nome origine definito durante la configurazione dell’origine. Se nella distribuzione è configurata un’origine VPC, puoi utilizzare questo metodo per aggiornare l’origine all’origine VPC. Per ulteriori informazioni, consulta [Limitazione dell’accesso con VPC Origins](private-content-vpc-origins.md). **Note** La `selectRequestOriginById()` funzione non può selezionare un'origine con TLS (origine) reciproco abilitato. Il tentativo di selezionare un'origine mutua abilitata per TLS (origine) utilizzando questa funzione genererà un errore di convalida. Se il tuo caso d'uso richiede una selezione dinamica dell'origine con TLS reciproco (origine), utilizza `updateRequestOrigin()` invece, assicurandoti che tutte le origini di destinazione utilizzino lo stesso certificato client. **Richiesta** ``` cf.selectRequestOriginById(origin_id, {origin_overrides}) ``` Nell'esempio precedente, `origin_id` è una stringa che punta al nome di origine di un'origine nella distribuzione che esegue la funzione. Il `origin_overrides ` parametro può contenere quanto segue: **HostHeader (opzionale, per origini personalizzate non S3)** L'intestazione host da utilizzare quando si effettua la richiesta all'origine. Se non viene fornito, viene utilizzato il valore del `domainName` parametro. Se non vengono forniti né l'intestazione host né il parametro del nome di dominio, viene utilizzato il nome di dominio dell'origine assegnata o l'intestazione host della richiesta in entrata se la politica di inoltro all'origine (FTO) include l'host. L'intestazione host non può includere i due punti (`:`) e non può essere un indirizzo IP. L'intestazione host può contenere fino a 253 caratteri. **sni (opzionale, per origini personalizzate non S3)** La Server Name Indication (SNI) è un'estensione del protocollo Transport Layer Security (TLS) con cui un client indica a quale nome host sta tentando di connettersi all'inizio del processo di handshake TLS. Questo valore deve corrispondere a un nome comune su un certificato TLS sul server di origine. In caso contrario, il server di origine potrebbe generare un errore. Se questo non viene fornito, viene utilizzato il valore del `hostHeader` parametro. Se l'intestazione dell'host non viene fornita, viene utilizzato il valore del `domainName` parametro. Se non vengono forniti né l'intestazione host né il parametro del nome di dominio, viene utilizzato il nome di dominio dell'origine assegnata o l'intestazione host della richiesta in entrata se la politica di inoltro all'origine (FTO) include l'host. L'SNI non può includere i due punti (`:`) e non può essere un indirizzo IP. Il codice SNI può contenere fino a 253 caratteri. **allowedCertificateNames (opzionale, per origini personalizzate non S3)** È possibile includere un elenco di nomi di certificati validi da utilizzare per CloudFront convalidare la corrispondenza del dominio con il certificato TLS del server di origine durante l'handshake TLS con il server di origine. Questo campo prevede una matrice di nomi di dominio validi e può includere domini wildcard, come. `*.example.com` È possibile specificare fino a 20 nomi di certificato consentiti. Ogni nome di certificato può contenere fino a 64 caratteri. **Richiesta** ``` selectRequestOriginById(origin_id) ``` Nell’esempio precedente, `origin_id` è una stringa che punta al nome dell’origine nella distribuzione che esegue la funzione. **Example — Selezione dell’origine della richiesta Amazon S3** Nell’esempio seguente viene selezionata l’origine denominata `amzn-s3-demo-bucket-in-us-east-1` dall’elenco delle origini associate alla distribuzione e applicate le impostazioni di configurazione dell’origine `amzn-s3-demo-bucket-in-us-east-1` alla richiesta. ``` cf.selectRequestOriginById("amzn-s3-demo-bucket-in-us-east-1"); ``` **Example — Selezione dell’origine della richiesta Application Load Balancer** Nell’esempio seguente viene selezionata un’origine Application Load Balancer denominata `myALB-prod` dall’elenco delle origini associate alla distribuzione e applicate le impostazioni di configurazione di `myALB-prod` alla richiesta. ``` cf.selectRequestOriginById("myALB-prod"); ``` **Example — Seleziona l'origine della richiesta Application Load Balancer e sovrascrivi l'intestazione dell'host** Come nell'esempio precedente, l'esempio seguente seleziona un'origine Application Load Balancer `myALB-prod` denominata dall'elenco di origini associate alla distribuzione e applica le impostazioni `myALB-prod` di configurazione di alla richiesta. Tuttavia, questo esempio sostituisce il valore dell'intestazione dell'host utilizzando. `origin_overrides` ``` cf.overrideRequestOrigin("myALB-prod",{ "hostHeader" : "test.example.com" }); ``` ## createRequestOriginMetodo Group () Utilizza `createRequestOriginGroup()` per definire due origini da utilizzare come [gruppo di origine](high_availability_origin_failover.md#concept_origin_groups.creating) per il failover in scenari che richiedono un’elevata disponibilità. Un gruppo di origine include due origini (una primaria e una secondaria) e un criterio di failover specificato. Si crea un gruppo di origine per supportare il failover di origine in CloudFront. Quando si crea o si aggiorna un gruppo di origine utilizzando questo metodo, è possibile specificare il gruppo di origine anziché una singola origine. CloudFront eseguirà il failover dall'origine primaria all'origine secondaria, utilizzando i criteri di failover. Se nella distribuzione è configurata un’origine VPC, puoi utilizzare questo metodo per creare un gruppo di origini utilizzando un’origine VPC. Per ulteriori informazioni, consulta [Limitazione dell’accesso con VPC Origins](private-content-vpc-origins.md). **Note** La `createRequestOriginGroup()` funzione non supporta la creazione di gruppi di origine che includono origini abilitate per Mutual TLS (origin). I gruppi di origine con origini Mutual TLS (origin) non possono essere creati dinamicamente tramite Functions. CloudFront Se hai bisogno di funzionalità di failover di origine con Mutual TLS (origin), configura i gruppi di origine direttamente nelle impostazioni di CloudFront distribuzione anziché crearli dinamicamente nelle funzioni. ### Richiesta ``` createRequestOriginGroup({origin_group_properties}) ``` Nell’esempio precedente, `origin_group_properties` può contenere quanto segue: **originIds (obbligatorio)** Array di `origin_ids`, dove `origin_id` è una stringa che punta al nome di origine di un’origine nella distribuzione che esegue la funzione. È necessario fornire due origini come parte dell’array. La prima origine nell’elenco è l’origine primaria, mentre la seconda funge da origine secondaria per il failover. **OriginOverrides (opzionale)** È possibile sovrascrivere alcune impostazioni avanzate utilizzando il parametro. `{origin_overrides}` Le `origin overrides` possono contenere i seguenti valori: **HostHeader (opzionale, per origini personalizzate non S3)** L'intestazione host da utilizzare quando si effettua la richiesta all'origine. Se non viene fornito, viene utilizzato il valore del `domainName` parametro. Se non vengono forniti né l'intestazione host né il parametro del nome di dominio, viene utilizzato il nome di dominio dell'origine assegnata o l'intestazione host della richiesta in entrata se la politica di inoltro all'origine (FTO) include l'host. L'intestazione host non può includere i due punti (`:`) e non può essere un indirizzo IP. L'intestazione host può contenere fino a 253 caratteri. **sni (opzionale, per origini personalizzate non S3)** La Server Name Indication (SNI) è un'estensione del protocollo Transport Layer Security (TLS) con cui un client indica a quale nome host sta tentando di connettersi all'inizio del processo di handshake TLS. Questo valore deve corrispondere a un nome comune su un certificato TLS sul server di origine, altrimenti il server di origine potrebbe generare un errore. Se questo non viene fornito, viene utilizzato il valore del `hostHeader` parametro. Se l'intestazione dell'host non viene fornita, viene utilizzato il valore del `domainName` parametro. Se non vengono forniti né l'intestazione host né il parametro del nome di dominio, viene utilizzato il nome di dominio dell'origine assegnata o l'intestazione host della richiesta in entrata se la politica di inoltro all'origine (FTO) include l'host. L'SNI non può includere i due punti (`:`) e non può essere un indirizzo IP. Il codice SNI può contenere fino a 253 caratteri. **allowedCertificateNames (opzionale, per origini personalizzate non S3)** È possibile includere un elenco di nomi di certificati validi da utilizzare per CloudFront convalidare la corrispondenza del dominio con il certificato TLS del server di origine durante l'handshake TLS con il server di origine. Questo campo prevede una matrice di nomi di dominio validi e può includere domini wildcard, come. `*.example.com` È possibile specificare fino a 20 nomi di certificato consentiti. Ogni nome di certificato può contenere fino a 64 caratteri. **selectionCriteria (facoltativo)** Scegli se utilizzare i criteri di failover di origine `default` o la logica di failover basata su `media-quality-score`. I valori validi sono: + `default` utilizza i criteri di failover, in base ai codici di stato specificati in `failoverCriteria`. Se non si imposta `selectionCriteria` nella funzione, verrà utilizzato `default`. + `media-quality-score` viene utilizzato quando è attiva la funzionalità di instradamento sensibile ai contenuti multimediali. **failoverCriteria (obbligatorio)** Una serie di codici di stato che, se restituiti dall'origine principale, attivano CloudFront il failover sull'origine secondaria. Se si sovrascrive un gruppo di origine esistente, questo array sovrascriverà tutti i codici di stato di failover impostati nella configurazione originale del gruppo di origine. Quando lo utilizzi `media-quality-score``selectionCriteria`, CloudFront tenterà di indirizzare le richieste in base al punteggio di qualità multimediale. Se l'origine selezionata restituisce un codice di errore impostato in questo array, CloudFront eseguirà il failover sull'altra origine. **Example — Creazione del gruppo di origini della richiesta** L'esempio seguente crea un gruppo di origine per una richiesta utilizzando l'origine IDs. Queste origini IDs provengono dalla configurazione del gruppo di origine per la distribuzione utilizzata per eseguire questa funzione. Facoltativamente, è possibile utilizzare `originOverrides` per sovrascrivere le configurazioni del gruppo di origine per`sni`, `hostHeader` e. `allowedCertificateNames` ``` import cf from 'cloudfront'; function handler(event) { cf.createRequestOriginGroup({ "originIds": [ { "originId": "origin-1", "originOverrides": { "hostHeader": "hostHeader.example.com", "sni": "sni.example.com", "allowedCertificateNames": ["cert1.example.com", "cert2.example.com", "cert3.example.com"] } }, { "originId": "origin-2", "originOverrides": { "hostHeader": "hostHeader2.example.com", "sni": "sni2.example.com", "allowedCertificateNames": ["cert4.example.com", "cert5.example.com"] } } ], "failoverCriteria": { "statusCodes": [500] } }); event.request.headers['x-hookx'] = { value: 'origin-overrides' }; return event.request; } ``` # Metodi di supporto per le proprietà di CloudFront SaaS Manager Utilizza le seguenti funzioni di supporto per CloudFront SaaS Manager per recuperare i valori per le distribuzioni multi-tenant nella funzione che crei. Per utilizzare gli esempi in questa pagina, è necessario innanzitutto creare una CloudFront funzione utilizzando runtime 2.0. JavaScript Per ulteriori informazioni, consulta, [JavaScript funzionalità di runtime 2.0 per CloudFront Functions](functions-javascript-runtime-20.md). **Topics** + [ ## Gruppi di connessioni ](#connection-groups-helper-function) + [ ## Tenant di distribuzione ](#distribution-tenants-helper-functions) ## Gruppi di connessioni Il gruppo di connessioni associato ai tenant di distribuzione dispone di un nome di dominio. Per ottenere questo valore, utilizza il campo `endpoint` dell’oggetto secondario `context` dell’oggetto evento. **Richiesta** ``` const value = event.context.endpoint; ``` **Risposta** La risposta è una `string` che contiene il nome di dominio del gruppo di connessioni, ad esempio d111111abcdef8.cloudfront.net. Il campo `endpoint` viene visualizzato solo quando la funzione viene invocata per una distribuzione multi-tenant con un gruppo di connessioni associato. Per ulteriori informazioni, consulta [Oggetto Context](functions-event-structure.md#functions-event-structure-context). ## Tenant di distribuzione CloudFront Functions dispone di un modulo che fornisce l'accesso a valori specifici del tenant di distribuzione. Per utilizzare questo modulo, includi la seguente istruzione nella prima riga del codice funzione: ``` import cf from 'cloudfront'; ``` Puoi utilizzare i seguenti esempi solo nella funzione `handler`, direttamente o tramite qualsiasi funzione di chiamata nidificata. ### Campo `distributionTenant.id` Utilizza questo campo per ottenere il valore dell’ID del tenant di distribuzione. **Richiesta** ``` const value = cf.distributionTenant.id; ``` **Risposta** La risposta è una `string` che contiene l’ID del tenant di distribuzione, ad esempio `dt_1a2b3c4d5e6f7`. **Gestione errori** Se la funzione viene invocata per una distribuzione standard, specificando il campo `distributionTenant.id` verrà restituito l’errore di tipo `distributionTenant module is not available`. Per gestire questo caso d’uso, puoi aggiungere un blocco `catch` e `try` al codice. ### Metodo `distributionTenant.parameters.get()` Utilizza questo metodo per restituire il valore dei nomi dei parametri tenant di distribuzione specificati. ``` distributionTenant.parameters.get("key"); ``` `key`: il nome del parametro tenant di distribuzione di cui desideri recuperare il valore. **Richiesta** ``` const value = distributionTenant.parameters.get("key"); ``` **Risposta** La risposta è una `string` che contiene il valore per il parametro tenant di distribuzione. Ad esempio, se il nome della chiave è `TenantPath`, il valore di questo parametro potrebbe essere `tenant1`. **Gestione errori** Potrebbero verificarsi i seguenti errori: + Se la funzione viene invocata per una distribuzione standard, il metodo `distributionTenant.parameters.get()` restituirà l’errore di tipo `distributionTenant module is not available`. + L’errore `DistributionTenantParameterKeyNotFound` viene restituito quando il parametro tenant di distribuzione specificato non esiste. Per gestire questi casi d’uso, puoi aggiungere un blocco `try` e `catch` al codice. # Uso di async e await CloudFront Le funzioni JavaScript di runtime di Functions 2.0 forniscono una `async` `await` sintassi per gestire `Promise` gli oggetti. Le promesse rappresentano risultati con ritardo a cui è possibile accedere tramite la parola chiave `await` nelle funzioni contrassegnate come `async`. Diverse nuove WebCrypto funzioni utilizzano Promises. Per ulteriori informazioni sugli oggetti `Promise`, consulta [Promessa](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise). **Nota** È necessario utilizzare JavaScript runtime 2.0 per i seguenti esempi di codice. `await` può essere utilizzato solo all’interno delle funzioni `async`. Argomenti e chiusure `async` non sono supportati. ``` async function answer() { return 42; } // Note: async, await can be used only inside an async function. async arguments and closures are not supported. async function handler(event) { // var answer_value = answer(); // returns Promise, not a 42 value let answer_value = await answer(); // resolves Promise, 42 console.log("Answer"+answer_value); event.request.headers['answer'] = { value : ""+answer_value }; return event.request; } ``` Il JavaScript codice di esempio seguente mostra come visualizzare le promesse con il metodo `then` chain. È possibile utilizzare `catch` per visualizzare gli errori. **avvertimento** L’uso dei combinatori di promesse (ad esempio, `Promise.all`, `Promise.any`) e dei metodi di catena di promesse (ad esempio, `then` e `catch`) può richiedere un elevato utilizzo della memoria delle funzioni. Se la funzione supera la quota [massima di memoria delle funzioni](cloudfront-limits.md#limits-functions), non verrà eseguita. Per evitare questo errore, ti consigliamo di utilizzare la sintassi `await` anziché i metodi `promise`. ``` async function answer() { return 42; } async function squared_answer() { return answer().then(value => value * value) } // Note: async, await can be used only inside an async function. async arguments and closures are not supported. async function handler(event) { // var answer_value = answer(); // returns Promise, not a 42 value let answer_value = await squared_answer(); // resolves Promise, 42 console.log("Answer"+answer_value); event.request.headers['answer'] = { value : ""+answer_value }; return event.request; } ``` # Supporto CWT per le funzioni CloudFront Questa sezione fornisce dettagli sul supporto per i token Web CBOR (CWT) nelle CloudFront funzioni, che consente l'autenticazione e l'autorizzazione sicure basate su token presso le edge location. CloudFront Questo supporto viene fornito come modulo, accessibile nella funzione. CloudFront Per utilizzare questo modulo, create una CloudFront funzione utilizzando JavaScript runtime 2.0 e includete la seguente istruzione nella prima riga del codice della funzione: ``` import cf from 'cloudfront'; ``` I metodi associati a questo modulo sono accessibili tramite (dove\$1 è un jolly che rappresenta le diverse funzioni presenti nel modulo): ``` cf.cwt.* ``` Per ulteriori informazioni, consulta [JavaScript funzionalità di runtime 2.0 per CloudFront Functions](functions-javascript-runtime-20.md). Attualmente, il modulo supporta solo la struttura MAC0 con algoritmo HS256 (HMAC-SHA256) con un limite di 1 KB per la dimensione massima del token. ## Struttura dei token Questa sezione illustra la struttura dei token prevista dal modulo CWT. Il modulo si aspetta che il token sia etichettato e identificabile correttamente (ad esempio COSE MAC0). Inoltre, per quanto riguarda la struttura del token, il modulo segue gli standard stabiliti da [CBOR Object Signing and Encryption (COSE) [](https://datatracker.ietf.org/doc/html/rfc8152)RFC 8152]. ``` ( // CWT Tag (Tag value: 61) --- optional ( // COSE MAC0 Structure Tag (Tag value: 17) --- required [ protectedHeaders, unprotectedHeaders, payload, tag, ] ) ) ``` **Example : CWT utilizza la struttura COSE MAC0** ``` 61( // CWT tag 17( // COSE_MAC0 tag [ { // Protected Headers 1: 4 // algorithm : HMAC-256-64 }, { // Unprotected Headers 4: h'53796d6d6574726963323536' // kid : Symmetric key id }, { // Payload 1: "https://iss.example.com", // iss 2: "exampleUser", // sub 3: "https://aud.example.com", // aud 4: 1444064944, // exp 5: 1443944944, // nbf 6: 1443944944, // iat }, h'093101ef6d789200' // tag ] ) ) ``` Il tag CWT è opzionale per la generazione di token. Tuttavia, il tag di struttura COSE è obbligatorio. ## metodo validateToken () La funzione decodifica e convalida un token CWT utilizzando la chiave specificata. Se la convalida ha esito positivo, restituisce il token CWT decodificato. Altrimenti, genera un errore. Tieni presente che questa funzione non esegue alcuna convalida sul set di attestazioni. ### Richiesta ``` cf.cwt.validateToken(token, handlerContext{key}) ```Parameters **token (richiesto)** Token codificato per la convalida. Questo deve essere un JavaScript buffer. **HandlerContext (obbligatorio)** Un JavaScript oggetto che memorizza il contesto per la chiamata validateToken. Al momento, è supportata solo la proprietà key. **chiave (obbligatoria)** Chiave segreta per il calcolo del message digest. Può essere fornita come stringa o JavaScript buffer. ### Risposta Quando il `validateToken()` metodo restituisce un token convalidato correttamente, la risposta della funzione è a `CWTObject` nel seguente formato. Una volta decodificate, tutte le chiavi di rivendicazione vengono rappresentate come stringhe. ``` CWTObject { protectedHeaders, unprotectedHeaders, payload } ``` ### Esempio: convalida il token con kid inviato come parte del token Questo esempio dimostra la convalida del token CWT, in cui il kid viene estratto dall'header. Il bambino viene quindi passato KeyValueStore a CloudFront Functions per recuperare la chiave segreta usata per convalidare il token. ``` import cf from 'cloudfront' const CwtClaims = { iss: 1, aud: 3, exp: 4 } async function handler(event) { try { let request = event.request; let encodedToken = request.headers['x-cwt-token'].value; let kid = request.headers['x-cwt-kid'].value; // Retrieve the secret key from the kvs let secretKey = await cf.kvs().get(kid); // Now you can use the secretKey to decode & validate the token. let tokenBuffer = Buffer.from(encodedToken, 'base64url'); let handlerContext = { key: secretKey, } try { let cwtObj = cf.cwt.validateToken(tokenBuffer, handlerContext); // Check if token is expired const currentTime = Math.floor(Date.now() / 1000); // Current time in seconds if (cwtObj[CwtClaims.exp] && cwtObj[CwtClaims.exp] < currentTime) { return { statusCode: 401, statusDescription: 'Token expired' }; } } catch (error) { return { statusCode: 401, statusDescription: 'Invalid token' }; } } catch (error) { return { statusCode: 402, statusDescription: 'Token processing failed' }; } return request; } ``` ## metodo generateToken () Questa funzione genera un nuovo token CWT utilizzando il payload e le impostazioni di contesto fornite. ### Richiesta ``` cf.cwt.generateToken(generatorContext, payload) ```Parameters **GeneratorContext (obbligatorio)** Si tratta di un JavaScript oggetto che viene utilizzato come contesto per la generazione del token e contiene le seguenti coppie chiave-valore: **CwtTag (opzionale)** Questo valore è un booleano, che se lo `true` specifica deve essere aggiunto. `cwtTag` **CoseTag (obbligatorio)** Specifica il tipo di tag COSE. Attualmente supporta `MAC0` solo. **chiave (richiesta)** Chiave segreta per calcolare il message digest. Questo valore può essere una stringa o. JavaScript `Buffer` **payload (obbligatorio)** Payload di token per la codifica. Il payload deve essere in formato. `CWTObject` ### Risposta Restituisce un JavaScript Buffer contenente il token codificato. **Example : genera un token CWT** ``` import cf from 'cloudfront'; const CwtClaims = { iss: 1, sub: 2, exp: 4 }; const CatClaims = { catu: 401, catnip: 402, catm: 403, catr: 404 }; const Catu = { host: 1, path: 2, ext: 3 }; const CatuMatchTypes = { prefix_match: 1, suffix_match: 2, exact_match: 3 }; const Catr = { renewal_method: 1, next_renewal_time: 2, max_uses: 3 }; async function handler(event) { try { const response = { statusCode: 200, statusDescription: 'OK', headers: {} }; const commonAccessToken = { protected: { 1: "5", }, unprotected: {}, payload: { [CwtClaims.iss]: "cloudfront-documentation", [CwtClaims.sub]: "cwt-support-on-cloudfront-functions", [CwtClaims.exp]: 1740000000, [CatClaims.catu]: { [Catu.host]: { [CatuMatchTypes.suffix_match]: ".cloudfront.net" }, [Catu.path]: { [CatuMatchTypes.prefix_match]: "/media/live-stream/cf-4k/" }, [Catu.ext]: { [CatuMatchTypes.exact_match]: [ ".m3u8", ".ts", ".mpd" ] } }, [CatClaims.catnip]: [ "[IP_ADDRESS]", "[IP_ADDRESS]" ], [CatClaims.catm]: [ "GET", "HEAD" ], [CatClaims.catr]: { [Catr.renewal_method]: "header_renewal", [Catr.next_renewal_time]: 1750000000, [Catr.max_uses]: 5 } } }; if (!request.headers['x-cwt-kid']) { throw new Error('Missing x-cwt-kid header'); } const kid = request.headers['x-cwt-kid'].value; const secretKey = await cf.kvs().get(kid); if (!secretKey) { throw new Error('Secret key not found for provided kid'); } try { const genContext = { cwtTag: true, coseTag: "MAC0", key: secretKey }; const tokenBuffer = cf.cwt.generateToken(commonAccessToken, genContext); response.headers['x-generated-cwt-token'] = { value: tokenBuffer.toString('base64url') }; return response; } catch (tokenError) { return { statusCode: 401, statusDescription: 'Could not generate the token' }; } } catch (error) { return { statusCode: 402, statusDescription: 'Token processing failed' }; } } ``` **Example : Aggiorna il token in base a una logica** ``` import cf from 'cloudfront' const CwtClaims = { iss: 1, aud: 3, exp: 4 } async function handler(event) { try { let request = event.request; let encodedToken = request.headers['x-cwt-token'].value; let kid = request.headers['x-cwt-kid'].value; let secretKey = await cf.kvs().get(kid); // Retrieve the secret key from the kvs // Now you can use the secretKey to decode & validate the token. let tokenBuffer = Buffer.from(encodedToken, 'base64url'); let handlerContext = { key: secretKey, } try { let cwtJSON = cf.cwt.validateToken(tokenBuffer, handlerContext); // Check if token is expired const currentTime = Math.floor(Date.now() / 1000); // Current time in seconds if (cwtJSON[CwtClaims.exp] && cwtJSON[CwtClaims.exp] < currentTime) { // We can regnerate the token and add 8 hours to the expiry time cwtJSON[CwtClaims.exp] = Math.floor(Date.now() / 1000) + (8 * 60 * 60); let genContext = { coseTag: "MAC0", key: secretKey } let newTokenBuffer = cf.cwt.generateToken(cwtJSON, genContext); request.headers['x-cwt-regenerated-token'] = newTokenBuffer.toString('base64url'); } } catch (error) { return { statusCode: 401, statusDescription: 'Invalid token' }; } } catch (error) { return { statusCode: 402, statusDescription: 'Token processing failed' }; } return request; } ``` # Metodi generali di supporto Questa pagina fornisce metodi di supporto aggiuntivi all'interno CloudFront di Functions. Per utilizzare questi metodi, create una CloudFront funzione utilizzando JavaScript runtime 2.0. ``` import cf from 'cloudfront'; ``` Per ulteriori informazioni, consulta [JavaScript funzionalità di runtime 2.0 per CloudFront Functions](functions-javascript-runtime-20.md). ## `edgeLocation`metadati Questo metodo richiede l'utilizzo del `cloudfront` modulo. **Nota** È possibile utilizzare questo metodo solo per le funzioni di richiesta del visualizzatore. Per le funzioni di risposta del visualizzatore, questo metodo è vuoto. Utilizzate questo JavaScript oggetto per ottenere il codice dell'aeroporto della edge location, la regione [Regional Edge Cache](HowCloudFrontWorks.md#CloudFrontRegionaledgecaches) prevista o l'indirizzo IP del CloudFront server utilizzato per gestire la richiesta. Questi metadati sono disponibili solo nel trigger dell'evento di richiesta del visualizzatore. ``` cf.edgeLocation = { name: SEA serverIp: 1.2.3.4 region: us-west-2 } ``` L'`cf.edgeLocation`oggetto può contenere quanto segue: **nome** Il [codice IATA](https://en.wikipedia.org/wiki/IATA_airport_code) a tre lettere dell'edge location che ha gestito la richiesta. **IP del server** L' IPv6 indirizzo IPv4 o del server che ha gestito la richiesta. **region** La CloudFront Regional Edge Cache (REC) che la richiesta *dovrebbe utilizzare in* caso di perdita della cache. Questo valore non viene aggiornato nel caso in cui il REC previsto non sia disponibile e per la richiesta venga utilizzato un REC di backup. Questo non include la posizione Origin Shield utilizzata, tranne nei casi in cui il REC principale e l'Origin Shield si trovino nella stessa posizione. **Nota** CloudFront Functions non viene richiamato una seconda volta quando CloudFront è configurato per utilizzare il failover di origine. Per ulteriori informazioni, consulta [Ottimizza l'alta disponibilità con il failover di CloudFront origine](high_availability_origin_failover.md). ## Metodo `rawQueryString()` Questo metodo non richiede il `cloudFront` modulo. Utilizzate il `rawQueryString()` metodo per recuperare la stringa di query non analizzata e inalterata come stringa. **Richiesta** ``` function handler(event) { var request = event.request; const qs = request.rawQueryString(); } ``` **Risposta** Restituisce la stringa di query completa della richiesta in entrata come valore di stringa senza l'iniziale. `?` + Se non è presente una stringa di query, ma `?` è presente, le funzioni restituiscono una stringa vuota. + Se non è presente una stringa di query e `?` non è presente, la funzione restituisce`undefined`. **Caso 1: restituita la stringa di query completa (senza interlinea`?`)** URL della richiesta in entrata: `https://example.com/page?name=John&age=25&city=Boston` `rawQueryString()`restituisce: `"name=John&age=25&city=Boston"` **Caso 2: restituita una stringa vuota (quando `?` è presente ma senza parametri)** URL della richiesta in entrata: `https://example.com/page?` `rawQueryString()`restituisce: `""` **Caso 3: `undefined` restituito (nessuna stringa di query e no`?`)** URL della richiesta in entrata: `https://example.com/page` `rawQueryString()`restituisce: `undefined` # Creazione di funzioni La creazione di una funzione avviene in due fasi: 1. Crea il codice della funzione come JavaScript. Puoi utilizzare l’esempio predefinito della console CloudFront o scriverne uno personalizzato. Per ulteriori informazioni, consulta i seguenti argomenti: + [Scrittura del codice della funzione](writing-function-code.md) + [CloudFront Funzioni, struttura degli eventi](functions-event-structure.md) + [CloudFront Esempi di funzioni per CloudFront](service_code_examples_cloudfront_functions_examples.md) 1. Utilizza CloudFront per creare la funzione e includere il codice. Il codice è presente all'interno della funzione (non come riferimento). ------ #### [ Console ] **Per creare una funzione** 1. Accedi alla console CloudFront all’indirizzo [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) e scegli la pagina **Funzioni**. 1. Scegli **Crea funzione**. 1. Immetti un nome di funzione univoco all’interno dell’Account AWS, scegli la versione di JavaScript e infine seleziona **Continua**. Viene visualizzata la pagina dei dettagli relativa alla nuova funzione. **Nota** Per utilizzare [coppie chiave-valore](kvs-with-functions.md) nella funzione, è necessario scegliere JavaScript runtime 2.0. 1. Nella sezione **Codice funzione**, scegli la scheda **Compila** e immetti il codice funzione. Il codice di esempio incluso nella scheda **Compila** illustra la sintassi di base del codice funzione. 1. Scegli **Save changes** (Salva modifiche). 1. Se il codice funzione utilizza coppie chiave-valore, è necessario associare un archivio di valori delle chiavi. Puoi associare l’archivio di valori delle chiavi al momento della creazione della funzione. In alternativa, puoi associarlo in un secondo momento [aggiornando la funzione](update-function.md). Per associare subito un archivio di valori delle chiavi, procedi come segue: + Nella sezione **Associa KeyValueStore**, scegli **Associa KeyValueStore esistente**. + Seleziona l’archivio di valori delle chiavi contenente le coppie chiave-valore nella funzione, quindi scegli **Associata KeyValueStore**. CloudFront associa immediatamente l'archivio alla funzione. Non è necessario salvare la funzione. ------ #### [ CLI ] Con la CLI, in genere si crea prima il codice funzione in un file e poi si crea la funzione con AWS CLI. **Per creare una funzione** 1. Crea il codice funzione in un file e memorizzalo in una directory a cui il computer può connettersi. 1. Esegui il comando come mostrato nell'esempio. Questo esempio utilizza la notazione `fileb://` per passare il file. Include anche interruzioni di riga per rendere il comando più leggibile. ``` aws cloudfront create-function \ --name MaxAge \ --function-config '{"Comment":"Max Age 2 years","Runtime":"cloudfront-js-2.0","KeyValueStoreAssociations":{"Quantity":1,"Items":[{"KeyValueStoreARN":"arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"}]}}' \ --function-code fileb://function-max-age-v1.js ``` **Note** `Runtime`: la versione di JavaScript. Per utilizzare [coppie chiave-valore](kvs-with-functions.md) nella funzione, è necessario specificare la versione 2.0. `KeyValueStoreAssociations`: se la funzione utilizza coppie chiave-valore, puoi associare l’archivio dei valori delle chiavi al momento della creazione della funzione. In alternativa, puoi associarlo in un secondo momento utilizzando `update-function`. Il valore `Quantity` è sempre `1` perché a ogni funzione può essere associato un solo archivio di valori delle chiavi. Se il comando viene eseguito correttamente, vedrai un output simile al seguente. ``` ETag: ETVABCEXAMPLE FunctionSummary: FunctionConfig: Comment: Max Age 2 years Runtime: cloudfront-js-2.0 KeyValueStoreAssociations= \ {Quantity=1, \ Items=[{KeyValueStoreARN='arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111'}]} \ FunctionMetadata: CreatedTime: '2021-04-18T20:38:56.915000+00:00' FunctionARN: arn:aws:cloudfront::111122223333:function/MaxAge LastModifiedTime: '2023-11-19T20:38:56.915000+00:00' Stage: DEVELOPMENT Name: MaxAge Status: UNPUBLISHED Location: https://cloudfront.amazonaws.com/2020-05-31/function/arn:aws:cloudfront:::function/MaxAge ``` La maggior parte delle informazioni viene ripetuta dalla richiesta. Altre informazioni vengono aggiunte da CloudFront. **Note** `ETag`: questo valore cambia a ogni modifica dell’archivio di valori delle chiavi. Utilizza questo valore e il nome della funzione per fare riferimento alla funzione in futuro. Assicurati di utilizzare sempre l’`ETag` corrente. `FunctionARN`: l’ARN per la funzione CloudFront. 111122223333: l’Account AWS. `Stage`: la fase della funzione (`LIVE` o `DEVELOPMENT`). `Status`: lo stato della funzione (`PUBLISHED` o `UNPUBLISHED`). ------ Dopo aver creato la funzione, viene aggiunta alla fase `DEVELOPMENT`. Ti consigliamo di [provare la funzione](test-function.md) prima di [pubblicarla](publish-function.md). Dopo aver pubblicato la funzione, questa passa alla fase `LIVE`. # Test delle funzioni Prima di distribuire la funzione nella fase live (produzione), puoi testarla per verificare che funzioni come previsto. Per testare una funzione, specificate un *oggetto evento* che rappresenta una richiesta o una risposta HTTP che la CloudFront distribuzione potrebbe ricevere in produzione. CloudFront Functions esegue le seguenti operazioni: 1. Esegue la funzione, utilizzando l'oggetto evento fornito come input. 1. Restituisce il risultato della funzione (l'oggetto evento modificato) insieme a tutti i registri delle funzioni o messaggi di errore e l'*utilizzo del calcolo* della funzione. Per ulteriori informazioni sull’utilizzo delle capacità di calcolo, consultare [Informazioni sull’utilizzo del calcolo](#compute-utilization). **Nota** Quando si esegue il test di una funzione, esegue la convalida CloudFront solo in base agli errori di esecuzione della funzione. CloudFrontnon verifica se la richiesta passerà a buon fine una volta pubblicata. Ad esempio, se la funzione elimina un’intestazione obbligatoria, il test avrà esito positivo perché non vi è alcun problema con il codice. Tuttavia, se si pubblica la funzione e la si associa a una distribuzione, la funzione avrà esito negativo quando viene effettuata una richiesta. CloudFront **Contents** + [ ## Impostazione dell'oggetto evento ](#test-function-create-event) + [ ## Test della funzione ](#test-function-step-test) + [ ## Informazioni sull’utilizzo del calcolo ](#compute-utilization) ## Impostazione dell'oggetto evento Prima di testare una funzione, è necessario impostare l'oggetto evento per testarlo. Sono disponibili diverse opzioni. **Opzione 1: impostazione di un oggetto evento senza salvarlo** È possibile configurare un oggetto evento nell'editor visivo della CloudFront console e non salvarlo. È possibile utilizzare questo oggetto evento per testare la funzione dalla CloudFront console, anche se non è stato salvato. **Opzione 2: creazione di un oggetto evento nell'editor visuale** È possibile configurare un oggetto evento nell'editor visivo della CloudFront console e non salvarlo. È possibile creare 10 oggetti evento per ogni funzione, ad esempio per testare diversi input possibili. Quando create l'oggetto evento in questo modo, potete utilizzare l'oggetto evento per testare la funzione nella CloudFront console. Non puoi usarlo per testare la funzione utilizzando un' AWS API o un SDK. **Opzione 3: creazione di un oggetto evento utilizzando un editor di testo** Puoi utilizzare un editor di testo per creare un oggetto evento in formato JSON. Per informazioni sulla struttura di un oggetto evento, consulta [Struttura degli eventi](functions-event-structure.md). Puoi utilizzare l'oggetto evento per testare la funzione utilizzando la CLI. Ma non puoi usarlo per testare la funzione nella CloudFront console. **Come creare un oggetto evento (opzione 1 o 2)** 1. Accedi alla CloudFront console all'indirizzo [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) e scegli la pagina **Funzioni**. Scegli la funzione che desideri testare. 1. Nella pagina dei dettagli della funzione, seleziona la scheda **Test**. 1. Per **Tipo di evento**, scegli una delle seguenti opzioni: + Se la funzione modifica una richiesta HTTP o genera una risposta in base alla richiesta, scegli **Richiesta visualizzatore**. Viene visualizzata la sezione **Richiesta**. + Scegli **Risposta visualizzatore**. Vengono visualizzate le sezioni **Richiesta** e **Risposta**. 1. Completa tutti i campi da includere nell’evento. Puoi scegliere **Modifica JSON** per visualizzare il JSON non elaborato. 1. (Facoltativo) Per salvare l’evento, scegli **Salva** e nel campo **Salva evento di test**, inserisci un nome, quindi scegli **Salva**. Puoi anche scegliere **Modifica JSON** e copiare il file JSON non elaborato e salvarlo nel tuo file, all'esterno di. CloudFront **Come creare un oggetto evento (opzione 3)** Crea l'oggetto evento utilizzando un editor di testo. Archivia il file in una directory a cui il tuo computer può connettersi. Verifica di aver seguito queste linee guida: + Ometti i campi `distributionDomainName`, `distributionId` e `requestId`. + I nomi delle intestazioni, dei cookie e delle stringhe di query devono essere in minuscolo. Per creare un oggetto evento in questo modo è possibile creare un esempio utilizzando l'editor visuale. Hai così la certezza che l'esempio sia formattato correttamente. Puoi copiare il codice JSON non elaborato, incollarlo in un editor di testo e salvare il file. Per ulteriori informazioni sulla struttura di un evento, consulta [Struttura degli eventi](functions-event-structure.md). ## Test della funzione Puoi testare una funzione nella CloudFront console o con AWS Command Line Interface ()AWS CLI. ------ #### [ Console ] **Per testare la funzione** 1. Accedi alla CloudFront console all'indirizzo [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) e scegli la pagina **Funzioni**. 1. Scegli la funzione che desideri testare. 1. Seleziona la scheda **Test**. 1. Assicurati che venga visualizzato l'evento corretto. Per passare dall’evento attualmente visualizzato a un altro, scegli un altro evento nel campo **Seleziona evento di test**. 1. Scegli **Testa la funzione**. La console mostra l’output della funzione, inclusi i log delle funzioni e l’utilizzo del calcolo. ------ #### [ CLI ] Puoi testare una funzione utilizzando il comando **aws cloudfront test-function**. **Per testare la funzione** 1. Aprire una finestra a riga di comando. 1. Esegui il comando seguente dalla stessa directory che contiene il file specificato. Questo esempio utilizza la notazione `fileb://` per passare il file dell’evento oggetto. Include anche interruzioni di riga per rendere il comando più leggibile. ``` aws cloudfront test-function \ --name MaxAge \ --if-match ETVABCEXAMPLE \ --event-object fileb://event-maxage-test01.json \ --stage DEVELOPMENT ``` **Note** Si fa riferimento alla funzione tramite il nome e ETag (nel `if-match` parametro). Fai riferimento all'oggetto evento in base alla sua posizione nel file system. La fase può essere `DEVELOPMENT` o `LIVE`. Se il comando viene eseguito correttamente, vedrai un output simile al seguente. ``` TestResult: ComputeUtilization: '21' FunctionErrorMessage: '' FunctionExecutionLogs: [] FunctionOutput: '{"response":{"headers":{"cloudfront-functions":{"value":"generated-by-CloudFront-Functions"},"location":{"value":"https://aws.amazon.com/cloudfront/"}},"statusDescription":"Found","cookies":{},"statusCode":302}}' FunctionSummary: FunctionConfig: Comment: MaxAge function Runtime: cloudfront-js-2.0 KeyValueStoreAssociations= \ {Quantity=1, \ Items=[{KeyValueStoreARN='arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111'}]} \ FunctionMetadata: CreatedTime: '2021-04-18T20:38:56.915000+00:00' FunctionARN: arn:aws:cloudfront::111122223333:function/MaxAge LastModifiedTime: '2023-17-20T10:38:57.057000+00:00' Stage: DEVELOPMENT Name: MaxAge Status: UNPUBLISHED ``` ------ **Note** `FunctionExecutionLogs` contiene un elenco di righe di log che la funzione ha scritto nelle istruzioni `console.log()` (se presenti). `ComputeUtilization` contiene informazioni sull’esecuzione della funzione. Per informazioni, consulta [Informazioni sull’utilizzo del calcolo](#compute-utilization). `FunctionOutput` contiene l'oggetto evento restituito dalla funzione. ## Informazioni sull’utilizzo del calcolo **Compute utilization** (Utilizzo del calcolo) è la quantità di tempo impiegata per l'esecuzione della funzione come percentuale del tempo massimo consentito. Ad esempio, il valore 35 indica che la funzione è stata completata nel 35% del tempo massimo consentito. Se una funzione supera continuamente il tempo massimo consentito, limita CloudFront la funzione. L'elenco seguente illustra la probabilità che una funzione venga limitata in base al valore di utilizzo del calcolo. **Valore di utilizzo del calcolo:** + **Da 1 a 50**: la funzione è comodamente al di sotto del tempo massimo consentito e dovrebbe funzionare senza limitazione (della larghezza di banda della rete). + **Da 51 a 70**: la funzione si sta avvicinando al tempo massimo consentito. Prendere in considerazione l'ottimizzazione del codice della funzione. + **71-100**: la funzione è molto vicina o supera il tempo massimo consentito. CloudFront è probabile che limiti questa funzione se la si associa a una distribuzione. # Aggiornamento delle funzioni Puoi aggiornare una funzione in qualsiasi momento. Le modifiche vengono apportate solo alla versione della funzione che si trova nella fase `DEVELOPMENT`. Per copiare gli aggiornamenti dalla fase `DEVELOPMENT` in `LIVE`, devi [pubblicare la funzione](publish-function.md). Puoi aggiornare il codice di una funzione nella CloudFront console o con AWS Command Line Interface (AWS CLI). ------ #### [ Console ] **Come aggiornare il codice della funzione** 1. Accedi alla CloudFront console all'indirizzo [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) e scegli la pagina **Funzioni**. Scegliere la funzione da aggiornare. 1. Scegli **Modifica** e apporta le modifiche seguenti: + Aggiorna gli eventuali campi nella sezione **Dettagli**. + Modifica o rimuovi l’archivio di valori delle chiavi associato. Per ulteriori informazioni sugli archivi di valori delle chiavi, consulta [Amazon CloudFront KeyValueStore](kvs-with-functions.md). + Modifica il codice funzione. Scegli la scheda **Compila**, apporta le modifiche, quindi seleziona **Salva modifiche** per salvare le modifiche al codice. ------ #### [ CLI ] **Per aggiornare il codice della funzione** 1. Aprire una finestra a riga di comando. 1. Eseguire il seguente comando seguente. Questo esempio utilizza la notazione `fileb://` per passare il file. Include anche interruzioni di riga per rendere il comando più leggibile. ``` aws cloudfront update-function \ --name MaxAge \ --function-config '{"Comment":"Max Age 2 years","Runtime":"cloudfront-js-2.0","KeyValueStoreAssociations":{"Quantity":1,"Items":[{"KeyValueStoreARN":"arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"}]}}' \ --function-code fileb://function-max-age-v1.js \ --if-match ETVABCEXAMPLE ``` **Note** È possibile identificare la funzione sia dal nome che da ETag (nel `if-match` parametro). Assicurati di utilizzare la corrente ETag. È possibile ottenere questo valore dall'operazione [DescribeFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeFunction.html)API. È necessario includere `function-code`, anche se non intendi apportarvi modifiche. Fai attenzione con `function-config`. Devi passare tutto ciò che vuoi mantenere nella configurazione. In particolare, gestisci l'archivio di valori delle chiavi come segue: Per mantenere l’associazione esistente con l’archivio di valori delle chiavi (se presente), specifica il nome dell’archivio *esistente*. Per modificare l’associazione, specifica il nome del *nuovo* archivio di valori delle chiavi. Per rimuovere l’associazione, ometti il parametro `KeyValueStoreAssociations`. Se il comando viene eseguito correttamente, vedrai un output simile al seguente. ``` ETag: ETVXYZEXAMPLE FunctionSummary: FunctionConfig: Comment: Max Age 2 years \ Runtime: cloudfront-js-2.0 \ KeyValueStoreAssociations= \ {Quantity=1, \ Items=[{KeyValueStoreARN='arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111'}]} \ FunctionMetadata: \ CreatedTime: '2021-04-18T20:38:56.915000+00:00' \ FunctionARN: arn:aws:cloudfront::111122223333:function/MaxAge \ LastModifiedTime: '2023-12-19T23:41:15.389000+00:00' \ Stage: DEVELOPMENT \ Name: MaxAge \ Status: UNPUBLISHED ``` ------ La maggior parte delle informazioni viene ripetuta dalla richiesta. Altre informazioni vengono aggiunte da CloudFront. **Note** `ETag`: questo valore cambia a ogni modifica dell’archivio di valori delle chiavi. `FunctionARN`— L'ARN per la tua CloudFront funzione. `Stage`: la fase della funzione (`LIVE` o `DEVELOPMENT`). `Status`: lo stato della funzione (`PUBLISHED` o `UNPUBLISHED`). # Pubblicazione di funzioni Quando pubblichi la funzione, questa operazione copia la funzione dalla fase `DEVELOPMENT` alla fase `LIVE`. Se alla funzione non sono associati comportamenti cache, la sua pubblicazione consente di associarla a un comportamento cache. Puoi associare i comportamenti della cache solo alle funzioni che si trovano nella fase `LIVE`. **Importante** Prima di pubblicare, ti consigliamo di [provare la funzione](test-function.md). Dopo aver pubblicato la funzione, tutti i comportamenti cache associati a tale funzione iniziano automaticamente a utilizzare la copia appena pubblicata, non appena le distribuzioni completano l’implementazione. Puoi pubblicare una funzione nella console CloudFront o con l'AWS CLI. ------ #### [ Console ] **Come pubblicare una funzione** 1. Accedi alla console CloudFront all’indirizzo [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) e scegli la pagina **Funzioni**. 1. Scegliere la funzione da aggiornare. 1. Scegli la scheda **Pubblica**, quindi seleziona **Pubblica**. Se la funzione è già collegata a uno o più comportamenti cache, scegli **Pubblica e aggiorna**. 1. (Facoltativo) Per visualizzare le distribuzioni associate alla funzione, seleziona **Distribuzioni CloudFront associate** per espandere tale sezione. In caso di esito positivo, nella parte superiore della pagina viene visualizzato un banner che indica il ***nome della funzione* pubblicata correttamente**. Puoi anche scegliere la scheda **Genera** e quindi **Live** per visualizzare la versione live del codice funzione. ------ #### [ CLI ] **Come pubblicare una funzione** 1. Aprire una finestra a riga di comando. 1. Eseguire il seguente comando **aws cloudfront publish-function**. Nell'esempio vengono fornite interruzioni di riga per rendere l'esempio più leggibile. ``` aws cloudfront publish-function \ --name MaxAge \ --if-match ETVXYZEXAMPLE ``` Se il comando viene eseguito correttamente, vedrai un output simile al seguente. ``` FunctionSummary: FunctionConfig: Comment: Max Age 2 years Runtime: cloudfront-js-2.0 FunctionMetadata: CreatedTime: '2021-04-18T21:24:21.314000+00:00' FunctionARN: arn:aws:cloudfront::111122223333:function/ExampleFunction LastModifiedTime: '2023-12-19T23:41:15.389000+00:00' Stage: LIVE Name: MaxAge Status: UNASSOCIATED ``` ------ # Associazione delle funzioni alle distribuzioni Per utilizzare una funzione con una distribuzione, è necessario associare la funzione a uno o più comportamenti cache nella distribuzione. Puoi associare una funzione a più comportamenti della cache in più distribuzioni. Puoi associare una funzione con uno qualsiasi di questi elementi: + Un comportamento cache esistente + Un nuovo comportamento cache in una distribuzione esistente + Un nuovo comportamento cache in una nuova distribuzione Quando associ una funzione a un comportamento di cache, è necessario scegliere un *tipo di evento*. Il tipo di evento determina quando CloudFront esegue la funzione. Puoi scegliere i seguenti tipi di evento: + **Richiesta visualizzatore**: la funzione viene eseguita quando CloudFront riceve una richiesta da un visualizzatore. + **Risposta visualizzatore**: la funzione viene eseguita prima che CloudFront restituisca una risposta al visualizzatore. Non puoi utilizzare tipi di eventi rivolti all’origine (*richiesta origine* e *risposta origine*) con Funzioni CloudFront. Puoi invece usare Lambda@Edge. Per ulteriori informazioni, consulta [CloudFront eventi che possono attivare una funzione Lambda @Edge](lambda-cloudfront-trigger-events.md). **Nota** Prima di associare una funzione, è necessario [pubblicarla](publish-function.md) nella fase `LIVE`. Puoi associare una funzione a una distribuzione nella console CloudFront o tramite AWS Command Line Interface (AWS CLI). Nella procedura seguente viene illustrato come associare una funzione a un comportamento della cache esistente. ------ #### [ Console ] **Come associare una funzione a un comportamento cache esistente** 1. Accedi alla console CloudFront all’indirizzo [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) e scegli la pagina **Funzioni**. 1. Scegli la funzione che desideri associare. 1. Nella pagina **Funzioni**, seleziona la scheda **Pubblica**. 1. Scegli **Funzione Pubblica**. 1. Scegliere **Add Association (Aggiungi associazione)**. Nella finestra di dialogo che viene visualizzata, scegli una distribuzione, un tipo di evento e/o un comportamento cache. Per il tipo di evento, scegli quando eseguire questa funzione: + **Richiesta visualizzatore**: esegui la funzione ogni volta che CloudFront riceve una richiesta. + **Risposta visualizzatore**: esegui la funzione ogni volta che CloudFront restituisce una risposta. 1. Per salvare la configurazione, scegli **Aggiungi associazione**. CloudFront associa la distribuzione alla funzione. Attendere alcuni minuti affinché la distribuzione associata finisca la distribuzione. Per controllare l’avanzamento, puoi scegliere **Visualizza distribuzione** nella pagina dei dettagli della funzione. ------ #### [ CLI ] **Come associare una funzione a un comportamento cache esistente** 1. Aprire una finestra a riga di comando. 1. Inserisci il comando seguente per salvare la configurazione di distribuzione per la distribuzione di cui desideri associare il comportamento cache a una funzione. Questo comando salva la configurazione di distribuzione in un file denominato `dist-config.yaml`. Per utilizzare questo comando, effettua le seguenti operazioni: + Sostituisci *`DistributionID`* con l'ID della distribuzione. + Esegui il comando su una riga. Nell'esempio vengono fornite interruzioni di riga per rendere l'esempio più leggibile. ``` aws cloudfront get-distribution-config \ --id DistributionID \ --output yaml > dist-config.yaml ``` Se il comando viene eseguito correttamente, l'AWS CLI non restituisce alcun output. 1. Apri il file denominato `dist-config.yaml` creato. Modifica il file per apportare le modifiche seguenti. 1. Rinominare il campo `ETag` in `IfMatch`, ma non modificare il valore del campo. 1. Nel comportamento della cache, trova l'oggetto denominato `FunctionAssociations`. Aggiorna questo oggetto per aggiungere un'associazione di funzioni. La sintassi YAML per un'associazione di funzioni è simile all'esempio seguente. + L'esempio seguente mostra un oggetto evento Richiesta visualizzatore (trigger). Per utilizzare un tipo di evento Risposta del visualizzatore, sostituisci `viewer-request` con `viewer-response`. + Sostituisci *`arn:aws:cloudfront::111122223333:function/ExampleFunction`* con il nome della risorsa Amazon (ARN) della funzione che stai associando a questo comportamento della cache. Per ottenere l’ARN della funzione, puoi utilizzare il comando **aws cloudfront list-functions**. ``` FunctionAssociations: Items: - EventType: viewer-request FunctionARN: arn:aws:cloudfront::111122223333:function/ExampleFunction Quantity: 1 ``` 1. Dopo aver apportato queste modifiche, salva il file. 1. Utilizza il comando seguente per aggiornare la distribuzione, aggiungendo l'associazione di funzioni. Per utilizzare questo comando, effettua le seguenti operazioni: + Sostituisci *`DistributionID`* con l'ID della distribuzione. + Esegui il comando su una riga. Nell'esempio vengono fornite interruzioni di riga per rendere l'esempio più leggibile. ``` aws cloudfront update-distribution \ --id DistributionID \ --cli-input-yaml file://dist-config.yaml ``` Se il comando ha esito positivo, viene visualizzato un output simile al seguente che descrive la distribuzione appena aggiornata con l'associazione di funzioni. L'output di esempio seguente è stato troncato per una maggiore leggibilità. ``` Distribution: ARN: arn:aws:cloudfront::111122223333:distribution/EBEDLT3BGRBBW ... truncated ... DistributionConfig: ... truncated ... DefaultCacheBehavior: ... truncated ... FunctionAssociations: Items: - EventType: viewer-request FunctionARN: arn:aws:cloudfront::111122223333:function/ExampleFunction Quantity: 1 ... truncated ... DomainName: d111111abcdef8.cloudfront.net Id: EDFDVBD6EXAMPLE LastModifiedTime: '2021-04-19T22:39:09.158000+00:00' Status: InProgress ETag: E2VJGGQEG1JT8S ``` ------ Lo `Status` della distribuzione cambia in `InProgress` mentre la distribuzione viene ridistribuita. Quando la nuova configurazione di distribuzione raggiunge una posizione edge CloudFront, tale posizione edge inizia a utilizzare la funzione associata. Quando la distribuzione è completamente distribuita, `Status` torna a `Deployed`. Ciò indica che la funzione CloudFront associata è attiva in tutte le posizioni edge CloudFront in tutto il mondo. In genere sono necessari pochi minuti. # Amazon CloudFront KeyValueStore CloudFront KeyValueStore è un datastore di valori chiave sicuro, globale e a bassa latenza che consente l'accesso in lettura dall'interno di [CloudFront Functions](cloudfront-functions.md), abilitando una logica personalizzabile avanzata nelle sedi periferiche. CloudFront Con CloudFront KeyValueStore, si effettuano aggiornamenti al codice della funzione e ai dati associati a una funzione indipendentemente l'uno dall'altro. Questa separazione semplifica il codice della funzione e agevola l'aggiornamento dei dati senza la necessità di implementare modifiche al codice. **Nota** Per essere utilizzata CloudFront KeyValueStore, la CloudFront funzione deve utilizzare [JavaScript runtime 2.0](functions-javascript-runtime-20.md). Di seguito è riportata la procedura generale per l’utilizzo delle coppie chiave-valore: + Crea archivi di valori delle chiavi e compilali con un set di coppie chiave-valore. Puoi aggiungere archivi di valori delle chiavi a un bucket Amazon S3 o inserirli manualmente. + Associate gli archivi di valori chiave alla vostra CloudFront funzione. + All'interno del codice della funzione, utilizza il nome della chiave per recuperare il valore associato alla chiave stessa o stabilire se ne esiste una. Per ulteriori informazioni sull’utilizzo delle coppie chiave-valore nel codice della funzione e per informazioni sui metodi dell’assistente di gestione, consulta [Metodi helper per archivi di valori delle chiavi](functions-custom-methods.md). ## Casi d’uso Puoi utilizzare coppie chiave-valore per i seguenti esempi: + **Riscritture o reindirizzamenti degli URL**: la coppia chiave-valore può contenere la riscrittura o il reindirizzamento. URLs URLs + **Flag di funzionalità e test A/B**: puoi creare una funzione per eseguire esperimenti assegnando una percentuale di traffico a una versione specifica del sito web. + **Autorizzazione di accesso**: puoi implementare il controllo degli accessi per consentire o rifiutare richieste in base ai criteri definiti e ai dati archiviati in un archivio di valori delle chiavi. ## Formati supportati per i valori Puoi archiviare il valore in una coppia chiave-valore in uno qualsiasi dei seguenti formati: + Stringa + Stringa con codifica in byte + JSON ## Sicurezza La CloudFront funzione e tutti i relativi archivi di valori chiave vengono gestiti in modo sicuro, come segue: + CloudFront crittografa ogni archivio di valori chiave a riposo e durante il transito (durante la lettura o la scrittura negli archivi di valori chiave) quando si richiamano le [CloudFront KeyValueStore](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_Operations_Amazon_CloudFront_KeyValueStore.html)operazioni API. + Quando la funzione viene eseguita, CloudFront decripta ogni coppia chiave-valore in memoria nelle posizioni periferiche. CloudFront Per iniziare CloudFront KeyValueStore, consulta i seguenti argomenti. **Topics** + [ ## Casi d’uso ](#key-value-store-use-cases) + [ ## Formati supportati per i valori ](#key-value-store-supported-formats) + [ ## Sicurezza ](#key-value-store-security) + [ # Utilizzo dell’archivio di valori delle chiavi ](kvs-with-functions-kvs.md) + [ # Utilizzo dei dati dei valori delle chiavi ](kvs-with-functions-kvp.md) + Per ulteriori informazioni su come iniziare CloudFront KeyValueStore, consulta il post del CloudFront KeyValueStore AWS blog [Introducing Amazon](https://aws.amazon.com/blogs/aws/introducing-amazon-cloudfront-keyvaluestore-a-low-latency-datastore-for-cloudfront-functions/). # Utilizzo dell’archivio di valori delle chiavi È necessario creare un archivio chiave-valore per contenere le coppie chiave-valore che si desidera utilizzare in CloudFront Functions. Dopo aver creato gli archivi di valori chiave e le coppie chiave-valore aggiunto, è possibile utilizzare i valori chiave nel codice della funzione. CloudFront Per iniziare, consulta i seguenti argomenti: **Topics** + [ # Creazione di un archivio di valori delle chiavi ](kvs-with-functions-create.md) + [ # Associazione di un archivio di valori delle chiavi a una funzione ](kvs-with-functions-associate.md) + [ # Aggiornamento di un archivio di valori delle chiavi ](kvs-with-functions-edit.md) + [ # Ottenere un riferimento a un archivio di valori delle chiavi ](kvs-with-functions-get-reference.md) + [ # Eliminazione di un archivio di valori delle chiavi ](kvs-with-functions-delete.md) + [ # Formato file per coppie chiave-valore ](kvs-with-functions-create-s3-kvp.md) **Nota** Il JavaScript runtime 2.0 include alcuni metodi di supporto per lavorare con i valori chiave nel codice della funzione. Per ulteriori informazioni, consulta [Metodi helper per archivi di valori delle chiavi](functions-custom-methods.md). # Creazione di un archivio di valori delle chiavi Puoi creare contemporaneamente un archivio di valori delle chiavi e le rispettive coppie chiave-valore. Ora, puoi anche creare un archivio di valori delle chiavi vuoto e aggiungere le coppie chiave-valore in un secondo momento. **Nota** Se specifichi l’origine dati da un bucket Amazon S3, devi disporre delle autorizzazioni `s3:GetObject` e `s3:GetBucketLocation` per tale bucket. Se non disponi di queste autorizzazioni, non CloudFront puoi creare correttamente il tuo archivio di valori chiave. Scegli se desideri aggiungere coppie chiave-valore contemporaneamente alla creazione dell’archivio di valori delle chiavi. Puoi importare le coppie chiave-valore utilizzando la CloudFront console, l' CloudFrontAPI o. AWS SDKs Tuttavia, puoi importare il file di coppie chiave-valore solo quando crei *inizialmente* l’archivio di valori delle chiavi. Per creare un file di coppie chiave-valore, consulta [Formato file per coppie chiave-valore](kvs-with-functions-create-s3-kvp.md). ------ #### [ Console ] **Come creare un archivio di valori delle chiavi** 1. Accedi Console di gestione AWS e apri la pagina **Funzioni** nella CloudFront console all'indirizzo. [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) 1. Scegli la **KeyValueStores**scheda, quindi scegli **Crea KeyValueStore**. 1. Immetti un nome e una descrizione facoltativa per l'archivio di valori delle chiavi. 1. Completa **URI S3**: + Se disponi di un file di coppie chiave-valore, inserisci il percorso del bucket Amazon S3 in cui hai archiviato il file. + Lascia vuoto questo campo se intendi inserire manualmente le coppie chiave-valore. 1. Scegli **Create** (Crea). L’archivio di valori delle chiavi ora esiste. Viene visualizzata la pagina dei dettagli relativa al nuovo archivio di valori delle chiavi. Le informazioni sulla pagina includono l'ID e l'ARN dell'archivio di valori delle chiavi. + L'ID è una stringa casuale di caratteri che è unica nel tuo Account AWS. + La sintassi dell'ARN è la seguente: *Account AWS*`:key-value-store/`*the key value stores ID* 1. Osserva la sezione **Coppie chiave-valore**. Se hai importato un file, in questa sezione vengono visualizzate alcune coppie chiave-valore. Puoi fare quanto segue: + Se hai importato un file, puoi anche aggiungere altri valori manualmente. + Se non hai importato un file da un bucket Amazon S3 e vuoi aggiungere subito coppie chiave-valore, puoi completare la fase successiva. + Puoi ignorare questa fase e aggiungere le coppie chiave-valore in un secondo momento. 1. Per aggiungere subito le coppie: 1. Scegli **Aggiungi coppie chiave-valore**. 1. Scegli **Aggiungi coppia** e inserisci un nome e un valore. Ripeti questa fase per aggiungere altre coppie. 1. Al termine, scegli **Salva modifiche** per salvare tutte le coppie chiave-valore nell’archivio di valori delle chiavi. Nella finestra di dialogo visualizzata, scegli **Fatto**. 1. Per associare subito l’archivio di valori delle chiavi a una funzione, completa la sezione **Funzioni associate**. Per ulteriori informazioni, consulta [Creazione di funzioni](create-function.md) o [Aggiornamento delle funzioni](update-function.md). Puoi associare la funzione in un secondo momento, dalla pagina dei dettagli di questo archivio di valori delle chiavi o dalla pagina dei dettagli della funzione. ------ #### [ AWS CLI ] **Come creare un archivio di valori delle chiavi** + Esegui il comando seguente per creare un archivio di valori delle chiavi e importare le coppie chiave-valore da un bucket Amazon S3. ``` aws cloudfront create-key-value-store \ --name=keyvaluestore1 \ --comment="This is my key value store file" \ --import-source=SourceType=S3,SourceARN=arn:aws:s3:::amzn-s3-demo-bucket1/kvs-input.json ``` **Risposta** ``` { "ETag": "ETVABCEXAMPLE", "Location": "https://cloudfront.amazonaws.com/2020-05-31/key-value-store/arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example", "KeyValueStore": { "Name": "keyvaluestore1", "Id": "8aa76c93-3198-462c-aaf6-example", "Comment": "This is my key value store file", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example", "Status": "PROVISIONING", "LastModifiedTime": "2024-08-06T22:19:10.813000+00:00" } } ``` ------ #### [ API ] **Come creare un archivio di valori delle chiavi** 1. Usa l'[CloudFrontCreateKeyValueStore](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_CreateKeyValueStore.html)operazione. L'operazione richiede diversi parametri: + un `name` dell’archivio di valori delle chiavi; + un parametro `comment` che includa un commento; + un parametro `import-source` che consenta di importare coppie chiave-valore da un file archiviato in un bucket Amazon S3. Puoi importare da un file solo la prima volta che crei l’archivio di valori delle chiavi. Per informazioni sulla struttura dei file, consulta [Formato file per coppie chiave-valore](kvs-with-functions-create-s3-kvp.md). La risposta dell'operazione include le informazioni seguenti: + i valori trasmessi nella richiesta, incluso il nome assegnato; + dati come l'ora di creazione; + un `ETag` (ad esempio, `ETVABCEXAMPLE`), l’ARN che include il nome dell’archivio di valori delle chiavi (ad esempio, `arn:aws:cloudfront::123456789012:key-value-store/keyvaluestore1`). Per utilizzare l’archivio di valori delle chiavi a livello di codice, utilizzerai una combinazione di `ETag`, ARN e nome. ------ ## Stati dell’archivio di valori delle chiavi Quando crei un archivio di valori delle chiavi, i valori di stato del datastore possono essere i seguenti. **** | Valore | Description | | --- | --- | | **Approvvigionamento** | L'archivio di valori chiave è stato creato e CloudFront sta elaborando l'origine dati specificata. | | **Pronto** | L'archivio di valori chiave è stato creato ed ha elaborato CloudFront correttamente l'origine dati specificata. | | **Importazione non riuscita** | CloudFront non è stato in grado di elaborare l'origine dati specificata. Questo stato può essere visualizzato se il formato file non è valido o se supera il limite di dimensioni. Per ulteriori informazioni, consulta [Formato file per coppie chiave-valore](kvs-with-functions-create-s3-kvp.md). | # Associazione di un archivio di valori delle chiavi a una funzione Dopo aver creato l’archivio di valori delle chiavi, puoi aggiornare la funzione per associarla all’archivio di valori delle chiavi. Questa associazione è necessaria per utilizzare le coppie chiave-valore di tale archivio nella funzione. Si applicano le regole seguenti: + Una funzione può avere un solo archivio di valori delle chiavi + Puoi associare lo stesso archivio di valori delle chiavi a più funzioni ------ #### [ Console ] **Come associare un archivio di valori delle chiavi a una funzione** 1. Accedi alla CloudFront console all'indirizzo [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) e scegli la pagina **Funzioni**. 1. Scegli il nome della funzione. 1. Vai alla KeyValueStore sezione **Associa** e scegli **Associa esistente KeyValueStore**. 1. **Seleziona l'archivio chiave-valore che contiene le coppie chiave-valore nella funzione, quindi scegli Associa. KeyValueStore** CloudFront associa immediatamente l'archivio alla funzione. Non è necessario salvare la funzione. 1. Per specificare un diverso archivio di valori chiave, scegliete **Aggiorna associato KeyValueStore**, selezionate il nome di un altro archivio di valori chiave, quindi scegliete **Associa KeyValueStore**. Per ulteriori informazioni, consulta [Aggiornamento delle funzioni](update-function.md). ------ #### [ AWS CLI ] **Come associare un archivio di valori delle chiavi a una funzione** + Esegui il comando seguente per aggiornare la funzione `MaxAge` e associare una risorsa dell’archivio di valori delle chiavi. ``` aws cloudfront update-function \ --name MaxAge \ --function-config '{"Comment":"Max Age 2 years","Runtime":"cloudfront-js-2.0","KeyValueStoreAssociations":{"Quantity":1,"Items":[{"KeyValueStoreARN":"arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example"}]}}' \ --function-code fileb://function-max-age-v1.js \ --if-match ETVABCEXAMPLE ``` + Per associare un archivio di valori delle chiavi a una funzione, specifica il parametro `KeyValueStoreAssociations` e l’ARN dell’archivio di valori delle chiavi. + Per modificare l’associazione, specifica un altro ARN dell’archivio di valori delle chiavi. + Per rimuovere l’associazione, rimuovi il parametro `KeyValueStoreAssociations`. Per ulteriori informazioni, consulta [Aggiornamento delle funzioni](update-function.md). ------ #### [ API ] **Come associare un archivio di valori delle chiavi a una funzione** + Usa l'operazione API [UpdateFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateFunction.html). Per ulteriori informazioni, consulta [Aggiornamento delle funzioni](update-function.md). ------ **Note** Se modifichi un archivio di valori delle chiavi senza cambiare le coppie chiave-valore, o se modifichi solo le coppie chiave-valore nell’archivio di valori delle chiavi, non devi associare nuovamente l’archivio di valori delle chiavi. Inoltre, non è necessario ripubblicare la funzione. Tuttavia, ti consigliamo di testare la funzione per verificare che funzioni nel modo previsto. Per ulteriori informazioni, consulta [Test delle funzioni](test-function.md). Puoi visualizzare tutte le funzioni che utilizzano un archivio di valori delle chiavi specifico. Sulla CloudFront console, scegli la pagina dei dettagli del key value store. # Aggiornamento di un archivio di valori delle chiavi Quando aggiorni un archivio di valori delle chiavi, puoi modificare le coppie chiave-valore o modificare l’associazione tra l’archivio di valori delle chiavi e la funzione. ------ #### [ Console ] **Come aggiornare un archivio di valori delle chiavi** 1. Accedi Console di gestione AWS e apri la pagina **Funzioni** nella CloudFront console all'indirizzo[https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Scegli la scheda **KeyValueStores**. 1. Seleziona l’archivio dei valori delle chiavi che desideri aggiornare. + Per aggiornare le coppie chiave-valore, scegli **Modifica** nella sezione **Coppie chiave-valore**. Puoi aggiungere o eliminare qualsiasi coppia chiave-valore. Puoi anche modificare il valore di una coppia chiave-valore esistente. Al termine, scegli **Salva le modifiche**. + Per aggiornare l’associazione per questo archivio di valori delle chiavi, scegli **Vai alle funzioni**. Per ulteriori informazioni, consulta [Associazione di un archivio di valori delle chiavi a una funzione](kvs-with-functions-associate.md). ------ #### [ AWS CLI ] **Come aggiornare un archivio di valori delle chiavi** 1. **Modificare le coppie chiave-valore**: puoi aggiungere altre coppie chiave-valore, eliminare una o più coppie chiave-valore, nonché modificare il valore di una coppia chiave-valore esistente. Per ulteriori informazioni, consulta [Utilizzo dei dati dei valori delle chiavi](kvs-with-functions-kvp.md). 1. **Modificare l’associazione della funzione per l’archivio di valori delle chiavi**: per aggiornare l’associazione della funzione per l’archivio di valori delle chiavi, consulta [Associazione di un archivio di valori delle chiavi a una funzione](kvs-with-functions-associate.md). **Suggerimento** Avrai bisogno dell'ARN dell'archivio di valori delle chiavi. Per ulteriori informazioni, consulta [Ottenere un riferimento a un archivio di valori delle chiavi](kvs-with-functions-get-reference.md). ------ #### [ API ] **Come aggiornare un archivio di valori delle chiavi** 1. **Modificare le coppie chiave-valore**: puoi aggiungere altre coppie chiave-valore, eliminare una o più coppie chiave-valore, nonché modificare il valore di una coppia chiave-valore esistente. Per ulteriori informazioni, consulta [Utilizzo dei dati dei valori delle chiavi](kvs-with-functions-kvp.md). 1. **Modifica l'associazione delle funzioni per l'archivio di valori chiave**: per aggiornare l'associazione delle funzioni per l'archivio di valori chiave, utilizza l'operazione [UpdateFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateFunction.html)API. Per ulteriori informazioni, consulta [Aggiornamento delle funzioni](update-function.md). **Suggerimento** Avrai bisogno dell'ARN dell'archivio di valori delle chiavi. Per ulteriori informazioni, consulta [Ottenere un riferimento a un archivio di valori delle chiavi](kvs-with-functions-get-reference.md). ------ # Ottenere un riferimento a un archivio di valori delle chiavi Per utilizzare gli archivi di valori delle chiavi a livello di codice, sono necessari l’`ETag` e il nome dell’archivio di valori delle chiavi. Per ottenere entrambi i valori, puoi utilizzare AWS Command Line Interface (AWS CLI) o l' CloudFront API. ------ #### [ AWS CLI ] **Come ottenere il riferimento all’archivio di valori delle chiavi** 1. Per restituire un elenco di archivi di valori delle chiavi, il seguente comando trova il nome dell’archivio di valori delle chiavi da modificare. ``` aws cloudfront list-key-value-stores ``` 1. Dalla risposta, trova il nome dell’archivio di valori delle chiavi desiderato. **Risposta** ``` { "KeyValueStoreList": { "Items": [ { "Name": "keyvaluestore3", "Id": "37435e19-c205-4271-9e5c-example3", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example3", "Status": "READY", "LastModifiedTime": "2024-05-08T14:50:18.876000+00:00" }, { "Name": "keyvaluestore2", "Id": "47970d59-6408-474d-b850-example2", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/47970d59-6408-474d-b850-example2", "Status": "READY", "LastModifiedTime": "2024-05-30T21:06:22.113000+00:00" }, { "Name": "keyvaluestore1", "Id": "8aa76c93-3198-462c-aaf6-example", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example", "Status": "READY", "LastModifiedTime": "2024-08-06T22:19:30.510000+00:00" } ] } } ``` 1. Esegui il comando seguente per restituire l’`ETag` per l’archivio di valori delle chiavi specificato. ``` aws cloudfront describe-key-value-store \ --name=keyvaluestore1 ``` **Risposta** ``` { "ETag": "E3UN6WX5RRO2AG", "KeyValueStore": { "Name": "keyvaluestore1", "Id": "8aa76c93-3198-462c-aaf6-example", "Comment": "This is an example KVS", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example", "Status": "READY", "LastModifiedTime": "2024-08-06T22:19:30.510000+00:00" } } ``` ------ #### [ API ] **Come ottenere il riferimento all’archivio di valori delle chiavi** 1. Utilizza l’operazione API [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html) per restituire un elenco di archivi di valori delle chiavi. Trova il nome dell’archivio di valori delle chiavi da modificare. 1. Utilizza l’operazione API [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeKeyValueStore.html) e specifica il nome dell’archivio di valori delle chiavi restituito dalla fase precedente. ------ La risposta include un UUID, nonché l’ARN e l’`ETag` dell’archivio di valori delle chiavi. + Un `ETag`, ad esempio `E3UN6WX5RRO2AG` + L’UUID è a 128 bit, ad esempio `8aa76c93-3198-462c-aaf6-example` + L'ARN include il Account AWS numero, la costante e l'UUID`key-value-store`, come nell'esempio seguente: `arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example` Per ulteriori informazioni sull’operazione `DescribeKeyValueStore`, consulta [Informazioni su CloudFront KeyValueStore](kvs-with-functions-kvp.md#kvs-with-functions-api-describe). # Eliminazione di un archivio di valori delle chiavi Puoi eliminare il tuo archivio di valori chiave utilizzando la CloudFront console o l'API Amazon. ------ #### [ Console ] **Come eliminare un archivio di valori delle chiavi** 1. Accedi Console di gestione AWS e apri la pagina **Funzioni** nella CloudFront console all'indirizzo[https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Scegli il nome della funzione. 1. KeyValueStoreNella sezione **Associato**, verifica se un archivio di valori chiave è associato alla funzione. In tal caso, rimuovi l'associazione scegliendo **Dissocia**, KeyValueStore quindi scegli **Rimuovi associazione**. 1. Nel riquadro di navigazione, scegli la pagina **Funzioni**, quindi scegli la **KeyValueStores**scheda. 1. Seleziona l’archivio di valori delle chiavi da eliminare, quindi scegli **Elimina**. ------ #### [ AWS CLI ] **Come eliminare un archivio di valori delle chiavi** 1. Ottieni l’`ETag` e il nome dell’archivio di valori delle chiavi. Per ulteriori informazioni, consulta [Ottenere un riferimento a un archivio di valori delle chiavi](kvs-with-functions-get-reference.md). 1. Verifica se l’archivio di valori delle chiavi è associato a una funzione. Se lo è, rimuovi l'associazione. Per ulteriori informazioni su questi due passaggi, consulta [Aggiornamento delle funzioni](update-function.md). 1. Dopo aver ottenuto il nome e l’`ETag` dell’archivio di valori delle chiavi e dopo che questo non è più associato a una funzione, puoi eliminarlo. Esegui il comando seguente per eliminare l’l’archivio di valori delle chiavi specificato. ``` aws cloudfront delete-key-value-store \ --name=keyvaluestore1 \ --if-match=E3UN6WX5RRO2AG ``` ------ #### [ API ] **Come eliminare un archivio di valori delle chiavi** 1. Ottieni l’`ETag` e il nome dell’archivio di valori delle chiavi. Per ulteriori informazioni, consulta [Ottenere un riferimento a un archivio di valori delle chiavi](kvs-with-functions-get-reference.md). 1. Verifica se l’archivio di valori delle chiavi è associato a una funzione. Se lo è, rimuovi l'associazione. Per ulteriori informazioni su questi due passaggi, consulta [Aggiornamento delle funzioni](update-function.md). 1. Per eliminare l'archivio dei valori chiave, utilizza l'operazione CloudFront [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DeleteKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DeleteKeyValueStore.html)API. ------ # Formato file per coppie chiave-valore Quando crei un file con codifica UTF-8, utilizza il seguente formato JSON: ``` { "data":[ { "key":"key1", "value":"value" }, { "key":"key2", "value":"value" } ] } ``` Il file non può includere chiavi duplicate. Se hai specificato un file non valido nel bucket Amazon S3, puoi aggiornare il file per rimuovere eventuali duplicati e quindi provare a creare nuovamente l’archivio di valori delle chiavi. Per ulteriori informazioni, consulta [Creazione di un archivio di valori delle chiavi](kvs-with-functions-create.md). **Nota** Il file per l'origine dati e le relative coppie chiave-valore hanno i seguenti limiti: Dimensione del file: 5 MB Dimensione della chiave: 512 caratteri Dimensione del valore: 1024 caratteri # Utilizzo dei dati dei valori delle chiavi In questa sezione viene descritto come aggiungere coppie chiave-valore a un archivio di valori delle chiavi esistente. Per includere coppie chiave-valore durante la creazione iniziale degli archivi di valori delle chiavi, consulta [Creazione di un archivio di valori delle chiavi](kvs-with-functions-create.md). **Topics** + [ ## Utilizzo di coppie chiave-valore (console) ](#kvs-with-functions-kvp-using-console) + [ ## Informazioni su CloudFront KeyValueStore ](#kvs-with-functions-api-describe) + [ ## Utilizzo di coppie chiave-valore (AWS CLI) ](#work-with-kvs-cli-keys) + [ ## Utilizzo di coppie chiave-valore (API) ](#kvs-with-functions-kvp-using-api) ## Utilizzo di coppie chiave-valore (console) Puoi usare la CloudFront console per lavorare con le tue coppie chiave-valore. **Come utilizzare coppie chiave-valore** 1. Accedi Console di gestione AWS e apri la pagina **Funzioni** nella CloudFront console all'indirizzo. [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) 1. Scegli la scheda **KeyValueStores**. 1. Seleziona l'archivio dei valori delle chiavi da modificare. 1. Nella sezione **Coppie chiave-valore**, scegli **Modifica**. 1. Puoi aggiungere una coppia chiave-valore, eliminarla o modificare il valore di una coppia esistente. 1. Al termine, scegli **Salva le modifiche**. ## Informazioni su CloudFront KeyValueStore **Suggerimento** L' CloudFront KeyValueStore API è un servizio globale che utilizza Signature Version 4A (SigV4a) per l'autenticazione. L’utilizzo di credenziali temporanee con SigV4A richiede i token sessione versione 2. Per ulteriori informazioni, consulta [Utilizzo di credenziali temporanee con l'API CloudFront KeyValueStore](cloudfront-function-restrictions.md#regional-endpoint-for-key-value-store). Se stai usando il AWS Command Line Interface (AWS CLI) o il tuo codice per chiamare l' CloudFront KeyValueStore API, consulta le seguenti sezioni. Quando utilizzi un archivio di valori delle chiavi e le relative coppie chiave-valore, il servizio che chiami dipende dal tuo caso d’uso: + Per utilizzare le coppie chiave-valore in un archivio di valori chiave *esistente*, utilizza il CloudFront KeyValueStore servizio. + Per includere coppie chiave-valore nell'archivio valori chiave quando crei *inizialmente* l'archivio valori chiave, utilizza il servizio. CloudFront Sia l' CloudFront API che l' CloudFront KeyValueStore API hanno un'`DescribeKeyValueStore`operazione. Vengono chiamate per diversi motivi. Per comprendere le differenze, consulta la tabella seguente. | | API CloudFront DescribeKeyValueStore | API CloudFront KeyValueStore DescribeKeyValueStore | | --- | --- | --- | | Dati relativi all’archivio di valori delle chiavi | Restituisce dati quali lo stato e la data dell’ultima modifica dell’archivio di valori delle chiavi. | Restituisce dati relativi ai *contenuti* della risorsa di archiviazione: le coppie chiave-valore nell’archivio e le dimensioni del contenuto. | | Dati che identificano l’archivio di valori delle chiavi | Restituisce un `ETag`, l’UUID e l’ARN dell’archivio di valori delle chiavi. | Restituisce un `ETag` e l’ARN dell’archivio di valori delle chiavi. | **Note** Ogni operazione DescribeKeyValueStore restituisce un *diverso* `ETag`. Gli `ETags` non sono intercambiabili. Quando chiami un’operazione API per completare un’azione, devi specificare l’`ETag` dall’API appropriata. Ad esempio, nell' CloudFront KeyValueStore[ DeleteKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DeleteKey.html)operazione, si specifica `ETag` ciò che si è restituito dall' CloudFront KeyValueStore [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html)operazione. Quando richiamate le CloudFront funzioni utilizzando CloudFront KeyValueStore, i valori nell'archivio di valori chiave non vengono aggiornati o modificati durante la chiamata della funzione. Gli aggiornamenti vengono elaborati tra le invocazioni di una funzione. ## Utilizzo di coppie chiave-valore (AWS CLI) È possibile eseguire i seguenti AWS Command Line Interface comandi per. CloudFront KeyValueStore **Contents** + [ ### Elencare coppie chiave/valore ](#kvs-cli-list-keys) + [ ### Ottenere coppie chiave/valore ](#kvs-cli-get-keys) + [ ### Descrizione di un archivio di valori delle chiavi ](#kvs-cli-describe-keys) + [ ### Creazione di una coppia chiave-valore ](#kvs-cli-create-keys) + [ ### Eliminazione di una coppia chiave-valore ](#kvs-cli-delete-keys) + [ ### Aggiornamento di coppie chiave-valore ](#kvs-cli-update-key) ### Elencare coppie chiave/valore Per elencare coppie chiave-valore nell’archivio di valori delle chiavi, esegui il comando seguente. ``` aws cloudfront-keyvaluestore list-keys \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Risposta** ``` { "Items": [ { "Key": "key1", "Value": "value1" } ] } ``` ### Ottenere coppie chiave/valore Per ottenere una coppia chiave-valore nell’archivio di valori delle chiavi, esegui il comando seguente. ``` aws cloudfront-keyvaluestore get-key \ --key=key1 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Risposta** ``` { "Key": "key1", "Value": "value1", "ItemCount": 1, "TotalSizeInBytes": 11 } ``` ### Descrizione di un archivio di valori delle chiavi Per descrivere un archivio di valori delle chiavi, esegui il comando seguente. ``` aws cloudfront-keyvaluestore describe-key-value-store \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Risposta** ``` { "ETag": "KV1F83G8C2ARO7P", "ItemCount": 1, "TotalSizeInBytes": 11, "KvsARN": "arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example", "Created": "2024-05-08T07:48:45.381000-07:00", "LastModified": "2024-08-05T13:50:58.843000-07:00", "Status": "READY" } ``` ### Creazione di una coppia chiave-valore Per creare una coppia chiave-valore nell’archivio di valori delle chiavi, esegui il comando seguente. ``` aws cloudfront-keyvaluestore put-key \ --if-match=KV1PA6795UKMFR9 \ --key=key2 \ --value=value2 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Risposta** ``` { "ETag": "KV13V1IB3VIYZZH", "ItemCount": 3, "TotalSizeInBytes": 31 } ``` ### Eliminazione di una coppia chiave-valore Per eliminare una coppia chiave-valore, esegui il comando seguente. ``` aws cloudfront-keyvaluestore delete-key \ --if-match=KV13V1IB3VIYZZH \ --key=key1 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Output** ``` { "ETag": "KV1VC38T7YXB528", "ItemCount": 2, "TotalSizeInBytes": 22 } ``` ### Aggiornamento di coppie chiave-valore Puoi utilizzare il comando `update-keys` per aggiornare più coppie chiave-valore. Ad esempio, per eliminare una coppia chiave-valore esistente e crearne un’altra, esegui il comando seguente. ``` aws cloudfront-keyvaluestore update-keys \ --if-match=KV2EUQ1WTGCTBG2 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example \ --deletes '[{"Key":"key2"}]' \ --puts '[{"Key":"key3","Value":"value3"}]' ``` **Risposta** ``` { "ETag": "KV3AEGXETSR30VB", "ItemCount": 3, "TotalSizeInBytes": 28 } ``` ## Utilizzo di coppie chiave-valore (API) Segui questa sezione per utilizzare le coppie chiave-valore a livello di codice. **Contents** + [ ### Ottenere un riferimento a un archivio di valori delle chiavi ](#kvs-with-functions-api-ref) + [ ### Modifica delle coppie chiave-valore in un archivio di valori delle chiavi ](#kvs-with-functions-api-actions) + [ ### Codice di esempio per CloudFront KeyValueStore ](#example-code-key-value-store) ### Ottenere un riferimento a un archivio di valori delle chiavi Quando si utilizza l' CloudFront KeyValueStore API per chiamare un'operazione di scrittura, è necessario specificare l'ARN e l'archivio `ETag` dei valori della chiave. Per ottenere questi dati, procedi come descritto di seguito: **Come ottenere un riferimento a un archivio di valori delle chiavi** 1. Utilizza l’operazione API [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html) per ottenere un elenco di archivi di valori delle chiavi. Trova l’archivio di valori delle chiavi da modificare. 1. Utilizza l’[operazione API CloudFrontKeyValueStore DescribeKeyValueStore](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html) e specifica l’archivio di valori delle chiavi della fase precedente. La risposta include l’ARN e l’`ETag` dell’archivio di valori delle chiavi. + L'ARN include il Account AWS numero, la costante `key-value-store` e l'UUID, come nell'esempio seguente: `arn:aws:cloudfront::123456789012:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111` + Un `ETag` il cui aspetto è simile a quello dell’esempio seguente: `ETVABCEXAMPLE2` ### Modifica delle coppie chiave-valore in un archivio di valori delle chiavi Puoi specificare l’archivio di valori delle chiavi che contiene la coppia chiave-valore che desideri aggiornare. Vedi le seguenti operazioni API: CloudFront KeyValueStore + [CloudFrontKeyValueStore DeleteKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DeleteKey.html)— Elimina una coppia chiave-valore + [CloudFrontKeyValueStore GetKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_GetKey.html)— Restituisce una coppia chiave-valore + [CloudFrontKeyValueStore ListKeys](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_ListKeys.html)— Restituisce un elenco di coppie chiave-valore + [CloudFrontKeyValueStore PutKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_PutKey.html)— È possibile eseguire le seguenti attività: + Creare una coppia chiave-valore in un unico archivio di valori delle chiavi specificando un nuovo nome e valore della chiave. + Impostare un valore diverso in una coppia chiave-valore esistente specificando un nome chiave esistente e un nuovo valore della chiave. + [CloudFrontKeyValueStore UpdateKeys](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_UpdateKeys.html)— È possibile eseguire una o più delle seguenti azioni in all-or-nothing un'unica operazione: + Eliminare una o più coppie chiave-valore + Creare una o più nuove coppie chiave-valore + Impostare un valore diverso in una o più coppie chiave-valore esistenti ### Codice di esempio per CloudFront KeyValueStore **Example** Il codice seguente mostra come chiamare l’operazione API `DescribeKeyValueStore` per un archivio di valori delle chiavi. ``` const { CloudFrontKeyValueStoreClient, DescribeKeyValueStoreCommand, } = require("@aws-sdk/client-cloudfront-keyvaluestore"); require("@aws-sdk/signature-v4-crt"); (async () => { try { const client = new CloudFrontKeyValueStoreClient({ region: "us-east-1" }); const input = { KvsARN: "arn:aws:cloudfront::123456789012:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111", }; const command = new DescribeKeyValueStoreCommand(input); const response = await client.send(command); } catch (e) { console.log(e); } })(); ```