Here is your custom content.
" } } } ``` ## Beispiel für Ereignisobjekt Das folgende Beispiel zeigt ein vollständiges `event`-Objekt: Dies ist ein Beispielaufruf für eine Standarddistribution und nicht für eine Multi-Tenant-Distribution. Bei Mehrmandantenverteilungen wird das `endpoint` Feld anstelle von verwendet. `distributionDomainName` Der Wert von `endpoint` ist der CloudFront Domänenname (z. B. d111111abcdef8.cloudfront.net) der Verbindungsgruppe, die dem Ereignis zugeordnet ist. **Anmerkung** Das `event`-Objekt ist die Eingabe für Ihre Funktion. Ihre Funktion gibt nur das `request`- oder `response`-Objekt zurück, nicht das vollständige `event`-Objekt. ``` { "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-Laufzeit-Features für CloudFront-Funktionen Die JavaScript-Laufzeitumgebung von CloudFront-Funktionen ist mit [ECMAScript (ES) Version 5.1](https://www.ecma-international.org/ecma-262/5.1/) kompatibel und unterstützt auch einige Features der ES-Versionen 6 bis 12. Wir empfehlen, die JavaScript-Laufzeitumgebung 2.0 für die neuesten Features zu verwenden. Die Features der JavaScript-Laufzeitumgebung 2.0 weisen im Vergleich zu 1.0 die folgenden Änderungen auf: + Puffermodul-Methoden sind verfügbar. + Die folgenden nicht standardmäßigen Prototyp-Methoden für Zeichenfolgen sind nicht verfügbar: + `String.prototype.bytesFrom()` + `String.prototype.fromBytes()` + `String.prototype.fromUTF8()` + `String.prototype.toBytes()` + `String.prototype.toUTF8()` + Das kryptografische Modul weist die folgenden Änderungen auf: + `hash.digest()` – Der Rückgabetyp wird in `Buffer` geändert, wenn keine Kodierung angegeben ist. + `hmac.digest()` – Der Rückgabetyp wird in `Buffer` geändert, wenn keine Kodierung angegeben ist. + Weitere Informationen zu den zusätzlichen neuen Features finden Sie unter [Features von JavaScript Runtime 2.0 für CloudFront-Funktionen](functions-javascript-runtime-20.md). **Topics** + [Funktionen von JavaScript Runtime 1.0](functions-javascript-runtime-10.md) + [Features von JavaScript Runtime 2.0](functions-javascript-runtime-20.md) # Funktionen von JavaScript Runtime 1.0 für CloudFront-Funktionen Die JavaScript-Laufzeitumgebung von CloudFront-Funktionen ist mit [ECMAScript (ES) Version 5.1](https://262.ecma-international.org/5.1/) kompatibel und unterstützt auch einige Features der ES-Versionen 6 bis 9. Sie enthält auch einige nicht standardmäßige Methoden, die nicht Teil der ES-Spezifikationen sind. In den folgenden Themen werden alle unterstützten Sprachfunktionen aufgeführt. **Topics** + [ ## Kernfunktionen ](#writing-functions-javascript-features-core) + [ ## Primitive Objekte ](#writing-functions-javascript-features-primitive-objects) + [ ## Integrierte Objekte ](#writing-functions-javascript-features-builtin-objects) + [ ## Fehlertypen ](#writing-functions-javascript-features-error-types) + [ ## Globale ](#writing-functions-javascript-features-globals) + [ ## Integrierten Module ](#writing-functions-javascript-features-builtin-modules) + [ ## Eingeschränkte Funktionen ](#writing-functions-javascript-features-restricted-features) ## Kernfunktionen Die folgenden Kern-Features von ES werden unterstützt. **Typen** Alle ES 5.1-Typen werden unterstützt. Dies umfasst boolesche Werte, Zahlen, Zeichenfolgen, Objekte, Arrays, Funktionen, Funktionskonstruktoren und reguläre Ausdrücke. **Operatoren** Alle ES 5.1-Operatoren werden unterstützt. Der Potenzierungsoperator (`**`) wird unterstützt. **Anweisungen** `const`- und `let`-Anweisungen werden nicht unterstützt. Die folgenden ES 5.1-Anweisungen werden unterstützt: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `return` + `switch` + `throw` + `try` + `var` + `while` + Bezeichnete Anweisungen **Literale** ES 6-Vorlagenliterale werden unterstützt: mehrzeilige Zeichenfolgen, Interpolation von Ausdrücken und Verschachtelungsvorlagen. **Funktionen** Alle Features von ES 5.1 werden unterstützt. ES 6-Pfeilfunktionen werden unterstützt, und die ES 6 Rest-Parametersyntax wird unterstützt. **Unicode** Quelltext und Zeichenfolgenliterale können Unicode-codierte Zeichen enthalten. Unicode-Code-Punkt-Escape-Sequenzen von sechs Zeichen (z. B. `\uXXXX`) werden ebenfalls unterstützt. **Strikter Modus** Funktionen arbeiten standardmäßig im strikten Modus, sodass Sie Ihrem Funktionscode keine `use strict`-Anweisung hinzufügen müssen. Dies können nicht geändert werden. ## Primitive Objekte Die folgenden primitiven Objekte von ES werden unterstützt. **Objekt** Die folgenden ES 5.1-Methoden für Objekte werden unterstützt: + `create` (ohne Eigenschaftenliste) + `defineProperties` + `defineProperty` + `freeze` + `getOwnPropertyDescriptor` + `getOwnPropertyNames` + `getPrototypeOf` + `hasOwnProperty` + `isExtensible` + `isFrozen` + `prototype.isPrototypeOf` + `isSealed` + `keys` + `preventExtensions` + `prototype.propertyIsEnumerable` + `seal` + `prototype.toString` + `prototype.valueOf` Die folgenden ES 6-Methoden für Objekte werden unterstützt: + `assign` + `is` + `prototype.setPrototypeOf` Die folgenden ES 8-Methoden für Objekte werden unterstützt: + `entries` + `values` **Zeichenfolge** Die folgenden ES 5.1-Methoden für Zeichenfolgen werden unterstützt: + `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` Die folgenden ES 6-Methoden für Zeichenfolgen werden unterstützt: + `fromCodePoint` + `prototype.codePointAt` + `prototype.endsWith` + `prototype.includes` + `prototype.repeat` + `prototype.startsWith` Die folgenden ES 8-Methoden für Zeichenfolgen werden unterstützt: + `prototype.padStart` + `prototype.padEnd` Die folgenden ES 9-Methoden für Zeichenfolgen werden unterstützt: + `prototype.trimStart` + `prototype.trimEnd` Die folgenden nicht standardmäßigen Methoden für Zeichenfolgen werden unterstützt: + `prototype.bytesFrom(array | string, encoding)` Erstellt eine Bytezeichenfolge aus einem Array von Oktetten oder einer codierten Zeichenfolge. Die Optionen für die Zeichenfolgencodierung sind `hex`, `base64` und `base64url`. + `prototype.fromBytes(start[, end])` Erstellt eine Unicode-Zeichenfolge aus einer Bytezeichenfolge, in der jedes Byte durch den entsprechenden Unicode-Codepunkt ersetzt wird. + `prototype.fromUTF8(start[, end])` Erstellt eine Unicode-Zeichenfolge aus einer UTF-8-codierten Bytezeichenfolge. Wenn die Codierung falsch ist, wird zurückgegebe `null`. + `prototype.toBytes(start[, end])` Erstellt eine Bytezeichenfolge aus einer Unicode-Zeichenfolge. Alle Zeichen müssen im Bereich von [0,255] liegen. Wenn nicht, wird zurückgegebe `null`. + `prototype.toUTF8(start[, end])` Erstellt eine UTF-8-codierte Bytezeichenfolge aus einer Unicode-Zeichenfolge. **Nummer** Alle ES 5.1-Methoden für Zahlen werden unterstützt. Die folgenden ES 6-Methoden für Zahlen werden unterstützt: + `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` ## Integrierte Objekte Die folgenden integrierten Objekte von ES werden unterstützt. **Math-Knoten** Alle Mathematikmethoden von ES 5.1 werden unterstützt. In der Laufzeitumgebung von CloudFront-Funktionen verwendet die `Math.random()`-Implementierung OpenBSD `arc4random`, das den Zeitstempel der Funktion als Startwert verwendet. Die folgenden ES 6-Mathematikmethoden werden unterstützt: + `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` **Datum** Alle `Date`-Features von ES 5.1 werden unterstützt. Aus Sicherheitsgründen gibt `Date` immer den gleichen Wert – die Startzeit der Funktion – während der Lebensdauer einer einzelnen Funktionsausführung zurück. Weitere Informationen finden Sie unter [Eingeschränkte Funktionen](#writing-functions-javascript-features-restricted-features). **Funktion** Die Methoden `apply`, `bind` und `call` werden unterstützt. Funktionskonstruktoren werden nicht unterstützt. **Reguläre Ausdrücke** Alle Features für reguläre Ausdrücke von ES 5.1 werden unterstützt. Die Sprache für reguläre Ausdrücke ist Perl-kompatibel. ES 9 benannte Aufnahmegruppen werden unterstützt. **JSON** Alle Funktionen von ES 5.1 JSON werden unterstützt, einschließlich `parse` und `stringify`. **Array** Die folgenden ES 5.1-Methoden für Arrays werden unterstützt: + `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` Die folgenden ES 6-Methoden für Arrays werden unterstützt: + `of` + `prototype.copyWithin` + `prototype.fill` + `prototype.find` + `prototype.findIndex` Die folgenden ES 7-Methoden für Arrays werden unterstützt: + `prototype.includes` **Eingegebene Arrays** Die folgenden von ES 6 eingegebenen Arrays werden unterstützt: + `Int8Array` + `Uint8Array` + `Uint8ClampedArray` + `Int16Array` + `Uint16Array` + `Int32Array` + `Uint32Array` + `Float32Array` + `Float64Array` + `prototype.copyWithin` + `prototype.fill` + `prototype.join` + `prototype.set` + `prototype.slice` + `prototype.subarray` + `prototype.toString` **ArrayBuffer** Die folgenden Methoden für `ArrayBuffer` werden unterstützt: + `prototype.isView` + `prototype.slice` **Promise** Die folgenden Methoden für Versprechen werden unterstützt: + `reject` + `resolve` + `prototype.catch` + `prototype.finally` + `prototype.then` **Crypto** Das kryptografische Modul bietet standardmäßige Hashing- und Hash-basierte HMAC-Helfer (Message Authentication Code). Sie können das Modul mit lade `require('crypto')`. Das Modul stellt die folgenden Methoden bereit, die sich genau wie ihre Gegenstücke von Node.js verhalten: + `createHash(algorithm)` + `hash.update(data)` + `hash.digest([encoding])` + `createHmac(algorithm, secret key)` + `hmac.update(data)` + `hmac.digest([encoding])` Weitere Informationen finden Sie unter [Krypto (Hash und HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) im Abschnitt über integrierte Module. **Konsole** Dies ist ein Hilfsobjekt zum Debuggen. Es unterstützt nur die `log()`-Methode, um Protokollnachrichten aufzuzeichnen. CloudFront Functions unterstützt keine Kommasyntax, wie z. B. `console.log('a', 'b')`. Verwenden Sie stattdessen das Format `console.log('a' + ' ' + 'b')`. ## Fehlertypen Die folgenden Fehlerobjekte werden unterstützt: + `Error` + `EvalError` + `InternalError` + `MemoryError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Globale Das `globalThis`-Objekt wird unterstützt. Die folgenden globalen Funktionen von ES 5.1 werden unterstützt: + `decodeURI` + `decodeURIComponent` + `encodeURI` + `encodeURIComponent` + `isFinite` + `isNaN` + `parseFloat` + `parseInt` Die folgenden globalen Konstanten werden unterstützt: + `NaN` + `Infinity` + `undefined` ## Integrierten Module Die folgenden integrierten Module werden unterstützt. **Topics** + [ ### Krypto (Hash und HMAC) ](#writing-functions-javascript-features-builtin-modules-crypto) + [ ### Abfragezeichenfolge ](#writing-functions-javascript-features-builtin-modules-query-string) ### Krypto (Hash und HMAC) Das kryptographische Modul (`crypto`) bietet standardmäßige Hashing- und HMAC-Helfer (Hash-basierter Nachrichtenauthentifizierungscode). Sie können das Modul mit lade `require('crypto')`. Das Modul bietet die folgenden Methoden, die sich genau wie ihre Gegenstücke von Node.js verhalten. **Hashing-Methoden** `crypto.createHash(algorithm)` Erstellt und gibt ein Hash-Objekt zurück, mit dem Sie Hash-Digests mit dem angegebenen Algorithmus generieren können: `md5`, `sha1` oder `sha256`. `hash.update(data)` Aktualisiert den Hash-Inhalt mit dem angegebenen `data`. `hash.digest([encoding])` Berechnet den Digest aller mit übergebenen Date `hash.update()`. Die Codierung kann `hex`, `base64` oder `base64url` sein. **HMAC-Methoden** `crypto.createHmac(algorithm, secret key)` Erstellt und gibt ein HMAC-Objekt zurück, das das angegebene `algorithm` und `secret key` verwendet. Der Algorithmus kann `md5`, `sha1` oder `sha256` sein. `hmac.update(data)` Aktualisiert den HMAC-Inhalt mit den angegebenen `data`. `hmac.digest([encoding])` Berechnet den Digest aller mit übergebenen Date `hmac.update()`. Die Codierung kann `hex`, `base64` oder `base64url` sein. ### Abfragezeichenfolge **Anmerkung** Das [CloudFront Functions-Ereignisobjekt](functions-event-structure.md) parst automatisch URL-Abfragezeichenfolgen für Sie. Das bedeutet, dass Sie dieses Modul in den meisten Fällen nicht verwenden müssen. Das Modul für Abfragezeichenfolgen (`querystring`) bietet Methoden zum Analysieren und Formatieren von URL-Abfragezeichenfolgen. Sie können das Modul mit lade `require('querystring')`. Das Modul bietet die folgenden Methoden. `querystring.escape(string)` URL-kodiert die angegebene `string` und gibt eine entflohene Abfragezeichenfolge zurück. Die Methode wird von `querystring.stringify()` verwendet und sollte nicht direkt verwendet werden. `querystring.parse(string[, separator[, equal[, options]]])` Analysiert eine Abfragezeichenfolge (`string`) und gibt ein Objekt zurück. Der `separator`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüssel- und Wertepaaren in der Abfragezeichenfolge. Standardmäßig ist dies `&`. Der `equal`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüsseln und Werten in der Abfragezeichenfolge. Standardmäßig ist dies `=`. Der `options`-Parameter ist ein Objekt mit den folgenden Schlüsseln: `decodeURIComponent function` Eine Funktion zum Entschlüsseln von prozentkodierten Zeichen in der Abfragezeichenfolge. Standardmäßig ist dies `querystring.unescape()`. `maxKeys number` Die maximale Anzahl der Schlüssel zum Parsen. Standardmäßig ist dies `1000`. Verwenden Sie den Wert `0`, um die Beschränkungen für das Zählen von Schlüsseln aufzuheben. Standardmäßig wird davon ausgegangen, dass prozentcodierte Zeichen innerhalb der Abfragezeichenfolge die UTF-8-Codierung verwenden. Ungültige UTF-8-Sequenzen werden durch das Ersatzzeichen `U+FFFD` ersetzt. Zum Beispiel für die folgende Abfragezeichenfolge: ``` 'name=value&abc=xyz&abc=123' ``` Der Rückgabewert von `querystring.parse()` ist: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` ist ein Alias für `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serialisiert ein `object` und gibt eine Abfragezeichenfolge zurück. Der `separator`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüssel- und Wertepaaren in der Abfragezeichenfolge. Standardmäßig ist dies `&`. Der `equal`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüsseln und Werten in der Abfragezeichenfolge. Standardmäßig ist dies `=`. Der `options`-Parameter ist ein Objekt mit den folgenden Schlüsseln: `encodeURIComponent function` Die Funktion, die zum Konvertieren von URL-unsicheren Zeichen in die prozentuale Kodierung in der Abfragezeichenfolge verwendet wird. Standardmäßig ist dies `querystring.escape()`. Standardmäßig werden Zeichen, die eine prozentuale Kodierung innerhalb der Abfragezeichenfolge erfordern, als UTF-8 codiert. Um eine andere Codierung zu verwenden, geben Sie die Option `encodeURIComponent` an. Zum Beispiel für den folgenden Code: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` Der Rückgabewert ist: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` ist ein Alias für `querystring.stringify()`. `querystring.unescape(string)` Dekodiert die prozentualen Zeichen der URL in der angegebenen `string` und gibt eine nicht entdeckene Abfragezeichenfolge zurück. Diese Methode wird von `querystring.parse()` verwendet und sollte nicht direkt verwendet werden. ## Eingeschränkte Funktionen Die folgenden JavaScript-Sprach-Features werden aufgrund von Sicherheitsbedenken entweder nicht unterstützt oder eingeschränkt. **Dynamische Codeauswertung** Die dynamische Codeauswertung wird nicht unterstützt. Sowohl `eval()`- als auch `Function`-Konstruktoren geben einen Fehler aus, wenn sie versucht werden. Zum Beispiel gibt `const sum = new Function('a', 'b', 'return a + b')` einen Fehler aus. **Timer ** Die Funktionen `setTimeout()`, `setImmediate()` und `clearTimeout()` werden nicht unterstützt. Es gibt keine Bestimmung, innerhalb einer Funktionsausführung zu verschieben oder zu ergeben. Ihre Funktion muss synchron bis zum Abschluss ausgeführt werden. **Datum und Zeitstempel** Aus Sicherheitsgründen besteht kein Zugang zu hochauflösenden Timern. Alle `Date`-Methoden zum Abfragen der aktuellen Uhrzeit geben während der Lebensdauer einer einzelnen Funktionsausführung immer den gleichen Wert zurück. Der zurückgegebene Zeitstempel ist die Zeit, zu der die Funktion gestartet wurde. Folglich können Sie die verstrichene Zeit in Ihrer Funktion nicht messen. **Zugriff auf das Dateisystem** Es gibt keinen Zugriff auf das Dateisystem. Zum Beispiel gibt es kein `fs`-Modul für den Dateisystemzugriff wie in Node.js. **Prozesszugriff** Es gibt keinen Prozesszugriff. Zum Beispiel gibt es kein globales `process`-Objekt für die Verarbeitung von Informationszugriffen wie in Node.js. **Umgebungsvariablen** Es gibt keinen Zugriff auf Umgebungsvariablen. Stattdessen können Sie CloudFront KeyValueStore verwenden, um einen zentralen Datenspeicher mit Schlüssel-Wert-Paaren für CloudFront Functions zu erstellen. CloudFront KeyValueStore ermöglicht dynamische Updates Ihrer Konfigurationsdaten, ohne dass Codeänderungen implementiert werden müssen. Sie müssen die [JavaScript-Laufzeitumgebung 2.0](functions-javascript-runtime-20.md) verwenden, um CloudFront KeyValueStore verwenden zu können. Weitere Informationen finden Sie unter [Amazon CloudFront Schlüsselwertspeicher](kvs-with-functions.md). **Netzwerkzugriff** Es gibt keine Unterstützung für Netzwerkaufrufe. Zum Beispiel werden XHR, HTTP(S) und Socket nicht unterstützt. # Features von JavaScript Runtime 2.0 für CloudFront-Funktionen Die JavaScript-Laufzeitumgebung von CloudFront-Funktionen ist mit [ECMAScript (ES) Version 5.1](https://262.ecma-international.org/5.1/) kompatibel und unterstützt auch einige Features der ES-Versionen 6 bis 12. Sie enthält auch einige nicht standardmäßige Methoden, die nicht Teil der ES-Spezifikationen sind. In den folgenden Themen werden alle unterstützten Features dieser Laufzeit aufgeführt. **Topics** + [ ## Kern-Features ](#writing-functions-javascript-features-core-20) + [ ## Primitive Objekte ](#writing-functions-javascript-features-primitive-objects-20) + [ ## Integrierte Objekte ](#writing-functions-javascript-features-builtin-objects-20) + [ ## Fehlertypen ](#writing-functions-javascript-features-error-types-20) + [ ## Globale ](#writing-functions-javascript-features-globals-20) + [ ## Integrierten Module ](#writing-functions-javascript-features-builtin-modules-20) + [ ## Eingeschränkte Features ](#writing-functions-javascript-features-restricted-features-20) ## Kern-Features Die folgenden Kern-Features von ES werden unterstützt. **Typen** Alle ES 5.1-Typen werden unterstützt. Dies umfasst boolesche Werte, Zahlen, Zeichenfolgen, Objekte, Arrays, Funktionen und reguläre Ausdrücke. **Operatoren** Alle ES 5.1-Operatoren werden unterstützt. Der Potenzierungsoperator (`**`) wird unterstützt. **Anweisungen** Die folgenden ES 5.1-Anweisungen werden unterstützt: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `label` + `return` + `switch` + `throw` + `try` + `var` + `while` Die folgenden ES 6-Anweisungen werden unterstützt: + `const` + `let` Die folgenden ES 8-Anweisungen werden unterstützt: + `async` + `await` `async`, `await`, `const` und `let` werden in der JavaScript-Laufzeitumgebung 2.0 unterstützt. `await` kann nur innerhalb von `async`-Funktionen verwendet werden. `async`-Argumente und -Schließungen werden nicht unterstützt. **Literale** ES 6-Vorlagenliterale werden unterstützt: mehrzeilige Zeichenfolgen, Interpolation von Ausdrücken und Verschachtelungsvorlagen. **Funktionen** Alle Features von ES 5.1 werden unterstützt. ES 6-Pfeilfunktionen werden unterstützt, und die ES 6 Rest-Parametersyntax wird unterstützt. **Unicode** Quelltext und Zeichenfolgenliterale können Unicode-codierte Zeichen enthalten. Unicode-Code-Punkt-Escape-Sequenzen von sechs Zeichen (z. B. `\uXXXX`) werden ebenfalls unterstützt. **Strikter Modus** Funktionen arbeiten standardmäßig im strikten Modus, sodass Sie Ihrem Funktionscode keine `use strict`-Anweisung hinzufügen müssen. Dies können nicht geändert werden. ## Primitive Objekte Die folgenden primitiven Objekte von ES werden unterstützt. **Objekt** Die folgenden ES 5.1-Methoden für Objekte werden unterstützt: + `Object.create()` (ohne Eigenschaftenliste) + `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()` Die folgenden ES 6-Methoden für Objekte werden unterstützt: + `Object.assign()` Die folgenden ES 8-Methoden für Objekte werden unterstützt: + `Object.entries()` + `Object.values()` Die folgenden ES-5.1-Prototyp-Methoden für Objekte werden unterstützt: + `Object.prototype.hasOwnProperty()` + `Object.prototype.isPrototypeOf()` + `Object.prototype.propertyIsEnumerable()` + `Object.prototype.toString()` + `Object.prototype.valueOf()` Die folgenden ES 6-Prototyp-Methoden für Objekte werden unterstützt: + `Object.prototype.is()` + `Object.prototype.setPrototypeOf()` **String** Die folgenden ES 5.1-Methoden für Zeichenfolgen werden unterstützt: + `String.fromCharCode()` Die folgenden ES 6-Methoden für Zeichenfolgen werden unterstützt: + `String.fromCodePoint()` Die folgenden ES-5.1-Prototyp-Methoden für Zeichenfolgen werden unterstützt: + `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()` Die folgenden ES 6-Prototyp-Methoden für Zeichenfolgen werden unterstützt: + `String.prototype.codePointAt()` + `String.prototype.endsWith()` + `String.prototype.includes()` + `String.prototype.repeat()` + `String.prototype.startsWith()` Die folgenden ES 8-Prototyp-Methoden für Zeichenfolgen werden unterstützt: + `String.prototype.padStart()` + `String.prototype.padEnd()` Die folgenden ES 9-Prototyp-Methoden für Zeichenfolgen werden unterstützt: + `String.prototype.trimStart()` + `String.prototype.trimEnd()` Die folgenden ES 12-Prototyp-Methoden für Zeichenfolgen werden unterstützt: + `String.prototype.replaceAll()` **Anmerkung** `String.prototype.replaceAll()` ist neu in JavaScript Runtime 2.0. **Anzahl** ALLE ES 5-Zahlen werden unterstützt. Die folgenden ES 6-Eigenschaften für Zahlen werden unterstützt: + `Number.EPSILON` + `Number.MAX_SAFE_INTEGER` + `Number.MIN_SAFE_INTEGER` + `Number.MAX_VALUE` + `Number.MIN_VALUE` + `Number.NaN` + `Number.NEGATIVE_INFINITY` + `Number.POSITIVE_INFINITY` Die folgenden ES 6-Methoden für Zahlen werden unterstützt: + `Number.isFinite()` + `Number.isInteger()` + `Number.isNaN()` + `Number.isSafeInteger()` + `Number.parseInt()` + `Number.parseFloat()` Die folgenden ES 5.1-Prototyp-Methoden für Zahlen werden unterstützt: + `Number.prototype.toExponential()` + `Number.prototype.toFixed()` + `Number.prototype.toPrecision()` Numerische ES 12-Trennzeichen werden unterstützt. Numerische ES 12-Trennzeichen sind neu in JavaScript Runtime 2.0. ## Integrierte Objekte Die folgenden integrierten Objekte von ES werden unterstützt. **Math-Knoten** Alle Mathematikmethoden von ES 5.1 werden unterstützt. In der Laufzeitumgebung von CloudFront-Funktionen verwendet die `Math.random()`-Implementierung OpenBSD `arc4random`, das den Zeitstempel der Funktion als Startwert verwendet. Die folgenden ES 6-Mathematikeigenschaften werden unterstützt: + `Math.E` + `Math.LN10` + `Math.LN2` + `Math.LOG10E` + `Math.LOG2E` + `Math.PI` + `Math.SQRT1_2` + `Math.SQRT2` Die folgenden ES 6-Mathematikmethoden werden unterstützt: + `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()` **Datum** Alle `Date`-Features von ES 5.1 werden unterstützt. Aus Sicherheitsgründen gibt `Date` immer den gleichen Wert – die Startzeit der Funktion – während der Lebensdauer einer einzelnen Funktionsausführung zurück. Weitere Informationen finden Sie unter [Eingeschränkte Funktionen](functions-javascript-runtime-10.md#writing-functions-javascript-features-restricted-features). **Funktion** Die folgenden ES-5.1-Prototyp-Methoden werden unterstützt: + `Function.prototype.apply()` + `Function.prototype.bind()` + `Function.prototype.call()` Funktionskonstruktoren werden nicht unterstützt. **Reguläre Ausdrücke** Alle Features für reguläre Ausdrücke von ES 5.1 werden unterstützt. Die Sprache für reguläre Ausdrücke ist Perl-kompatibel. Die folgenden ES-5.1-Prototyp-Zugriffseigenschaften werden unterstützt: + `RegExp.prototype.global` + `RegExp.prototype.ignoreCase` + `RegExp.protoype.multiline` + `RegExp.protoype.source` + `RegExp.prototype.sticky` + `RegExp.prototype.flags` **Anmerkung** `RegExp.prototype.sticky` und `RegExp.prototype.flags` sind neu in JavaScript Runtime 2.0. Die folgenden ES-5.1-Prototyp-Methoden werden unterstützt: + `RegExp.prototype.exec()` + `RegExp.prototype.test()` + `RegExp.prototype.toString()` + `RegExp.prototype[@@replace]()` + `RegExp.prototype[@@split]()` **Anmerkung** `RegExp.prototype[@@split]()` ist neu in JavaScript Runtime 2.0. Die folgenden ES-5.1-Instance-Eigenschaften werden unterstützt: + `lastIndex` ES 9 benannte Aufnahmegruppen werden unterstützt. **JSON** Die folgenden ES 5.1-Mathematikmethoden werden unterstützt: + `JSON.parse()` + `JSON.stringify()` **Array** Die folgenden ES 5.1-Methoden für Arrays werden unterstützt: + `Array.isArray()` Die folgenden ES 6-Methoden für Arrays werden unterstützt: + `Array.of()` Die folgenden ES-5.1-Prototyp-Methoden werden unterstützt: + `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()` Die folgenden ES 6-Prototyp-Methoden werden unterstützt: + `Array.prototype.copyWithin()` + `Array.prototype.fill()` + `Array.prototype.find()` + `Array.prototype.findIndex()` Die folgenden ES 7-Prototyp-Methoden werden unterstützt: + `Array.prototype.includes()` **Eingegebene Arrays** Die folgenden von ES 6 eingegebenen Array-Konstruktoren werden unterstützt: + `Float32Array` + `Float64Array` + `Int8Array` + `Int16Array` + `Int32Array` + `Uint8Array` + `Uint8ClampedArray` + `Uint16Array` + `Uint32Array` Die folgenden ES-6-Methoden werden unterstützt: + `TypedArray.from()` + `TypedArray.of()` **Anmerkung** `TypedArray.from()` und `TypedArray.of()` sind neu in JavaScript Runtime 2.0. Die folgenden ES 6-Prototyp-Methoden werden unterstützt: + `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()` **Anmerkung** `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()` und `TypedArray.prototype.some()` sind neu in JavaScript Runtime 2.0. **ArrayBuffer** Die folgenden ES 6-Methoden für ArrayBuffer werden unterstützt: + `isView()` Die folgenden ES 6-Prototypen-Methoden für ArrayBuffer werden unterstützt: + `ArrayBuffer.prototype.slice()` **Promise** Die folgenden ES 6-Methoden für Versprechen werden unterstützt: + `Promise.all()` + `Promise.allSettled()` + `Promise.any()` + `Promise.reject()` + `Promise.resolve()` + `Promise.race()` **Anmerkung** `Promise.all()`, `Promise.allSettled()`, `Promise.any()` und `Promise.race()` sind neu in JavaScript Runtime 2.0. Die folgenden ES 6-Prototyp-Methoden für Versprechen werden unterstützt: + `Promise.prototype.catch()` + `Promise.prototype.finally()` + `Promise.prototype.then()` **DataView** Die folgenden ES 6-Prototyp-Methoden werden unterstützt: + `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()` **Anmerkung** Alle Prototyp-Methoden von Dataview ES 6 sind neu in JavaScript Runtime 2.0. **Symbol** Die folgenden ES-6-Methoden werden unterstützt: + `Symbol.for()` + `Symbol.keyfor()` **Anmerkung** Alle Methoden von Symbol ES 6 sind neu in JavaScript Runtime 2.0. **Textdecoder** Die folgenden Prototyp-Methoden werden unterstützt: + `TextDecoder.prototype.decode()` Die folgenden Prototyp-Zugriffseigenschaften werden unterstützt: + `TextDecoder.prototype.encoding` + `TextDecoder.prototype.fatal` + `TextDecoder.prototype.ignoreBOM` **Text-Encoder** Die folgenden Prototyp-Methoden werden unterstützt: + `TextEncoder.prototype.encode()` + `TextEncoder.prototype.encodeInto()` ## Fehlertypen Die folgenden Fehlerobjekte werden unterstützt: + `Error` + `EvalError` + `InternalError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Globale Das `globalThis`-Objekt wird unterstützt. Die folgenden globalen Funktionen von ES 5.1 werden unterstützt: + `decodeURI()` + `decodeURIComponent()` + `encodeURI()` + `encodeURIComponent()` + `isFinite()` + `isNaN()` + `parseFloat()` + `parseInt()` Die folgenden globalen Funktionen von ES 6 werden unterstützt: + `atob()` + `btoa()` **Anmerkung** `atob()` und `btoa()` sind neu in JavaScript Runtime 2.0. Die folgenden globalen Konstanten werden unterstützt: + `NaN` + `Infinity` + `undefined` + `arguments` ## Integrierten Module Die folgenden integrierten Module werden unterstützt. **Topics** + [ ### Buffer ](#writing-functions-javascript-features-builtin-modules-buffer-20) + [ ### Abfragezeichenfolge ](#writing-functions-javascript-features-builtin-modules-query-string-20) + [ ### Crypto ](#writing-functions-javascript-features-builtin-modules-crypto-20) ### Buffer Das Modul bietet die folgenden Methoden: + `Buffer.alloc(size[, fill[, encoding]])` Weisen Sie einen `Buffer` zu. + `size`: Puffergröße. Geben Sie eine Ganzzahl ein. + `fill`: Optional. Geben Sie eine Zeichenfolge, `Buffer`, Uint8Array oder eine Ganzzahl ein. Der Standardwert ist `0`. + `encoding`: Optional. Wenn `fill` eine Zeichenfolge ist, geben Sie eine der folgenden Optionen ein: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.allocUnsafe(size)` Weisen Sie einen nicht initialisierten `Buffer` zu. + `size`: Geben Sie eine Ganzzahl ein. + `Buffer.byteLength(value[, encoding])` Gibt die Länge eines Werts in Byte zurück. + `value`: Eine Zeichenfolge, `Buffer`, TypedArray, Dataview oder Arraybuffer. + `encoding`: Optional. Wenn `value` eine Zeichenfolge ist, geben Sie eine der folgenden Optionen ein: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.compare(buffer1, buffer2)` Vergleichen Sie zwei `Buffer`, um Arrays besser sortieren zu können. Gibt `0` zurück, wenn sie identisch sind, `-1`, wenn `buffer1` an erster Stelle steht, oder `1`, wenn `buffer2` an erster Stelle steht. + `buffer1`: Geben Sie einen `Buffer` ein. + `buffer2`: Geben Sie einen anderen `Buffer` ein. + `Buffer.concat(list[, totalLength])` Verketten Sie mehrere `Buffer`. Gibt `0` zurück, wenn keiner vorhanden ist. Gibt bis zu `totalLength` zurück. + `list`: Geben Sie eine Liste von `Buffer`n ein. Beachten Sie, dass dies auf `totalLength` gekürzt wird. + `totalLength`: Optional. Geben Sie eine Ganzzahl ohne Vorzeichen ein. Wenn das Feld leer ist, wird die Summe der `Buffer`-Instances in der Liste verwendet. + `Buffer.from(array)` Erstellen Sie einen `Buffer` aus einem Array. + `array`: Geben Sie ein Byte-Array von `0` bis `255` ein. + `Buffer.from(arrayBuffer, byteOffset[, length]))` Erstellen Sie eine Ansicht von `arrayBuffer`, beginnend beim Versatz `byteOffset` mit der Länge `length`. + `arrayBuffer`: Geben Sie ein `Buffer`-Array ein. + `byteOffset`: Geben Sie eine Ganzzahl ein. + `length`: Optional. Geben Sie eine Ganzzahl ein. + `Buffer.from(buffer)` Erstellen Sie eine Kopie des `Buffer`s. + `buffer`: Geben Sie einen `Buffer` ein. + `Buffer.from(object[, offsetOrEncoding[, length]])` Erstellen Sie einen `Buffer` aus einem Objekt. Gibt `Buffer.from(object.valueOf(), offsetOrEncoding, length)` zurück, wenn `valueOf()` nicht dem Objekt entspricht. + `object`: Geben Sie ein Objekt ein. + `offsetOrEncoding`: Optional. Geben Sie eine Ganzzahl oder eine Kodierungszeichenfolge ein. + `length`: Optional. Geben Sie eine Ganzzahl ein. + `Buffer.from(string[, encoding])` Erstellen Sie einen `Buffer` aus einer Zeichenfolge. + `string`: Geben Sie eine Zeichenfolge ein. + `encoding`: Optional. Machen Sie eine der folgenden Eingaben: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.isBuffer(object)` Prüfen Sie, ob `object` ein Puffer ist. Gibt `true` oder `false` zurück. + `object`: Geben Sie ein Objekt ein. + `Buffer.isEncoding(encoding)` Prüfen Sie, ob `encoding` unterstützt wird. Gibt `true` oder `false` zurück. + `encoding`: Optional. Machen Sie eine der folgenden Eingaben: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. Das Modul bietet die folgenden Puffer-Prototyp-Methoden: + `Buffer.prototype.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])` Vergleichen Sie `Buffer` mit dem Ziel. Gibt `0` zurück, wenn sie identisch sind, `1`, wenn `buffer` an erster Stelle steht, oder `-1`, wenn `target` an erster Stelle steht. + `target`: Geben Sie einen `Buffer` ein. + `targetStart`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `targetEnd`: Optional. Geben Sie eine Ganzzahl ein. Die Standardeinstellung ist die `target`-Länge. + `sourceStart`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `sourceEnd`: Optional. Geben Sie eine Ganzzahl ein. Die Standardeinstellung ist die `Buffer`-Länge. + `Buffer.prototype.copy(target[, targetStart[, sourceStart[, sourceEnd]]])` Kopieren Sie den Puffer nach `target`. + `target`: Geben Sie einen `Buffer` oder `Uint8Array` ein. + `targetStart`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `sourceStart`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `sourceEnd`: Optional. Geben Sie eine Ganzzahl ein. Die Standardeinstellung ist die `Buffer`-Länge. + `Buffer.prototype.equals(otherBuffer)` Vergleichen Sie `Buffer` mit `otherBuffer`. Gibt `true` oder `false` zurück. + `otherBuffer`: Geben Sie eine Zeichenfolge ein. + `Buffer.prototype.fill(value[, offset[, end][, encoding])` Geben Sie für den `Buffer` den Wert `value` ein. + `value`: Geben Sie eine Zeichenfolge, einen `Buffer` oder eine Ganzzahl ein. + `offset`: Optional. Geben Sie eine Ganzzahl ein. + `end`: Optional. Geben Sie eine Ganzzahl ein. + `encoding`: Optional. Machen Sie eine der folgenden Eingaben: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.prototype.includes(value[, byteOffset][, encoding])` Suchen Sie nach `value` im `Buffer`. Gibt `true` oder `false` zurück. + `value`: Geben Sie eine Zeichenfolge, einen `Buffer`, ein `Uint8Array` oder eine Ganzzahl ein. + `byteOffset`: Optional. Geben Sie eine Ganzzahl ein. + `encoding`: Optional. Machen Sie eine der folgenden Eingaben: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.prototype.indexOf(value[, byteOffset][, encoding])` Suchen Sie nach dem ersten `value` im `Buffer`. Gibt `index` zurück, wenn er gefunden wurde, oder gibt `-1` zurück, wenn er nicht gefunden wurde. + `value`: Geben Sie eine Zeichenfolge, einen `Buffer`, ein Unit8Array oder eine Ganzzahl von 0 bis 255 ein. + `byteOffset`: Optional. Geben Sie eine Ganzzahl ein. + `encoding`: Optional. Geben Sie eine der folgenden Optionen ein, wenn `value` eine Zeichenfolge ist: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.prototype.lastIndexOf(value[, byteOffset][, encoding])` Suchen Sie nach dem letzten `value` im `Buffer`. Gibt `index` zurück, wenn er gefunden wurde, oder gibt `-1` zurück, wenn er nicht gefunden wurde. + `value`: Geben Sie eine Zeichenfolge, einen `Buffer`, ein Unit8Array oder eine Ganzzahl von 0 bis 255 ein. + `byteOffset`: Optional. Geben Sie eine Ganzzahl ein. + `encoding`: Optional. Geben Sie eine der folgenden Optionen ein, wenn `value` eine Zeichenfolge ist: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.prototype.readInt8(offset)` Lesen Sie `Int8` beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readIntBE(offset, byteLength)` Lesen Sie `Int` als Big-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Optional. Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.readInt16BE(offset)` Lesen Sie `Int16` als Big-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readInt32BE(offset)` Lesen Sie `Int32` als Big-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readIntLE(offset, byteLength)` Lesen Sie `Int` als Little-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.readInt16LE(offset)` Lesen Sie `Int16` als Little-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readInt32LE(offset)` Lesen Sie `Int32` als Little-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readUInt8(offset)` Lesen Sie `UInt8` beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readUIntBE(offset, byteLength)` Lesen Sie `UInt` als Big-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.readUInt16BE(offset)` Lesen Sie `UInt16` als Big-Endian beim `offset` vom `Buffer`. + + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readUInt32BE(offset)` Lesen Sie `UInt32` als Big-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readUIntLE(offset, byteLength)` Lesen Sie `UInt` als Little-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.readUInt16LE(offset)` Lesen Sie `UInt16` als Little-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readUInt32LE(offset)` Lesen Sie `UInt32` als Little-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readDoubleBE([offset])` Lesen Sie einen 64-Bit-Double-Wert als Big-Endian beim `offset` vom `Buffer`. + `offset`: Optional. Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readDoubleLE([offset])` Lesen Sie einen 64-Bit-Double-Wert als Little-Endian beim `offset` vom `Buffer`. + `offset`: Optional. Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readFloatBE([offset])` Lesen Sie einen 32-Bit-Float-Wert als Big-Endian beim `offset` vom `Buffer`. + `offset`: Optional. Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readFloatLE([offset])` Lesen Sie einen 32-Bit-Float-Wert als Little-Endian beim `offset` vom `Buffer`. + `offset`: Optional. Geben Sie eine Ganzzahl ein. + `Buffer.prototype.subarray([start[, end]])` Gibt eine Kopie vom `Buffer` zurück, der versetzt und mit einem neuen `start` und `end` zugeschnitten wurde. + `start`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `end`: Optional. Geben Sie eine Ganzzahl ein. Die Standardeinstellung ist die Pufferlänge. + `Buffer.prototype.swap16()` Tauschen Sie die Byte-Reihenfolge des `Buffer`-Arrays aus und behandeln Sie es wie ein Array von 16-Bit-Zahlen. Die `Buffer`-Länge muss durch 2 teilbar sein, sonst erhalten Sie eine Fehlermeldung. + `Buffer.prototype.swap32()` Tauschen Sie die Byte-Reihenfolge des `Buffer`-Arrays aus und behandeln Sie es wie ein Array von 32-Bit-Zahlen. Die `Buffer`-Länge muss durch 4 teilbar sein, sonst erhalten Sie eine Fehlermeldung. + `Buffer.prototype.swap64()` Tauschen Sie die Byte-Reihenfolge des `Buffer`-Arrays aus und behandeln Sie es wie ein Array von 64-Bit-Zahlen. Die `Buffer`-Länge muss durch 8 teilbar sein, sonst erhalten Sie eine Fehlermeldung. + `Buffer.prototype.toJSON()` Gibt `Buffer` als JSON zurück. + `Buffer.prototype.toString([encoding[, start[, end]]])` Konvertieren Sie den `Buffer` von `start` bis `end` in eine kodierte Zeichenfolge. + `encoding`: Optional. Machen Sie eine der folgenden Eingaben: `utf8`, `hex`, `base64` oder `base64url`. Der Standardwert ist `utf8`. + `start`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `end`: Optional. Geben Sie eine Ganzzahl ein. Die Standardeinstellung ist die Pufferlänge. + `Buffer.prototype.write(string[, offset[, length]][, encoding])` Schreiben Sie die codierte `string` in den `Buffer`, wenn genügend Platz vorhanden ist, oder die gekürzte `string`, wenn nicht genügend Platz vorhanden ist. + `string`: Geben Sie eine Zeichenfolge ein. + `offset`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `length`: Optional. Geben Sie eine Ganzzahl ein. Die Standardeinstellung ist die Länge der Zeichenfolge. + `encoding`: Optional. Geben Sie optional eine der folgenden Optionen ein: `utf8`, `hex`, `base64` oder `base64url`. Der Standardwert ist `utf8`. + `Buffer.prototype.writeInt8(value, offset, byteLength)` Schreiben Sie den `Int8`-`value` der `byteLength` beim `offset` des `Buffer`s. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeIntBE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeInt16BE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeInt32BE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeIntLE(offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeInt16LE(offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeInt32LE(offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUInt8(value, offset, byteLength)` Schreiben Sie den `UInt8`-`value` der `byteLength` beim `offset` des `Buffer`s. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUIntBE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUInt16BE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUInt32BE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUIntLE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUInt16LE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUInt32LE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeDoubleBE(value, [offset])` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `Buffer.prototype.writeDoubleLE(value, [offset])` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `Buffer.prototype.writeFloatBE(value, [offset])` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `Buffer.prototype.writeFloatLE(value, [offset])` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. Die folgenden Instanzmethoden werden unterstützt: + `buffer[index]` Rufen Sie Oktett (Byte) beim `index` im `Buffer` ab oder legen Sie es fest. + Rufen Sie eine Zahl von `0` bis `255` ab. Oder legen Sie eine Zahl von `0` bis `255` fest. Die folgenden Instanzeigenschaften werden unterstützt: + `buffer` Rufen Sie das `ArrayBuffer`-Objekt für den Puffer ab. + `byteOffset` Rufen Sie das `byteOffset` vom `Arraybuffer`-Objekt des Puffers ab. + `length` Rufen Sie die Byteanzahl des Puffers ab. **Anmerkung** Alle Puffermodul-Methoden sind neu in JavaScript Runtime 2.0. ### Abfragezeichenfolge **Anmerkung** Das [CloudFront Functions-Ereignisobjekt](functions-event-structure.md) parst automatisch URL-Abfragezeichenfolgen für Sie. Das bedeutet, dass Sie dieses Modul in den meisten Fällen nicht verwenden müssen. Das Modul für Abfragezeichenfolgen (`querystring`) bietet Methoden zum Analysieren und Formatieren von URL-Abfragezeichenfolgen. Sie können das Modul mit lade `require('querystring')`. Das Modul bietet die folgenden Methoden. `querystring.escape(string)` URL-kodiert die angegebene `string` und gibt eine entflohene Abfragezeichenfolge zurück. Die Methode wird von `querystring.stringify()` verwendet und sollte nicht direkt verwendet werden. `querystring.parse(string[, separator[, equal[, options]]])` Analysiert eine Abfragezeichenfolge (`string`) und gibt ein Objekt zurück. Der `separator`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüssel- und Wertepaaren in der Abfragezeichenfolge. Standardmäßig ist dies `&`. Der `equal`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüsseln und Werten in der Abfragezeichenfolge. Standardmäßig ist dies `=`. Der `options`-Parameter ist ein Objekt mit den folgenden Schlüsseln: `decodeURIComponent function` Eine Funktion zum Entschlüsseln von prozentkodierten Zeichen in der Abfragezeichenfolge. Standardmäßig ist dies `querystring.unescape()`. `maxKeys number` Die maximale Anzahl der Schlüssel zum Parsen. Standardmäßig ist dies `1000`. Verwenden Sie den Wert `0`, um die Beschränkungen für das Zählen von Schlüsseln aufzuheben. Standardmäßig wird davon ausgegangen, dass prozentcodierte Zeichen innerhalb der Abfragezeichenfolge die UTF-8-Codierung verwenden. Ungültige UTF-8-Sequenzen werden durch das Ersatzzeichen `U+FFFD` ersetzt. Zum Beispiel für die folgende Abfragezeichenfolge: ``` 'name=value&abc=xyz&abc=123' ``` Der Rückgabewert von `querystring.parse()` ist: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` ist ein Alias für `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serialisiert ein `object` und gibt eine Abfragezeichenfolge zurück. Der `separator`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüssel- und Wertepaaren in der Abfragezeichenfolge. Standardmäßig ist dies `&`. Der `equal`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüsseln und Werten in der Abfragezeichenfolge. Standardmäßig ist dies `=`. Der `options`-Parameter ist ein Objekt mit den folgenden Schlüsseln: `encodeURIComponent function` Die Funktion, die zum Konvertieren von URL-unsicheren Zeichen in die prozentuale Kodierung in der Abfragezeichenfolge verwendet wird. Standardmäßig ist dies `querystring.escape()`. Standardmäßig werden Zeichen, die eine prozentuale Kodierung innerhalb der Abfragezeichenfolge erfordern, als UTF-8 codiert. Um eine andere Codierung zu verwenden, geben Sie die Option `encodeURIComponent` an. Zum Beispiel für den folgenden Code: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` Der Rückgabewert ist: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` ist ein Alias für `querystring.stringify()`. `querystring.unescape(string)` Dekodiert die prozentualen Zeichen der URL in der angegebenen `string` und gibt eine nicht entdeckene Abfragezeichenfolge zurück. Diese Methode wird von `querystring.parse()` verwendet und sollte nicht direkt verwendet werden. ### Crypto Das kryptographische Modul (`crypto`) bietet standardmäßige Hashing- und HMAC-Helfer (Hash-basierter Nachrichtenauthentifizierungscode). Sie können das Modul mit lade `require('crypto')`. **Hashing-Methoden** `crypto.createHash(algorithm)` Erstellt und gibt ein Hash-Objekt zurück, mit dem Sie Hash-Digests mit dem angegebenen Algorithmus generieren können: `md5`, `sha1` oder `sha256`. `hash.update(data)` Aktualisiert den Hash-Inhalt mit dem angegebenen `data`. `hash.digest([encoding])` Berechnet den Digest aller mit übergebenen Date `hash.update()`. Die Codierung kann `hex`, `base64` oder `base64url` sein. **HMAC-Methoden** `crypto.createHmac(algorithm, secret key)` Erstellt und gibt ein HMAC-Objekt zurück, das das angegebene `algorithm` und `secret key` verwendet. Der Algorithmus kann `md5`, `sha1` oder `sha256` sein. `hmac.update(data)` Aktualisiert den HMAC-Inhalt mit den angegebenen `data`. `hmac.digest([encoding])` Berechnet den Digest aller mit übergebenen Date `hmac.update()`. Die Codierung kann `hex`, `base64` oder `base64url` sein. ## Eingeschränkte Features Die folgenden JavaScript-Sprach-Features werden aufgrund von Sicherheitsbedenken entweder nicht unterstützt oder eingeschränkt. **Dynamische Codeauswertung** Die dynamische Codeauswertung wird nicht unterstützt. Sowohl `eval()`- als auch `Function`-Konstruktoren geben einen Fehler aus, wenn sie versucht werden. Zum Beispiel gibt `const sum = new Function('a', 'b', 'return a + b')` einen Fehler aus. **Timer ** Die Funktionen `setTimeout()`, `setImmediate()` und `clearTimeout()` werden nicht unterstützt. Es gibt keine Bestimmung, innerhalb einer Funktionsausführung zu verschieben oder zu ergeben. Ihre Funktion muss synchron bis zum Abschluss ausgeführt werden. **Datum und Zeitstempel** Aus Sicherheitsgründen besteht kein Zugang zu hochauflösenden Timern. Alle `Date`-Methoden zum Abfragen der aktuellen Uhrzeit geben während der Lebensdauer einer einzelnen Funktionsausführung immer den gleichen Wert zurück. Der zurückgegebene Zeitstempel ist die Zeit, zu der die Funktion gestartet wurde. Folglich können Sie die verstrichene Zeit in Ihrer Funktion nicht messen. **Zugriff auf das Dateisystem** Es gibt keinen Zugriff auf das Dateisystem. Zum Beispiel gibt es kein `fs`-Modul für den Dateisystemzugriff wie in Node.js. **Prozesszugriff** Es gibt keinen Prozesszugriff. Zum Beispiel gibt es kein globales `process`-Objekt für die Verarbeitung von Informationszugriffen wie in Node.js. **Umgebungsvariablen** Es gibt keinen Zugriff auf Umgebungsvariablen. Stattdessen können Sie CloudFront KeyValueStore verwenden, um einen zentralen Datenspeicher mit Schlüssel-Wert-Paaren für CloudFront Functions zu erstellen. CloudFront KeyValueStore ermöglicht dynamische Updates Ihrer Konfigurationsdaten, ohne dass Codeänderungen implementiert werden müssen. Weitere Informationen finden Sie unter [Amazon CloudFront Schlüsselwertspeicher](kvs-with-functions.md). **Netzwerkzugriff** Es gibt keine Unterstützung für Netzwerkaufrufe. Zum Beispiel werden XHR, HTTP(S) und Socket nicht unterstützt. # Hilfsmethoden für Schlüsselwertspeicher **Anmerkung** Aufrufe von Hilfsmethoden zum Speichern von Schlüsselwerten aus CloudFront Functions lösen kein AWS CloudTrail Datenereignis aus. Diese Ereignisse werden nicht im CloudTrail Ereignisverlauf protokolliert. Weitere Informationen finden Sie unter [Protokollieren von API-Aufrufen in Amazon CloudFront mit AWS CloudTrail](logging_using_cloudtrail.md). Dieser Abschnitt gilt, wenn Sie den [CloudFront Key Value Store](kvs-with-functions.md) verwenden, um Schlüsselwerte in die von Ihnen erstellte Funktion aufzunehmen. CloudFront Functions verfügt über ein Modul, das drei Hilfsmethoden zum Lesen von Werten aus dem Schlüsselwertspeicher bereitstellt. Um dieses Modul im Funktionscode zu verwenden, stellen Sie sicher, dass Sie der Funktion [einen Schlüsselwertspeicher zugeordnet](kvs-with-functions-associate.md) haben. Fügen Sie als Nächstes die folgenden Anweisungen in die ersten Zeilen des Funktionscodes ein: ``` import cf from 'cloudfront'; const kvsHandle = cf.kvs(); ``` ## `get()`-Methode Verwenden Sie diese Methode, um den Schlüsselwert für den Schlüsselnamen abzurufen, den Sie angeben. **Anforderung** ``` get("key", options); ``` + `key`: Der Name des Schlüssels, dessen Wert abgerufen werden muss + `options`: Es gibt eine Option, `format`. Diese stellt sicher, dass die Funktion die Daten korrekt analysiert. Mögliche Werte: + `string`: (Standard) UTF8 codiert + `json` + `bytes`: Roher Binärdatenpuffer **Beispiel anfordern** ``` const value = await kvsHandle.get("myFunctionKey", { format: "string"}); ``` **Antwort** Die Antwort ist ein `promise`, das zu einem Wert in dem von `options` angeforderten Format aufgelöst wird. Standardmäßig wird der Wert als Zeichenfolge zurückgegeben. ### Fehlerbehandlung Die `get()`-Methode gibt einen Fehler zurück, wenn der von Ihnen angeforderte Schlüssel nicht im zugehörigen Schlüsselwertspeicher vorhanden ist. Um dieses Problem zu beheben, können Sie Ihrem Code einen `try`- und `catch`-Block hinzufügen. **Warnung** Die Verwendung von Promise-Kombinatoren (z. B. `Promise.all`, `Promise.any`) und Promise-Verkettungsmethoden (z. B. `then` und `catch`) kann eine hohe Auslastung des Funktionsspeichers erfordern. Wenn Ihre Funktion das [maximale Funktionsspeicherkontingent](cloudfront-limits.md#limits-functions) überschreitet, kann sie nicht ausgeführt werden. Um diesen Fehler zu vermeiden, empfehlen wir, die `await`-Syntax sequentiell oder in Schleifen zu verwenden, um mehrere Werte anzufordern. **Beispiel** ``` var value1 = await kvs.get('key1'); var value2 = await kvs.get('key2'); ``` Derzeit verbessert die Verwendung von Promise-Kombinatoren zum Abrufen mehrerer Werte die Leistung nicht, wie im folgenden Beispiel. ``` var values = await Promise.all([kvs.get('key1'), kvs.get('key2'),]); ``` ## `exists()`-Methode Verwenden Sie diese Methode, um zu ermitteln, ob der Schlüssel im Schlüsselwertspeicher vorhanden ist. **Anforderung** ``` exists("key"); ``` **Beispiel anfordern** ``` const exist = await kvsHandle.exists("myFunctionkey"); ``` **Antwort** Die Antwort ist ein `promise`, das einen booleschen Wert (`true` oder `false`) zurückgibt. Dieser Wert gibt an, ob der Schlüssel im Schlüsselwertspeicher vorhanden ist. ## `meta()`-Methode Verwenden Sie diese Methode, um Metadaten über den Schlüsselwertspeicher zurückzugeben. **Anforderung** ``` meta(); ``` **Beispiel anfordern** ``` const meta = await kvsHandle.meta(); ``` **Antwort** Die Antwort ist ein `promise`, das in ein Objekt mit den folgenden Eigenschaften aufgelöst wird: + `creationDateTime`: Erstellungsdatum und -uhrzeit des Schlüsselwertspeichers im ISO 8601-Format. + `lastUpdatedDateTime`: Datum und Uhrzeit der letzten Synchronisierung des Schlüsselwertspeichers mit der Quelle im ISO 8601-Format. Der Wert beinhaltet nicht die Ausbreitungszeit bis zum Edge. + `keyCount`: Die Gesamtzahl der Schlüssel im KVS nach der letzten Synchronisierung mit der Quelle. **Beispiel für eine Antwort** ``` {keyCount:3,creationDateTime:2023-11-30T23:07:55.765Z,lastUpdatedDateTime:2023-12-15T03:57:52.411Z} ``` # Hilfsmethoden für die Änderung des Ursprungs Dieser Abschnitt gilt, wenn Sie den für die Anfrage verwendeten Ursprung in Ihrem CloudFront Functions-Code dynamisch aktualisieren oder ändern. Sie können den Ursprung nur auf *Anfrage des Betrachters aktualisieren. Dies* CloudFront gilt nur für Funktionen. CloudFront Functions verfügt über ein Modul, das Hilfsmethoden zur dynamischen Aktualisierung oder Änderung des Ursprungs bereitstellt. Um dieses Modul zu verwenden, erstellen Sie eine CloudFront Funktion mit JavaScript Runtime 2.0 und fügen Sie die folgende Anweisung in die erste Zeile des Funktionscodes ein: ``` import cf from 'cloudfront'; ``` Weitere Informationen finden Sie unter [Features von JavaScript Runtime 2.0 für CloudFront-Funktionen](functions-javascript-runtime-20.md). **Anmerkung** Auf den Seiten der Test-API und Testkonsole wird nicht getestet, ob eine Ursprungsänderung stattgefunden hat. Durch das Testen wird jedoch sichergestellt, dass der Funktionscode fehlerfrei ausgeführt wird. ## Wählen Sie zwischen CloudFront Functions und Lambda @Edge Sie können Ihre Ursprünge aktualisieren, indem Sie entweder CloudFront Functions oder Lambda @Edge verwenden. Wenn Sie CloudFront Functions verwenden, um Ursprünge zu aktualisieren, verwenden Sie den *Viewer-Request-Event-Trigger*, was bedeutet, dass diese Logik bei jeder Anfrage ausgeführt wird, wenn diese Funktion verwendet wird. Bei der Verwendung von Lambda@Edge befinden sich die Funktionen zur Aktualisierung des Ursprungs im Ereignisauslöser für *Ursprungsanforderungen*, sodass diese Logik nur bei Cache-Fehlern ausgeführt wird. Ihre Wahl hängt weitgehend von Ihrer Arbeitslast und der bestehenden Nutzung von CloudFront Functions und Lambda @Edge in Ihren Distributionen ab. Die folgenden Überlegungen können Ihnen bei der Entscheidung helfen, ob Sie CloudFront Functions oder Lambda @Edge verwenden möchten, um Ihre Ursprünge zu aktualisieren. CloudFront Functions ist in den folgenden Situationen am nützlichsten: + Wenn Ihre Anfragen dynamisch sind (was bedeutet, dass sie nicht zwischengespeichert werden können) und immer an den Ursprung weitergeleitet werden. CloudFront Functions bietet eine bessere Leistung und niedrigere Gesamtkosten. + Wenn Sie bereits über eine CloudFront Viewer-Anforderungsfunktion verfügen, die bei jeder Anfrage ausgeführt wird, können Sie die ursprüngliche Aktualisierungslogik zur vorhandenen Funktion hinzufügen. Informationen zur Verwendung von CloudFront Funktionen zur Aktualisierung von Ursprüngen finden Sie in den folgenden Themen in den Hilfsmethoden. Lambda@Edge ist in folgenden Situationen am besten geeignet: + Wenn Sie Inhalte haben, die in hohem Maße zwischengespeichert werden können, kann Lambda @Edge kostengünstiger sein, da es nur bei Cache-Fehlern ausgeführt wird, während CloudFront Functions bei jeder Anfrage ausgeführt wird. + Wenn Sie bereits über eine Lambda@Edge-Funktion für Ursprungsanforderungen verfügen, können Sie die Ursprungsaktualisierungslogik zur vorhandenen Funktion hinzufügen. + Diese Option ist auch von Vorteil, wenn Ihre Ursprungsaktualisierungslogik das Abrufen von Daten aus Datenquellen von Drittanbietern wie Amazon DynamoDB oder Amazon S3 erfordert. Weitere Informationen zu Lambda@Edge finden Sie unter [Anpassen am Edge mit Lambda@Edge](lambda-at-the-edge.md). ## updateRequestOrigin() -Methode Verwenden Sie die Methode `updateRequestOrigin()`, um die Ursprungseinstellungen für eine Anforderung zu aktualisieren. Sie können diese Methode verwenden, um bestehende Ursprungseigenschaften für Ursprünge zu aktualisieren, die bereits in Ihrer Distribution definiert sind, oder um einen neuen Ursprung für die Anforderung zu definieren. Geben Sie hierfür die zu ändernden Eigenschaften an. **Wichtig** Alle Einstellungen, die Sie in der Methode `updateRequestOrigin()` nicht angeben, werden aus der vorhandenen Ursprungskonfiguration *übernommen*. Der von der `updateRequestOrigin()` Methode festgelegte Ursprung kann ein beliebiger HTTP-Endpunkt sein und muss kein vorhandener Ursprung in Ihrer CloudFront Distribution sein. **Hinweise** Wenn Sie einen Ursprung aktualisieren, der Teil einer Ursprungsgruppe ist, wird nur der *primäre Ursprung* der Ursprungsgruppe aktualisiert. Der sekundäre Ursprung bleibt unverändert. Jeder Antwortcode des geänderten Ursprungs, der den Failover-Kriterien entspricht, löst einen Failover zum sekundären Ursprung aus. Wenn Sie den Ursprungstyp ändern und OAC aktiviert ist, stellen Sie sicher, dass der Ursprungstyp in `originAccessControlConfig` mit dem neuen Ursprungstyp übereinstimmt. Sie können die Methode `updateRequestOrigin()` nicht verwenden, um [VPC-Ursprünge](private-content-vpc-origins.md) zu aktualisieren. Eine solche Anforderung würde fehlschlagen. **Anforderung** ``` updateRequestOrigin({origin properties}) ``` `origin properties` kann die folgenden Werte enthalten: **domainName (optional)** Der Domänenname des Ursprungs. Bei fehlender Angabe wird der Domainname des zugewiesenen Ursprungs verwendet. **Für benutzerdefinierte Ursprünge** Geben Sie einen DNS-Domainnamen an, z. B. `www.example.com`. Der Domainname darf keinen Doppelpunkt (`:`) enthalten und darf keine IP-Adresse sein. Der Domänenname kann bis zu 253 Zeichen lang sein. **Für S3-Ursprünge** Geben Sie den DNS-Domainnamen des Amazon-S3-Buckets an, z. B. `amzn-s3-demo-bucket.s3.eu-west-1.amazonaws.com`. Der Name kann bis zu 128 Zeichen lang sein und muss in Kleinbuchstaben geschrieben werden. **HostHeader (optional, für benutzerdefinierte Ursprünge, die nicht zu S3 gehören)** Der Host-Header, der verwendet werden soll, wenn die Anfrage an den Ursprung gestellt wird. Wenn dies nicht angegeben wird, wird der Wert aus dem DomainName-Parameter verwendet. Wenn weder der Host-Header noch der Domain-Name-Parameter angegeben werden, wird der Domainname des zugewiesenen Ursprungs verwendet oder der Host-Header der eingehenden Anfrage, wenn die FTO-Richtlinie (Forward to Origin) den Host einschließt. Der Host-Header darf keinen Doppelpunkt (`:`) enthalten und darf keine IP-Adresse sein. Der Host-Header kann bis zu 253 Zeichen lang sein. **originPath (optional)** Der Verzeichnispfad auf dem Ursprung, aus dem die Anforderung den Inhalt abrufen soll. Der Pfad sollte mit einem Schrägstrich (/) beginnen, aber nicht damit enden. Zum Beispiel sollte er nicht mit `example-path/` enden. Bei fehlender Angabe wird der Ursprungspfad des zugewiesenen Ursprungs verwendet. **Für benutzerdefinierte Ursprünge** Der Pfad sollte URL-kodiert sein und eine maximale Länge von 255 Zeichen haben. **customHeaders (optional)** Sie können benutzerdefinierte Header in die Anforderung aufnehmen, indem Sie für jeden benutzerdefinierten Header einen Header-Namen und einen -Wert angeben. Das Format unterscheidet sich von dem der Anforderungs- und Antwortheader in der Ereignisstruktur. Verwenden Sie die folgende Syntax für das Schlüssel-Wert-Paar: ``` {"key1": "value1", "key2": "value2", ...} ``` Sie können keine Header hinzufügen, die nicht erlaubt sind, und ein Header mit dem gleichen Namen kann in den `headers` eingehender Anforderungen nicht vorhanden sein. Der Headername muss im Funktionscode in Kleinbuchstaben geschrieben werden. Wenn CloudFront Functions das Ereignisobjekt wieder in eine HTTP-Anforderung konvertiert, wird der erste Buchstabe jedes Worts in Header-Namen groß geschrieben und die Wörter werden durch einen Bindestrich getrennt. Wenn der Funktionscode beispielsweise einen Header mit dem Namen`example-header-name`, CloudFront konvertiert diesen `Example-Header-Name` in der HTTP-Anfrage in einen Header hinzufügt. Weitere Informationen erhalten Sie unter [Benutzerdefinierte Header, die CloudFront nicht zu Ursprungsanforderungen hinzufügen kann](add-origin-custom-headers.md#add-origin-custom-headers-denylist) und [Einschränkungen für Edge-Funktionen](edge-functions-restrictions.md). Bei fehlender Angabe werden benutzerdefinierte Header des zugewiesenen Ursprungs verwendet. **connectionAttempts (optional)** Gibt an, wie oft CloudFront versucht wird, eine Verbindung zum Ursprung herzustellen. Der Mindestwert ist 1 und der Höchstwert 3. Bei fehlender Angabe wird die Anzahl von Verbindungsversuchen des zugewiesenen Ursprungs verwendet. **originShield (optional)** Dadurch wird CloudFront Origin Shield aktiviert oder aktualisiert. Die Verwendung von Origin Shield kann dazu beitragen, die Belastung Ihres Ursprungs zu reduzieren. Weitere Informationen finden Sie unter [Verwenden Sie Amazon CloudFront Origin Shield](origin-shield.md). Bei fehlender Angabe werden die Origin-Shield-Einstellungen des zugewiesenen Ursprungs verwendet. **aktiviert (erforderlich)** Boolescher Ausdruck zur Aktivierung oder Deaktivierung von Origin Shield. Akzeptierte Werte sind `true` oder `false`. **Region (erforderlich, wenn aktiviert)** Das AWS-Region für Origin Shield. Geben Sie die AWS-Region an, die die niedrigste Latenz zu Ihrem Ursprung aufweist. Verwenden Sie den Regionscode, nicht den Namen der Region. Geben Sie beispielsweise `us-east-2` für die Region USA Ost (Ohio) an. Wenn du CloudFront Origin Shield aktivierst, musst du das AWS-Region dafür angeben. Eine Liste der verfügbaren AWS-Regionen und Hilfe bei der Auswahl der besten Region für Ihren Ursprung finden Sie unter [Wähle die AWS Region für Origin Shield](origin-shield.md#choose-origin-shield-region). **originAccessControlConfig (optional)** Die eindeutige Kennung der Ursprungszugriffssteuerung (OAC) für diesen Ursprung. Dies wird nur verwendet, wenn der Ursprung ein CloudFront OAC unterstützt, z. B. Amazon S3, Lambda-Funktion URLs und MediaStore MediaPackage V2. Bei fehlender Angabe werden die OAC-Einstellungen des zugewiesenen Ursprungs verwendet. Die veraltete Ursprungszugriffsidentität (OAI) wird nicht unterstützt. Weitere Informationen finden Sie unter [Beschränken des Zugriffs auf einen AWS -Ursprung](private-content-restricting-access-to-origin.md). **aktiviert (erforderlich)** Boolescher Ausdruck zum Aktivieren oder Deaktivieren von OAC. Akzeptierte Werte sind `true` oder `false`. **signingBehavior (erforderlich, wenn aktiviert)** Gibt an, welche Anfragen CloudFront signiert werden (fügt Authentifizierungsinformationen hinzu). Geben Sie `always` für den häufigsten Anwendungsfall an. Weitere Informationen finden Sie unter [Erweiterte Einstellungen für die Ursprungszugriffssteuerung](private-content-restricting-access-to-s3.md#oac-advanced-settings-s3). Folgende Werte sind in diesem Feld möglich: + `always`— CloudFront signiert alle ursprünglichen Anfragen und überschreibt dabei den `Authorization` Header der Viewer-Anfrage, falls vorhanden. + `never`— signiert CloudFront keine ursprünglichen Anfragen. Dieser Wert deaktiviert die Ursprungszugriffssteuerung für den Ursprung. + `no-override`— Wenn die Viewer-Anfrage den `Authorization` Header nicht enthält, wird die ursprüngliche Anfrage CloudFront signiert. Wenn die Viewer-Anfrage den `Authorization` Header enthält, wird die ursprüngliche Anfrage CloudFront nicht signiert und stattdessen der `Authorization` Header aus der Viewer-Anfrage weitergegeben. **Warnung** Um den `Authorization`-Header aus der Viewer-Anforderung zu übergeben, müssen Sie ihn einer Ursprungsanforderungsrichtlinie für alle Cache-Verhaltensweisen hinzufügen, die Ursprünge verwenden, die dieser Ursprungszugriffssteuerung zugeordnet sind. Weitere Informationen finden Sie unter [Steuern von Ursprungsanforderungen anhand einer Richtlinie](controlling-origin-requests.md). **signingProtocol (erforderlich, wenn aktiviert)** Das Signaturprotokoll des OAC, das festlegt, wie Anfragen CloudFront signiert (authentifiziert) werden. Der einzige gültige Wert ist `sigv4`. **originType (erforderlich, wenn aktiviert)** Der Typ des Ursprungs für diese OAC. Gültige Werte sind: `s3`, `mediapackagev2`, `mediastore` und `lambda`. **Timeouts (optional)** Timeouts, die Sie angeben können, wie lange versucht CloudFront werden soll, darauf zu warten, dass Origins antwortet oder Daten sendet. Bei fehlender Angabe werden die Timeout-Einstellungen des zugewiesenen Ursprungs verwendet. Sofern nicht anders vermerkt, unterstützen diese Timeouts sowohl benutzerdefinierte Ursprünge als auch Amazon-S3-Ursprünge. **readTimeout (optional)** `readTimeout` gilt für die beiden folgenden Werte: + Wie lange (in Sekunden) auf eine Antwort CloudFront gewartet wird, nachdem eine Anfrage an den Ursprung weitergeleitet wurde. + Wie lange (in Sekunden) nach dem Empfang eines Antwortpakets vom Ursprung und vor dem Empfang des nächsten Pakets CloudFront gewartet wird. Das Mindestwert für das Timeout ist 1 Sekunde und der Höchstwert 120 Sekunden. Weitere Informationen finden Sie unter [Antwort-Timeout](DownloadDistValuesOrigin.md#DownloadDistValuesOriginResponseTimeout). **responseCompletionTimeout (Optional)** Die Zeit (in Sekunden), während der eine Anfrage vom CloudFront Absender geöffnet bleiben und auf eine Antwort warten kann. Wenn bis zu diesem Zeitpunkt noch keine vollständige Antwort vom Ursprung eingegangen ist, wird die Verbindung CloudFront beendet. Der Wert für `responseCompletionTimeout` muss größer oder gleich dem für `readTimeout` angegebenen Wert sein. Weitere Informationen finden Sie unter [Timeout für den Abschluss der Antwort](DownloadDistValuesOrigin.md#response-completion-timeout). **keepAliveTimeout (Optional)** Dieses Timeout gilt nur für benutzerdefinierte Ursprünge, nicht für Amazon-S3-Ursprünge. (Bei S3-Ursprungskonfigurationen werden diese Einstellungen ignoriert.) Das `keepAliveTimeout` gibt an, wie lange versucht CloudFront werden soll, die Verbindung zum Ursprung aufrechtzuerhalten, nachdem das letzte Paket der Antwort empfangen wurde. Das Mindestwert für das Timeout ist 1 Sekunde und der Höchstwert 120 Sekunden. Weitere Informationen finden Sie unter [Keep-Alive-Timeout (nur benutzerdefinierte und VPC-Ursprünge)](DownloadDistValuesOrigin.md#DownloadDistValuesOriginKeepaliveTimeout). **connectionTimeout (optional)** Die Anzahl der Sekunden, die CloudFront gewartet wird, wenn versucht wird, eine Verbindung zum Ursprung herzustellen. Das Mindestwert für das Timeout ist 1 Sekunde und der Höchstwert 10 Sekunden. Weitere Informationen finden Sie unter [Verbindungstimeout](DownloadDistValuesOrigin.md#origin-connection-timeout). **customOriginConfig (Optional)** Verwenden Sie `customOriginConfig`, um Verbindungseinstellungen für Ursprünge anzugeben, die *kein* Amazon-S3-Bucket sind. Es gibt eine Ausnahme: Sie können diese Einstellung festlegen, wenn der S3-Bucket mit statischem Website-Hosting konfiguriert wird. (Bei anderen Arten von S3-Bucket-Konfigurationen werden diese Einstellungen ignoriert.) Wenn `customOriginConfig` nicht angegeben wird, werden die Einstellungen des zugewiesenen Ursprungs verwendet. **Port (erforderlich)** Der HTTP-Port, über CloudFront den eine Verbindung zum Ursprung hergestellt wird. Geben Sie den HTTP-Port an, den der Ursprung überwacht. **Protokoll (erforderlich)** Gibt das Protokoll (HTTP oder HTTPS) an, das für die Verbindung zum Ursprung CloudFront verwendet wird. Gültige Werte sind: + `http`— verwendet CloudFront immer HTTP, um eine Verbindung zum Ursprung herzustellen + `https`— verwendet CloudFront immer HTTPS, um eine Verbindung zum Ursprung herzustellen **sslProtocols (erforderlich)** Eine Liste, die das SSL/TLS Mindestprotokoll angibt, das CloudFront verwendet wird, wenn Sie über HTTPS eine Verbindung zu Ihrem Ursprung herstellen. Gültige Werte sind: `SSLv3`, `TLSv1`, `TLSv1.1` und `TLSv1.2`. Weitere Informationen finden Sie unter [Mindest-SSL-Protokoll für Ursprung](DownloadDistValuesOrigin.md#DownloadDistValuesOriginSSLProtocols). **ipAddressType (Optional)** Gibt den IP-Adresstyp an, der für die Verbindung mit dem Ursprung CloudFront verwendet wird. Gültige Werte sind: `ipv4`, `ipv6` und `dualstack`. Die Änderung von `ipAddressType` wird nur unterstützt, wenn auch die `domainName`-Eigenschaft geändert wird. **sni (optional, für benutzerdefinierte Ursprünge, die nicht zu S3 gehören)** Die Server Name Indication (SNI) ist eine Erweiterung des Transport Layer Security (TLS) -Protokolls, mit der ein Client zu Beginn des TLS-Handshake-Prozesses angibt, mit welchem Hostnamen er eine Verbindung herstellen möchte. Dieser Wert sollte mit einem allgemeinen Namen auf einem TLS-Zertifikat auf Ihrem Ursprungsserver übereinstimmen. Andernfalls könnte Ihr Ursprungsserver einen Fehler ausgeben. Wenn dies nicht angegeben wird, wird der Wert aus dem `hostHeader` Parameter verwendet. Wenn der Host-Header nicht angegeben wird, wird der Wert aus dem `domainName` Parameter verwendet. Wenn weder der Host-Header noch der Domain-Name-Parameter angegeben werden, wird der Domainname des zugewiesenen Ursprungs verwendet oder der Host-Header der eingehenden Anfrage, wenn die FTO-Richtlinie (Forward to Origin) den Host einschließt. Das SNI darf keinen Doppelpunkt (`:`) enthalten und darf keine IP-Adresse sein. Das SNI kann bis zu 253 Zeichen lang sein. **allowedCertificateNames (optional, für benutzerdefinierte Ursprünge außerhalb von S3)** Sie können eine Liste gültiger Zertifikatsnamen hinzufügen, die verwendet werden sollen, CloudFront um die Domainübereinstimmung mit Ihrem Ursprungsserver-TLS-Zertifikat während des TLS-Handshakes mit Ihrem Ursprungsserver zu validieren. Dieses Feld erwartet eine Reihe gültiger Domainnamen und kann Platzhalterdomänen enthalten, wie z. `*.example.com` Sie können bis zu 20 zulässige Zertifikatsnamen angeben. Jeder Zertifikatsname kann bis zu 64 Zeichen lang sein. **Example – Aktualisierung auf den Ursprung der Amazon-S3-Anforderung** Das folgende Beispiel ändert den Ursprung der Viewer-Anforderung in einen S3-Bucket, aktiviert OAC und setzt benutzerdefinierte Header zurück, die an den Ursprung gesendet wurden. ``` 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 – Aktualisierung auf Application Load Balancer als Anforderungsursprung** Das folgende Beispiel ändert den Ursprung der Viewer-Anforderung in einen Application Load Balancer und legt einen benutzerdefinierten Header und Timeouts fest. ``` 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 – Aktualisierung auf einen Ursprung mit aktiviertem Origin Shield** Im folgenden Beispiel ist Origin Shield für den Ursprung in der Distribution aktiviert. Der Funktionscode aktualisiert nur den für den Ursprung verwendeten Domainnamen und lässt alle anderen optionalen Parameter weg. In diesem Fall wird Origin Shield weiterhin mit dem geänderten Ursprungsdomainnamen verwendet, da die Origin-Shield-Parameter nicht aktualisiert wurden. ``` cf.updateRequestOrigin({ "domainName" : "www.example.com" }); ``` **Example — Aktualisieren Sie den Host-Header, das SNI und die Namen der zulässigen Zertifikate** In den meisten Anwendungsfällen müssen Sie diese Art der Änderung nicht für Anfragen verwenden, die an Ihren Absender gesendet werden. Diese Parameter sollten nur verwendet werden, wenn Sie wissen, welche Auswirkungen eine Änderung dieser Werte hat. Im folgenden Beispiel werden der Domainname, der Host-Header, SNI und zulässige Zertifikate für die Anfrage auf den Ursprung geändert. ``` cf.updateRequestOrigin({ "domainName": "www.example.com", "hostHeader": "test.example.com", "sni": "test.example.net", "allowedCertificateNames": ["*.example.com", "*.example.net"], }); ``` ## selectRequestOriginById() Methode Verwenden Sie `selectRequestOriginById()`, um einen vorhandenen Ursprung zu aktualisieren, indem Sie einen anderen Ursprung auswählen, der bereits in Ihrer Distribution konfiguriert ist. Diese Methode verwendet dieselben Einstellungen, die durch den aktualisierten Ursprung definiert sind. Diese Methode akzeptiert nur Ursprünge, die bereits in derselben Distribution definiert sind, die beim Ausführen der Funktion verwendet wurde. Ursprünge werden durch die Ursprungs-ID referenziert. Dabei handelt es sich um den Ursprungsnamen, den Sie bei der Einrichtung des Ursprungs definiert haben. Wenn in Ihrer Distribution ein VPC-Ursprung konfiguriert ist, können Sie mit dieser Methode Ihren Ursprung auf Ihren VPC-Ursprung aktualisieren. Weitere Informationen finden Sie unter [Zugriffsbeschränkung mit VPC-Ursprüngen](private-content-vpc-origins.md). **Hinweise** Die `selectRequestOriginById()` Funktion kann keinen Ursprung auswählen, für den Mutual TLS (Origin) aktiviert ist. Der Versuch, mit dieser Funktion einen für Mutual TLS (Origin) aktivierten Ursprung auszuwählen, führt zu einem Validierungsfehler. Wenn Ihr Anwendungsfall eine dynamische Ursprungsauswahl mit gegenseitigem TLS (Ursprung) erfordert, verwenden Sie `updateRequestOrigin()` stattdessen diese Option und stellen Sie sicher, dass alle Zielquellen dasselbe Client-Zertifikat verwenden. **Anforderung** ``` cf.selectRequestOriginById(origin_id, {origin_overrides}) ``` Im vorherigen Beispiel `origin_id` handelt es sich um eine Zeichenfolge, die auf den Ursprungsnamen eines Ursprungs in der Distribution verweist, auf der die Funktion ausgeführt wird. Der `origin_overrides ` Parameter kann Folgendes enthalten: **HostHeader (optional, für benutzerdefinierte Ursprünge, die nicht zu S3 gehören)** Der Host-Header, der verwendet werden soll, wenn die Anfrage an den Ursprung gestellt wird. Wenn dies nicht angegeben wird, wird der Wert aus dem `domainName` Parameter verwendet. Wenn weder der Host-Header noch der Domain-Namen-Parameter angegeben werden, wird der Domainname des zugewiesenen Ursprungs verwendet oder der Host-Header der eingehenden Anfrage, wenn die FTO-Richtlinie (Forward to Origin) den Host einschließt. Der Host-Header darf keinen Doppelpunkt (`:`) enthalten und darf keine IP-Adresse sein. Der Host-Header kann bis zu 253 Zeichen lang sein. **sni (optional, für benutzerdefinierte Ursprünge, die nicht zu S3 gehören)** Die Server Name Indication (SNI) ist eine Erweiterung des Transport Layer Security (TLS) -Protokolls, mit der ein Client zu Beginn des TLS-Handshake-Prozesses angibt, mit welchem Hostnamen er eine Verbindung herstellen möchte. Dieser Wert sollte mit einem allgemeinen Namen auf einem TLS-Zertifikat auf Ihrem Ursprungsserver übereinstimmen. Andernfalls könnte Ihr Ursprungsserver einen Fehler ausgeben. Wenn dies nicht angegeben wird, wird der Wert aus dem `hostHeader` Parameter verwendet. Wenn der Host-Header nicht angegeben wird, wird der Wert aus dem `domainName` Parameter verwendet. Wenn weder der Host-Header noch der Domain-Name-Parameter angegeben werden, wird der Domainname des zugewiesenen Ursprungs verwendet oder der Host-Header der eingehenden Anfrage, wenn die FTO-Richtlinie (Forward to Origin) den Host einschließt. Das SNI darf keinen Doppelpunkt (`:`) enthalten und darf keine IP-Adresse sein. Das SNI kann bis zu 253 Zeichen lang sein. **allowedCertificateNames (optional, für benutzerdefinierte Ursprünge außerhalb von S3)** Sie können eine Liste gültiger Zertifikatsnamen hinzufügen, die verwendet werden sollen, CloudFront um die Domainübereinstimmung mit Ihrem Ursprungsserver-TLS-Zertifikat während des TLS-Handshakes mit Ihrem Ursprungsserver zu validieren. Dieses Feld erwartet eine Reihe gültiger Domainnamen und kann Platzhalterdomänen enthalten, wie z. `*.example.com` Sie können bis zu 20 zulässige Zertifikatsnamen angeben. Jeder Zertifikatsname kann bis zu 64 Zeichen lang sein. **Anforderung** ``` selectRequestOriginById(origin_id) ``` Im vorherigen Beispiel handelt es sich bei `origin_id` um eine Zeichenfolge, die auf den Namen eines Ursprungs in der Distribution verweist, in der die Funktion ausgeführt wird. **Example – Auswahl des Ursprungs der Amazon-S3-Anforderung** Im folgenden Beispiel wird der Ursprung namens `amzn-s3-demo-bucket-in-us-east-1` aus der Liste der mit der Distribution verknüpften Ursprünge ausgewählt und die Konfigurationseinstellungen des Ursprungs `amzn-s3-demo-bucket-in-us-east-1` werden auf die Anforderung angewendet. ``` cf.selectRequestOriginById("amzn-s3-demo-bucket-in-us-east-1"); ``` **Example – Auswahl des Anforderungsursprungs von Application Load Balancer** Im folgenden Beispiel wird ein Application Load Balancer namens `myALB-prod` als Ursprung aus der Liste der mit der Distribution verknüpften Ursprünge ausgewählt und die Konfigurationseinstellungen von `myALB-prod` werden auf die Anforderung angewendet. ``` cf.selectRequestOriginById("myALB-prod"); ``` **Example — Wählen Sie den Ursprung der Application Load Balancer Balancer-Anforderung aus und überschreiben Sie den Host-Header** Wie im vorherigen Beispiel wählt das folgende Beispiel einen Application Load Balancer Balancer-Ursprung aus, der `myALB-prod` aus der Liste der mit der Verteilung verknüpften Ursprünge benannt ist, und wendet die Konfigurationseinstellungen von `myALB-prod` auf die Anfrage an. Dieses Beispiel überschreibt jedoch den Host-Header-Wert mit. `origin_overrides` ``` cf.overrideRequestOrigin("myALB-prod",{ "hostHeader" : "test.example.com" }); ``` ## createRequestOriginMethode Group () Verwenden Sie `createRequestOriginGroup()`, um zwei Ursprünge zu definieren, die als [Ursprungsgruppe](high_availability_origin_failover.md#concept_origin_groups.creating) für Failover in Szenarien verwendet werden sollen, die hohe Verfügbarkeit erfordern. Eine Ursprungsgruppe umfasst zwei Ursprünge (einen primären und einen sekundären) und ein Failover-Kriterium, das Sie angeben. Sie erstellen eine Ursprungsgruppe, um das Origin-Failover in CloudFront zu unterstützen. Wenn Sie mit dieser Methode eine Ursprungsgruppe erstellen oder aktualisieren, können Sie die Ursprungsgruppe anstelle eines einzelnen Ursprungs angeben. CloudFront führt unter Verwendung der Failover-Kriterien ein Failover vom primären Ursprung zum sekundären Ursprung durch. Wenn in Ihrer Distribution ein VPC-Ursprung konfiguriert ist, können Sie diese Methode verwenden, um eine Ursprungsgruppe mithilfe eines VPC-Ursprungs zu erstellen. Weitere Informationen finden Sie unter [Zugriffsbeschränkung mit VPC-Ursprüngen](private-content-vpc-origins.md). **Hinweise** Die `createRequestOriginGroup()` Funktion unterstützt nicht die Erstellung von Ursprungsgruppen, die für Mutual TLS (Origin) aktivierte Ursprünge enthalten. Ursprungsgruppen mit Mutual TLS (Origin) -Ursprüngen können nicht dynamisch über CloudFront Functions erstellt werden. Wenn Sie Origin-Failover-Funktionen mit Mutual TLS (Origin) benötigen, konfigurieren Sie Ursprungsgruppen direkt in Ihren CloudFront Verteilungseinstellungen, anstatt sie dynamisch in Funktionen zu erstellen. ### Anforderung ``` createRequestOriginGroup({origin_group_properties}) ``` In den vorangegangenen Beispielen kann `origin_group_properties` Folgendes enthalten: **originIds (erforderlich)** Array von `origin_ids`, wobei `origin_id` eine Zeichenfolge ist, die auf den Namen eines Ursprungs in der Distribution verweist, in der die Funktion ausgeführt wird. Sie müssen zwei Ursprünge als Teil des Arrays angeben. Der erste Ursprung in der Liste ist der primäre Ursprung und der zweite dient als sekundärer Ursprung für Failover-Zwecke. **OriginOverrides (optional)** Einige erweiterte Einstellungen können mithilfe des Parameters überschrieben werden. `{origin_overrides}` `origin overrides` kann die folgenden Werte enthalten: **HostHeader (optional, für benutzerdefinierte Ursprünge außerhalb von S3)** Der Host-Header, der verwendet werden soll, wenn die Anfrage an den Ursprung gestellt wird. Wenn dies nicht angegeben wird, wird der Wert aus dem `domainName` Parameter verwendet. Wenn weder der Host-Header noch der Domain-Namen-Parameter angegeben werden, wird der Domainname des zugewiesenen Ursprungs verwendet oder der Host-Header der eingehenden Anfrage, wenn die FTO-Richtlinie (Forward to Origin) den Host einschließt. Der Host-Header darf keinen Doppelpunkt (`:`) enthalten und darf keine IP-Adresse sein. Der Host-Header kann bis zu 253 Zeichen lang sein. **sni (optional, für benutzerdefinierte Ursprünge, die nicht zu S3 gehören)** Die Server Name Indication (SNI) ist eine Erweiterung des TLS-Protokolls (Transport Layer Security), mit der ein Client zu Beginn des TLS-Handshaking-Prozesses angibt, mit welchem Hostnamen er eine Verbindung herstellen möchte. Dieser Wert sollte mit einem allgemeinen Namen auf einem TLS-Zertifikat auf Ihrem Ursprungsserver übereinstimmen, da Ihr Ursprungsserver andernfalls möglicherweise einen Fehler ausgibt. Wenn dies nicht angegeben wird, wird der Wert aus dem `hostHeader` Parameter verwendet. Wenn der Host-Header nicht angegeben wird, wird der Wert aus dem `domainName` Parameter verwendet. Wenn weder der Host-Header noch der Domain-Name-Parameter angegeben werden, wird der Domainname des zugewiesenen Ursprungs verwendet oder der Host-Header der eingehenden Anfrage, wenn die FTO-Richtlinie (Forward to Origin) den Host einschließt. Das SNI darf keinen Doppelpunkt (`:`) enthalten und darf keine IP-Adresse sein. Das SNI kann bis zu 253 Zeichen lang sein. **allowedCertificateNames (optional, für benutzerdefinierte Ursprünge außerhalb von S3)** Sie können eine Liste gültiger Zertifikatsnamen hinzufügen, die verwendet werden sollen, CloudFront um die Domainübereinstimmung mit Ihrem Ursprungsserver-TLS-Zertifikat während des TLS-Handshakes mit Ihrem Ursprungsserver zu validieren. Dieses Feld erwartet eine Reihe gültiger Domainnamen und kann Platzhalterdomänen enthalten, wie z. `*.example.com` Sie können bis zu 20 zulässige Zertifikatsnamen angeben. Jeder Zertifikatsname kann bis zu 64 Zeichen lang sein. **selectionCriteria (optional)** Wählen Sie `default` aus, um die standardmäßigen Ursprungs-Failover-Kriterien zu verwenden, oder verwenden Sie die auf `media-quality-score` basierte Failover-Logik. Gültige Werte sind: + `default` verwendet die Failover-Kriterien basierend auf den Statuscodes, die in `failoverCriteria` angegeben sind. Bei fehlender Angabe für `selectionCriteria` wird `default` verwendet. + `media-quality-score` wird verwendet, wenn die Funktion zum Routing unter Berücksichtigung der Medienqualität verwendet wird. **failoverCriteria (erforderlich)** Eine Reihe von Statuscodes, die, wenn sie vom primären Ursprung zurückgegeben werden, einen Failover CloudFront zum sekundären Ursprung auslösen. Wenn Sie eine bestehende Ursprungsgruppe überschreiben, überschreibt dieses Array alle Failover-Statuscodes, die in der ursprünglichen Konfiguration der Ursprungsgruppe festgelegt sind. Wenn Sie diese Option verwenden `media-quality-score``selectionCriteria`, CloudFront wird versucht, Anfragen auf der Grundlage des Medienqualitätsfaktors weiterzuleiten. Wenn der ausgewählte Ursprung einen in diesem Array festgelegten Fehlercode zurückgibt, CloudFront erfolgt ein Failover zum anderen Ursprung. **Example – Erstellen einer Ursprungsgruppe für Anforderungen** Im folgenden Beispiel wird eine Ursprungsgruppe für eine Anfrage erstellt, die den Ursprung IDs verwendet. Diese Ursprünge IDs stammen aus der Konfiguration der Ursprungsgruppe für die Distribution, die zur Ausführung dieser Funktion verwendet wurde. Optional können Sie sie verwenden, `originOverrides` um die ursprünglichen Gruppenkonfigurationen für `sni``hostHeader`, und zu überschreiben`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; } ``` # Hilfsmethoden für CloudFront SaaS Manager-Eigenschaften Verwenden Sie die folgenden Hilfsfunktionen für CloudFront SaaS Manager, um Werte für Ihre Multi-Tenant-Verteilungen in der von Ihnen erstellten Funktion abzurufen. Um die Beispiele auf dieser Seite verwenden zu können, müssen Sie zuerst eine CloudFront Funktion mithilfe von JavaScript Runtime 2.0 erstellen. Weitere Informationen finden Sie unter [Features von JavaScript Runtime 2.0 für CloudFront-Funktionen](functions-javascript-runtime-20.md). **Topics** + [ ## Verbindungsgruppen ](#connection-groups-helper-function) + [ ## Distributionsmandanten ](#distribution-tenants-helper-functions) ## Verbindungsgruppen Die Verbindungsgruppe, die Ihren Distributionsmandanten zugeordnet ist, hat einen Domainnamen. Verwenden Sie das Feld `endpoint` des Unterobjekts `context` des Ereignisobjekts, um diesen Wert abzurufen. **Anforderung** ``` const value = event.context.endpoint; ``` **Antwort** Die Antwort ist ein `string`, der den Domainnamen der Verbindungsgruppe wie z. B. d111111abcdef8.cloudfront.net enthält. Das Feld `endpoint` wird nur angezeigt, wenn Ihre Funktion für eine Multi-Tenant-Distribution mit einer zugeordneten Verbindungsgruppe aufgerufen wird. Weitere Informationen finden Sie unter [Context-Objekt](functions-event-structure.md#functions-event-structure-context). ## Distributionsmandanten CloudFront Functions verfügt über ein Modul, das den Zugriff auf bestimmte Werte für den Distributionsmandanten ermöglicht. Um dieses Modul zu verwenden, fügen Sie die folgende Anweisung in die erste Zeile Ihres Funktionscodes ein: ``` import cf from 'cloudfront'; ``` Sie können die folgenden Beispiele nur in der `handler`-Funktion verwenden, entweder direkt oder über eine Funktion mit verschachtelten Aufrufen. ### `distributionTenant.id` field Verwenden Sie dieses Feld, um den Wert der Distributionsmandanten-ID abzurufen. **Anforderung** ``` const value = cf.distributionTenant.id; ``` **Antwort** Die Antwort ist ein `string`, der die Distributionsmandanten-ID wie z. B. `dt_1a2b3c4d5e6f7` enthält. **Fehlerbehandlung** Wenn Ihre Funktion für eine Standarddistribution aufgerufen wird, wird bei einer Angabe im Feld `distributionTenant.id` der Typfehler `distributionTenant module is not available` zurückgegeben. Um dieses Problem zu beheben, können Sie Ihrem Code einen `try`- und `catch`-Block hinzufügen. ### `distributionTenant.parameters.get()`-Methode Verwenden Sie diese Methode, um den Wert für die von Ihnen angegebenen Parameternamen für den Distributionsmandanten zurückzugeben. ``` distributionTenant.parameters.get("key"); ``` `key`: der Name des Parameters des Distributionsmandanten, für den Sie den Wert abrufen möchten **Anfrage** ``` const value = distributionTenant.parameters.get("key"); ``` **Antwort** Die Antwort ist ein `string`, der den Wert für den Parameter des Distributionsmandanten enthält. Wenn Ihr Schlüsselname beispielsweise `TenantPath` lautet, könnte der Wert für diesen Parameter `tenant1` lauten. **Fehlerbehandlung** Sie können die folgenden Fehler erhalten: + Wenn Ihre Funktion für eine Standarddistribution aufgerufen wird, gibt die Methode `distributionTenant.parameters.get()` den Typfehler `distributionTenant module is not available` zurück. + Der Fehler `DistributionTenantParameterKeyNotFound` wird zurückgegeben, wenn der von Ihnen angegebene Parameter für den Distributionsmandanten nicht existiert. Um diese Probleme zu beheben, können Sie Ihrem Code einen `try`- und `catch`-Block hinzufügen. # Verwendung von async und await CloudFront Funktionen, die in JavaScript Runtime Functions 2.0 ausgeführt werden, stellen eine `async` `await` Syntax für den Umgang mit `Promise` Objekten bereit. Promises stellen verzögerte Ergebnisse dar, auf die über das `await`-Schlüsselwort in Funktionen zugegriffen werden kann, die als `async` gekennzeichnet sind. Verschiedene neue WebCrypto Funktionen verwenden Promises. Weitere Informationen über `Promise`-Objekte finden Sie unter [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise). **Anmerkung** Sie müssen JavaScript Runtime 2.0 für die folgenden Codebeispiele verwenden. `await` kann nur innerhalb von `async`-Funktionen verwendet werden. `async`-Argumente und -Schließungen werden nicht unterstützt. ``` 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; } ``` Der folgende JavaScript Beispielcode zeigt, wie Versprechen mit der `then` Chain-Methode angezeigt werden. Sie können `catch` verwenden, um Fehler anzuzeigen. **Warnung** Die Verwendung von Promise-Kombinatoren (z. B. `Promise.all`, `Promise.any`) und Promise-Verkettungsmethoden (z. B. `then` und `catch`) kann eine hohe Auslastung des Funktionsspeichers erfordern. Wenn Ihre Funktion das [maximale Funktionsspeicherkontingent](cloudfront-limits.md#limits-functions) überschreitet, kann sie nicht ausgeführt werden. Um diesen Fehler zu vermeiden, empfehlen wir Ihnen, die `await`-Syntax anstelle von `promise`-Methoden zu verwenden. ``` 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; } ``` # CWT-Unterstützung für Funktionen CloudFront Dieser Abschnitt enthält Einzelheiten zur Unterstützung von CBOR-Web-Tokens (CWT) in Ihren CloudFront Funktionen, wodurch eine sichere tokenbasierte Authentifizierung und Autorisierung an Edge-Standorten ermöglicht wird. CloudFront Diese Unterstützung wird als Modul bereitgestellt, auf das Sie in Ihrer Funktion zugreifen können. CloudFront Um dieses Modul zu verwenden, erstellen Sie eine CloudFront Funktion mit JavaScript Runtime 2.0 und fügen Sie die folgende Anweisung in die erste Zeile des Funktionscodes ein: ``` import cf from 'cloudfront'; ``` Auf die mit diesem Modul verknüpften Methoden kann über zugegriffen werden (wobei \$1 ein Platzhalter ist, der die verschiedenen im Modul vorhandenen Funktionen darstellt): ``` cf.cwt.* ``` Weitere Informationen finden Sie unter [Features von JavaScript Runtime 2.0 für CloudFront-Funktionen](functions-javascript-runtime-20.md). Derzeit unterstützt das Modul nur die MAC0-Struktur mit HS256 (HMAC-SHA256) Algorithmus mit einem Limit von 1 KB für die maximale Tokengröße. ## Token-Struktur In diesem Abschnitt wird die Token-Struktur behandelt, die vom CWT-Modul erwartet wird. Das Modul erwartet, dass das Token korrekt markiert und identifizierbar ist (z. B. COSE MAC0). Darüber hinaus folgt das Modul in Bezug auf die Struktur des Tokens den Standards von [CBOR Object Signing and Encryption (COSE) [RFC](https://datatracker.ietf.org/doc/html/rfc8152) 8152]. ``` ( // CWT Tag (Tag value: 61) --- optional ( // COSE MAC0 Structure Tag (Tag value: 17) --- required [ protectedHeaders, unprotectedHeaders, payload, tag, ] ) ) ``` **Example : CWT verwendet die COSE MAC0-Struktur** ``` 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 ] ) ) ``` Das CWT-Tag ist bei der Generierung von Token optional. Das COSE-Struktur-Tag ist jedoch erforderlich. ## validateToken () -Methode Die Funktion dekodiert und validiert ein CWT-Token mithilfe des angegebenen Schlüssels. Wenn die Validierung erfolgreich ist, gibt sie das dekodierte CWT-Token zurück. Andernfalls wird ein Fehler ausgegeben. Bitte beachten Sie, dass diese Funktion keine Überprüfung des Anspruchssatzes durchführt. ### Anforderung ``` cf.cwt.validateToken(token, handlerContext{key}) ```Parameters **Token (erforderlich)** Codiertes Token zur Validierung. Das muss ein JavaScript Buffer sein. **HandlerContext (erforderlich)** Ein JavaScript Objekt, das den Kontext für den ValidateToken-Aufruf speichert. Derzeit wird nur die Schlüsseleigenschaft unterstützt. **Schlüssel (erforderlich)** Geheimer Schlüssel für die Berechnung des Message-Digests. Kann entweder als Zeichenfolge oder JavaScript als Puffer bereitgestellt werden. ### Antwort Wenn die `validateToken()` Methode ein erfolgreich validiertes Token zurückgibt, hat die Antwort `CWTObject` der Funktion das folgende Format. Nach der Dekodierung werden alle Claim-Schlüssel als Zeichenketten dargestellt. ``` CWTObject { protectedHeaders, unprotectedHeaders, payload } ``` ### Beispiel: Token validieren, wobei das Kind als Teil des Tokens gesendet wird Dieses Beispiel demonstriert die CWT-Token-Validierung, bei der das Kind aus dem Header extrahiert wird. Das Kind wird dann an CloudFront Functions übergeben KeyValueStore , um den geheimen Schlüssel abzurufen, der zur Validierung des Tokens verwendet wurde. ``` 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; } ``` ## Methode generateToken () Diese Funktion generiert ein neues CWT-Token unter Verwendung der bereitgestellten Payload- und Kontexteinstellungen. ### Anforderung ``` cf.cwt.generateToken(generatorContext, payload) ```Parameters **GeneratorContext (erforderlich)** Dies ist ein JavaScript Objekt, das als Kontext für die Generierung des Tokens verwendet wird und die folgenden Schlüssel-Wert-Paare enthält: **cwtTag (optional)** Dieser Wert ist ein boolescher Wert, der, wenn er `true` angibt, hinzugefügt werden soll. `cwtTag` **CoseTag (erforderlich)** Gibt den Typ des COSE-Tags an. Unterstützt derzeit nur`MAC0`. **Schlüssel (erforderlich)** Geheimer Schlüssel zur Berechnung des Message Digest. Dieser Wert kann entweder eine Zeichenfolge oder JavaScript `Buffer` sein. **Nutzlast (erforderlich)** Token-Nutzlast für die Kodierung. Die Nutzdaten müssen im `CWTObject` Format vorliegen. ### Antwort Gibt einen JavaScript Buffer zurück, der das kodierte Token enthält. **Example : Generieren Sie ein CWT-Token** ``` 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 : Aktualisiere das Token auf der Grundlage einer bestimmten Logik** ``` 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; } ``` # Allgemeine Hilfsmethoden Diese Seite bietet zusätzliche Hilfsmethoden innerhalb von CloudFront Functions. Um diese Methoden zu verwenden, erstellen Sie eine CloudFront Funktion mit JavaScript Runtime 2.0. ``` import cf from 'cloudfront'; ``` Weitere Informationen finden Sie unter [Features von JavaScript Runtime 2.0 für CloudFront-Funktionen](functions-javascript-runtime-20.md). ## `edgeLocation`Metadaten Diese Methode erfordert die Verwendung des `cloudfront` Moduls. **Anmerkung** Sie können diese Methode nur für Funktionen verwenden, die von Zuschauern angefordert werden. Für Zuschauer-Antwort-Funktionen ist diese Methode leer. Verwenden Sie dieses JavaScript Objekt, um den Flughafencode des Edge-Standorts, die erwartete [regionale Edge-Cache-Region](HowCloudFrontWorks.md#CloudFrontRegionaledgecaches) oder die CloudFront Server-IP-Adresse abzurufen, die für die Bearbeitung der Anfrage verwendet wurde. Diese Metadaten sind nur für den Event-Trigger der Viewer-Anforderung verfügbar. ``` cf.edgeLocation = { name: SEA serverIp: 1.2.3.4 region: us-west-2 } ``` Das `cf.edgeLocation` Objekt kann Folgendes enthalten: **Name** Der aus drei Buchstaben bestehende [IATA-Code](https://en.wikipedia.org/wiki/IATA_airport_code) des Edge-Standorts, der die Anfrage bearbeitet hat. **Server-IP** Die IPv6 Adresse IPv4 oder des Servers, der die Anfrage bearbeitet hat. **Region** Der CloudFront Regional Edge Cache (REC), den die Anfrage *voraussichtlich* verwenden wird, wenn ein Cache-Fehler auftritt. Dieser Wert wird nicht aktualisiert, falls der erwartete REC nicht verfügbar ist und ein Backup-REC für die Anfrage verwendet wird. Dies beinhaltet nicht, dass der Origin Shield-Standort verwendet wird, außer in Fällen, in denen sich das primäre REC und das Origin Shield am selben Standort befinden. **Anmerkung** CloudFront Functions wird kein zweites Mal aufgerufen, wenn CloudFront es für die Verwendung von Origin-Failover konfiguriert ist. Weitere Informationen finden Sie unter [Optimieren der Hochverfügbarkeit mit CloudFront Origin Failover](high_availability_origin_failover.md). ## `rawQueryString()`-Methode Für diese Methode ist das Modul nicht erforderlich. `cloudFront` Verwenden Sie die `rawQueryString()` Methode, um die ungeparste und unveränderte Abfragezeichenfolge als Zeichenfolge abzurufen. **Anforderung** ``` function handler(event) { var request = event.request; const qs = request.rawQueryString(); } ``` **Antwort** Gibt die vollständige Abfragezeichenfolge der eingehenden Anfrage als Zeichenkettenwert ohne den Anfang zurück. `?` + Wenn es keine Abfragezeichenfolge gibt, aber die vorhanden `?` ist, geben die Funktionen eine leere Zeichenfolge zurück. + Wenn es keine Abfragezeichenfolge gibt und die `?` nicht vorhanden ist, gibt die Funktion zurück`undefined`. **Fall 1: Vollständige Abfragezeichenfolge zurückgegeben (ohne Leerlauf`?`)** URL der eingehenden Anfrage: `https://example.com/page?name=John&age=25&city=Boston` `rawQueryString()`gibt zurück: `"name=John&age=25&city=Boston"` **Fall 2: Es wurde eine leere Zeichenfolge zurückgegeben (wenn sie vorhanden `?` ist, aber ohne Parameter)** URL der eingehenden Anfrage: `https://example.com/page?` `rawQueryString()`gibt zurück: `""` **Fall 3: `undefined` zurückgegeben (keine Abfragezeichenfolge und nein`?`)** URL der eingehenden Anfrage: `https://example.com/page` `rawQueryString()`gibt zurück: `undefined`