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` # Erstellen von Funktionen Sie erstellen eine Funktion in zwei Phasen: 1. Erstellen Sie den Funktionscode als JavaScript. Sie können das Standardbeispiel aus der CloudFront-Konsole verwenden oder einen eigenen schreiben. Weitere Informationen finden Sie unter den folgenden Themen: + [Schreiben von Funktionscode](writing-function-code.md) + [CloudFront Funktionen, Ereignisstruktur](functions-event-structure.md) + [CloudFront Funktionen, Beispiele für CloudFront](service_code_examples_cloudfront_functions_examples.md) 1. Verwenden Sie CloudFront, um die Funktion zu erstellen und den Code einzufügen. Der Code ist innerhalb der Funktion vorhanden (nicht als Referenz). ------ #### [ Console ] **Eine Funktion erstellen** 1. Melden Sie sich auf [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) bei der CloudFront-Konsole an und öffnen Sie die Seite **Funktionen**. 1. Wählen Sie **Funktion erstellen**. 1. Geben Sie einen Funktionsnamen ein, der innerhalb des AWS-Konto eindeutig ist. Wählen Sie dann die JavaScript-Version aus und klicken Sie auf **Weiter**. Die Seite mit den Details der neuen Funktion wird angezeigt. **Anmerkung** Wenn Sie [Schlüssel-Wert-Paare](kvs-with-functions.md) in der Funktion verwenden möchten, müssen Sie die JavaScript-Laufzeitumgebung 2.0 wählen. 1. Wählen Sie im Abschnitt **Funktionscode** die Registerkarte **Erstellen** aus und geben Sie Ihren Funktionscode ein. Der auf der Registerkarte **Erstellen** angezeigte Beispielcode veranschaulicht die grundlegende Syntax für den Funktionscode. 1. Wählen Sie **Änderungen speichern ** aus. 1. Wenn der Funktionscode Schlüssel-Wert-Paare verwendet, müssen Sie einen Schlüsselwertspeicher zuordnen. Sie können den Schlüsselwertspeicher beim Erstellen der Funktion zuordnen. Sie können ihn auch später zuordnen, indem Sie [die Funktion aktualisieren](update-function.md). Gehen Sie wie folgt vor, um jetzt einen Schlüsselwertspeicher zuzuordnen: + Wählen Sie im Abschnitt **KeyValueStore zuordnen** die Option **Vorhandenen KeyValueStore zuordnen** aus. + Wählen Sie den Schlüsselwertspeicher, der die Schlüssel-Wert-Paare in der Funktion enthält, und dann **KeyValueStore zuordnen** aus. CloudFront ordnet den Store sofort der Funktion zu. Sie müssen die Funktion nicht speichern. ------ #### [ CLI ] Wenn Sie die CLI verwenden, erstellen Sie normalerweise zuerst den Funktionscode in einer Datei und dann die Funktion mit der AWS CLI. **Eine Funktion erstellen** 1. Erstellen Sie den Funktionscode in einer Datei und speichern Sie ihn in einem Verzeichnis, mit dem Ihr Computer eine Verbindung herstellen kann. 1. Führen Sie den Befehl wie im Beispiel veranschaulicht aus. In diesem Beispiel wird die Notation `fileb://` verwendet, um die Datei zu übergeben. Es sind Zeilenumbrüche enthalten, um den Befehl lesbarer zu machen. ``` aws cloudfront create-function \ --name MaxAge \ --function-config '{"Comment":"Max Age 2 years","Runtime":"cloudfront-js-2.0","KeyValueStoreAssociations":{"Quantity":1,"Items":[{"KeyValueStoreARN":"arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"}]}}' \ --function-code fileb://function-max-age-v1.js ``` **Hinweise** `Runtime` – die Version von Java Script. Wenn Sie [Schlüssel-Wert-Paare](kvs-with-functions.md) in der Funktion verwenden möchten, müssen Sie Version 2.0 angeben. `KeyValueStoreAssociations` – Wenn Ihre Funktion Schlüssel-Wert-Paare verwendet, können Sie den Schlüsselwertspeicher beim Erstellen der Funktion zuordnen. Oder Sie können ihn später mit `update-function` zuordnen. Die `Quantity` ist immer `1`, weil jeder Funktion nur ein Schlüsselwertspeicher zugeordnet werden kann. Wenn der Befehl erfolgreich ausgeführt wurde, wird die Ausgabe folgendermaßen angezeigt. ``` ETag: ETVABCEXAMPLE FunctionSummary: FunctionConfig: Comment: Max Age 2 years Runtime: cloudfront-js-2.0 KeyValueStoreAssociations= \ {Quantity=1, \ Items=[{KeyValueStoreARN='arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111'}]} \ FunctionMetadata: CreatedTime: '2021-04-18T20:38:56.915000+00:00' FunctionARN: arn:aws:cloudfront::111122223333:function/MaxAge LastModifiedTime: '2023-11-19T20:38:56.915000+00:00' Stage: DEVELOPMENT Name: MaxAge Status: UNPUBLISHED Location: https://cloudfront.amazonaws.com/2020-05-31/function/arn:aws:cloudfront:::function/MaxAge ``` Die meisten Informationen werden aus der Anfrage wiederholt. Andere Informationen werden von CloudFront hinzugefügt. **Hinweise** `ETag` – Dieser Wert ändert sich jedes Mal, wenn Sie den Schlüsselwertspeicher ändern. Sie verwenden diesen Wert und den Funktionsnamen, um in Zukunft auf die Funktion zu verweisen. Stellen Sie sicher, dass Sie immer das aktuelle `ETag` verwenden. `FunctionARN` – der ARN für Ihre CloudFront-Funktion. 111122223333 – das AWS-Konto. `Stage` – die Phase der Funktion (`LIVE` oder `DEVELOPMENT`) `Status` – der Status der Funktion (`PUBLISHED` oder `UNPUBLISHED`) ------ Nachdem Sie die Funktion erstellt haben, wird sie der Phase `DEVELOPMENT` hinzugefügt. Wir empfehlen Ihnen, [Ihre Funktion zu testen](test-function.md), bevor Sie sie [veröffentlichen](publish-function.md). Nachdem Sie Ihre Funktion veröffentlicht haben, wechselt sie zur Phase `LIVE`. # Testfunktionen Bevor Sie die Funktion in der Live-Phase (Produktion) bereitstellen, können Sie sie testen, um sicherzustellen, dass sie wie vorgesehen funktioniert. Um eine Funktion zu testen, geben Sie ein *Ereignisobjekt* an, das eine HTTP-Anforderung oder Antwort darstellt, die Ihre CloudFront-Distribution in der Produktion erhalten könnte. CloudFront Functions führt Folgendes aus: 1. Führt die Funktion aus, wobei das bereitgestellte Ereignisobjekt als Eingabe verwendet wird. 1. Gibt das Ergebnis der Funktion (das geänderte Ereignisobjekt) zusammen mit allen Funktionsprotokollen oder Fehlermeldungen und der *Rechenauslastung* der Funktion zurück. Weitere Informationen zur Computing-Nutzung finden Sie unter [Informationen zur Rechenauslastung](#compute-utilization). **Anmerkung** Wenn Sie eine Funktion testen, überprüft CloudFront nur, ob Fehler bei der Funktionsausführung vorliegen. CloudFront überprüft nicht, ob die Anforderung nach der Veröffentlichung erfolgreich weitergeleitet wird. Wenn Ihre Funktion beispielsweise einen erforderlichen Header löscht, ist der Test erfolgreich, da kein Problem mit dem Code vorliegt. Wenn Sie die Funktion jedoch veröffentlichen und sie einer Distribution zuordnen, schlägt die bei einer Anforderung über CloudFront fehl. **Contents** + [ ## Einrichten des Ereignisobjekts ](#test-function-create-event) + [ ## Testen der Funktion ](#test-function-step-test) + [ ## Informationen zur Rechenauslastung ](#compute-utilization) ## Einrichten des Ereignisobjekts Bevor Sie eine Funktion testen, müssen Sie das Ereignisobjekt einrichten, mit dem Sie sie testen können. Es gibt mehrere Möglichkeiten, dies zu tun. **Option 1: Einrichten eines Ereignisobjekts, ohne es zu speichern** Sie können ein Ereignisobjekt im visuellen Editor in der CloudFront-Konsole einrichten, ohne es zu speichern. Sie können dieses Ereignisobjekt verwenden, um die Funktion von der CloudFront-Konsole aus zu testen, auch wenn es nicht gespeichert ist. **Option 2: Erstellen eines Ereignisobjekts im visuellen Editor** Sie können ein Ereignisobjekt im visuellen Editor in der CloudFront-Konsole einrichten, ohne es zu speichern. Sie können für jede Funktion 10 Ereignisobjekte erstellen, so dass Sie beispielsweise verschiedene mögliche Eingaben testen können. Wenn Sie das Ereignisobjekt auf diese Weise erstellen, können Sie es verwenden, um die Funktion in der CloudFront-Konsole zu testen. Sie können es nicht verwenden, um die Funktion mit einer AWS-API oder einem SDK zu testen. **Option 3: Erstellen eines Ereignisobjekts mit einem Texteditor** Sie können einen Texteditor verwenden, um ein Ereignisobjekt im JSON-Format zu erstellen. Informationen zur Struktur eines Ereignisobjekts finden Sie unter [Ereignisstruktur](functions-event-structure.md). Sie können dieses Ereignisobjekt verwenden, um die Funktion mit der CLI zu testen. Sie können es jedoch nicht verwenden, um die Funktion in der CloudFront-Konsole zu testen. **So erstellen Sie ein Ereignisobjekt (Option 1 oder 2)** 1. Melden Sie sich auf [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) bei der CloudFront-Konsole an und öffnen Sie die Seite **Funktionen**. Wählen Sie die Funktion, die Sie testen möchten. 1. Wählen Sie auf der Seite der Funktionsdetails die Registerkarte **Test** aus. 1. Wählen Sie für **Ereignistyp** eine der folgenden Optionen aus: + Wenn die Funktion eine HTTP-Anfrage ändert oder basierend auf der Anfrage eine Antwort generiert, wählen Sie **Betrachteranfrage** aus. Der Abschnitt **Anforderung** wird angezeigt. + Wählen Sie **Viewer-Antwort**. Die Abschnitte **Anforderung** und **Antwort** werden angezeigt. 1. Füllen Sie die Felder aus, die Sie in das Ereignis aufnehmen möchten. Sie können **JSON bearbeiten** wählen, um den unformatierten JSON-Code anzuzeigen. 1. (Optional) Um das Ereignis zu speichern, wählen Sie **Speichern** aus, geben im Feld **Testereignis speichern** einen Namen ein und wählen Sie dann **Speichern** aus. Sie können auch **JSON bearbeiten** wählen, den unformatierten JSON-Code kopieren und in Ihrer eigenen Datei außerhalb von CloudFront speichern. **So erstellen Sie ein Ereignisobjekt (Option 3)** Erstellen Sie das Ereignisobjekt mit einem Texteditor. Speichern Sie die Datei in einem Verzeichnis, mit dem Ihr Computer eine Verbindung herstellen kann. Vergewissern Sie sich, diese Richtlinien zu befolgen: + Ignorieren Sie die Felder `distributionDomainName`, `distributionId` und `requestId`. + Die Namen von Headern, Cookies und Abfragezeichenfolgen müssen in Kleinbuchstaben geschrieben sein. Eine Möglichkeit, ein Ereignisobjekt auf diese Weise zu erstellen, besteht darin, mit dem visuellen Editor ein Beispiel zu erstellen. Sie können sicher sein, dass das Beispiel korrekt formatiert ist. Sie können dann den unformatierten JSON-Code kopieren, in einen Text-Editor einfügen und die Datei speichern. Weitere Informationen zur Struktur eines Ereignisses finden Sie unter [Ereignisstruktur](functions-event-structure.md). ## Testen der Funktion Sie können eine Funktion in der CloudFront-Konsole oder mit der AWS Command Line Interface (AWS CLI) testen. ------ #### [ Console ] **So testen Sie die -Funktion** 1. Melden Sie sich auf [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) bei der CloudFront-Konsole an und öffnen Sie die Seite **Funktionen**. 1. Wählen Sie die Funktion, die Sie testen möchten. 1. Wählen Sie die Registerkarte **Test**. 1. Stellen Sie sicher, dass das korrekte Ereignis angezeigt wird. Um vom aktuell angezeigten Ereignis zu einem anderen zu wechseln, wählen Sie im Feld **Testereignis auswählen** ein anderes Ereignis aus. 1. Wählen Sie **Testfunktion** aus. Die Konsole zeigt die Ausgabe der Funktion, einschließlich der Funktionsprotokolle und Rechenauslastung. ------ #### [ CLI ] Sie können eine Funktion mit dem Befehl **aws cloudfront test-function** testen. **So testen Sie die -Funktion** 1. Öffnen Sie ein Befehlszeilenfenster. 1. Führen Sie den folgenden Befehl über dasselbe Verzeichnis aus, das die angegebene Datei enthält. In diesem Beispiel wird die Notation `fileb://` verwendet, um die Ereignisobjektdatei zu übergeben. Es sind Zeilenumbrüche enthalten, um den Befehl lesbarer zu machen. ``` aws cloudfront test-function \ --name MaxAge \ --if-match ETVABCEXAMPLE \ --event-object fileb://event-maxage-test01.json \ --stage DEVELOPMENT ``` **Hinweise** Sie verweisen auf die Funktion mit ihrem Namen und ETag (im `if-match`-Parameter). Sie verweisen auf das Ereignisobjekt anhand seines Speicherorts in Ihrem Dateisystem. Die Phase kann `DEVELOPMENT` oder `LIVE` sein. Wenn der Befehl erfolgreich ausgeführt wurde, wird die Ausgabe folgendermaßen angezeigt. ``` TestResult: ComputeUtilization: '21' FunctionErrorMessage: '' FunctionExecutionLogs: [] FunctionOutput: '{"response":{"headers":{"cloudfront-functions":{"value":"generated-by-CloudFront-Functions"},"location":{"value":"https://aws.amazon.com/cloudfront/"}},"statusDescription":"Found","cookies":{},"statusCode":302}}' FunctionSummary: FunctionConfig: Comment: MaxAge function Runtime: cloudfront-js-2.0 KeyValueStoreAssociations= \ {Quantity=1, \ Items=[{KeyValueStoreARN='arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111'}]} \ FunctionMetadata: CreatedTime: '2021-04-18T20:38:56.915000+00:00' FunctionARN: arn:aws:cloudfront::111122223333:function/MaxAge LastModifiedTime: '2023-17-20T10:38:57.057000+00:00' Stage: DEVELOPMENT Name: MaxAge Status: UNPUBLISHED ``` ------ **Hinweise** `FunctionExecutionLogs` enthält eine Liste von Protokollzeilen, die die Funktion in `console.log()`-Anweisungen geschrieben hat (falls vorhanden). `ComputeUtilization` enthält Informationen zur Ausführung Ihrer Funktion. Siehe [Informationen zur Rechenauslastung](#compute-utilization). `FunctionOutput` enthält das von der Funktion zurückgegebene Ereignisobjekt. ## Informationen zur Rechenauslastung **Rechenauslastung** ist die Zeit, die die Ausführung der Funktion in Anspruch genommen hat, als Prozentsatz der maximal zulässigen Zeit. Zum Beispiel bedeutet ein Wert von 35, dass die Funktion in 35 % der maximal zulässigen Zeit abgeschlossen wurde. Wenn eine Funktion die maximal zulässige Zeit kontinuierlich überschreitet, drosselt CloudFront die Funktion. Die folgende Liste zeigt, mit welcher Wahrscheinlichkeit eine Funktion basierend auf dem Wert der Rechenauslastung gedrosselt wird. **Rechenauslastungswert:** + **1 – 50** – Die Funktion liegt deutlich unter der maximal zulässigen Zeit und sollte ohne Drosselung ausgeführt werden. + **51 – 70** – Die Funktion nähert sich der maximal zulässigen Zeit. Erwägen Sie die Optimierung des Funktionscodes. + **71 – 100** – Die Funktion kommt der maximal zulässigen Zeit sehr nahe oder überschreitet diese. CloudFront wird diese Funktion wahrscheinlich drosseln, wenn Sie sie einer Distribution zuordnen. # Aktualisieren von Funktionen Sie können eine Funktion jederzeit aktualisieren. Die Änderungen werden nur an der Version der Funktion vorgenommen, die sich in der `DEVELOPMENT`-Phase befindet. Um die Updates von der `DEVELOPMENT`-Phase in die `LIVE`-Phase zu kopieren, müssen Sie [die Funktion veröffentlichen](publish-function.md). Sie können den Code einer Funktion in der CloudFront-Konsole oder mit der AWS Command Line Interface (AWS CLI) aktualisieren. ------ #### [ Console ] **So aktualisieren Sie den Funktionscode** 1. Melden Sie sich auf [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) bei der CloudFront-Konsole an und öffnen Sie die Seite **Funktionen**. Wählen Sie die zu aktualisierende Funktion aus. 1. Wählen Sie **Bearbeiten** aus und nehmen Sie die folgenden Änderungen vor. + Aktualisieren Sie die entsprechenden Felder im Abschnitt **Details**. + Ändern oder entfernen Sie den zugeordneten Schlüsselwertspeicher. Weitere Hinweise zu Schlüsselwertspeichern finden Sie unter [Amazon CloudFront Schlüsselwertspeicher](kvs-with-functions.md). + Ändern Sie den Funktionscode. Wählen Sie die Registerkarte **Erstellen** aus, nehmen Sie die entsprechenden Änderungen vor und wählen Sie dann **Änderungen speichern** aus, um die Änderungen am Code zu speichern. ------ #### [ CLI ] **So aktualisieren Sie den Funktionscode:** 1. Öffnen Sie ein Befehlszeilenfenster. 1. Führen Sie den folgenden Befehl aus. In diesem Beispiel wird die Notation `fileb://` verwendet, um die Datei zu übergeben. Es sind Zeilenumbrüche enthalten, um den Befehl lesbarer zu machen. ``` aws cloudfront update-function \ --name MaxAge \ --function-config '{"Comment":"Max Age 2 years","Runtime":"cloudfront-js-2.0","KeyValueStoreAssociations":{"Quantity":1,"Items":[{"KeyValueStoreARN":"arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"}]}}' \ --function-code fileb://function-max-age-v1.js \ --if-match ETVABCEXAMPLE ``` **Hinweise** Sie können die Funktion anhand ihres Namen und ETags (im `if-match`-Parameter) identifizieren. Stellen Sie sicher, dass Sie das aktuelle ETag verwenden. Sie können diesen Wert anhand der API-Operation [DescribeFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeFunction.html) abrufen. Sie müssen den `function-code` angeben, auch wenn Sie ihn nicht ändern möchten. Seien Sie vorsichtig mit der `function-config`. Sie sollten alles übergeben, was Sie in der Konfiguration beibehalten möchten. Gehen Sie insbesondere mit dem Schlüsselwertspeicher folgendermaßen vor: Um die bestehende Schlüsselwertspeicher-Zuordnung (falls vorhanden) beizubehalten, geben Sie den Namen des *vorhandenen* Speichers an. Um die Zuordnung zu ändern, geben Sie den Namen des *neuen* Schlüsselwertspeichers an. Um die Zuordnung zu entfernen, lassen Sie den `KeyValueStoreAssociations`-Parameter weg. Wenn der Befehl erfolgreich ausgeführt wurde, wird die Ausgabe folgendermaßen angezeigt. ``` ETag: ETVXYZEXAMPLE FunctionSummary: FunctionConfig: Comment: Max Age 2 years \ Runtime: cloudfront-js-2.0 \ KeyValueStoreAssociations= \ {Quantity=1, \ Items=[{KeyValueStoreARN='arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111'}]} \ FunctionMetadata: \ CreatedTime: '2021-04-18T20:38:56.915000+00:00' \ FunctionARN: arn:aws:cloudfront::111122223333:function/MaxAge \ LastModifiedTime: '2023-12-19T23:41:15.389000+00:00' \ Stage: DEVELOPMENT \ Name: MaxAge \ Status: UNPUBLISHED ``` ------ Die meisten Informationen werden aus der Anfrage wiederholt. Andere Informationen werden von CloudFront hinzugefügt. **Hinweise** `ETag` – Dieser Wert ändert sich jedes Mal, wenn Sie den Schlüsselwertspeicher ändern. `FunctionARN` – der ARN für Ihre CloudFront-Funktion `Stage` – die Phase der Funktion (`LIVE` oder `DEVELOPMENT`) `Status` – der Status der Funktion (`PUBLISHED` oder `UNPUBLISHED`) # Veröffentlichen von Funktionen Wenn Sie Ihre Funktion veröffentlichen, wird die Funktion von der `DEVELOPMENT`-Phase in die `LIVE`-Phase kopiert. Wenn der Funktion kein Cacheverhalten zugeordnet ist, können Sie sie beim Veröffentlichen mit einem Cacheverhalten verknüpfen. Sie können Cache-Verhalten nur Funktionen zuordnen, die sich in der `LIVE`-Phase befinden. **Wichtig** Wir empfehlen, die Funktion vor dem Veröffentlichen [zu testen](test-function.md). Nachdem Sie die Funktion veröffentlicht haben, verwenden alle Cacheverhaltensweisen, die mit der Funktion verknüpft sind, automatisch die neu veröffentlichte Kopie, sobald die Bereitstellung der Distributionen abgeschlossen ist. Sie können eine Funktion in der CloudFront-Konsole oder mit der veröffentlichen AWS CLI. ------ #### [ Console ] **So veröffentlichen Sie eine Funktion** 1. Melden Sie sich auf [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) bei der CloudFront-Konsole an und öffnen Sie die Seite **Funktionen**. 1. Wählen Sie die zu aktualisierende Funktion aus. 1. Wählen Sie die Registerkarte **Veröffentlichen** und dann die Option **Veröffentlichen** aus. Wenn Ihre Funktion bereits an ein oder mehrere Cacheverhaltensweisen angehängt ist, wählen Sie **Veröffentlichen und aktualisieren**. 1. (Optional) Um die Verteilungen anzuzeigen, die mit der Funktion verknüpft sind, wählen Sie **Associated CloudFront distributions**, um diesen Abschnitt zu erweitern. Wenn dies gelingt, wird oben auf der Seite ein Banner mit dem Hinweis ***Funktionsname* erfolgreich veröffentlicht** angezeigt. Sie können auch den Tab **Build** und dann **Live** auswählen, um die Live-Version des Funktionscodes anzuzeigen. ------ #### [ CLI ] **So veröffentlichen Sie eine Funktion** 1. Öffnen Sie ein Befehlszeilenfenster. 1. Führen Sie den Befehl **aws cloudfront publish-function** aus. Im Beispiel werden Zeilenumbrüche bereitgestellt, um das Beispiel besser lesbar zu machen. ``` aws cloudfront publish-function \ --name MaxAge \ --if-match ETVXYZEXAMPLE ``` Wenn der Befehl erfolgreich ausgeführt wurde, wird die Ausgabe folgendermaßen angezeigt. ``` FunctionSummary: FunctionConfig: Comment: Max Age 2 years Runtime: cloudfront-js-2.0 FunctionMetadata: CreatedTime: '2021-04-18T21:24:21.314000+00:00' FunctionARN: arn:aws:cloudfront::111122223333:function/ExampleFunction LastModifiedTime: '2023-12-19T23:41:15.389000+00:00' Stage: LIVE Name: MaxAge Status: UNASSOCIATED ``` ------ # Verknüpfen von Funktionen mit Distributionen Um eine Funktion mit einer Distribution zu verwenden, verknüpfen Sie die Funktion einem oder mehreren Cacheverhalten in der Distribution. Sie können eine Funktion mit mehreren Cache-Verhaltensweisen in mehreren Verteilungen verknüpfen. Sie können eine Funktion den folgenden Verhaltensweisen zuordnen: + einem vorhandenen Cacheverhalten + einem neuen Cacheverhalten in einer vorhandenen Distribution + einem neuen Cacheverhalten in einer neuen Distribution Wenn Sie eine Funktion mit einem Cache-Verhalten verknüpfen, müssen Sie einen *Ereignistyp* auswählen. Der Ereignistyp bestimmt, wann CloudFront die Funktion ausführt. Sie können aus den folgenden Ereignistypen auswählen: + **Betrachteranfrage** – Die Funktion wird ausgeführt, wenn CloudFront eine Anfrage von einem Betrachter erhält. + **Betrachterantwort** – Die Funktion wird ausgeführt, bevor CloudFront eine Antwort an den Betrachter zurückgibt. Sie können keine Ursprungsereignistypen (*Ursprungsanforderung* und *Ursprungsantwort*) mit CloudFront Functions verwenden. Stattdessen können Sie Lambda@Edge verwenden. Weitere Informationen finden Sie unter [CloudFront Ereignisse, die eine Lambda @Edge -Funktion auslösen können](lambda-cloudfront-trigger-events.md). **Anmerkung** Bevor Sie eine Funktion verknüpfen, müssen Sie sie in der `LIVE`-Phase [veröffentlichen](publish-function.md). Sie können eine Funktion mit einer Distribution in der CloudFront-Konsole oder mit der AWS Command Line Interface (AWS CLI) verknüpfen. Das folgende Verfahren zeigt, wie eine Funktion mit einem vorhandenen Cache-Verhalten verknüpft wird. ------ #### [ Console ] **So verknüpfen Sie eine Funktion mit einem vorhandenen Cacheverhalten** 1. Melden Sie sich auf [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) bei der CloudFront-Konsole an und öffnen Sie die Seite **Funktionen**. 1. Wählen Sie die Funktion aus, die Sie verknüpfen möchten. 1. Wählen Sie auf der Seite **Funktion** die Registerkarte **Veröffentlichen** aus. 1. Wählen Sie die **Funktion „Veröffentlichen“** aus. 1. Wählen Sie **Add association**. Wählen Sie im daraufhin angezeigten Dialogfeld eine Distribution, einen Ereignistyp und/oder ein Cacheverhalten aus. Wählen Sie für den Ereignistyp aus, wann diese Funktion ausgeführt werden soll: + **Viewer-Anforderung** – Die Funktion wird jedes Mal ausgeführt, wenn CloudFront eine Anforderung erhält. + **Viewer-Antwort** – Die Funktion wird jedes Mal ausgeführt, wenn CloudFront eine Antwort zurückgibt. 1. Um die Konfiguration zu speichern, wählen Sie **Zuordnung hinzufügen**. CloudFront ordnet die Verteilung der Funktion zu. Warten Sie ein paar Minuten, bis die zugehörige Verteilung die Bereitstellung abgeschlossen hat. Sie können auf der Seite mit den Funktionsdetails die Option **Distribution anzeigen** auswählen, um den Fortschritt zu überprüfen. ------ #### [ CLI ] **So verknüpfen Sie eine Funktion mit einem vorhandenen Cacheverhalten** 1. Öffnen Sie ein Befehlszeilenfenster. 1. Geben Sie den folgenden Befehl ein, um die Distributionskonfiguration für die Distribution zu speichern, deren Cacheverhalten Sie einer Funktion zuordnen möchten. Dieser Befehl speichert die Verteilungskonfiguration in einer Datei mit dem Namen `dist-config.yaml`. Um diesen Befehl zu verwenden, gehen Sie folgendermaßen vor: + Ersetzen Sie *`DistributionID`* durch die ID der Verteilung. + Führen Sie den Befehl in einer Zeile aus. Im Beispiel werden Zeilenumbrüche bereitgestellt, um das Beispiel besser lesbar zu machen. ``` aws cloudfront get-distribution-config \ --id DistributionID \ --output yaml > dist-config.yaml ``` Wenn der Befehl erfolgreich ist, gibt die AWS CLI keine Ausgabe zurück. 1. Öffnen Sie die Datei mit dem Namen `dist-config.yaml`, die Sie erstellt haben. Bearbeiten Sie die Datei, indem Sie die folgenden Änderungen vornehmen. 1. Benennen Sie das `ETag`-Feld in `IfMatch` um, ändern Sie jedoch nicht den Wert des Feldes. 1. Suchen Sie im Cache-Verhalten das Objekt mit dem Namen `FunctionAssociations`. Aktualisieren Sie dieses Objekt, um eine Funktionszuordnung hinzuzufügen. Die YAML-Syntax für eine Funktionszuordnung sieht wie im folgenden Beispiel aus. + Das folgende Beispiel zeigt den Ereignistyp Betrachteranfrage (Auslöser). Um den Ereignistyp Betrachterantwort zu verwenden, ersetzen Sie `viewer-request` durch `viewer-response`. + Ersetzen Sie *`arn:aws:cloudfront::111122223333:function/ExampleFunction`* durch den Amazon-Ressourcennamen (ARN) der Funktion, die Sie diesem Cache-Verhalten zuordnen. Um die Funktion ARN zu erhalten, können Sie den Befehl **aws cloudfront list-functions** verwenden. ``` FunctionAssociations: Items: - EventType: viewer-request FunctionARN: arn:aws:cloudfront::111122223333:function/ExampleFunction Quantity: 1 ``` 1. Nachdem Sie diese Änderungen vorgenommen haben, speichern Sie die Datei. 1. Verwenden Sie den folgenden Befehl, um die Verteilung zu aktualisieren und die Funktionszuordnung hinzuzufügen. Um diesen Befehl zu verwenden, gehen Sie folgendermaßen vor: + Ersetzen Sie *`DistributionID`* durch die ID der Verteilung. + Führen Sie den Befehl in einer Zeile aus. Im Beispiel werden Zeilenumbrüche bereitgestellt, um das Beispiel besser lesbar zu machen. ``` aws cloudfront update-distribution \ --id DistributionID \ --cli-input-yaml file://dist-config.yaml ``` Wenn der Befehl erfolgreich ist, sehen Sie eine Ausgabe wie die folgende, die die Verteilung beschreibt, die gerade mit der Funktionszuordnung aktualisiert wurde. Die folgende Beispielausgabe wird zur besseren Lesbarkeit abgeschnitten. ``` Distribution: ARN: arn:aws:cloudfront::111122223333:distribution/EBEDLT3BGRBBW ... truncated ... DistributionConfig: ... truncated ... DefaultCacheBehavior: ... truncated ... FunctionAssociations: Items: - EventType: viewer-request FunctionARN: arn:aws:cloudfront::111122223333:function/ExampleFunction Quantity: 1 ... truncated ... DomainName: d111111abcdef8.cloudfront.net Id: EDFDVBD6EXAMPLE LastModifiedTime: '2021-04-19T22:39:09.158000+00:00' Status: InProgress ETag: E2VJGGQEG1JT8S ``` ------ Der `Status` der Verteilung ändert sich in `InProgress` während der erneuten Bereitstellung der Verteilung. Wenn die neue Distributionskonfiguration einen CloudFront-Edge-Standort erreicht, beginnt dieser Edge-Standort mit der Verwendung der zugehörigen Funktion. Wenn die Distribution vollständig bereitgestellt ist, ändert sich der `Status` wieder in `Deployed`. Dies weist darauf hin, dass die zugehörige CloudFront-Funktion an allen CloudFront-Edge-Standorten weltweit aktiv ist. Dies dauert in der Regel einige Minuten. # Amazon CloudFront Schlüsselwertspeicher Bei CloudFront KeyValueStore handelt es sich um einen sicheren, globalen Schlüsselwertdatenspeicher mit niedriger Latenz, der Lesezugriff von [CloudFront Functions](cloudfront-functions.md) aus ermöglicht und so eine erweiterte, anpassbare Logik an den CloudFront-Edge-Standorten ermöglicht. Mit CloudFront KeyValueStore aktualisieren Sie unabhängig voneinander Funktionscode und Daten, die mit einer Funktion verknüpft sind. Diese Trennung vereinfacht den Funktionscode und erleichtert die Aktualisierung von Daten, ohne dass Codeänderungen vorgenommen werden müssen. **Anmerkung** Um CloudFront KeyValueStore verwenden zu können, muss Ihre CloudFront-Funktion die [JavaScript-Laufzeitumgebung 2.0](functions-javascript-runtime-20.md) verwenden. Dies ist das allgemeine Verfahren für die Verwendung von Schlüssel-Wert-Paaren: + Erstellen Sie Schlüsselwertspeicher und füllen Sie sie mit einer Reihe von Schlüssel-Wert-Paaren. Sie können Ihre Schlüsselwertspeicher zu einem Amazon-S3-Bucket hinzufügen oder sie manuell eingeben. + Ordnen Sie die Schlüsselwertspeicher Ihrer CloudFront-Funktion zu. + Verwenden Sie in Ihrem Funktionscode den Namen des Schlüssels, um entweder den mit dem Schlüssel verknüpften Wert abzurufen oder um zu bestimmen, ob ein Schlüssel existiert. Weitere Informationen zur Verwendung von Schlüssel-Wert-Paaren im Funktionscode und zu Hilfsmethoden finden Sie unter [Hilfsmethoden für Schlüsselwertspeicher](functions-custom-methods.md). ## Anwendungsfälle Sie können Schlüssel-Wert-Paare für die folgenden Beispiele verwenden: + **URL-Umschreibungen oder -Weiterleitungen** – Das Schlüssel-Wert-Paar kann die umgeschriebenen oder umgeleiteten URLs enthalten. + **A/B-Tests und Feature-Flags** – Sie können eine Funktion zur Durchführung von Experimenten erstellen, indem Sie einer bestimmten Version Ihrer Website einen Prozentsatz des Datenverkehrs zuweisen. + **Zugriffsberechtigung** – Sie können eine Zugriffskontrolle implementieren, um Anforderungen auf der Grundlage von Kriterien zuzulassen oder abzulehnen, die von Ihnen und den in einem Schlüsselwertspeicher gespeicherten Daten definiert wurden. ## Unterstützte Formate für Werte Der Wert in einem Schlüssel-Wert-Paar kann in einem der folgenden Formate gespeichert werden: + String + bytekodierte Zeichenfolge + JSON ## Sicherheit Die Sicherheit der CloudFront-Funktion und der Daten ihrer Schlüsselwertspeicher wird wie folgt sichergestellt: + CloudFront verschlüsselt jeden Schlüsselwertspeicher im Ruhezustand und während der Übertragung (beim Lesen oder Schreiben in den Schlüsselwertspeicher), wenn Sie die API-Operationen von [CloudFront KeyValueStore](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_Operations_Amazon_CloudFront_KeyValueStore.html) aufrufen. + Wenn die Funktion ausgeführt wird, entschlüsselt CloudFront jedes Schlüssel-Wert-Paar im Speicher an den CloudFront-Edge-Standorten. Die ersten Schritte mit CloudFront KeyValueStore werden in den folgenden Themen erläutert. **Topics** + [ ## Anwendungsfälle ](#key-value-store-use-cases) + [ ## Unterstützte Formate für Werte ](#key-value-store-supported-formats) + [ ## Sicherheit ](#key-value-store-security) + [ # Arbeiten mit einem Schlüsselwertspeicher ](kvs-with-functions-kvs.md) + [ # Arbeiten mit Schlüsselwertdaten ](kvs-with-functions-kvp.md) + Weitere Informationen zu den ersten Schritten mit CloudFront KeyValueStore finden Sie im AWS-Blogbeitrag [Introducing Amazon CloudFront KeyValueStore](https://aws.amazon.com/blogs/aws/introducing-amazon-cloudfront-keyvaluestore-a-low-latency-datastore-for-cloudfront-functions/). # Arbeiten mit einem Schlüsselwertspeicher Sie müssen einen Schlüsselwertspeicher für die Schlüssel-Wert-Paare erstellen, die Sie in CloudFront Functions verwenden möchten. Nachdem Sie den Schlüsselwertspeicher erstellt und Schlüssel-Wert-Paare hinzugefügt haben, können Sie die Schlüsselwerte in Ihrem CloudFront-Funktionscode verwenden. Die ersten Schritte werden in den folgenden Themen behandelt: **Topics** + [ # Erstellen eines Schlüsselwertspeichers ](kvs-with-functions-create.md) + [ # Zuordnen eines Schlüsselwertspeichers zu einer Funktion ](kvs-with-functions-associate.md) + [ # Aktualisieren eines Schlüsselwertspeichers ](kvs-with-functions-edit.md) + [ # Abrufen eines Verweises auf einen Schlüsselwertspeicher ](kvs-with-functions-get-reference.md) + [ # Löschen eines Schlüsselwertspeichers ](kvs-with-functions-delete.md) + [ # Dateiformat für Schlüssel-Wert-Paare ](kvs-with-functions-create-s3-kvp.md) **Anmerkung** Die JavaScript-Runtime 2.0 enthält einige Hilfsmethoden für die Arbeit mit Schlüsselwerten im Funktionscode. Weitere Informationen finden Sie unter [Hilfsmethoden für Schlüsselwertspeicher](functions-custom-methods.md). # Erstellen eines Schlüsselwertspeichers Sie können einen Schlüsselwertspeicher und seine Schlüssel-Wert-Paare gleichzeitig erstellen. Sie können auch einen leeren Schlüsselwertspeicher erstellen und später die Schlüssel-Wert-Paare hinzufügen. **Anmerkung** Wenn Sie einen Amazon-S3-Bucket als Ihre Datenquelle angeben, benötigen Sie die `s3:GetBucketLocation`- und `s3:GetObject`-Berechtigungen für diesen Bucket. Wenn Sie nicht über diese Berechtigungen verfügen, kann CloudFront Ihren Schlüsselwertspeicher nicht erfolgreich erstellen. Entscheiden Sie, ob Sie Schlüssel-Wert-Paare zeitgleich zur Erstellung des Schlüsselwertspeichers hinzufügen möchten. Sie können Ihre Schlüssel-Wert-Paare mithilfe der CloudFront-Konsole, der CloudFront-API oder der AWS SDKs importieren. Sie können Ihre Datei mit Schlüssel-Wert-Paaren jedoch nur dann importieren, wenn Sie den Schlüsselwertspeicher *neu* erstellen. Informationen zum Erstellen einer Datei mit Schlüssel-Wert-Paaren finden Sie unter [Dateiformat für Schlüssel-Wert-Paare](kvs-with-functions-create-s3-kvp.md). ------ #### [ Console ] **So erstellen Sie einen Schlüsselwertspeicher** 1. Melden Sie sich bei AWS-Managementkonsole an und öffnen Sie die Seite **Functions** in der CloudFront-Konsole unter [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Wählen Sie die Registerkarte **KeyValueStores** und dann **KeyValueStore erstellen** aus. 1. Geben Sie für den Schlüsselwertspeicher einen Namen und optional eine Beschreibung ein. 1. Vollständige **S3-URI**: + Wenn Sie über eine Datei mit Schlüssel-Wert-Paaren verfügen, geben Sie den Pfad zum Amazon-S3-Bucket ein, in dem Sie die Datei gespeichert haben. + Lassen Sie dieses Feld leer, wenn Sie die Schlüssel-Wert-Paare manuell eingeben möchten. 1. Wählen Sie **Erstellen** aus. Der Schlüsselwertspeicher ist jetzt vorhanden. Die Seite mit den Details für den neuen Schlüsselwertspeicher wird angezeigt. Die Informationen auf der Seite umfassen die ID und den ARN des Schlüsselwertspeichers. + Die ID ist eine zufällige Zeichenfolge, die in Ihrem AWS-Konto einzigartig ist. + Der ARN hat folgende Syntax: *AWS-Konto`:key-value-store/`**ID des Schlüsselwertspeichers* 1. Sehen Sie sich den Abschnitt **Schlüssel-Wert-Paare** an. Wenn Sie eine Datei importiert haben, werden in diesem Abschnitt einige Schlüssel-Wert-Paare angezeigt. Sie haben die folgenden Möglichkeiten: + Wenn Sie eine Datei importiert haben, können Sie weitere Werte manuell hinzufügen. + Wenn Sie keine Datei aus einem Amazon-S3-Bucket importiert haben und jetzt Schlüssel-Wert-Paare hinzufügen möchten, können Sie den nächsten Schritt ausführen. + Sie können diesen Schritt überspringen und die Schlüssel-Wert-Paare später hinzufügen. 1. So fügen Sie die Paare jetzt hinzu: 1. Wählen Sie **Schlüssel-Wert-Paare hinzufügen** aus. 1. Wählen Sie **Paar hinzufügen** und geben Sie einen Namen und einen Wert ein. Wiederholen Sie diesen Schritt, um weitere Paare hinzuzufügen. 1. Wenn Sie fertig sind, wählen Sie **Änderungen speichern**, um alle Schlüssel-Wert-Paare im Schlüsselwertspeicher zu speichern. Wählen Sie im angezeigten Dialogfeld **Ja** aus. 1. Wenn Sie den Schlüsselwertspeicher jetzt einer Funktion zuordnen möchten, füllen Sie den Abschnitt **Zugeordnete Funktionen** aus. Weitere Informationen finden Sie unter [Erstellen von Funktionen](create-function.md) oder [Aktualisieren von Funktionen](update-function.md). Sie können die Funktion auch später zuordnen und zwar entweder auf der Detailseite des Schlüsselwertspeichers oder auf der Detailseite der Funktionen. ------ #### [ AWS CLI ] **So erstellen Sie einen Schlüsselwertspeicher** + Führen Sie den folgenden Befehl aus, um einen Schlüsselwertspeicher zu erstellen und die Schlüssel-Wert-Paare aus einem Amazon-S3-Bucket zu importieren. ``` aws cloudfront create-key-value-store \ --name=keyvaluestore1 \ --comment="This is my key value store file" \ --import-source=SourceType=S3,SourceARN=arn:aws:s3:::amzn-s3-demo-bucket1/kvs-input.json ``` **Antwort** ``` { "ETag": "ETVABCEXAMPLE", "Location": "https://cloudfront.amazonaws.com/2020-05-31/key-value-store/arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example", "KeyValueStore": { "Name": "keyvaluestore1", "Id": "8aa76c93-3198-462c-aaf6-example", "Comment": "This is my key value store file", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example", "Status": "PROVISIONING", "LastModifiedTime": "2024-08-06T22:19:10.813000+00:00" } } ``` ------ #### [ API ] **So erstellen Sie einen Schlüsselwertspeicher** 1. Verwenden Sie die Operation [CloudFront CreateKeyValueStore](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_CreateKeyValueStore.html). Für diese Operation sind mehrere Parameter erforderlich: + ein `name` des Schlüsselwertspeichers. + Ein `comment`-Parameter mit einem Kommentar. + ein `import-source`-Parameter, mit dem Sie Schlüssel-Wert-Paare aus einer Datei importieren können, die in einem Amazon-S3-Bucket gespeichert ist. Der Import aus einer Datei ist nur beim Erstellen des Schlüsselwertspeichers möglich. Weitere Informationen zur Dateistruktur finden Sie unter [Dateiformat für Schlüssel-Wert-Paare](kvs-with-functions-create-s3-kvp.md). Die Operationsantwort enthält die folgenden Informationen: + Die in der Anforderung übergebenen Werte, einschließlich des von Ihnen zugewiesenen Namens. + Daten wie die Erstellungszeit. + ein `ETag` (z. B. `ETVABCEXAMPLE`), der ARN mit dem Namen des Schlüsselwertspeichers (z. B. `arn:aws:cloudfront::123456789012:key-value-store/keyvaluestore1`). Sie verwenden eine Kombination aus `ETag`, ARN und dem Namen, um programmgesteuert mit dem Schlüsselwertspeicher zu arbeiten. ------ ## Statuswerte des Schlüsselwertspeichers Wenn Sie einen Schlüsselwertspeicher erstellen, kann der Datenspeicher die folgenden Statuswerte haben. **** | Wert | Beschreibung | | --- | --- | | **Bereitstellung** | Der Schlüsselwertspeicher wurde erstellt und CloudFront verarbeitet die von Ihnen angegebene Datenquelle. | | **Bereit** | Der Schlüsselwertspeicher wurde erstellt und CloudFront hat die von Ihnen angegebene Datenquelle erfolgreich verarbeitet. | | **Import fehlgeschlagen** | CloudFront konnte die von Ihnen angegebene Datenquelle nicht verarbeiten. Dieser Status kann angezeigt werden, wenn Ihr Dateiformat nicht gültig ist oder wenn die Datei die Größenbeschränkung überschreitet. Weitere Informationen finden Sie unter [Dateiformat für Schlüssel-Wert-Paare](kvs-with-functions-create-s3-kvp.md). | # Zuordnen eines Schlüsselwertspeichers zu einer Funktion Nachdem Sie Ihren Schlüsselwertspeicher erstellt haben, können Sie Ihre Funktion aktualisieren, um sie Ihrem Schlüsselwertspeicher zuzuordnen. Sie müssen diese Zuordnung vornehmen, um die Schlüssel-Wert-Paare aus diesem Speicher in dieser Funktion verwenden zu können. Die folgenden Regeln gelten: + Eine Funktion kann nur einen Schlüsselwertspeicher haben. + Ein Schlüsselwertspeicher kann mehreren Funktionen zugeordnet werden. ------ #### [ Console ] **So ordnen Sie einen Schlüsselwertspeicher einer Funktion zu** 1. Melden Sie sich auf [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) bei der CloudFront-Konsole an und öffnen Sie die Seite **Funktionen**. 1. Wählen Sie den Funktionsnamen aus. 1. Wählen Sie im Abschnitt **KeyValueStore zuordnen** die Option **Vorhandenen KeyValueStore zuordnen** aus. 1. Wählen Sie den Schlüsselwertspeicher, der die Schlüssel-Wert-Paare in der Funktion enthält, und dann **KeyValueStore zuordnen** aus. CloudFront ordnet den Store sofort der Funktion zu. Sie müssen die Funktion nicht speichern. 1. Um einen anderen Schlüsselwertspeicher anzugeben, wählen Sie **Zugeordneten KeyValueStore aktualisieren**, den Namen eines anderen Schlüsselwertspeichers und anschließend **KeyValueStore zuordnen** aus. Weitere Informationen finden Sie unter [Aktualisieren von Funktionen](update-function.md). ------ #### [ AWS CLI ] **So ordnen Sie einen Schlüsselwertspeicher einer Funktion zu** + Führen Sie den folgenden Befehl aus, um die `MaxAge`-Funktion zu aktualisieren und eine Schlüsselwertspeicherressource zuzuordnen. ``` aws cloudfront update-function \ --name MaxAge \ --function-config '{"Comment":"Max Age 2 years","Runtime":"cloudfront-js-2.0","KeyValueStoreAssociations":{"Quantity":1,"Items":[{"KeyValueStoreARN":"arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example"}]}}' \ --function-code fileb://function-max-age-v1.js \ --if-match ETVABCEXAMPLE ``` + Um einen Schlüsselwertspeicher einer Funktion zuzuordnen, geben Sie den Parameter `KeyValueStoreAssociations` und den ARN des Schlüsselwertspeichers an. + Um die Zuordnung zu ändern, geben Sie den ARN eines anderen Schlüsselwertspeichers an. + Um die Zuordnung zu entfernen, entfernen Sie den Parameter `KeyValueStoreAssociations`. Weitere Informationen finden Sie unter [Aktualisieren von Funktionen](update-function.md). ------ #### [ API ] **So ordnen Sie einen Schlüsselwertspeicher einer Funktion zu** + Verwenden Sie die API-Operation [UpdateFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateFunction.html). Weitere Informationen finden Sie unter [Aktualisieren von Funktionen](update-function.md). ------ **Hinweise** Wenn Sie einen Schlüsselwertspeicher bearbeiten, ohne die Schlüssel-Wert-Paare zu ändern, oder wenn Sie nur die Schlüssel-Wert-Paare im Schlüsselwertspeicher bearbeiten, müssen Sie den Schlüsselwertspeicher nicht erneut zuordnen. Sie müssen die Funktion auch nicht erneut veröffentlichen. Wir empfehlen jedoch, die Funktion zu testen, um zu überprüfen, ob sie erwartungsgemäß funktioniert. Weitere Informationen finden Sie unter [Testfunktionen](test-function.md). Sie können alle Funktionen anzeigen, die bestimmte Schlüsselwertspeicher verwenden. Öffnen Sie in der CloudFront-Konsole die Detailseite des Schlüsselwertspeichers. # Aktualisieren eines Schlüsselwertspeichers Wenn Sie einen Schlüsselwertspeicher aktualisieren, können Sie die Schlüssel-Wert-Paare ändern oder die Zuordnung zwischen dem Schlüsselwertspeicher und der Funktion ändern. ------ #### [ Console ] **So aktualisieren Sie einen Schlüsselwertspeicher** 1. Melden Sie sich bei AWS-Managementkonsole an und öffnen Sie die Seite **Functions** in der CloudFront-Konsole unter [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Wählen Sie die Registerkarte **KeyValueStores**. 1. Wählen Sie den Schlüsselwertspeicher aus, den Sie aktualisieren möchten. + Um die Schlüssel-Wert-Paare zu aktualisieren, wählen Sie **Bearbeiten** im Abschnitt **Schlüssel-Wert-Paare** aus. Sie können beliebige Schlüssel-Wert-Paare hinzufügen oder löschen. Sie können auch den Wert eines vorhandenen Schlüssel-Wert-Paares ändern. Wenn Sie fertig sind, wählen Sie **Änderungen speichern** aus. + Um die Zuordnung dieses Schlüsselwertspeichers zu aktualisieren, wählen Sie **Gehe zu Funktionen** aus. Weitere Informationen finden Sie unter [Zuordnen eines Schlüsselwertspeichers zu einer Funktion](kvs-with-functions-associate.md). ------ #### [ AWS CLI ] **So aktualisieren Sie einen Schlüsselwertspeicher** 1. **Ändern der Schlüssel-Wert-Paare** – Sie können weitere Schlüssel-Wert-Paare hinzufügen, ein oder mehrere Schlüssel-Wert-Paare löschen und den Wert für ein vorhandenes Schlüssel-Wert-Paar ändern. Weitere Informationen finden Sie unter [Arbeiten mit Schlüsselwertdaten](kvs-with-functions-kvp.md). 1. **Ändern der Funktionszuordnung für den Schlüsselwertspeicher** – Informationen zum Aktualisieren der Funktionszuordnung für den Schlüsselwertspeicher finden Sie unter [Zuordnen eines Schlüsselwertspeichers zu einer Funktion](kvs-with-functions-associate.md). **Tipp** Sie benötigen den ARN des Schlüsselwertspeichers. Weitere Informationen finden Sie unter [Abrufen eines Verweises auf einen Schlüsselwertspeicher](kvs-with-functions-get-reference.md). ------ #### [ API ] **So aktualisieren Sie einen Schlüsselwertspeicher** 1. **Ändern der Schlüssel-Wert-Paare** – Sie können weitere Schlüssel-Wert-Paare hinzufügen, ein oder mehrere Schlüssel-Wert-Paare löschen und den Wert für ein vorhandenes Schlüssel-Wert-Paar ändern. Weitere Informationen finden Sie unter [Arbeiten mit Schlüsselwertdaten](kvs-with-functions-kvp.md). 1. **Ändern der Funktionszuordnung für den Schlüsselwertspeicher** – Verwenden Sie zum Aktualisieren der Funktionszuordnung für den Schlüsselwertspeicher die API-Operation [UpdateFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateFunction.html). Weitere Informationen finden Sie unter [Aktualisieren von Funktionen](update-function.md). **Tipp** Sie benötigen den ARN des Schlüsselwertspeichers. Weitere Informationen finden Sie unter [Abrufen eines Verweises auf einen Schlüsselwertspeicher](kvs-with-functions-get-reference.md). ------ # Abrufen eines Verweises auf einen Schlüsselwertspeicher Sie benötigen das `ETag` und den Namen des Schlüsselwertspeichers, um programmgesteuert mit dem Schlüsselwertspeicher arbeiten zu können. Um beide Werte abzurufen, können Sie die AWS Command Line Interface (AWS CLI) oder die CloudFront-API verwenden. ------ #### [ AWS CLI ] **So rufen Sie den Verweis auf einen Schlüsselwertspeicher ab** 1. Um eine Liste von Schlüsselwertspeichern abzurufen, führen Sie den folgenden Befehl aus. Suchen Sie den Namen des Schlüsselwertspeichers, den Sie bearbeiten möchten. ``` aws cloudfront list-key-value-stores ``` 1. Suchen Sie in der Antwort den Namen des gewünschten Schlüsselwertspeichers. **Antwort** ``` { "KeyValueStoreList": { "Items": [ { "Name": "keyvaluestore3", "Id": "37435e19-c205-4271-9e5c-example3", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example3", "Status": "READY", "LastModifiedTime": "2024-05-08T14:50:18.876000+00:00" }, { "Name": "keyvaluestore2", "Id": "47970d59-6408-474d-b850-example2", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/47970d59-6408-474d-b850-example2", "Status": "READY", "LastModifiedTime": "2024-05-30T21:06:22.113000+00:00" }, { "Name": "keyvaluestore1", "Id": "8aa76c93-3198-462c-aaf6-example", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example", "Status": "READY", "LastModifiedTime": "2024-08-06T22:19:30.510000+00:00" } ] } } ``` 1. Führen Sie den folgenden Befehl aus, um das `ETag` für den angegebenen Schlüsselwertspeicher abzurufen. ``` aws cloudfront describe-key-value-store \ --name=keyvaluestore1 ``` **Antwort** ``` { "ETag": "E3UN6WX5RRO2AG", "KeyValueStore": { "Name": "keyvaluestore1", "Id": "8aa76c93-3198-462c-aaf6-example", "Comment": "This is an example KVS", "ARN": "arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example", "Status": "READY", "LastModifiedTime": "2024-08-06T22:19:30.510000+00:00" } } ``` ------ #### [ API ] **So rufen Sie den Verweis auf einen Schlüsselwertspeicher ab** 1. Verwenden Sie die API-Operation [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html), um eine Liste von Schlüsselwertspeichern abzurufen. Suchen Sie den Namen des Schlüsselwertspeichers aus, den Sie ändern möchten. 1. Verwenden Sie die API-Operation [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeKeyValueStore.html) und geben Sie den Namen des im vorherigen Schritt zurückgegebenen Schlüsselwertspeichers an. ------ Die Antwort enthält eine UUID, den ARN des Schlüsselwertspeichers und das `ETag` des Schlüsselwertspeichers. + Das `ETag` ähnelt dem im Beispiel angegebenen `E3UN6WX5RRO2AG`. + Die UUID ist 128 Bit groß, wie z. B. `8aa76c93-3198-462c-aaf6-example`. + Der ARN umfasst die AWS-Konto-Nummer, die Konstante `key-value-store` und die UUID, wie im folgenden Beispiel: `arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example` Weitere Informationen über die `DescribeKeyValueStore`-Operation finden Sie unter [Informationen zum CloudFront KeyValueStore](kvs-with-functions-kvp.md#kvs-with-functions-api-describe). # Löschen eines Schlüsselwertspeichers Sie können Ihren Schlüsselwertspeicher mit der Amazon-CloudFront-Konsole oder der API löschen. ------ #### [ Console ] **So löschen Sie einen Schlüsselwertspeicher** 1. Melden Sie sich bei AWS-Managementkonsole an und öffnen Sie die Seite **Functions** in der CloudFront-Konsole unter [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Wählen Sie den Funktionsnamen aus. 1. Überprüfen Sie im Abschnitt **Zugeordneter KeyValueStore**, ob der Funktion ein Schlüsselwertspeicher zugeordnet ist. Ist dies der Fall, entfernen Sie die Zuordnung, indem Sie **KeyValueStore trennen** und dann **Zuordnung entfernen** auswählen. 1. Wählen Sie im Navigationsbereich die Seite **Funktionen** und dann die Registerkarte **KeyValueStores** aus. 1. Wählen Sie den zu löschenden Schlüsselwertspeicher und dann **Löschen** aus. ------ #### [ AWS CLI ] **So löschen Sie einen Schlüsselwertspeicher** 1. Rufen Sie das `ETag` und den Namen des Schlüsselwertspeichers ab. Weitere Informationen finden Sie unter [Abrufen eines Verweises auf einen Schlüsselwertspeicher](kvs-with-functions-get-reference.md). 1. Überprüfen Sie, ob der Schlüsselwertspeicher einer Funktion zugeordnet ist. Wenn dies der Fall ist, entfernen Sie die Zuordnung. Weitere Informationen zu diesen beiden Schritten finden Sie unter [Aktualisieren von Funktionen](update-function.md). 1. Wenn Sie den Namen und das `ETag` des Schlüsselwertspeichers abgerufen haben und dieser nicht mehr mit einer Funktion verknüpft ist, können Sie ihn löschen. Führen Sie den folgenden Befehl aus, um den angegebenen Schlüsselwertspeicher zu löschen. ``` aws cloudfront delete-key-value-store \ --name=keyvaluestore1 \ --if-match=E3UN6WX5RRO2AG ``` ------ #### [ API ] **So löschen Sie einen Schlüsselwertspeicher** 1. Rufen Sie das `ETag` und den Namen des Schlüsselwertspeichers ab. Weitere Informationen finden Sie unter [Abrufen eines Verweises auf einen Schlüsselwertspeicher](kvs-with-functions-get-reference.md). 1. Überprüfen Sie, ob der Schlüsselwertspeicher einer Funktion zugeordnet ist. Wenn dies der Fall ist, entfernen Sie die Zuordnung. Weitere Informationen zu diesen beiden Schritten finden Sie unter [Aktualisieren von Funktionen](update-function.md). 1. Verwenden Sie die CloudFront-API-Operation [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DeleteKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DeleteKeyValueStore.html), um den Schlüsselwertspeicher zu löschen. ------ # Dateiformat für Schlüssel-Wert-Paare Verwenden Sie das folgende JSON-Format, wenn Sie eine UTF-8-kodierte Datei erstellen: ``` { "data":[ { "key":"key1", "value":"value" }, { "key":"key2", "value":"value" } ] } ``` Ihre Datei darf keine doppelten Schlüssel enthalten. Wenn Sie in Ihrem Amazon-S3-Bucket eine ungültige Datei angegeben haben, können Sie die Datei aktualisieren, um alle Duplikate zu entfernen, und dann erneut versuchen, Ihren Schlüsselwertspeicher zu erstellen. Weitere Informationen finden Sie unter [Erstellen eines Schlüsselwertspeichers](kvs-with-functions-create.md). **Anmerkung** Die Datei für Ihre Datenquelle und ihre Schlüssel-Wert-Paare haben die folgenden Beschränkungen: Dateigröße – 5 MB Schlüsselgröße – 512 Zeichen Wertgröße – 1 024 Zeichen # Arbeiten mit Schlüsselwertdaten In diesem Thema wird beschrieben, wie Schlüssel-Wert-Paare zu einem vorhandenen Schlüsselwertspeicher hinzugefügt werden. Informationen zum Einbeziehen von Schlüssel-Wert-Paaren bei der anfänglichen Erstellung des Schlüsselwertspeichers finden Sie unter [Erstellen eines Schlüsselwertspeichers](kvs-with-functions-create.md). **Topics** + [ ## Arbeiten mit Schlüssel-Wert-Paaren (Konsole) ](#kvs-with-functions-kvp-using-console) + [ ## Informationen zum CloudFront KeyValueStore ](#kvs-with-functions-api-describe) + [ ## Arbeiten mit Schlüssel-Wert-Paaren (AWS CLI) ](#work-with-kvs-cli-keys) + [ ## Arbeiten mit Schlüssel-Wert-Paaren (API) ](#kvs-with-functions-kvp-using-api) ## Arbeiten mit Schlüssel-Wert-Paaren (Konsole) Sie können die CloudFront-Konsole verwenden, um mit Ihren Schlüssel-Wert-Paaren zu arbeiten. **So arbeiten Sie mit Schlüssel-Wert-Paaren** 1. Melden Sie sich bei AWS-Managementkonsole an und öffnen Sie die Seite **Functions** in der CloudFront-Konsole unter [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Wählen Sie die Registerkarte **KeyValueStores**. 1. Wählen Sie den Schlüsselwertspeicher aus, den Sie bearbeiten möchten. 1. Wählen Sie im Abschnitt **Schlüssel-Wert-Paare** die Option **Bearbeiten** aus. 1. Sie können ein Schlüssel-Wert-Paar hinzufügen oder löschen oder den Wert für ein vorhandenes Schlüssel-Wert-Paar ändern. 1. Wenn Sie fertig sind, wählen Sie **Änderungen speichern** aus. ## Informationen zum CloudFront KeyValueStore **Tipp** Die CloudFront-KeyValueStore-API ist ein globaler Dienst, der Signature Version 4A (SigV4A) für die Authentifizierung verwendet. Für die Verwendung temporärer Anmeldeinformationen mit SigV4A sind Sitzungstoken der Version 2 erforderlich. Weitere Informationen finden Sie unter [Verwenden temporärer Anmeldeinformationen mit der CloudFront-KeyValueStore-API](cloudfront-function-restrictions.md#regional-endpoint-for-key-value-store). Wenn Sie die AWS Command Line Interface (AWS CLI) oder Ihren eigenen Code verwenden, um die CloudFront-KeyValueStore-API aufzurufen, lesen Sie die folgenden Abschnitte. Wenn Sie mit einem Schlüsselwertspeicher und dessen Schlüssel-Wert-Paaren arbeiten, hängt der Service, den Sie aufrufen, von Ihrem Anwendungsfall ab: + Verwenden Sie den CloudFront-KeyValueStore-Service, um mit Schlüssel-Wert-Paaren in einem *vorhandenen* Schlüsselwertspeicher zu arbeiten. + Verwenden Sie den CloudFront-Service, um bei der *anfänglichen* Erstellung des Schlüsselwertspeichers Schlüssel-Wert-Paare in den Schlüsselwertspeicher aufzunehmen. Sowohl die CloudFront-API als auch die CloudFront-KeyValueStore-API verfügen über eine `DescribeKeyValueStore`-Operation. Sie werden zu unterschiedlichen Zwecken aufgerufen. Informationen zu den Unterschieden finden Sie in der folgenden Tabelle. | | DescribeKeyValueStore der CloudFront-API | DescribeKeyValueStore der CloudFront-KeyValueStore-API | | --- | --- | --- | | Daten über den Schlüsselwertspeicher | Gibt Daten zurück, z. B. den Status und das Datum, an dem der Schlüsselwertspeicher zuletzt geändert wurde. | Gibt Daten über die *Inhalte* der Speicherressource zurück – die Schlüssel-Wert-Paare im Speicher und die Größe der Inhalte. | | Daten, die den Schlüsselwertspeicher identifizieren | Gibt ein `ETag`, die UUID und den ARN des Schlüsselwertspeichers zurück. | Gibt ein `ETag` und den ARN des Schlüsselwertspeichers zurück. | **Hinweise** Jede DescribeKeyValueStore-Operation gibt ein *anderes* `ETag` zurück. Die `ETags` sind nicht austauschbar. Wenn Sie einen API-Vorgang aufrufen, um eine Aktion abzuschließen, müssen Sie das `ETag` der entsprechenden API angeben. Beispielsweise geben Sie bei der [DeleteKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DeleteKey.html)-Operation für CloudFront KeyValueStore das `ETag` an, das bei der [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html)-Operation für CloudFront KeyValueStore zurückgegeben wurde. Wenn Sie CloudFront Functions mithilfe von CloudFront KeyValueStore aufrufen, werden die Werte im Schlüsselwertspeicher während des Aufrufs der Funktion nicht aktualisiert oder geändert. Aktualisierungen werden zwischen den Aufrufen einer Funktion verarbeitet. ## Arbeiten mit Schlüssel-Wert-Paaren (AWS CLI) Sie können die folgenden AWS Command Line Interface-Befehle für CloudFront KeyValueStore ausführen. **Contents** + [ ### Auflisten von Schlüssel-Wert-Paaren ](#kvs-cli-list-keys) + [ ### Abrufen von Schlüssel-Wert-Paaren ](#kvs-cli-get-keys) + [ ### Beschreiben eines Schlüsselwertspeichers ](#kvs-cli-describe-keys) + [ ### Erstellen eines Schlüssel-Wert-Paares ](#kvs-cli-create-keys) + [ ### Löschen eines Schlüssel-Wert-Paares ](#kvs-cli-delete-keys) + [ ### Aktualisieren eines Schlüssel-Wert-Paares ](#kvs-cli-update-key) ### Auflisten von Schlüssel-Wert-Paaren Führen Sie den folgenden Befehl aus, um Schlüssel-Wert-Paare in Ihrem Schlüsselwertspeicher aufzulisten. ``` aws cloudfront-keyvaluestore list-keys \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Antwort** ``` { "Items": [ { "Key": "key1", "Value": "value1" } ] } ``` ### Abrufen von Schlüssel-Wert-Paaren Um ein Schlüssel-Wert-Paar in Ihrem Schlüsselwertspeicher abzurufen, führen Sie den folgenden Befehl aus. ``` aws cloudfront-keyvaluestore get-key \ --key=key1 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Antwort** ``` { "Key": "key1", "Value": "value1", "ItemCount": 1, "TotalSizeInBytes": 11 } ``` ### Beschreiben eines Schlüsselwertspeichers Um einen Schlüsselwertspeicher zu beschreiben, führen Sie den folgenden Befehl aus. ``` aws cloudfront-keyvaluestore describe-key-value-store \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Antwort** ``` { "ETag": "KV1F83G8C2ARO7P", "ItemCount": 1, "TotalSizeInBytes": 11, "KvsARN": "arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example", "Created": "2024-05-08T07:48:45.381000-07:00", "LastModified": "2024-08-05T13:50:58.843000-07:00", "Status": "READY" } ``` ### Erstellen eines Schlüssel-Wert-Paares Um ein Schlüssel-Wert-Paar in Ihrem Schlüsselwertspeicher zu erstellen, führen Sie den folgenden Befehl aus. ``` aws cloudfront-keyvaluestore put-key \ --if-match=KV1PA6795UKMFR9 \ --key=key2 \ --value=value2 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Antwort** ``` { "ETag": "KV13V1IB3VIYZZH", "ItemCount": 3, "TotalSizeInBytes": 31 } ``` ### Löschen eines Schlüssel-Wert-Paares Um ein Schlüssel-Wert-Paar zu löschen, führen Sie den folgenden Befehl aus. ``` aws cloudfront-keyvaluestore delete-key \ --if-match=KV13V1IB3VIYZZH \ --key=key1 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Output** ``` { "ETag": "KV1VC38T7YXB528", "ItemCount": 2, "TotalSizeInBytes": 22 } ``` ### Aktualisieren eines Schlüssel-Wert-Paares Sie können den `update-keys`-Befehl verwenden, um mehr als ein Schlüssel-Wert-Paar zu aktualisieren. Um beispielsweise ein vorhandenes Schlüssel-Wert-Paar zu löschen und ein anderes zu erstellen, führen Sie den folgenden Befehl aus. ``` aws cloudfront-keyvaluestore update-keys \ --if-match=KV2EUQ1WTGCTBG2 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example \ --deletes '[{"Key":"key2"}]' \ --puts '[{"Key":"key3","Value":"value3"}]' ``` **Antwort** ``` { "ETag": "KV3AEGXETSR30VB", "ItemCount": 3, "TotalSizeInBytes": 28 } ``` ## Arbeiten mit Schlüssel-Wert-Paaren (API) Folgen Sie diesem Abschnitt, um programmatisch mit Ihren Schlüssel-Wert-Paaren zu arbeiten. **Contents** + [ ### Abrufen eines Verweises auf einen Schlüsselwertspeicher ](#kvs-with-functions-api-ref) + [ ### Ändern von Schlüssel-Wert-Paaren in einem Schlüsselwertspeicher ](#kvs-with-functions-api-actions) + [ ### Beispielcode für CloudFront KeyValueStore ](#example-code-key-value-store) ### Abrufen eines Verweises auf einen Schlüsselwertspeicher Wenn Sie mit der CloudFront-KeyValueStore-API eine Schreiboperation aufrufen, müssen Sie den ARN und das `ETag` des Schlüsselwertspeichers angeben. Gehen Sie wie folgt vor, um diese Daten abzurufen: **So rufen Sie einen Verweis auf einen Schlüsselwertspeicher ab** 1. Verwenden Sie die API-Operation [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html), um eine Liste von Schlüsselwertspeichern abzurufen. Suchen Sie den Schlüsselwertspeicher, den Sie bearbeiten möchten. 1. Verwenden Sie die [API-Operation CloudFrontKeyValueStore DescribeKeyValueStore](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html) und geben Sie den Schlüsselwertspeicher aus dem vorherigen Schritt an. Die Antwort enthält den ARN und das `ETag` des Schlüsselwertspeichers. + Der ARN umfasst die AWS-Konto-Nummer, die Konstante `key-value-store` und die UUID, wie im folgenden Beispiel: `arn:aws:cloudfront::123456789012:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111` + Ein `ETag` sieht z. B. folgendermaßen aus: `ETVABCEXAMPLE2` ### Ändern von Schlüssel-Wert-Paaren in einem Schlüsselwertspeicher Sie können den Schlüsselwertspeicher angeben, der das zu aktualisierende Schlüssel-Wert-Paar enthält. Sehen Sie sich die folgenden API-Operationen für CloudFront KeyValueStore an: + [CloudFrontKeyValueStore DeleteKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DeleteKey.html) – löscht ein Schlüssel-Wert-Paar + [CloudFrontKeyValueStore GetKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_GetKey.html) – gibt ein Schlüssel-Wert-Paar zurück + [CloudFrontKeyValueStore ListKeys](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_ListKeys.html) – gibt eine Liste von Schlüssel-Wert-Paaren zurück + [CloudFrontKeyValueStore PutKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_PutKey.html) – ermöglicht die Ausführung folgender Aufgaben: + Erstellen Sie ein Schlüssel-Wert-Paar in einem Schlüsselwertspeicher, indem Sie einen neuen Schlüsselnamen und Wert angeben. + Legen Sie einen anderen Wert in einem vorhandenen Schlüssel-Wert-Paar fest, indem Sie einen vorhandenen Schlüsselnamen und einen neuen Schlüsselwert angeben. + [CloudFrontKeyValueStore UpdateKeys](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_UpdateKeys.html) – ermöglicht die Ausführung einer oder mehrerer der folgenden Aktionen in einer Alles-oder-Nichts-Operation: + Löschen eines oder mehrerer Schlüssel-Wert-Paare + Erstellen eines oder mehrerer neuer Schlüssel-Wert-Paare + Festlegen eines anderen Werts in einem oder mehreren vorhandenen Schlüssel-Wert-Paaren ### Beispielcode für CloudFront KeyValueStore **Example** Der folgende Code zeigt Ihnen, wie Sie die API-Operation `DescribeKeyValueStore` für einen Schlüsselwertspeicher aufrufen. ``` const { CloudFrontKeyValueStoreClient, DescribeKeyValueStoreCommand, } = require("@aws-sdk/client-cloudfront-keyvaluestore"); require("@aws-sdk/signature-v4-crt"); (async () => { try { const client = new CloudFrontKeyValueStoreClient({ region: "us-east-1" }); const input = { KvsARN: "arn:aws:cloudfront::123456789012:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111", }; const command = new DescribeKeyValueStoreCommand(input); const response = await client.send(command); } catch (e) { console.log(e); } })(); ```