Here is your custom content.
" } } } ``` ## Contoh objek acara Contoh berikut menunjukkan objek `event` lengkap. Ini adalah contoh pemanggilan untuk distribusi standar, dan bukan untuk distribusi multi-penyewa. Untuk distribusi multi-penyewa, `endpoint` bidang digunakan sebagai ganti Nilai dari `distributionDomainName` adalah nama CloudFront domain (misalnya, d111111abcdef8.cloudfront.net) dari `endpoint` grup koneksi yang terkait dengan acara tersebut. **catatan** Objek `event` adalah masukan untuk fungsi Anda. Fungsi Anda hanya mengembalikan hanya objek `request` atau `response`, bukan objek `event` lengkap. ``` { "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 fitur runtime untuk Fungsi CloudFront Lingkungan JavaScript runtime CloudFront Functions sesuai dengan [ECMAScript (ES) versi 5.1](https://www.ecma-international.org/ecma-262/5.1/) dan juga mendukung beberapa fitur ES versi 6 hingga 12. Untuk sebagian besar up-to-date fitur, kami menyarankan Anda menggunakan JavaScript runtime 2.0. Fitur JavaScript runtime 2.0 memiliki perubahan berikut dibandingkan dengan 1.0: + Metode modul buffer tersedia + Metode prototipe string non-standar berikut tidak tersedia: + `String.prototype.bytesFrom()` + `String.prototype.fromBytes()` + `String.prototype.fromUTF8()` + `String.prototype.toBytes()` + `String.prototype.toUTF8()` + Modul kriptografi memiliki perubahan berikut: + `hash.digest()`— Jenis pengembalian diubah menjadi `Buffer` jika tidak ada pengkodean yang disediakan + `hmac.digest()`— Jenis pengembalian diubah menjadi `Buffer` jika tidak ada pengkodean yang disediakan + Untuk informasi selengkapnya tentang fitur baru tambahan, lihat[JavaScript fitur runtime 2.0 untuk Fungsi CloudFront](functions-javascript-runtime-20.md). **Topics** + [JavaScript fitur runtime 1.0](functions-javascript-runtime-10.md) + [JavaScript fitur runtime 2.0](functions-javascript-runtime-20.md) # JavaScript fitur runtime 1.0 untuk Fungsi CloudFront Lingkungan JavaScript runtime CloudFront Functions sesuai dengan [ECMAScript (ES) versi 5.1](https://262.ecma-international.org/5.1/) dan juga mendukung beberapa fitur ES versi 6 hingga 9. Lingkungan ini juga menyediakan beberapa metode standar yang bukan bagian dari spesifikasi ES. Topik berikut mencantumkan semua fitur bahasa yang didukung. **Topics** + [Fitur inti](#writing-functions-javascript-features-core) + [Objek primitif](#writing-functions-javascript-features-primitive-objects) + [Objek bawaan](#writing-functions-javascript-features-builtin-objects) + [Jenis kesalahan](#writing-functions-javascript-features-error-types) + [Global](#writing-functions-javascript-features-globals) + [Modul bawaan](#writing-functions-javascript-features-builtin-modules) + [Fitur yang dibatasi](#writing-functions-javascript-features-restricted-features) ## Fitur inti Mendukung fitur inti ES berikut. **Jenis** Mendukung semua jenis ES 5.1. Ini termasuk nilai, angka, string, objek, susunan, fungsi, konstruktor fungsi, dan ekspresi reguler Boolean. **Operator** Mendukung Semua operator ES 5.1 didukung. Mendukung operator eksponensial ES 7 (`**`). **Pernyataan** Tidak mendukung pernyataan `const` dan `let`. Mendukung pernyataan ES 5.1 berikut: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `return` + `switch` + `throw` + `try` + `var` + `while` + Pernyataan berlabel **Literal** Literal template ES 6 didukung: string multiline, interpolasi ekspresi, dan templat bersarang. **Fungsi** Mendukung semua fitur fungsi ES 5.1. Mendukung fungsi panah ES 6 didukung, dan sintaks parameter ES 6 sintaks parameter istirahat. **Unicode** Sumber teks dan literal string dapat berisi karakter Unicode yang dikodekan. Juga mendukung unicode code point escape sequence enam karakter (misalnya, `\uXXXX`). **Mode ketat** Fungsi beroperasi dalam mode ketat secara default, sehingga Anda tidak perlu menambahkan pernyataan `use strict` dalam kode fungsi Anda. Ini tidak dapat diubah. ## Objek primitif Mendukung objek primitif ES berikut. **Objek** Mendukung metode ES 5.1 berikut pada objek: + `create` (tanpa daftar properti) + `defineProperties` + `defineProperty` + `freeze` + `getOwnPropertyDescriptor` + `getOwnPropertyNames` + `getPrototypeOf` + `hasOwnProperty` + `isExtensible` + `isFrozen` + `prototype.isPrototypeOf` + `isSealed` + `keys` + `preventExtensions` + `prototype.propertyIsEnumerable` + `seal` + `prototype.toString` + `prototype.valueOf` Mendukung metode ES 6 berikut pada objek: + `assign` + `is` + `prototype.setPrototypeOf` Mendukung metode ES 8 berikut pada objek: + `entries` + `values` **String** Mendukung metode ES 5.1 berikut pada string: + `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` Mendukung metode ES 6 berikut pada string: + `fromCodePoint` + `prototype.codePointAt` + `prototype.endsWith` + `prototype.includes` + `prototype.repeat` + `prototype.startsWith` Mendukung metode ES 8 berikut pada string: + `prototype.padStart` + `prototype.padEnd` Mendukung metode ES 9 berikut pada string: + `prototype.trimStart` + `prototype.trimEnd` Mendukung metode tidak standar berikut pada string: + `prototype.bytesFrom(array | string, encoding)` Menciptakan string byte dari susunan oktet atau string yang dikodekan. Opsi pengkodean string adalah `hex`, `base64`, dan `base64url`. + `prototype.fromBytes(start[, end])` Menciptakan string Unicode dari string byte di mana setiap byte diganti dengan titik kode Unicode yang sesuai. + `prototype.fromUTF8(start[, end])` Menciptakan string Unicode dari UTF-8 string byte yang dikodekan. Jika pengkodean salah, akan muncul `null`. + `prototype.toBytes(start[, end])` Menciptakan string byte dari string Unicode. Semua karakter harus dalam rentang [0,255]. Jika tidak, akan muncul `null`. + `prototype.toUTF8(start[, end])` Menciptakan UTF-8 string byte yang dikodekan dari string Unicode. **Nomor** Mendukung semua metode ES 5.1 pada nomor. Mendukung metode ES 6 berikut pada nomor: + `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` ## Objek bawaan Mendukung objek ES bawaan berikut. **Matematika** Mendukung semua metode matematika ES 5.1. Di lingkungan runtime CloudFront Functions, `Math.random()` implementasi menggunakan `arc4random` OpenBSD yang diunggulkan dengan stempel waktu saat fungsi berjalan. Mendukung metode matematika ES 6 berikut: + `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` **Tanggal** Mendukung semua fitur ES 5.1 `Date`. Untuk alasan keamanan, `Date` selalu mengembalikan nilai yang sama—waktu mulai fungsi ini—saat menjalankan fungsi tunggal. Untuk informasi selengkapnya, lihat [Fitur yang dibatasi](#writing-functions-javascript-features-restricted-features). **Fungsi** Mendukung metode `apply`, `bind`, dan `call`. Tidak mendukung konstruktor fungsi. **Ekspresi reguler** Mendukung semua fitur ekspresi reguler ES 5.1. Bahasa ekspresi reguler adalah kompatibel dengan Perl. Mendukung kelompok penangkap bernama ES 9. **JSON** Mendukung semua fitur JSON ES 5.1 JSON, termasuk `parse` dan `stringify`. **Susunan** Mendukung metode ES 5.1 berikut pada susunan: + `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` Mendukung metode ES 6 berikut pada susunan: + `of` + `prototype.copyWithin` + `prototype.fill` + `prototype.find` + `prototype.findIndex` Mendukung metode ES 7 berikut pada susunan: + `prototype.includes` **Susunan yang dijeniskan** Mendukung susunan yang diketik ES 6 berikut: + `Int8Array` + `Uint8Array` + `Uint8ClampedArray` + `Int16Array` + `Uint16Array` + `Int32Array` + `Uint32Array` + `Float32Array` + `Float64Array` + `prototype.copyWithin` + `prototype.fill` + `prototype.join` + `prototype.set` + `prototype.slice` + `prototype.subarray` + `prototype.toString` **ArrayBuffer** Mendukung metode pada `ArrayBuffer` berikut: + `prototype.isView` + `prototype.slice` **Janji** Mendukung metode janji berikut: + `reject` + `resolve` + `prototype.catch` + `prototype.finally` + `prototype.then` **Kripto** Modul kriptografi menyediakan hashing standar dan pembantu kode autentikasi pesan berbasis hash (HMAC). Anda dapat memuat modul menggunakan `require('crypto')`. Modul ini memperlihatkan metode berikut yang berperilaku persis seperti rekan-rekan Node.js mereka: + `createHash(algorithm)` + `hash.update(data)` + `hash.digest([encoding])` + `createHmac(algorithm, secret key)` + `hmac.update(data)` + `hmac.digest([encoding])` Untuk informasi lebih lanjut, lihat [Kripto (hash dan HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) di bagian modul bawaan. **Konsol** Ini adalah objek pembantu untuk debugging. Ini hanya mendukung metode `log()`, untuk merekam pesan log. CloudFront Fungsi tidak mendukung sintaks koma, seperti. `console.log('a', 'b')` Sebagai gantinya, gunakan `console.log('a' + ' ' + 'b')` formatnya. ## Jenis kesalahan Mendukung objek kesalahan berikut: + `Error` + `EvalError` + `InternalError` + `MemoryError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Global Mendukung objek `globalThis`. Mendukung fungsi global ES 5.1 berikut: + `decodeURI` + `decodeURIComponent` + `encodeURI` + `encodeURIComponent` + `isFinite` + `isNaN` + `parseFloat` + `parseInt` Mendukung konstanta global berikut: + `NaN` + `Infinity` + `undefined` ## Modul bawaan Mendukung modul bawaan berikut. **Topics** + [Kripto (hash dan HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) + [String kueri](#writing-functions-javascript-features-builtin-modules-query-string) ### Kripto (hash dan HMAC) Modul kriptografi (`crypto`) menyediakan hashing standar dan pembantu kode autentikasi pesan berbasis hash (HMAC). Anda dapat memuat modul menggunakan `require('crypto')`. Modul ini menyediakan metode berikut yang berperilaku persis seperti rekan-rekan Node.js mereka. **Metode hashing** `crypto.createHash(algorithm)` Menciptakan dan mengembalikan objek hash yang dapat digunakan untuk menghasilkan hash digests menggunakan algoritme yang diberikan: `md5`, `sha1`, atau `sha256`. `hash.update(data)` Update konten hash dengan `data` yang tersedia. `hash.digest([encoding])` Menghitung digest dari semua data yang diteruskan menggunakan `hash.update()`. Pengkodean dapat berupa `hex`, `base64`, atau `base64url`. **Metode HMAC** `crypto.createHmac(algorithm, secret key)` Menciptakan dan mengembalikan objek HMAC yang menggunakan `algorithm` dan `secret key` yang tersedia. Algoritma dapat berupa `md5`, `sha1`, atau `sha256`. `hmac.update(data)` Memperbarui konten HMAC dengan `data` yang tersedia. `hmac.digest([encoding])` Menghitung digest dari semua data yang diteruskan menggunakan `hmac.update()`. Pengkodean dapat berupa `hex`, `base64`, atau `base64url`. ### String kueri **catatan** [Objek acara CloudFront Functions](functions-event-structure.md) secara otomatis mem-parsing string kueri URL untuk Anda. Itu berarti bahwa dalam kebanyakan kasus Anda tidak perlu menggunakan modul ini. Modul string kueri (`querystring`) menyediakan metode untuk mengurai dan memformat string kueri URL. Anda dapat memuat modul menggunakan `require('querystring')`. Modul ini menyediakan metode berikut. `querystring.escape(string)` Mengkodekan URL `string` yang tersedia, mengembalikan string kueri yang lolos. Metode ini digunakan oleh `querystring.stringify()` dan tidak boleh digunakan secara langsung. `querystring.parse(string[, separator[, equal[, options]]])` Mengurai string kueri (`string`) dan mengembalikan objek. Parameter `separator` adalah substring untuk membatasi pasangan kunci dan nilai dalam string kueri. Secara default, itu adalah `&`. Parameter `equal` adalah substring untuk membatasi kunci dan nilai dalam string kueri. Secara default, itu adalah `=`. Parameter `options` adalah objek dengan kunci berikut: `decodeURIComponent function` Sebuah fungsi untuk memecahkan kode karakter persentase dikodekan dalam string kueri. Secara default, itu adalah `querystring.unescape()`. `maxKeys number` Jumlah kunci maksimum untuk diurai Secara default, itu adalah `1000`. Gunakan nilai `0` untuk menghapus pembatasan untuk menghitung kunci. Secara default, karakter persentase dikodekan dalam string kueri diasumsikan menggunakan pengkodean UTF-8. Urutan UTF-8 tidak valid diganti dengan karakter pengganti `U+FFFD`. Misalnya, untuk string kueri berikut: ``` 'name=value&abc=xyz&abc=123' ``` Nilai `querystring.parse()` yang dikembalikan adalah: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` adalah alias untuk `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Menyerialisasi `object` dan mengembalikan string kueri. Parameter `separator` adalah substring untuk membatasi pasangan kunci dan nilai dalam string kueri. Secara default, itu adalah `&`. Parameter `equal` adalah substring untuk membatasi kunci dan nilai dalam string kueri. Secara default, itu adalah `=`. Parameter `options` adalah objek dengan kunci berikut: `encodeURIComponent function` Fungsi yang digunakan untuk mengonversi karakter URL yang tidak aman untuk pengkodean persentase dalam string kueri. Secara default, itu adalah `querystring.escape()`. Secara default, karakter yang memerlukan pengkodean persentase dalam string kueri dikodekan sebagai UTF-8. Untuk menggunakan pengkodean yang berbeda, tentukan opsi `encodeURIComponent`. Misalnya, gunakan kode berikut: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` Nilai yang dikembalikan adalah: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` adalah alias untuk `querystring.stringify()`. `querystring.unescape(string)` Mendekode karakter yang dikodekan persentase URL dalam `string` yang tersedia, mengembalikan string kueri yang tidak lolos. Metode ini digunakan oleh `querystring.parse()` dan tidak boleh digunakan secara langsung. ## Fitur yang dibatasi Fitur JavaScript bahasa berikut tidak didukung atau dibatasi karena masalah keamanan. **Evaluasi kode dinamis** Evaluasi kode dinamis tidak didukung. Konstruktor `eval()` dan `Function` mengalami kesalahan jika dicoba. Misalnya, `const sum = new Function('a', 'b', 'return a + b')` mengalami kesalahan. **Timer** Fungsi `setTimeout()`, `setImmediate()`, dan `clearTimeout()` tidak didukung. Tidak ada ketentuan untuk menunda atau menghasilkan dalam fungsi jalankan. Fungsi Anda harus dijalankan secara serentak sampai selesai. **Tanggal dan stempel waktu** Untuk alasan keamanan, tidak ada akses ke timer beresolusi tinggi. Semua metode `Date` untuk meminta waktu saat ini selalu mengembalikan nilai yang sama saat menjalankan fungsi tunggal. Stempel waktu yang dikembalikan adalah waktu fungsi mulai berjalan. Akibatnya, Anda tidak dapat mengukur waktu berlalu dalam fungsi Anda. **Akses sistem file** Tidak ada akses sistem file. Misalnya, tidak ada modul `fs` untuk akses sistem file seperti yang ada di Node.js. **Akses proses** Tidak ada akses proses. Misalnya, tidak ada objek `process` global untuk memproses akses informasi seperti yang ada di Node.js. **Variabel-variabel lingkungan** Tidak ada akses ke variabel lingkungan. Sebagai gantinya, Anda dapat menggunakan CloudFront KeyValueStore untuk membuat datastore terpusat dari pasangan kunci-nilai untuk Fungsi Anda. CloudFront CloudFront KeyValueStore memungkinkan pembaruan dinamis ke data konfigurasi Anda tanpa perlu menerapkan perubahan kode. Anda harus menggunakan [JavaScript runtime 2.0](functions-javascript-runtime-20.md) untuk menggunakannya CloudFront KeyValueStore. Untuk informasi selengkapnya, lihat [Amazon CloudFront KeyValueStore](kvs-with-functions.md). **Akses jaringan** Tidak ada dukungan untuk panggilan jaringan. Misalnya, XHR, HTTP (S), dan soket tidak didukung. # JavaScript fitur runtime 2.0 untuk Fungsi CloudFront Lingkungan JavaScript runtime CloudFront Functions sesuai dengan [ECMAScript (ES) versi 5.1](https://262.ecma-international.org/5.1/) dan juga mendukung beberapa fitur ES versi 6 hingga 12. Lingkungan ini juga menyediakan beberapa metode standar yang bukan bagian dari spesifikasi ES. Topik berikut mencantumkan semua fitur yang didukung dalam runtime ini. **Topics** + [Fitur inti](#writing-functions-javascript-features-core-20) + [Objek primitif](#writing-functions-javascript-features-primitive-objects-20) + [Objek bawaan](#writing-functions-javascript-features-builtin-objects-20) + [Jenis kesalahan](#writing-functions-javascript-features-error-types-20) + [Global](#writing-functions-javascript-features-globals-20) + [Modul bawaan](#writing-functions-javascript-features-builtin-modules-20) + [Fitur yang dibatasi](#writing-functions-javascript-features-restricted-features-20) ## Fitur inti Mendukung fitur inti ES berikut. **Jenis** Mendukung semua jenis ES 5.1. Ini termasuk nilai boolean, angka, string, objek, array, fungsi, dan ekspresi reguler. **Operator** Mendukung Semua operator ES 5.1 didukung. Mendukung operator eksponensial ES 7 (`**`). **Pernyataan** Mendukung pernyataan ES 5.1 berikut: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `label` + `return` + `switch` + `throw` + `try` + `var` + `while` Pernyataan ES 6 berikut didukung: + `const` + `let` Pernyataan ES 8 berikut didukung: + `async` + `await` `async`,`await`,`const`, dan `let` didukung dalam JavaScript runtime 2.0. `await`hanya dapat digunakan di dalam `async` fungsi. `async`argumen dan penutupan tidak didukung. **Literal** Literal template ES 6 didukung: string multiline, interpolasi ekspresi, dan templat bersarang. **Fungsi** Mendukung semua fitur fungsi ES 5.1. Mendukung fungsi panah ES 6 didukung, dan sintaks parameter ES 6 sintaks parameter istirahat. **Unicode** Sumber teks dan literal string dapat berisi karakter Unicode yang dikodekan. Juga mendukung unicode code point escape sequence enam karakter (misalnya, `\uXXXX`). **Mode ketat** Fungsi beroperasi dalam mode ketat secara default, sehingga Anda tidak perlu menambahkan pernyataan `use strict` dalam kode fungsi Anda. Ini tidak dapat diubah. ## Objek primitif Mendukung objek primitif ES berikut. **Objek** Mendukung metode ES 5.1 berikut pada objek: + `Object.create()` (tanpa daftar properti) + `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()` Mendukung metode ES 6 berikut pada objek: + `Object.assign()` Mendukung metode ES 8 berikut pada objek: + `Object.entries()` + `Object.values()` Metode prototipe ES 5.1 berikut pada objek didukung: + `Object.prototype.hasOwnProperty()` + `Object.prototype.isPrototypeOf()` + `Object.prototype.propertyIsEnumerable()` + `Object.prototype.toString()` + `Object.prototype.valueOf()` Metode prototipe ES 6 berikut pada objek didukung: + `Object.prototype.is()` + `Object.prototype.setPrototypeOf()` **String** Mendukung metode ES 5.1 berikut pada string: + `String.fromCharCode()` Mendukung metode ES 6 berikut pada string: + `String.fromCodePoint()` Metode prototipe ES 5.1 berikut pada string didukung: + `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()` Metode prototipe ES 6 berikut pada string didukung: + `String.prototype.codePointAt()` + `String.prototype.endsWith()` + `String.prototype.includes()` + `String.prototype.repeat()` + `String.prototype.startsWith()` Metode prototipe ES 8 berikut pada string didukung: + `String.prototype.padStart()` + `String.prototype.padEnd()` Metode prototipe ES 9 berikut pada string didukung: + `String.prototype.trimStart()` + `String.prototype.trimEnd()` Metode prototipe ES 12 berikut pada string didukung: + `String.prototype.replaceAll()` **catatan** `String.prototype.replaceAll()`baru di JavaScript runtime 2.0. **Bilangan** SEMUA nomor ES 5 didukung. Properti ES 6 berikut pada angka didukung: + `Number.EPSILON` + `Number.MAX_SAFE_INTEGER` + `Number.MIN_SAFE_INTEGER` + `Number.MAX_VALUE` + `Number.MIN_VALUE` + `Number.NaN` + `Number.NEGATIVE_INFINITY` + `Number.POSITIVE_INFINITY` Mendukung metode ES 6 berikut pada nomor: + `Number.isFinite()` + `Number.isInteger()` + `Number.isNaN()` + `Number.isSafeInteger()` + `Number.parseInt()` + `Number.parseFloat()` Metode prototipe ES 5.1 berikut pada angka didukung: + `Number.prototype.toExponential()` + `Number.prototype.toFixed()` + `Number.prototype.toPrecision()` Pemisah numerik ES 12 didukung. Pemisah numerik ES 12 baru di JavaScript runtime 2.0. ## Objek bawaan Mendukung objek ES bawaan berikut. **Matematika** Mendukung semua metode matematika ES 5.1. Di lingkungan runtime CloudFront Functions, `Math.random()` implementasi menggunakan `arc4random` OpenBSD yang diunggulkan dengan stempel waktu saat fungsi berjalan. Properti matematika ES 6 berikut didukung: + `Math.E` + `Math.LN10` + `Math.LN2` + `Math.LOG10E` + `Math.LOG2E` + `Math.PI` + `Math.SQRT1_2` + `Math.SQRT2` Mendukung metode matematika ES 6 berikut: + `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()` **Tanggal** Mendukung semua fitur ES 5.1 `Date`. Untuk alasan keamanan, `Date` selalu mengembalikan nilai yang sama—waktu mulai fungsi ini—saat menjalankan fungsi tunggal. Untuk informasi selengkapnya, lihat [Fitur yang dibatasi](functions-javascript-runtime-10.md#writing-functions-javascript-features-restricted-features). **Fungsi** Metode prototipe ES 5.1 berikut didukung: + `Function.prototype.apply()` + `Function.prototype.bind()` + `Function.prototype.call()` Tidak mendukung konstruktor fungsi. **Ekspresi reguler** Mendukung semua fitur ekspresi reguler ES 5.1. Bahasa ekspresi reguler adalah kompatibel dengan Perl. Properti pengakses prototipe ES 5.1 berikut didukung: + `RegExp.prototype.global` + `RegExp.prototype.ignoreCase` + `RegExp.protoype.multiline` + `RegExp.protoype.source` + `RegExp.prototype.sticky` + `RegExp.prototype.flags` **catatan** `RegExp.prototype.sticky`dan `RegExp.prototype.flags` baru di JavaScript runtime 2.0. Metode prototipe ES 5.1 berikut didukung: + `RegExp.prototype.exec()` + `RegExp.prototype.test()` + `RegExp.prototype.toString()` + `RegExp.prototype[@@replace]()` + `RegExp.prototype[@@split]()` **catatan** `RegExp.prototype[@@split]()`baru di JavaScript runtime 2.0. Properti instans ES 5.1 berikut didukung: + `lastIndex` Mendukung kelompok penangkap bernama ES 9. **JSON** Metode ES 5.1 berikut didukung: + `JSON.parse()` + `JSON.stringify()` **Array** Mendukung metode ES 5.1 berikut pada susunan: + `Array.isArray()` Mendukung metode ES 6 berikut pada susunan: + `Array.of()` Metode prototipe ES 5.1 berikut didukung: + `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()` Metode prototipe ES 6 berikut didukung + `Array.prototype.copyWithin()` + `Array.prototype.fill()` + `Array.prototype.find()` + `Array.prototype.findIndex()` Metode prototipe ES 7 berikut didukung: + `Array.prototype.includes()` **Susunan yang dijeniskan** Konstruktor array yang diketik ES 6 berikut didukung: + `Float32Array` + `Float64Array` + `Int8Array` + `Int16Array` + `Int32Array` + `Uint8Array` + `Uint8ClampedArray` + `Uint16Array` + `Uint32Array` Metode ES 6 berikut didukung: + `TypedArray.from()` + `TypedArray.of()` **catatan** `TypedArray.from()`dan `TypedArray.of()` baru di JavaScript runtime 2.0. Metode prototipe ES 6 berikut didukung: + `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()` **catatan** `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()`,, dan `TypedArray.prototype.some()` baru di JavaScript runtime 2.0. **ArrayBuffer** Metode ES 6 berikut ArrayBuffer didukung: + `isView()` Metode prototipe ES 6 berikut ArrayBuffer didukung: + `ArrayBuffer.prototype.slice()` **Janji** Metode ES 6 berikut pada janji didukung: + `Promise.all()` + `Promise.allSettled()` + `Promise.any()` + `Promise.reject()` + `Promise.resolve()` + `Promise.race()` **catatan** `Promise.all()`,`Promise.allSettled()`,`Promise.any()`, dan `Promise.race()` baru di JavaScript runtime 2.0. Metode prototipe ES 6 berikut pada janji didukung: + `Promise.prototype.catch()` + `Promise.prototype.finally()` + `Promise.prototype.then()` **DataView** Metode prototipe ES 6 berikut didukung: + `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()` **catatan** Semua metode prototipe Dataview ES 6 baru di JavaScript runtime 2.0. **Simbol** Metode ES 6 berikut didukung: + `Symbol.for()` + `Symbol.keyfor()` **catatan** Semua metode Symbol ES 6 baru di JavaScript runtime 2.0. **Teks Decoder** Metode prototipe berikut didukung: + `TextDecoder.prototype.decode()` Properti pengakses prototipe berikut didukung: + `TextDecoder.prototype.encoding` + `TextDecoder.prototype.fatal` + `TextDecoder.prototype.ignoreBOM` **Encoder Teks** Metode prototipe berikut didukung: + `TextEncoder.prototype.encode()` + `TextEncoder.prototype.encodeInto()` **Konsol** Ini adalah objek pembantu untuk debugging. Ini hanya mendukung metode `log()`, untuk merekam pesan log. CloudFront Fungsi tidak mendukung sintaks koma, seperti. `console.log('a', 'b')` Sebagai gantinya, gunakan `console.log('a' + ' ' + 'b')` formatnya. ## Jenis kesalahan Mendukung objek kesalahan berikut: + `Error` + `EvalError` + `InternalError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Global Mendukung objek `globalThis`. Mendukung fungsi global ES 5.1 berikut: + `decodeURI()` + `decodeURIComponent()` + `encodeURI()` + `encodeURIComponent()` + `isFinite()` + `isNaN()` + `parseFloat()` + `parseInt()` Fungsi global ES 6 berikut didukung: + `atob()` + `btoa()` **catatan** `atob()`dan `btoa()` baru di JavaScript runtime 2.0. Mendukung konstanta global berikut: + `NaN` + `Infinity` + `undefined` + `arguments` ## Modul bawaan Mendukung modul bawaan berikut. **Topics** + [Penyangga](#writing-functions-javascript-features-builtin-modules-buffer-20) + [String kueri](#writing-functions-javascript-features-builtin-modules-query-string-20) + [Kripto](#writing-functions-javascript-features-builtin-modules-crypto-20) ### Penyangga Modul ini menyediakan metode berikut: + `Buffer.alloc(size[, fill[, encoding]])` Alokasikan a. `Buffer` + `size`: Ukuran penyangga. Masukkan bilangan bulat. + `fill`: Opsional. Masukkan string,`Buffer`, Uint8Array, atau integer. Default-nya adalah `0`. + `encoding`: Opsional. `fill`Kapan string, masukkan salah satu dari berikut ini:`utf8`,`hex`,`base64`,`base64url`. Default-nya adalah `utf8`. + `Buffer.allocUnsafe(size)` Alokasikan `Buffer` non-inisialisasi. + `size`: Masukkan bilangan bulat. + `Buffer.byteLength(value[, encoding])` Kembalikan panjang nilai, dalam byte. + `value`: Sebuah string,,`Buffer`, Dataview TypedArray, atau Arraybuffer. + `encoding`: Opsional. `value`Kapan string, masukkan salah satu dari berikut ini:`utf8`,`hex`,`base64`,`base64url`. Default-nya adalah `utf8`. + `Buffer.compare(buffer1, buffer2)` Bandingkan dua `Buffer` s untuk membantu mengurutkan array. Mengembalikan `0` jika mereka sama, `-1` jika `buffer1` datang lebih dulu, atau `1` jika `buffer2` datang lebih dulu. + `buffer1`: Masukkan a`Buffer`. + `buffer2`: Masukkan yang berbeda`Buffer`. + `Buffer.concat(list[, totalLength])` Gandungkan beberapa s. `Buffer` Kembali `0` jika tidak ada. Kembali hingga`totalLength`. + `list`: Masukkan daftar `Buffer` s. Perhatikan ini akan dipotong menjadi. `totalLength` + `totalLength`: Opsional. Masukkan bilangan bulat yang tidak ditandatangani. Gunakan jumlah `Buffer` instance dalam daftar jika kosong. + `Buffer.from(array)` Buat `Buffer` dari array. + `array`: Masukkan array byte dari `0` ke`255`. + `Buffer.from(arrayBuffer, byteOffset[, length]))` Buat tampilan dari`arrayBuffer`, mulai dari offset `byteOffset` dengan panjang`length`. + `arrayBuffer`: Masukkan `Buffer` array. + `byteOffset`: Masukkan bilangan bulat. + `length`: Opsional. Masukkan bilangan bulat. + `Buffer.from(buffer)` Buat salinan dari`Buffer`. + `buffer`: Masukkan a`Buffer`. + `Buffer.from(object[, offsetOrEncoding[, length]])` Buat `Buffer` dari objek. Mengembalikan `Buffer.from(object.valueOf(), offsetOrEncoding, length)` jika `valueOf()` tidak sama dengan objek. + `object`: Masukkan objek. + `offsetOrEncoding`: Opsional. Masukkan integer atau string encoding. + `length`: Opsional. Masukkan bilangan bulat. + `Buffer.from(string[, encoding])` Buat `Buffer` dari string. + `string`: Masukkan string. + `encoding`: Opsional. Masukkan salah satu dari berikut ini:`utf8`,`hex`,`base64`,`base64url`. Default-nya adalah `utf8`. + `Buffer.isBuffer(object)` Periksa apakah `object` itu Buffer. Pengembalian `true` atau`false`. + `object`: Masukkan objek. + `Buffer.isEncoding(encoding)` Periksa `encoding` apakah didukung. Pengembalian `true` atau`false`. + `encoding`: Opsional. Masukkan salah satu dari berikut ini:`utf8`,`hex`,`base64`,`base64url`. Default-nya adalah `utf8`. Modul ini menyediakan metode prototipe buffer berikut: + `Buffer.prototype.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])` Bandingkan `Buffer` dengan target. Mengembalikan `0` jika mereka sama, `1` jika `buffer` datang lebih dulu, atau `-1` jika `target` datang lebih dulu. + `target`: Masukkan a`Buffer`. + `targetStart`: Opsional. Masukkan bilangan bulat. Default-nya adalah 0. + `targetEnd`: Opsional. Masukkan bilangan bulat. Default adalah `target` panjang. + `sourceStart`: Opsional. Masukkan bilangan bulat. Default-nya adalah 0. + `sourceEnd`: Opsional. Masukkan bilangan bulat. Default adalah `Buffer` panjang. + `Buffer.prototype.copy(target[, targetStart[, sourceStart[, sourceEnd]]])` Salin buffer ke`target`. + `target`: Masukkan a `Buffer` atau`Uint8Array`. + `targetStart`: Opsional. Masukkan bilangan bulat. Default-nya adalah 0. + `sourceStart`: Opsional. Masukkan bilangan bulat. Default-nya adalah 0. + `sourceEnd`: Opsional. Masukkan bilangan bulat. Default adalah `Buffer` panjang. + `Buffer.prototype.equals(otherBuffer)` Bandingkan `Buffer` dengan`otherBuffer`. Pengembalian `true` atau`false`. + `otherBuffer`: Masukkan string. + `Buffer.prototype.fill(value[, offset[, end][, encoding])` Isi `Buffer` dengan`value`. + `value`: Masukkan string,`Buffer`, atau bilangan bulat. + `offset`: Opsional. Masukkan bilangan bulat. + `end`: Opsional. Masukkan bilangan bulat. + `encoding`: Opsional. Masukkan salah satu dari berikut ini:`utf8`,`hex`,`base64`,`base64url`. Default-nya adalah `utf8`. + `Buffer.prototype.includes(value[, byteOffset][, encoding])` Cari `value` di`Buffer`. Pengembalian `true` atau`false`. + `value`: Masukkan string,, `Buffer``Uint8Array`, atau bilangan bulat. + `byteOffset`: Opsional. Masukkan bilangan bulat. + `encoding`: Opsional. Masukkan salah satu dari berikut ini:`utf8`,`hex`,`base64`,`base64url`. Default-nya adalah `utf8`. + `Buffer.prototype.indexOf(value[, byteOffset][, encoding])` Cari yang pertama `value` di`Buffer`. Mengembalikan `index` jika ditemukan; kembali `-1` jika tidak ditemukan. + `value`: Masukkan string,`Buffer`, Unit8Array, atau bilangan bulat dari 0 hingga 255. + `byteOffset`: Opsional. Masukkan bilangan bulat. + `encoding`: Opsional. Masukkan salah satu dari berikut jika `value` adalah string:`utf8`,`hex`,`base64`,`base64url`. Default-nya adalah `utf8`. + `Buffer.prototype.lastIndexOf(value[, byteOffset][, encoding])` Cari yang terakhir `value` di`Buffer`. Mengembalikan `index` jika ditemukan; kembali `-1` jika tidak ditemukan. + `value`: Masukkan string,`Buffer`, Unit8Array, atau bilangan bulat dari 0 hingga 255. + `byteOffset`: Opsional. Masukkan bilangan bulat. + `encoding`: Opsional. Masukkan salah satu dari berikut jika `value` adalah string:`utf8`,`hex`,`base64`,`base64url`. Default-nya adalah `utf8`. + `Buffer.prototype.readInt8(offset)` Baca `Int8` di `offset` dari`Buffer`. + `offset`: Masukkan bilangan bulat. + `Buffer.prototype.readIntBE(offset, byteLength)` Baca `Int` sebagai big-endian di from. `offset` `Buffer` + `offset`: Masukkan bilangan bulat. + `byteLength`: Opsional. Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.readInt16BE(offset)` Baca `Int16` sebagai big-endian di from. `offset` `Buffer` + `offset`: Masukkan bilangan bulat. + `Buffer.prototype.readInt32BE(offset)` Baca `Int32` sebagai big-endian di from. `offset` `Buffer` + `offset`: Masukkan bilangan bulat. + `Buffer.prototype.readIntLE(offset, byteLength)` Baca `Int` sebagai endian kecil di dari. `offset` `Buffer` + `offset`: Masukkan bilangan bulat. + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.readInt16LE(offset)` Baca `Int16` sebagai endian kecil di dari. `offset` `Buffer` + `offset`: Masukkan bilangan bulat. + `Buffer.prototype.readInt32LE(offset)` Baca `Int32` sebagai endian kecil di dari. `offset` `Buffer` + `offset`: Masukkan bilangan bulat. + `Buffer.prototype.readUInt8(offset)` Baca `UInt8` di `offset` dari`Buffer`. + `offset`: Masukkan bilangan bulat. + `Buffer.prototype.readUIntBE(offset, byteLength)` Baca `UInt` sebagai big-endian di from. `offset` `Buffer` + `offset`: Masukkan bilangan bulat. + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.readUInt16BE(offset)` Baca `UInt16` sebagai big-endian di from. `offset` `Buffer` + + `offset`: Masukkan bilangan bulat. + `Buffer.prototype.readUInt32BE(offset)` Baca `UInt32` sebagai big-endian di from. `offset` `Buffer` + `offset`: Masukkan bilangan bulat. + `Buffer.prototype.readUIntLE(offset, byteLength)` Baca `UInt` sebagai endian kecil di dari. `offset` `Buffer` + `offset`: Masukkan bilangan bulat. + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.readUInt16LE(offset)` Baca `UInt16` sebagai endian kecil di dari. `offset` `Buffer` + `offset`: Masukkan bilangan bulat. + `Buffer.prototype.readUInt32LE(offset)` Baca `UInt32` sebagai endian kecil di dari. `offset` `Buffer` + `offset`: Masukkan bilangan bulat. + `Buffer.prototype.readDoubleBE([offset])` Baca 64-bit ganda sebagai big-endian di from. `offset` `Buffer` + `offset`: Opsional. Masukkan bilangan bulat. + `Buffer.prototype.readDoubleLE([offset])` Baca 64-bit ganda sebagai endian kecil di from. `offset` `Buffer` + `offset`: Opsional. Masukkan bilangan bulat. + `Buffer.prototype.readFloatBE([offset])` Baca float 32-bit sebagai big-endian di from. `offset` `Buffer` + `offset`: Opsional. Masukkan bilangan bulat. + `Buffer.prototype.readFloatLE([offset])` Baca float 32-bit sebagai endian kecil di from. `offset` `Buffer` + `offset`: Opsional. Masukkan bilangan bulat. + `Buffer.prototype.subarray([start[, end]])` Mengembalikan salinan `Buffer` yang diimbangi dan dipotong dengan yang baru `start` dan. `end` + `start`: Opsional. Masukkan bilangan bulat. Default-nya adalah 0. + `end`: Opsional. Masukkan bilangan bulat. Default adalah panjang buffer. + `Buffer.prototype.swap16()` Tukar urutan byte `Buffer` array, memperlakukannya sebagai array angka 16-bit. `Buffer`panjangnya harus habis dibagi 2, atau Anda akan menerima kesalahan. + `Buffer.prototype.swap32()` Tukar urutan byte `Buffer` array, memperlakukannya sebagai array angka 32-bit. `Buffer`panjangnya harus habis dibagi 4, atau Anda akan menerima kesalahan. + `Buffer.prototype.swap64()` Tukar urutan byte `Buffer` array, memperlakukannya sebagai array angka 64-bit. `Buffer`panjangnya harus habis dibagi 8, atau Anda akan menerima kesalahan. + `Buffer.prototype.toJSON()` Kembali `Buffer` sebagai JSON. + `Buffer.prototype.toString([encoding[, start[, end]]])` Konversi`Buffer`, dari `start` ke`end`, ke string yang dikodekan. + `encoding`: Opsional. Masukkan salah satu dari berikut ini:`utf8`,`hex`,`base64`, atau`base64url`. Default-nya adalah `utf8`. + `start`: Opsional. Masukkan bilangan bulat. Default-nya adalah 0. + `end`: Opsional. Masukkan bilangan bulat. Default adalah panjang buffer. + `Buffer.prototype.write(string[, offset[, length]][, encoding])` Tulis dikodekan `string` ke `Buffer` jika ada spasi, atau terpotong `string` jika tidak ada cukup ruang. + `string`: Masukkan string. + `offset`: Opsional. Masukkan bilangan bulat. Default-nya adalah 0. + `length`: Opsional. Masukkan bilangan bulat. Default adalah panjang string. + `encoding`: Opsional. Secara opsional masukkan salah satu dari berikut ini:`utf8`,`hex`,`base64`, atau`base64url`. Default-nya adalah `utf8`. + `Buffer.prototype.writeInt8(value, offset, byteLength)` Menulis `Int8` `value` dari `byteLength` at `offset` ke`Buffer`. + `value`: Masukkan bilangan bulat. + `offset`: Masukkan bilangan bulat + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeIntBE(value, offset, byteLength)` Menulis `value` di `offset` ke`Buffer`, menggunakan big-endian. + `value`: Masukkan bilangan bulat. + `offset`: Masukkan bilangan bulat + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeInt16BE(value, offset, byteLength)` Menulis `value` di `offset` ke`Buffer`, menggunakan big-endian. + `value`: Masukkan bilangan bulat. + `offset`: Masukkan bilangan bulat + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeInt32BE(value, offset, byteLength)` Menulis `value` di `offset` ke`Buffer`, menggunakan big-endian. + `value`: Masukkan bilangan bulat. + `offset`: Masukkan bilangan bulat + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeIntLE(offset, byteLength)` Menulis `value` di `offset` ke`Buffer`, menggunakan little-endian. + `offset`: Masukkan bilangan bulat. + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeInt16LE(offset, byteLength)` Menulis `value` di `offset` ke`Buffer`, menggunakan little-endian. + `offset`: Masukkan bilangan bulat. + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeInt32LE(offset, byteLength)` Menulis `value` di `offset` ke`Buffer`, menggunakan little-endian. + `offset`: Masukkan bilangan bulat. + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeUInt8(value, offset, byteLength)` Menulis `UInt8` `value` dari `byteLength` at `offset` ke`Buffer`. + `value`: Masukkan bilangan bulat. + `offset`: Masukkan bilangan bulat + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeUIntBE(value, offset, byteLength)` Menulis `value` di `offset` ke`Buffer`, menggunakan big-endian. + `value`: Masukkan bilangan bulat. + `offset`: Masukkan bilangan bulat + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeUInt16BE(value, offset, byteLength)` Menulis `value` di `offset` ke`Buffer`, menggunakan big-endian. + `value`: Masukkan bilangan bulat. + `offset`: Masukkan bilangan bulat + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeUInt32BE(value, offset, byteLength)` Menulis `value` di `offset` ke`Buffer`, menggunakan big-endian. + `value`: Masukkan bilangan bulat. + `offset`: Masukkan bilangan bulat + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeUIntLE(value, offset, byteLength)` Menulis `value` di `offset` ke`Buffer`, menggunakan little-endian. + `value`: Masukkan bilangan bulat. + `offset`: Masukkan bilangan bulat + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeUInt16LE(value, offset, byteLength)` Menulis `value` di `offset` ke`Buffer`, menggunakan little-endian. + `value`: Masukkan bilangan bulat. + `offset`: Masukkan bilangan bulat + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeUInt32LE(value, offset, byteLength)` Menulis `value` di `offset` ke`Buffer`, menggunakan little-endian. + `value`: Masukkan bilangan bulat. + `offset`: Masukkan bilangan bulat + `byteLength`: Masukkan bilangan bulat dari `1` ke`6`. + `Buffer.prototype.writeDoubleBE(value, [offset])` Menulis `value` di `offset` ke`Buffer`, menggunakan big-endian. + `value`: Masukkan bilangan bulat. + `offset`: Opsional. Masukkan bilangan bulat. Default-nya adalah 0. + `Buffer.prototype.writeDoubleLE(value, [offset])` Menulis `value` di `offset` ke`Buffer`, menggunakan little-endian. + `value`: Masukkan bilangan bulat. + `offset`: Opsional. Masukkan bilangan bulat. Default-nya adalah 0. + `Buffer.prototype.writeFloatBE(value, [offset])` Menulis `value` di `offset` ke`Buffer`, menggunakan big-endian. + `value`: Masukkan bilangan bulat. + `offset`: Opsional. Masukkan bilangan bulat. Default-nya adalah 0. + `Buffer.prototype.writeFloatLE(value, [offset])` Menulis `value` di `offset` ke`Buffer`, menggunakan little-endian. + `value`: Masukkan bilangan bulat. + `offset`: Opsional. Masukkan bilangan bulat. Default-nya adalah 0. Metode contoh berikut didukung: + `buffer[index]` Dapatkan dan atur oktet (byte) di `index` dalam. `Buffer` + Dapatkan nomor dari `0` ke`255`. Atau tetapkan angka dari dari `0` ke`255`. Properti contoh berikut didukung: + `buffer` Dapatkan `ArrayBuffer` objek untuk buffer. + `byteOffset` Dapatkan `Arraybuffer` objek buffer. `byteOffset` + `length` Dapatkan jumlah byte buffer. **catatan** Semua metode modul Buffer baru di JavaScript runtime 2.0. ### String kueri **catatan** [Objek acara CloudFront Functions](functions-event-structure.md) secara otomatis mem-parsing string kueri URL untuk Anda. Itu berarti bahwa dalam kebanyakan kasus Anda tidak perlu menggunakan modul ini. Modul string kueri (`querystring`) menyediakan metode untuk mengurai dan memformat string kueri URL. Anda dapat memuat modul menggunakan `require('querystring')`. Modul ini menyediakan metode berikut. `querystring.escape(string)` Mengkodekan URL `string` yang tersedia, mengembalikan string kueri yang lolos. Metode ini digunakan oleh `querystring.stringify()` dan tidak boleh digunakan secara langsung. `querystring.parse(string[, separator[, equal[, options]]])` Mengurai string kueri (`string`) dan mengembalikan objek. Parameter `separator` adalah substring untuk membatasi pasangan kunci dan nilai dalam string kueri. Secara default, itu adalah `&`. Parameter `equal` adalah substring untuk membatasi kunci dan nilai dalam string kueri. Secara default, itu adalah `=`. Parameter `options` adalah objek dengan kunci berikut: `decodeURIComponent function` Sebuah fungsi untuk memecahkan kode karakter persentase dikodekan dalam string kueri. Secara default, itu adalah `querystring.unescape()`. `maxKeys number` Jumlah kunci maksimum untuk diurai Secara default, itu adalah `1000`. Gunakan nilai `0` untuk menghapus pembatasan untuk menghitung kunci. Secara default, karakter persentase dikodekan dalam string kueri diasumsikan menggunakan pengkodean UTF-8. Urutan UTF-8 tidak valid diganti dengan karakter pengganti `U+FFFD`. Misalnya, untuk string kueri berikut: ``` 'name=value&abc=xyz&abc=123' ``` Nilai `querystring.parse()` yang dikembalikan adalah: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` adalah alias untuk `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Menyerialisasi `object` dan mengembalikan string kueri. Parameter `separator` adalah substring untuk membatasi pasangan kunci dan nilai dalam string kueri. Secara default, itu adalah `&`. Parameter `equal` adalah substring untuk membatasi kunci dan nilai dalam string kueri. Secara default, itu adalah `=`. Parameter `options` adalah objek dengan kunci berikut: `encodeURIComponent function` Fungsi yang digunakan untuk mengonversi karakter URL yang tidak aman untuk pengkodean persentase dalam string kueri. Secara default, itu adalah `querystring.escape()`. Secara default, karakter yang memerlukan pengkodean persentase dalam string kueri dikodekan sebagai UTF-8. Untuk menggunakan pengkodean yang berbeda, tentukan opsi `encodeURIComponent`. Misalnya, gunakan kode berikut: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` Nilai yang dikembalikan adalah: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` adalah alias untuk `querystring.stringify()`. `querystring.unescape(string)` Mendekode karakter yang dikodekan persentase URL dalam `string` yang tersedia, mengembalikan string kueri yang tidak lolos. Metode ini digunakan oleh `querystring.parse()` dan tidak boleh digunakan secara langsung. ### Kripto Modul kriptografi (`crypto`) menyediakan hashing standar dan pembantu kode autentikasi pesan berbasis hash (HMAC). Anda dapat memuat modul menggunakan `require('crypto')`. **Metode hashing** `crypto.createHash(algorithm)` Menciptakan dan mengembalikan objek hash yang dapat digunakan untuk menghasilkan hash digests menggunakan algoritme yang diberikan: `md5`, `sha1`, atau `sha256`. `hash.update(data)` Update konten hash dengan `data` yang tersedia. `hash.digest([encoding])` Menghitung digest dari semua data yang diteruskan menggunakan `hash.update()`. Pengkodean dapat berupa `hex`, `base64`, atau `base64url`. **Metode HMAC** `crypto.createHmac(algorithm, secret key)` Menciptakan dan mengembalikan objek HMAC yang menggunakan `algorithm` dan `secret key` yang tersedia. Algoritma dapat berupa `md5`, `sha1`, atau `sha256`. `hmac.update(data)` Memperbarui konten HMAC dengan `data` yang tersedia. `hmac.digest([encoding])` Menghitung digest dari semua data yang diteruskan menggunakan `hmac.update()`. Pengkodean dapat berupa `hex`, `base64`, atau `base64url`. ## Fitur yang dibatasi Fitur JavaScript bahasa berikut tidak didukung atau dibatasi karena masalah keamanan. **Evaluasi kode dinamis** Evaluasi kode dinamis tidak didukung. Konstruktor `eval()` dan `Function` mengalami kesalahan jika dicoba. Misalnya, `const sum = new Function('a', 'b', 'return a + b')` mengalami kesalahan. **Timer** Fungsi `setTimeout()`, `setImmediate()`, dan `clearTimeout()` tidak didukung. Tidak ada ketentuan untuk menunda atau menghasilkan dalam fungsi jalankan. Fungsi Anda harus dijalankan secara serentak sampai selesai. **Tanggal dan stempel waktu** Untuk alasan keamanan, tidak ada akses ke timer beresolusi tinggi. Semua metode `Date` untuk meminta waktu saat ini selalu mengembalikan nilai yang sama saat menjalankan fungsi tunggal. Stempel waktu yang dikembalikan adalah waktu fungsi mulai berjalan. Akibatnya, Anda tidak dapat mengukur waktu berlalu dalam fungsi Anda. **Akses sistem file** Tidak ada akses sistem file. Misalnya, tidak ada modul `fs` untuk akses sistem file seperti yang ada di Node.js. **Akses proses** Tidak ada akses proses. Misalnya, tidak ada objek `process` global untuk memproses akses informasi seperti yang ada di Node.js. **Variabel-variabel lingkungan** Tidak ada akses ke variabel lingkungan. Sebagai gantinya, Anda dapat menggunakan CloudFront KeyValueStore untuk membuat datastore terpusat dari pasangan kunci-nilai untuk Fungsi Anda. CloudFront CloudFront KeyValueStore memungkinkan pembaruan dinamis ke data konfigurasi Anda tanpa perlu menerapkan perubahan kode. Untuk informasi selengkapnya, lihat [Amazon CloudFront KeyValueStore](kvs-with-functions.md). **Akses jaringan** Tidak ada dukungan untuk panggilan jaringan. Misalnya, XHR, HTTP (S), dan soket tidak didukung. # Metode pembantu untuk penyimpanan nilai kunci **catatan** Panggilan metode pembantu penyimpanan nilai kunci dari CloudFront Fungsi tidak memicu peristiwa AWS CloudTrail data. Peristiwa ini tidak dicatat dalam riwayat CloudTrail peristiwa. Untuk informasi selengkapnya, lihat [Pencatatan panggilan CloudFront API Amazon menggunakan AWS CloudTrail](logging_using_cloudtrail.md). Bagian ini berlaku jika Anda menggunakan [CloudFront Key Value Store](kvs-with-functions.md) untuk menyertakan nilai kunci dalam fungsi yang Anda buat. CloudFront Fungsi memiliki modul yang menyediakan tiga metode pembantu untuk membaca nilai dari penyimpanan nilai kunci. Untuk menggunakan modul ini dalam kode fungsi, pastikan bahwa Anda telah [mengaitkan penyimpanan nilai kunci](kvs-with-functions-associate.md) dengan fungsi tersebut. Selanjutnya, sertakan pernyataan berikut di baris pertama kode fungsi: ``` import cf from 'cloudfront'; const kvsHandle = cf.kvs(); ``` ## Metode `get()` Gunakan metode ini untuk mengembalikan nilai kunci untuk nama kunci yang Anda tentukan. **Permintaan** ``` get("key", options); ``` + `key`: Nama kunci yang nilainya perlu diambil + `options`: Ada satu pilihan,`format`. Ini memastikan bahwa fungsi mem-parsing data dengan benar. Kemungkinan nilai: + `string`: (Default) UTF8 dikodekan + `json` + `bytes`: Buffer data biner mentah **Minta contoh** ``` const value = await kvsHandle.get("myFunctionKey", { format: "string"}); ``` **Respons** Responsnya adalah `promise` yang menyelesaikan nilai dalam format yang diminta dengan menggunakan. `options` Secara default, nilai dikembalikan sebagai string. ### Penanganan kesalahan `get()`Metode ini akan mengembalikan kesalahan ketika kunci yang Anda minta tidak ada di penyimpanan nilai kunci terkait. Untuk mengelola kasus penggunaan ini, Anda dapat menambahkan `try` dan `catch` memblokir kode Anda. **Awas** Menggunakan kombinator janji (misalnya,`Promise.all`,`Promise.any`, dan metode rantai janji (misalnya, `then` dan`catch`) dapat memerlukan penggunaan memori fungsi tinggi. Jika fungsi Anda melebihi kuota [memori fungsi maksimum](cloudfront-limits.md#limits-functions), itu akan gagal dijalankan. Untuk menghindari kesalahan ini, kami sarankan Anda menggunakan `await` sintaks secara berurutan atau dalam loop untuk meminta beberapa nilai. **Contoh** ``` var value1 = await kvs.get('key1'); var value2 = await kvs.get('key2'); ``` Saat ini, menggunakan kombinator janji untuk mendapatkan beberapa nilai tidak akan meningkatkan kinerja, seperti contoh berikut. ``` var values = await Promise.all([kvs.get('key1'), kvs.get('key2'),]); ``` ## Metode `exists()` Gunakan metode ini untuk mengidentifikasi apakah kunci ada di penyimpanan nilai kunci atau tidak. **Permintaan** ``` exists("key"); ``` **Minta contoh** ``` const exist = await kvsHandle.exists("myFunctionkey"); ``` **Respons** Responsnya adalah `promise` yang mengembalikan Boolean (`true`atau`false`). Nilai ini menentukan apakah kunci ada atau tidak di penyimpanan nilai kunci. ## Metode `meta()` Gunakan metode ini untuk mengembalikan metadata tentang penyimpanan nilai kunci. **Permintaan** ``` meta(); ``` **Minta contoh** ``` const meta = await kvsHandle.meta(); ``` **Respons** Responsnya adalah `promise` yang menyelesaikan objek dengan properti berikut: + `creationDateTime`: Tanggal dan waktu penyimpanan nilai kunci dibuat, dalam format ISO 8601. + `lastUpdatedDateTime`: Tanggal dan waktu penyimpanan nilai kunci terakhir disinkronkan dari sumber, dalam format ISO 8601. Nilainya tidak termasuk waktu propagasi ke tepi. + `keyCount`: Jumlah total kunci di KVS setelah sinkronisasi terakhir dari sumber. **Contoh respons** ``` {keyCount:3,creationDateTime:2023-11-30T23:07:55.765Z,lastUpdatedDateTime:2023-12-15T03:57:52.411Z} ``` # Metode pembantu untuk modifikasi asal Bagian ini berlaku jika Anda secara dinamis memperbarui atau mengubah asal yang digunakan pada permintaan di dalam kode CloudFront Fungsi Anda. Anda dapat memperbarui asal hanya pada CloudFront fungsi *permintaan penampil*. CloudFront Fungsi memiliki modul yang menyediakan metode pembantu untuk memperbarui atau mengubah asal secara dinamis. Untuk menggunakan modul ini, buat CloudFront fungsi menggunakan JavaScript runtime 2.0 dan sertakan pernyataan berikut di baris pertama kode fungsi: ``` import cf from 'cloudfront'; ``` Untuk informasi selengkapnya, lihat [JavaScript fitur runtime 2.0 untuk Fungsi CloudFront](functions-javascript-runtime-20.md). **catatan** Halaman Test API dan Test console tidak menguji apakah modifikasi asal telah terjadi. Namun, pengujian memastikan bahwa kode fungsi dijalankan tanpa kesalahan. ## Pilih antara CloudFront Fungsi dan Lambda @Edge Anda dapat memperbarui asal Anda dengan menggunakan CloudFront Fungsi atau Lambda @Edge. Saat menggunakan CloudFront Fungsi untuk memperbarui asal, Anda menggunakan pemicu peristiwa *permintaan penampil*, yang berarti logika ini akan berjalan pada setiap permintaan saat fungsi ini digunakan. Saat menggunakan Lambda @Edge, kemampuan pembaruan asal ada di pemicu peristiwa *permintaan asal*, yang berarti logika ini hanya berjalan pada kesalahan cache. Pilihan Anda sangat bergantung pada beban kerja Anda dan penggunaan CloudFront Fungsi dan Lambda @Edge yang ada pada distribusi Anda. Pertimbangan berikut dapat membantu Anda memutuskan apakah akan menggunakan CloudFront Fungsi atau Lambda @Edge untuk memperbarui asal Anda. CloudFront Fungsi paling berguna dalam situasi berikut: + Ketika permintaan Anda dinamis (artinya mereka tidak dapat di-cache) dan akan selalu pergi ke asal. CloudFront Fungsi memberikan kinerja yang lebih baik dan biaya keseluruhan yang lebih rendah. + Ketika Anda sudah memiliki CloudFront fungsi permintaan penampil yang ada yang akan berjalan pada setiap permintaan, Anda dapat menambahkan logika pembaruan asal ke dalam fungsi yang ada. Untuk menggunakan CloudFront Fungsi untuk memperbarui asal, lihat metode pembantu dalam topik berikut. Lambda @Edge paling berguna dalam situasi berikut: + Ketika Anda memiliki konten yang sangat dapat di-cache, Lambda @Edge bisa lebih hemat biaya karena hanya berjalan pada cache yang gagal, sementara Fungsi berjalan pada setiap permintaan. CloudFront + Ketika Anda sudah memiliki fungsi Lambda @Edge permintaan asal yang ada, Anda dapat menambahkan logika pembaruan asal ke dalam fungsi yang ada. + Bila logika pembaruan asal Anda memerlukan pengambilan data dari sumber data pihak ketiga, seperti Amazon DynamoDB atau Amazon S3. Untuk informasi selengkapnya tentang Lambda @Edge, lihat. [Sesuaikan di tepi dengan Lambda @Edge](lambda-at-the-edge.md) ## updateRequestOrigin() metode Gunakan `updateRequestOrigin()` metode ini untuk memperbarui pengaturan asal untuk permintaan. Anda dapat menggunakan metode ini untuk memperbarui properti asal yang ada untuk asal yang sudah ditentukan dalam distribusi Anda, atau untuk menentukan asal baru untuk permintaan tersebut. Untuk melakukannya, tentukan properti yang ingin Anda ubah. **penting** Pengaturan apa pun yang tidak Anda tentukan `updateRequestOrigin()` akan mewarisi *pengaturan yang sama* dari konfigurasi asal yang ada. Asal yang ditetapkan oleh `updateRequestOrigin()` metode dapat berupa titik akhir HTTP apa pun dan tidak perlu menjadi asal yang ada dalam CloudFront distribusi Anda. **Catatan** Jika Anda memperbarui asal yang merupakan bagian dari grup asal, hanya *asal utama* grup asal yang diperbarui. Asal sekunder tetap tidak berubah. Kode respons apa pun dari asal yang dimodifikasi yang cocok dengan kriteria failover akan memicu failover ke asal sekunder. Jika Anda mengubah tipe asal dan mengaktifkan OAC, pastikan tipe asal `originAccessControlConfig` cocok dengan tipe asal baru. Anda tidak dapat menggunakan `updateRequestOrigin()` metode ini untuk memperbarui asal [VPC](private-content-vpc-origins.md). Permintaan akan gagal. **Permintaan** ``` updateRequestOrigin({origin properties}) ``` `origin properties`Dapat berisi yang berikut: **domainName (opsional)** Nama domain asal. Jika ini tidak disediakan, nama domain dari asal yang ditetapkan digunakan sebagai gantinya. **Untuk asal kustom** Tentukan nama domain DNS, seperti`www.example.com`. Nama domain tidak dapat menyertakan titik dua (`:`) dan tidak bisa menjadi alamat IP. Nama domain dapat terdiri dari hingga 253 karakter. **Untuk asal S3** Tentukan nama domain DNS bucket Amazon S3, seperti. `amzn-s3-demo-bucket.s3.eu-west-1.amazonaws.com` Nama bisa sampai 128 karakter dan harus berupa huruf kecil. **Hostheader (opsional, untuk asal-usul kustom non-S3)** Header host untuk digunakan saat membuat permintaan ke asal. Jika ini tidak disediakan, nilai dari parameter domainName digunakan. Jika header host atau parameter nama domain tidak disediakan, nama domain dari asal yang ditetapkan akan digunakan atau header host dari permintaan masuk jika kebijakan penerusan ke asal (FTO) menyertakan host. Header host tidak dapat menyertakan titik dua (`:`) dan tidak bisa menjadi alamat IP. Header host dapat mencapai 253 karakter. **originPath (opsional)** Jalur direktori di tempat asal permintaan harus menemukan konten. Jalur harus dimulai dengan garis miring (/) tetapi tidak boleh diakhiri dengan garis miring. Misalnya, seharusnya tidak berakhir dengan`example-path/`. Jika ini tidak disediakan, maka jalur asal dari asal yang ditetapkan digunakan. **Untuk asal kustom** Jalur harus dikodekan URL dan memiliki panjang maksimum 255 karakter. **CustomHeaders (opsional)** Anda dapat menyertakan judul kustom dengan permintaan dengan menyebutkan nama header dan pasangan nilai untuk masing-masing header khusus. Formatnya berbeda dari header permintaan dan respons dalam struktur acara. Gunakan sintaks pasangan kunci-nilai berikut: ``` {"key1": "value1", "key2": "value2", ...} ``` Anda tidak dapat menambahkan header yang tidak diizinkan, dan header dengan nama yang sama juga tidak dapat hadir dalam permintaan masuk. `headers` Nama header harus huruf kecil dalam kode fungsi Anda. Ketika CloudFront Fungsi mengubah objek acara kembali ke permintaan HTTP, huruf pertama dari setiap kata dalam nama header dikapitalisasi, dan kata-kata dipisahkan oleh tanda hubung. Misalnya, jika kode fungsi Anda menambahkan header bernama`example-header-name`, CloudFront mengkonversi ini ke `Example-Header-Name` dalam permintaan HTTP. Untuk informasi selengkapnya, lihat [Header khusus yang tidak CloudFront dapat ditambahkan ke permintaan asal](add-origin-custom-headers.md#add-origin-custom-headers-denylist) dan [Pembatasan pada fungsi edge](edge-functions-restrictions.md). Jika ini tidak disediakan, maka header khusus apa pun dari asal yang ditetapkan akan digunakan. **ConnectionAtts (opsional)** Berapa kali yang CloudFront mencoba untuk terhubung ke asal. Minimal adalah 1 dan maksimum adalah 3. Jika ini tidak disediakan, upaya koneksi dari asal yang ditetapkan digunakan. **OriginShield (opsional)** Ini memungkinkan atau memperbarui CloudFront Origin Shield. Menggunakan Shield Asal dapat membantu mengurangi beban pada asal Anda. Untuk informasi selengkapnya, lihat [Gunakan Amazon CloudFront Origin Shield](origin-shield.md). Jika ini tidak disediakan, pengaturan Origin Shield dari asal yang ditetapkan akan digunakan. **diaktifkan (wajib)** Ekspresi Boolean untuk mengaktifkan atau menonaktifkan Origin Shield. Menerima `false` nilai `true` atau. **wilayah (diperlukan saat diaktifkan)** Wilayah AWS Untuk Origin Shield. Tentukan Wilayah AWS yang memiliki latensi terendah pada asal Anda. Gunakan kode Region, bukan nama Region. Misalnya, gunakan `us-east-2` untuk menentukan Wilayah Timur AS (Ohio). Ketika Anda mengaktifkan CloudFront Origin Shield, Anda harus menentukan Wilayah AWS untuk itu. Untuk daftar yang tersedia Wilayah AWS dan membantu memilih Wilayah terbaik untuk asal Anda, lihat[Pilih AWS Wilayah untuk Origin Shield](origin-shield.md#choose-origin-shield-region). **originAccessControlConfig (opsional)** Pengidentifikasi unik dari kontrol akses asal (OAC) untuk asal ini. Ini hanya digunakan ketika asal mendukung CloudFront OAC, seperti Amazon S3, URLs fungsi MediaStore Lambda, dan V2. MediaPackage Jika ini tidak disediakan, maka pengaturan OAC dari asal yang ditetapkan digunakan. Ini tidak mendukung identitas akses asal warisan (OAI). Untuk informasi selengkapnya, lihat [Batasi akses ke asal AWS](private-content-restricting-access-to-origin.md). **diaktifkan (wajib)** Ekspresi Boolean untuk mengaktifkan atau menonaktifkan OAC. Menerima `false` nilai `true` atau. **SigningBehavior (diperlukan saat diaktifkan)** Menentukan permintaan CloudFront tanda (menambahkan informasi otentikasi ke). Tentukan `always` untuk kasus penggunaan yang paling umum. Untuk informasi selengkapnya, lihat [Pengaturan lanjutan untuk kontrol akses asal](private-content-restricting-access-to-s3.md#oac-advanced-settings-s3). Bidang ini dapat memiliki salah satu nilai berikut: + `always`— CloudFront menandatangani semua permintaan asal, menimpa `Authorization` header dari permintaan penampil jika ada. + `never`— CloudFront tidak menandatangani permintaan asal apa pun. Nilai ini mematikan kontrol akses asal untuk asal. + `no-override`— Jika permintaan penampil tidak berisi `Authorization` header, maka CloudFront tandatangani permintaan asal. Jika permintaan penampil berisi `Authorization` header, maka CloudFront tidak menandatangani permintaan asal dan sebagai gantinya meneruskan `Authorization` header dari permintaan penampil. **Awas** Untuk meneruskan `Authorization` header dari permintaan penampil, Anda harus menambahkannya ke kebijakan permintaan asal untuk semua perilaku cache yang menggunakan asal yang terkait dengan kontrol akses asal ini. Untuk informasi selengkapnya, lihat [Kontrol permintaan asal dengan kebijakan](controlling-origin-requests.md). **SigningProtocol (diperlukan saat diaktifkan)** Protokol penandatanganan OAC, yang menentukan bagaimana CloudFront tanda (mengotentikasi) permintaan. Satu-satunya nilai yang valid adalah `sigv4`. **OriginType (diperlukan saat diaktifkan)** Jenis asal untuk OAC ini. Nilai yang valid termasuk `s3`, `mediapackagev2`, `mediastore`, dan `lambda`. **batas waktu (opsional)** Timeout yang dapat Anda tentukan untuk berapa lama CloudFront harus mencoba menunggu asal merespons atau mengirim data. Jika ini tidak disediakan, maka pengaturan batas waktu dari asal yang ditetapkan digunakan. Kecuali ditentukan, batas waktu ini mendukung asal kustom dan asal Amazon S3. **ReadTimeout (opsional)** `readTimeout`Ini berlaku untuk kedua nilai berikut: + Berapa lama (dalam detik) CloudFront menunggu respons setelah meneruskan permintaan ke asal. + Berapa lama (dalam detik) CloudFront menunggu setelah menerima paket respons dari asal dan sebelum menerima paket berikutnya. Batas waktu minimum adalah 1 detik dan maksimum 120 detik. Untuk informasi selengkapnya, lihat [Batas waktu respons](DownloadDistValuesOrigin.md#DownloadDistValuesOriginResponseTimeout). **responseCompletionTimeout (opsional)** Waktu (dalam detik) permintaan dari CloudFront ke asal dapat tetap terbuka dan menunggu tanggapan. Jika respons lengkap tidak diterima dari asal saat ini, CloudFront akhiri koneksi. Nilai untuk `responseCompletionTimeout` harus sama dengan atau lebih besar dari nilai untuk`readTimeout`. Untuk informasi selengkapnya, lihat [Batas waktu penyelesaian respons](DownloadDistValuesOrigin.md#response-completion-timeout). **keepAliveTimeout (opsional)** Batas waktu ini hanya berlaku untuk asal kustom, bukan asal Amazon S3. (Konfigurasi asal S3 akan mengabaikan pengaturan ini.) `keepAliveTimeout`Menentukan berapa lama CloudFront harus mencoba untuk mempertahankan koneksi ke asal setelah menerima paket terakhir dari respon. Batas waktu minimum adalah 1 detik dan maksimum 120 detik. Untuk informasi selengkapnya, lihat [Keep-alive timeout (khusus dan hanya asal VPC)](DownloadDistValuesOrigin.md#DownloadDistValuesOriginKeepaliveTimeout). **ConnectionTimeout (opsional)** Jumlah detik yang CloudFront menunggu ketika mencoba membuat koneksi ke asal. Batas waktu minimum adalah 1 detik dan maksimum 10 detik. Untuk informasi selengkapnya, lihat [Batas waktu koneksi](DownloadDistValuesOrigin.md#origin-connection-timeout). **customOriginConfig (opsional)** Gunakan `customOriginConfig` untuk menentukan setelan koneksi untuk asal yang *bukan* bucket Amazon S3. Ada satu pengecualian: Anda dapat menentukan pengaturan ini jika bucket S3 dikonfigurasi dengan hosting situs web statis. (Jenis konfigurasi bucket S3 lainnya akan mengabaikan pengaturan ini.) Jika tidak `customOriginConfig` disediakan, maka pengaturan dari asal yang ditetapkan digunakan. **port (diperlukan)** Port HTTP yang CloudFront digunakan untuk terhubung ke asal. Tentukan port HTTP yang didengar oleh asal. **protokol (wajib)** Menentukan protokol (HTTP atau HTTPS) yang CloudFront digunakan untuk terhubung ke asal. Nilai yang valid adalah sebagai berikut: + `http`— CloudFront selalu menggunakan HTTP untuk terhubung ke asal + `https`— CloudFront selalu menggunakan HTTPS untuk terhubung ke asal **SSLProtocols (wajib)** Daftar yang menentukan SSL/TLS protokol minimum yang CloudFront digunakan saat menghubungkan ke asal Anda melalui HTTPS. Nilai yang valid termasuk `SSLv3`, `TLSv1`, `TLSv1.1`, dan `TLSv1.2`. Untuk informasi selengkapnya, lihat [Protokol SSL asal minimum](DownloadDistValuesOrigin.md#DownloadDistValuesOriginSSLProtocols). **ipAddressType (opsional)** Menentukan jenis alamat IP yang CloudFront digunakan untuk terhubung ke asal. Nilai yang valid termasuk `ipv4`, `ipv6`, dan `dualstack`. Perubahan `ipAddressType` hanya didukung ketika `domainName` properti juga sedang diubah. **sni (opsional, untuk asal kustom non-S3)** Server Name Indication (SNI) adalah ekstensi ke protokol Transport Layer Security (TLS) dimana klien menunjukkan nama host mana yang ingin disambungkan pada awal proses jabat tangan TLS. Nilai ini harus cocok dengan nama umum pada sertifikat TLS di server asal Anda. Jika tidak, server asal Anda mungkin akan menimbulkan kesalahan. Jika ini tidak disediakan, nilai dari `hostHeader` parameter digunakan. Jika header host tidak disediakan, nilai dari `domainName` parameter digunakan. Jika header host atau parameter nama domain tidak disediakan, nama domain dari asal yang ditetapkan akan digunakan atau header host dari permintaan masuk jika kebijakan penerusan ke asal (FTO) menyertakan host. SNI tidak dapat menyertakan titik dua (`:`) dan tidak dapat menjadi alamat IP. SNI dapat mencapai 253 karakter. **allowedCertificateNames (opsional, untuk asal kustom non-S3)** Anda dapat menyertakan daftar nama sertifikat yang valid yang akan digunakan CloudFront untuk memvalidasi pencocokan domain dari sertifikat TLS server asal Anda selama jabat tangan TLS dengan server asal Anda. Bidang ini mengharapkan array nama domain yang valid dan dapat menyertakan domain wildcard, seperti. `*.example.com` Anda dapat menentukan hingga 20 nama sertifikat yang diizinkan. Setiap nama sertifikat dapat memiliki hingga 64 karakter. **Example - Perbarui ke asal permintaan Amazon S3** Contoh berikut mengubah asal permintaan viewer ke bucket S3, mengaktifkan OAC, dan mengatur ulang header kustom yang dikirim ke asal. ``` 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 — Perbarui ke asal permintaan Application Load Balancer** Contoh berikut mengubah asal permintaan penampil ke asal Application Load Balancer dan menetapkan header dan batas waktu kustom. ``` 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 — Perbarui ke asal dengan Origin Shield diaktifkan** Dalam contoh berikut, asal dalam distribusi mengaktifkan Origin Shield. Kode fungsi hanya memperbarui nama domain yang digunakan untuk asal dan menghilangkan semua parameter opsional lainnya. Dalam hal ini, Origin Shield akan tetap digunakan dengan nama domain asal yang dimodifikasi karena parameter Origin Shield tidak diperbarui. ``` cf.updateRequestOrigin({ "domainName" : "www.example.com" }); ``` **Example — Perbarui header host, SNI, dan nama sertifikat yang diizinkan** Untuk sebagian besar kasus penggunaan, Anda tidak perlu menggunakan jenis modifikasi ini untuk permintaan yang menuju ke asal Anda. Parameter ini tidak boleh digunakan kecuali Anda memahami dampak dari mengubah nilai-nilai ini. Contoh berikut mengubah nama domain, header host, SNI, dan sertifikat yang diizinkan atas permintaan ke asal. ``` cf.updateRequestOrigin({ "domainName": "www.example.com", "hostHeader": "test.example.com", "sni": "test.example.net", "allowedCertificateNames": ["*.example.com", "*.example.net"], }); ``` ## selectRequestOriginById() metode Gunakan `selectRequestOriginById()` untuk memperbarui asal yang ada dengan memilih asal berbeda yang sudah dikonfigurasi dalam distribusi Anda. Metode ini menggunakan semua pengaturan yang sama yang ditentukan oleh asal yang diperbarui. Metode ini hanya menerima asal yang sudah ditentukan dalam distribusi yang sama yang digunakan saat menjalankan fungsi. Origins direferensikan oleh ID asal, yang merupakan nama asal yang Anda tentukan saat mengatur asal. Jika Anda memiliki asal VPC yang dikonfigurasi dalam distribusi Anda, Anda dapat menggunakan metode ini untuk memperbarui asal Anda ke asal VPC Anda. Untuk informasi selengkapnya, lihat [Batasi akses dengan asal VPC](private-content-vpc-origins.md). **Catatan** `selectRequestOriginById()`Fungsi tidak dapat memilih asal yang mengaktifkan TLS (asal) timbal balik. Mencoba memilih asal yang diaktifkan TLS (origin) bersama menggunakan fungsi ini akan menghasilkan kesalahan validasi. Jika kasus penggunaan Anda memerlukan pemilihan asal dinamis dengan TLS timbal balik (asal), gunakan `updateRequestOrigin()` sebagai gantinya, pastikan semua asal target menggunakan sertifikat klien yang sama. **Permintaan** ``` cf.selectRequestOriginById(origin_id, {origin_overrides}) ``` Pada contoh sebelumnya, `origin_id` adalah string yang menunjuk ke nama asal asal dalam distribusi yang menjalankan fungsi. `origin_overrides `Parameter dapat berisi yang berikut: **Hostheader (opsional, untuk asal-usul kustom non-S3)** Header host untuk digunakan saat membuat permintaan ke asal. Jika ini tidak disediakan, nilai dari `domainName` parameter digunakan. Jika header host atau parameter nama domain tidak disediakan, nama domain dari asal yang ditetapkan akan digunakan atau header host dari permintaan masuk jika kebijakan penerusan ke asal (FTO) menyertakan host. Header host tidak dapat menyertakan titik dua (`:`) dan tidak bisa menjadi alamat IP. Header host dapat mencapai 253 karakter. **sni (opsional, untuk asal kustom non-S3)** Server Name Indication (SNI) adalah ekstensi ke protokol Transport Layer Security (TLS) dimana klien menunjukkan nama host mana yang ingin disambungkan pada awal proses jabat tangan TLS. Nilai ini harus cocok dengan nama umum pada sertifikat TLS di server asal Anda. Jika tidak, server asal Anda mungkin akan menimbulkan kesalahan. Jika ini tidak disediakan, nilai dari `hostHeader` parameter digunakan. Jika header host tidak disediakan, nilai dari `domainName` parameter digunakan. Jika header host atau parameter nama domain tidak disediakan, nama domain dari asal yang ditetapkan akan digunakan atau header host dari permintaan masuk jika kebijakan penerusan ke asal (FTO) menyertakan host. SNI tidak dapat menyertakan titik dua (`:`) dan tidak dapat menjadi alamat IP. SNI dapat mencapai 253 karakter. **allowedCertificateNames (opsional, untuk asal kustom non-S3)** Anda dapat menyertakan daftar nama sertifikat yang valid yang akan digunakan CloudFront untuk memvalidasi pencocokan domain dari sertifikat TLS server asal Anda selama jabat tangan TLS dengan server asal Anda. Bidang ini mengharapkan array nama domain yang valid dan dapat menyertakan domain wildcard, seperti. `*.example.com` Anda dapat menentukan hingga 20 nama sertifikat yang diizinkan. Setiap nama sertifikat dapat memiliki hingga 64 karakter. **Permintaan** ``` selectRequestOriginById(origin_id) ``` Dalam contoh sebelumnya, `origin_id` adalah string yang menunjuk ke nama asal asal dalam distribusi yang menjalankan fungsi. **Example — Pilih asal permintaan Amazon S3** Contoh berikut memilih asal yang dinamai `amzn-s3-demo-bucket-in-us-east-1` dari daftar asal yang terkait dengan distribusi, dan menerapkan pengaturan konfigurasi `amzn-s3-demo-bucket-in-us-east-1` asal ke permintaan. ``` cf.selectRequestOriginById("amzn-s3-demo-bucket-in-us-east-1"); ``` **Example — Pilih asal permintaan Application Load Balancer** Contoh berikut memilih asal Application Load Balancer `myALB-prod` bernama dari daftar asal yang terkait dengan distribusi, dan menerapkan pengaturan konfigurasi untuk `myALB-prod` permintaan. ``` cf.selectRequestOriginById("myALB-prod"); ``` **Example — Pilih asal permintaan Application Load Balancer dan ganti header host** Seperti contoh sebelumnya, contoh berikut memilih asal Application Load Balancer yang `myALB-prod` dinamai dari daftar asal yang terkait dengan distribusi, dan menerapkan pengaturan konfigurasi untuk `myALB-prod` permintaan. Namun, contoh ini mengesampingkan nilai header host menggunakan. `origin_overrides` ``` cf.overrideRequestOrigin("myALB-prod",{ "hostHeader" : "test.example.com" }); ``` ## createRequestOriginMetode grup () Gunakan `createRequestOriginGroup()` untuk mendefinisikan dua asal untuk digunakan sebagai [grup asal](high_availability_origin_failover.md#concept_origin_groups.creating) untuk failover dalam skenario yang membutuhkan ketersediaan tinggi. Grup asal mencakup dua asal (primer dan sekunder) dan kriteria failover yang Anda tentukan. Anda membuat grup asal untuk mendukung failover asal. CloudFront Saat membuat atau memperbarui grup asal menggunakan metode ini, Anda dapat menentukan grup asal, bukan satu asal. CloudFront akan failover dari asal primer ke asal sekunder, menggunakan kriteria failover. Jika Anda memiliki asal VPC yang dikonfigurasi dalam distribusi Anda, Anda dapat menggunakan metode ini untuk membuat grup asal menggunakan asal VPC. Untuk informasi selengkapnya, lihat [Batasi akses dengan asal VPC](private-content-vpc-origins.md). **Catatan** `createRequestOriginGroup()`Fungsi ini tidak mendukung pembuatan grup asal yang menyertakan asal yang diaktifkan Mutual TLS (origin). Grup asal dengan asal Mutual TLS (asal) tidak dapat dibuat secara dinamis melalui CloudFront Fungsi. Jika Anda memerlukan kemampuan failover asal dengan Mutual TLS (origin), konfigurasikan grup asal secara langsung di pengaturan CloudFront distribusi Anda daripada membuatnya secara dinamis dalam fungsi. ### Permintaan ``` createRequestOriginGroup({origin_group_properties}) ``` Dalam contoh sebelumnya, `origin_group_properties` dapat berisi yang berikut: **OriginIds (wajib)** Array dari`origin_ids`, di mana `origin_id` adalah string yang menunjuk ke nama asal asal dalam distribusi yang menjalankan fungsi. Anda harus memberikan dua asal sebagai bagian dari array. Asal pertama dalam daftar adalah asal primer dan yang kedua berfungsi sebagai asal kedua untuk tujuan failover. **OriginOverrides (opsional)** Beberapa pengaturan lanjutan diizinkan untuk ditimpa dengan menggunakan `{origin_overrides}` parameter. `origin overrides`Dapat berisi yang berikut: **Hostheader (opsional, untuk asal-usul kustom non-S3)** Header host untuk digunakan saat membuat permintaan ke asal. Jika ini tidak disediakan, nilai dari `domainName` parameter digunakan. Jika header host atau parameter nama domain tidak disediakan, nama domain dari asal yang ditetapkan akan digunakan atau header host dari permintaan masuk jika kebijakan penerusan ke asal (FTO) menyertakan host. Header host tidak dapat menyertakan titik dua (`:`) dan tidak bisa menjadi alamat IP. Header host dapat mencapai 253 karakter. **sni (opsional, untuk asal kustom non-S3)** Server Name Indication (SNI) adalah ekstensi ke protokol Transport Layer Security (TLS) dimana klien menunjukkan nama host mana yang ingin disambungkan pada awal proses handshaking TLS. Nilai ini harus cocok dengan nama umum pada sertifikat TLS di server asal Anda, jika tidak, server asal Anda dapat menimbulkan kesalahan. Jika ini tidak disediakan, nilai dari `hostHeader` parameter digunakan. Jika header host tidak disediakan, nilai dari `domainName` parameter digunakan. Jika header host atau parameter nama domain tidak disediakan, nama domain dari asal yang ditetapkan akan digunakan atau header host dari permintaan masuk jika kebijakan penerusan ke asal (FTO) menyertakan host. SNI tidak dapat menyertakan titik dua (`:`) dan tidak dapat menjadi alamat IP. SNI dapat mencapai 253 karakter. **allowedCertificateNames (opsional, untuk asal kustom non-S3)** Anda dapat menyertakan daftar nama sertifikat yang valid yang akan digunakan CloudFront untuk memvalidasi pencocokan domain dari sertifikat TLS server asal Anda selama jabat tangan TLS dengan server asal Anda. Bidang ini mengharapkan array nama domain yang valid dan dapat menyertakan domain wildcard, seperti. `*.example.com` Anda dapat menentukan hingga 20 nama sertifikat yang diizinkan. Setiap nama sertifikat dapat memiliki hingga 64 karakter. **SelectionCriteria (opsional)** Pilih apakah akan menggunakan kriteria failover `default` asal atau menggunakan logika failover `media-quality-score` berbasis. Nilai yang valid adalah sebagai berikut: + `default`menggunakan kriteria failover, berdasarkan kode status yang ditentukan dalam. `failoverCriteria` Jika Anda tidak mengatur `selectionCriteria` fungsi, `default` akan digunakan. + `media-quality-score`digunakan ketika kemampuan perutean sadar media sedang digunakan. **FailOverCriteria (wajib)** Array kode status yang, ketika dikembalikan dari asal primer, akan memicu failover CloudFront ke asal sekunder. Jika Anda menimpa grup asal yang ada, larik ini akan menimpa semua kode status failover yang ditetapkan dalam konfigurasi asli grup asal. Saat Anda menggunakan `media-quality-score``selectionCriteria`, CloudFront akan mencoba untuk merutekan permintaan berdasarkan skor kualitas media. Jika asal yang dipilih mengembalikan kode kesalahan yang diatur dalam array ini, CloudFront akan failover ke asal lainnya. **Example — Buat grup asal permintaan** Contoh berikut membuat grup asal untuk permintaan menggunakan asal IDs. Asal ini IDs berasal dari konfigurasi grup asal untuk distribusi yang digunakan untuk menjalankan fungsi ini. Secara opsional, Anda dapat menggunakan `originOverrides` untuk mengganti konfigurasi grup asal untuk`sni`,, `hostHeader` dan. `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; } ``` # Metode pembantu untuk properti CloudFront SaaS Manager Gunakan fungsi pembantu berikut untuk CloudFront SaaS Manager untuk mengambil nilai untuk distribusi multi-penyewa Anda dalam fungsi yang Anda buat. Untuk menggunakan contoh di halaman ini, Anda harus terlebih dahulu membuat CloudFront fungsi dengan menggunakan JavaScript runtime 2.0. Untuk informasi selengkapnya, lihat [JavaScript fitur runtime 2.0 untuk Fungsi CloudFront](functions-javascript-runtime-20.md). **Topics** + [Grup koneksi](#connection-groups-helper-function) + [Penyewa distribusi](#distribution-tenants-helper-functions) ## Grup koneksi Grup koneksi yang terkait dengan penyewa distribusi Anda memiliki nama domain. Untuk mendapatkan nilai ini, gunakan `endpoint` bidang `context` subobject dari objek acara. **Permintaan** ``` const value = event.context.endpoint; ``` **Respons** Responsnya adalah `string` yang berisi nama domain grup koneksi, seperti d111111abcdef8.cloudfront.net. `endpoint`Bidang hanya muncul ketika fungsi Anda dipanggil untuk distribusi multi-penyewa dengan grup koneksi terkait. Untuk informasi selengkapnya, lihat [Objek konteks](functions-event-structure.md#functions-event-structure-context). ## Penyewa distribusi CloudFront Fungsi memiliki modul yang menyediakan akses ke nilai penyewa distribusi tertentu. Untuk menggunakan modul ini, sertakan pernyataan berikut di baris pertama kode fungsi Anda: ``` import cf from 'cloudfront'; ``` Anda dapat menggunakan contoh berikut hanya dalam `handler` fungsi, baik secara langsung atau melalui fungsi panggilan bersarang. ### `distributionTenant.id`lapangan Gunakan bidang ini untuk mendapatkan nilai ID penyewa distribusi. **Permintaan** ``` const value = cf.distributionTenant.id; ``` **Respons** Responsnya adalah `string` yang berisi ID penyewa distribusi, seperti`dt_1a2b3c4d5e6f7`. **Penanganan kesalahan** Jika fungsi Anda dipanggil untuk distribusi standar, menentukan `distributionTenant.id` bidang akan mengembalikan kesalahan `distributionTenant module is not available` tipe. Untuk menangani kasus penggunaan ini, Anda dapat menambahkan `try` dan `catch` memblokir kode Anda. ### Metode `distributionTenant.parameters.get()` Gunakan metode ini untuk mengembalikan nilai untuk nama parameter penyewa distribusi yang Anda tentukan. ``` distributionTenant.parameters.get("key"); ``` `key`: Nama parameter penyewa distribusi yang ingin Anda ambil nilainya. **Permintaan** ``` const value = distributionTenant.parameters.get("key"); ``` **Respons** Responsnya adalah a `string` yang berisi nilai untuk parameter penyewa distribusi. Misalnya, jika nama kunci Anda adalah`TenantPath`, maka nilai untuk parameter ini mungkin`tenant1`. **Penanganan kesalahan** Anda mungkin menerima kesalahan berikut: + Jika fungsi Anda dipanggil untuk distribusi standar, `distributionTenant.parameters.get()` metode akan mengembalikan kesalahan `distributionTenant module is not available` tipe. + `DistributionTenantParameterKeyNotFound`Kesalahan dikembalikan ketika parameter penyewa distribusi yang Anda tentukan tidak ada. Untuk mengelola kasus penggunaan ini, Anda dapat menambahkan `try` dan `catch` memblokir kode Anda. # Gunakan async dan await CloudFront Fungsi JavaScript runtime function 2.0 menyediakan `async` dan `await` sintaks untuk menangani `Promise` objek. Janji mewakili hasil tertunda yang dapat diakses melalui `await` kata kunci dalam fungsi yang ditandai sebagai`async`. Berbagai WebCrypto fungsi baru menggunakan Promises. Untuk informasi selengkapnya tentang `Promise` objek, lihat [Janji](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise). **catatan** Anda harus menggunakan JavaScript runtime 2.0 untuk contoh kode berikut. `await`hanya dapat digunakan di dalam `async` fungsi. `async`argumen dan penutupan tidak didukung. ``` 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; } ``` JavaScript Kode contoh berikut menunjukkan cara melihat janji dengan metode `then` rantai. Anda dapat menggunakan `catch` untuk melihat kesalahan. **Awas** Menggunakan kombinator janji (misalnya,`Promise.all`,`Promise.any`, dan metode rantai janji (misalnya, `then` dan`catch`) dapat memerlukan penggunaan memori fungsi tinggi. Jika fungsi Anda melebihi kuota [memori fungsi maksimum](cloudfront-limits.md#limits-functions), itu akan gagal dijalankan. Untuk menghindari kesalahan ini, kami sarankan Anda menggunakan `await` sintaks alih-alih `promise` metode. ``` 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; } ``` # Dukungan CWT untuk Fungsi CloudFront Bagian ini memberikan detail tentang dukungan untuk CBOR Web Tokens (CWT) di CloudFront Fungsi Anda, yang memungkinkan otentikasi dan otorisasi berbasis token yang aman di Lokasi Edge. CloudFront Dukungan ini disediakan sebagai modul, dapat diakses di CloudFront Fungsi Anda. Untuk menggunakan modul ini, buat CloudFront Function menggunakan JavaScript runtime 2.0 dan sertakan pernyataan berikut di baris pertama kode fungsi: ``` import cf from 'cloudfront'; ``` Metode yang terkait dengan modul ini dapat diakses melalui (di mana \$1 adalah wildcard yang mewakili berbagai fungsi yang ada dalam modul): ``` cf.cwt.* ``` Untuk informasi selengkapnya, lihat [JavaScript fitur runtime 2.0 untuk Fungsi CloudFront](functions-javascript-runtime-20.md). Saat ini, modul hanya mendukung struktur MAC0 dengan algoritma HS256 (HMAC-SHA256) dengan batas 1KB untuk ukuran token maksimum. ## Struktur token Bagian ini mencakup struktur token yang diharapkan oleh modul CWT. Modul mengharapkan token ditandai dengan benar dan dapat diidentifikasi (misalnya COSE MAC0). Selain itu, untuk struktur token, modul mengikuti standar yang ditetapkan oleh [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 menggunakan struktur COSE MAC0** ``` 61( // CWT tag 17( // COSE_MAC0 tag [ { // Protected Headers 1: 4 // algorithm : HMAC-256-64 }, { // Unprotected Headers 4: h'53796d6d6574726963323536' // kid : Symmetric key id }, { // Payload 1: "https://iss.example.com", // iss 2: "exampleUser", // sub 3: "https://aud.example.com", // aud 4: 1444064944, // exp 5: 1443944944, // nbf 6: 1443944944, // iat }, h'093101ef6d789200' // tag ] ) ) ``` Tag CWT bersifat opsional saat menghasilkan token. Namun, tag struktur COSE diperlukan. ## metode validateToken () Fungsi menerjemahkan dan memvalidasi token CWT menggunakan kunci yang ditentukan. Jika validasi berhasil, ia mengembalikan token CWT yang diterjemahkan. Jika tidak, itu akan menimbulkan kesalahan. Harap dicatat bahwa fungsi ini tidak melakukan validasi pada set klaim. ### Permintaan ``` cf.cwt.validateToken(token, handlerContext{key}) ```Parameter **token (wajib)** Token yang dikodekan untuk validasi. Ini pasti JavaScript Buffer. **HandlerContext (Diperlukan)** JavaScript Objek yang menyimpan konteks untuk panggilan ValidateToken. Saat ini, hanya properti kunci yang didukung. **kunci (Diperlukan)** Kunci rahasia untuk perhitungan intisari pesan. Dapat disediakan baik sebagai string atau JavaScript Buffer. ### Respons Ketika `validateToken()` metode mengembalikan token berhasil divalidasi, respon dari fungsi adalah `CWTObject` dalam format berikut. Setelah diterjemahkan, semua kunci klaim direpresentasikan sebagai string. ``` CWTObject { protectedHeaders, unprotectedHeaders, payload } ``` ### Contoh - Validasi token dengan anak dikirim sebagai bagian dari token Contoh ini menunjukkan validasi token CWT, di mana anak diekstraksi dari header. Anak itu kemudian diteruskan ke CloudFront Fungsi KeyValueStore untuk mengambil kunci rahasia yang digunakan untuk memvalidasi token. ``` import cf from 'cloudfront' const CwtClaims = { iss: 1, aud: 3, exp: 4 } async function handler(event) { try { let request = event.request; let encodedToken = request.headers['x-cwt-token'].value; let kid = request.headers['x-cwt-kid'].value; // Retrieve the secret key from the kvs let secretKey = await cf.kvs().get(kid); // Now you can use the secretKey to decode & validate the token. let tokenBuffer = Buffer.from(encodedToken, 'base64url'); let handlerContext = { key: secretKey, } try { let cwtObj = cf.cwt.validateToken(tokenBuffer, handlerContext); // Check if token is expired const currentTime = Math.floor(Date.now() / 1000); // Current time in seconds if (cwtObj[CwtClaims.exp] && cwtObj[CwtClaims.exp] < currentTime) { return { statusCode: 401, statusDescription: 'Token expired' }; } } catch (error) { return { statusCode: 401, statusDescription: 'Invalid token' }; } } catch (error) { return { statusCode: 402, statusDescription: 'Token processing failed' }; } return request; } ``` ## metode generateToken () Fungsi ini menghasilkan token CWT baru menggunakan pengaturan payload dan konteks yang disediakan. ### Permintaan ``` cf.cwt.generateToken(generatorContext, payload) ```Parameter **GeneratorContext (Diperlukan)** Ini JavaScript Object yang digunakan sebagai konteks untuk menghasilkan token dan berisi pasangan nilai kunci berikut: **CWTTag (Opsional)** Nilai ini adalah boolean, yang jika `true` menentukan `cwtTag` harus ditambahkan. **CoseTag (Diperlukan)** Menentukan jenis tag COSE. Saat ini hanya mendukung`MAC0`. **kunci (Diperlukan)** Kunci rahasia untuk menghitung intisari pesan. Nilai ini dapat berupa string atau JavaScript `Buffer`. **payload (Wajib)** Payload token untuk pengkodean. Muatan harus dalam `CWTObject` format. ### Respons Mengembalikan JavaScript Buffer yang berisi token dikodekan. **Example : Menghasilkan token CWT** ``` import cf from 'cloudfront'; const CwtClaims = { iss: 1, sub: 2, exp: 4 }; const CatClaims = { catu: 401, catnip: 402, catm: 403, catr: 404 }; const Catu = { host: 1, path: 2, ext: 3 }; const CatuMatchTypes = { prefix_match: 1, suffix_match: 2, exact_match: 3 }; const Catr = { renewal_method: 1, next_renewal_time: 2, max_uses: 3 }; async function handler(event) { try { const response = { statusCode: 200, statusDescription: 'OK', headers: {} }; const commonAccessToken = { protected: { 1: "5", }, unprotected: {}, payload: { [CwtClaims.iss]: "cloudfront-documentation", [CwtClaims.sub]: "cwt-support-on-cloudfront-functions", [CwtClaims.exp]: 1740000000, [CatClaims.catu]: { [Catu.host]: { [CatuMatchTypes.suffix_match]: ".cloudfront.net" }, [Catu.path]: { [CatuMatchTypes.prefix_match]: "/media/live-stream/cf-4k/" }, [Catu.ext]: { [CatuMatchTypes.exact_match]: [ ".m3u8", ".ts", ".mpd" ] } }, [CatClaims.catnip]: [ "[IP_ADDRESS]", "[IP_ADDRESS]" ], [CatClaims.catm]: [ "GET", "HEAD" ], [CatClaims.catr]: { [Catr.renewal_method]: "header_renewal", [Catr.next_renewal_time]: 1750000000, [Catr.max_uses]: 5 } } }; if (!request.headers['x-cwt-kid']) { throw new Error('Missing x-cwt-kid header'); } const kid = request.headers['x-cwt-kid'].value; const secretKey = await cf.kvs().get(kid); if (!secretKey) { throw new Error('Secret key not found for provided kid'); } try { const genContext = { cwtTag: true, coseTag: "MAC0", key: secretKey }; const tokenBuffer = cf.cwt.generateToken(commonAccessToken, genContext); response.headers['x-generated-cwt-token'] = { value: tokenBuffer.toString('base64url') }; return response; } catch (tokenError) { return { statusCode: 401, statusDescription: 'Could not generate the token' }; } } catch (error) { return { statusCode: 402, statusDescription: 'Token processing failed' }; } } ``` **Example : Segarkan token berdasarkan beberapa logika** ``` 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; } ``` # Metode pembantu umum Halaman ini menyediakan metode pembantu tambahan di dalam CloudFront Fungsi. Untuk menggunakan metode ini, buat CloudFront fungsi menggunakan JavaScript runtime 2.0. ``` import cf from 'cloudfront'; ``` Untuk informasi selengkapnya, lihat [JavaScript fitur runtime 2.0 untuk Fungsi CloudFront](functions-javascript-runtime-20.md). ## `edgeLocation`metadata Metode ini membutuhkan penggunaan `cloudfront` modul. **catatan** Anda hanya dapat menggunakan metode ini untuk fungsi permintaan pemirsa. Untuk fungsi respons pemirsa, metode ini kosong. Gunakan JavaScript objek ini untuk mendapatkan kode bandara lokasi tepi, wilayah [Regional Edge Cache](HowCloudFrontWorks.md#CloudFrontRegionaledgecaches) yang diharapkan atau alamat IP CloudFront server yang digunakan untuk menangani permintaan. Metadata ini hanya tersedia pemicu peristiwa permintaan penampil. ``` cf.edgeLocation = { name: SEA serverIp: 1.2.3.4 region: us-west-2 } ``` `cf.edgeLocation`Objek dapat berisi yang berikut: **name** [Kode IATA](https://en.wikipedia.org/wiki/IATA_airport_code) tiga huruf dari lokasi tepi yang menangani permintaan. **ServeIP** IPv6 Alamat IPv4 atau server yang menangani permintaan. **region** CloudFront Regional Edge Cache (REC) yang *diharapkan akan* digunakan permintaan jika ada cache yang hilang. Nilai ini tidak diperbarui jika REC yang diharapkan tidak tersedia dan REC cadangan digunakan untuk permintaan tersebut. Ini tidak termasuk lokasi Origin Shield yang digunakan, kecuali jika REC utama dan Origin Shield berada di lokasi yang sama. **catatan** CloudFront Fungsi tidak dipanggil untuk kedua kalinya ketika CloudFront dikonfigurasi untuk menggunakan failover asal. Untuk informasi selengkapnya, lihat [Optimalkan ketersediaan tinggi dengan failover CloudFront asal](high_availability_origin_failover.md). ## Metode `rawQueryString()` Metode ini tidak memerlukan `cloudFront` modul. Gunakan `rawQueryString()` metode ini untuk mengambil string kueri yang tidak diurai dan tidak diubah sebagai string. **Permintaan** ``` function handler(event) { var request = event.request; const qs = request.rawQueryString(); } ``` **Respons** Mengembalikan string query lengkap dari permintaan masuk sebagai nilai string tanpa memimpin`?`. + Jika tidak ada string query, tetapi `?` hadir, fungsi mengembalikan string kosong. + Jika tidak ada string kueri dan `?` tidak hadir, fungsi kembali`undefined`. **Kasus 1: String kueri lengkap dikembalikan (tanpa memimpin`?`)** URL permintaan masuk: `https://example.com/page?name=John&age=25&city=Boston` `rawQueryString()`mengembalikan: `"name=John&age=25&city=Boston"` **Kasus 2: String kosong dikembalikan (kapan `?` ada tetapi tanpa parameter)** URL permintaan masuk: `https://example.com/page?` `rawQueryString()`mengembalikan: `""` **Kasus 3: `undefined` dikembalikan (tidak ada string kueri dan tidak`?`)** URL permintaan masuk: `https://example.com/page` `rawQueryString()`mengembalikan: `undefined` # Buat fungsi Anda membuat fungsi dalam dua tahap: 1. Buat kode fungsi sebagai JavaScript. Anda dapat menggunakan contoh default dari CloudFront konsol atau menulis sendiri. Untuk informasi selengkapnya, lihat topik berikut. + [Tulis kode fungsi](writing-function-code.md) + [CloudFront Fungsi struktur acara](functions-event-structure.md) + [CloudFront Contoh fungsi untuk CloudFront](service_code_examples_cloudfront_functions_examples.md) 1. Gunakan CloudFront untuk membuat fungsi dan sertakan kode Anda. Kode ada di dalam fungsi (bukan sebagai referensi). ------ #### [ Console ] **Untuk membuat fungsi** 1. Masuk ke CloudFront konsol di [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) dan pilih halaman **Fungsi**. 1. Pilih **Buat fungsi**. 1. Masukkan nama fungsi yang unik di dalam Akun AWS, pilih JavaScript versi, lalu pilih **Lanjutkan**. Halaman detail untuk fungsi baru muncul. **catatan** Untuk menggunakan [pasangan kunci-nilai](kvs-with-functions.md) dalam fungsi, Anda harus memilih JavaScript runtime 2.0. 1. Di bagian **Kode fungsi**, pilih tab **Build** dan masukkan kode fungsi Anda. Kode contoh yang disertakan dalam tab **Build** mengilustrasikan sintaks dasar untuk kode fungsi. 1. Pilih **Simpan perubahan**. 1. Jika kode fungsi menggunakan pasangan kunci-nilai, Anda harus mengaitkan penyimpanan nilai kunci. Anda dapat mengaitkan penyimpanan nilai kunci saat pertama kali membuat fungsi. Atau, Anda dapat mengaitkannya nanti, dengan [memperbarui fungsi](update-function.md). Untuk mengaitkan penyimpanan nilai kunci sekarang, ikuti langkah-langkah berikut: + Buka KeyValueStore bagian **Associate** dan pilih **Associate existing KeyValueStore**. + **Pilih penyimpanan nilai kunci yang berisi pasangan kunci-nilai dalam fungsi, lalu pilih Associate. KeyValueStore** CloudFront segera mengaitkan toko dengan fungsinya. Anda tidak perlu menyimpan fungsinya. ------ #### [ CLI ] Jika Anda menggunakan CLI, Anda biasanya pertama kali membuat kode fungsi dalam file, dan kemudian membuat fungsi dengan. AWS CLI **Untuk membuat fungsi** 1. Buat kode fungsi dalam file, dan simpan di direktori tempat komputer Anda dapat terhubung. 1. Jalankan perintah seperti yang ditunjukkan pada contoh. Contoh ini menggunakan `fileb://` notasi untuk meneruskan file. Ini juga termasuk jeda baris untuk membuat perintah lebih mudah dibaca. ``` 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 ``` **Catatan** `Runtime`— Versi JavaScript. Untuk menggunakan [pasangan nilai kunci](kvs-with-functions.md) dalam fungsi, Anda harus menentukan versi 2.0. `KeyValueStoreAssociations`— Jika fungsi Anda menggunakan pasangan kunci-nilai, Anda dapat mengaitkan penyimpanan nilai kunci saat pertama kali membuat fungsi. Atau, Anda dapat mengaitkannya nanti, dengan menggunakan`update-function`. `Quantity`Itu selalu `1` karena setiap fungsi hanya dapat memiliki satu penyimpanan nilai kunci yang terkait dengannya. Ketika perintah berhasil, Anda melihat output seperti berikut ini. ``` 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 ``` Sebagian besar informasi diulang dari permintaan. Informasi lain ditambahkan oleh CloudFront. **Catatan** `ETag`— Nilai ini berubah setiap kali Anda memodifikasi penyimpanan nilai kunci. Anda menggunakan nilai ini dan nama fungsi untuk mereferensikan fungsi di masa depan. Pastikan Anda selalu menggunakan arus`ETag`. `FunctionARN`— ARN untuk fungsi Anda CloudFront. 111122223333 —. Akun AWS `Stage`— Tahap fungsi (`LIVE`atau`DEVELOPMENT`). `Status`— Status fungsi (`PUBLISHED`atau`UNPUBLISHED`). ------ Setelah Anda membuat fungsi, itu ditambahkan ke `DEVELOPMENT` panggung. Kami menyarankan Anda [menguji fungsi Anda](test-function.md) sebelum [mempublikasikannya](publish-function.md). Setelah Anda mempublikasikan fungsi Anda, fungsi berubah ke `LIVE` panggung. # Fungsi uji Sebelum Anda menerapkan fungsi ke live stage (produksi), Anda dapat menguji fungsi Anda untuk memverifikasi bahwa fungsi berfungsi sebagaimana dimaksud. Untuk menguji fungsi, Anda menentukan *objek peristiwa* yang mewakili permintaan HTTP atau respons yang dapat diterima CloudFront distribusi Anda dalam produksi. CloudFront Fungsi melakukan hal berikut: 1. Menjalankan fungsi, menggunakan objek acara yang disediakan sebagai input. 1. Mengembalikan hasil fungsi (objek peristiwa yang dimodifikasi) bersama dengan log fungsi atau pesan kesalahan dan *pemanfaatan komputasi* fungsi. Untuk informasi lebih lanjut tentang pemanfaatan komputasi, lihat. [Memahami pemanfaatan komputasi](#compute-utilization) **catatan** Saat Anda menguji suatu fungsi, CloudFront hanya memvalidasi terhadap kesalahan eksekusi fungsi. CloudFronttidak memvalidasi apakah permintaan akan berhasil mengalir setelah diterbitkan. Misalnya, jika fungsi Anda menghapus header yang diperlukan, pengujian akan berhasil karena tidak ada masalah dengan kode. Namun, jika Anda mempublikasikan fungsi dan mengaitkannya dengan distribusi, fungsi tersebut akan gagal saat permintaan dibuat CloudFront. **Contents** + [Mengatur objek acara](#test-function-create-event) + [Uji fungsi](#test-function-step-test) + [Memahami pemanfaatan komputasi](#compute-utilization) ## Mengatur objek acara Sebelum Anda menguji suatu fungsi, Anda harus mengatur objek acara untuk mengujinya. Ada beberapa opsi. **Opsi 1: Siapkan objek acara tanpa menyimpannya** Anda dapat mengatur objek acara di editor visual di CloudFront konsol dan tidak menyimpannya. Anda dapat menggunakan objek acara ini untuk menguji fungsi dari CloudFront konsol, meskipun tidak disimpan. **Opsi 2: Buat objek acara di editor visual** Anda dapat mengatur objek acara di editor visual di CloudFront konsol dan tidak menyimpannya. Anda dapat membuat 10 objek acara untuk setiap fungsi sehingga Anda dapat, misalnya, menguji berbagai kemungkinan input. Saat Anda membuat objek acara dengan cara ini, Anda dapat menggunakan objek acara untuk menguji fungsi di CloudFront konsol. Anda tidak dapat menggunakannya untuk menguji fungsi menggunakan AWS API atau SDK. **Opsi 3: Buat objek acara menggunakan editor teks** Anda dapat menggunakan editor teks untuk membuat objek acara dalam format JSON. Untuk informasi tentang struktur objek peristiwa, lihat[Struktur peristiwa](functions-event-structure.md). Anda dapat menggunakan objek acara ini untuk menguji fungsi menggunakan CLI. Tetapi Anda tidak dapat menggunakannya untuk menguji fungsi di CloudFront konsol. **Untuk membuat objek acara (opsi 1 atau 2)** 1. Masuk ke CloudFront konsol di [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) dan pilih halaman **Fungsi**. Pilih fungsi yang ingin Anda uji. 1. Pada halaman detail fungsi, pilih tab **Uji**. 1. Untuk **jenis Acara**, pilih salah satu opsi berikut: + Pilih **permintaan Viewer** jika fungsi memodifikasi permintaan HTTP atau menghasilkan respons berdasarkan permintaan. Bagian **Permintaan** muncul. + Pilih **Respons penampil**. Bagian **Permintaan** dan **Respons** muncul. 1. Lengkapi bidang untuk disertakan dalam acara tersebut. Anda dapat memilih **Edit JSON** untuk melihat JSON mentah. 1. (Opsional) Untuk menyimpan acara, pilih **Simpan** dan di **acara uji Simpan**, masukkan nama lalu pilih **Simpan**. Anda juga dapat memilih **Edit JSON** dan menyalin JSON mentah, dan menyimpannya di file Anda sendiri, di luar. CloudFront **Untuk membuat objek acara (opsi 3)** Buat objek acara menggunakan editor teks. Simpan file di direktori tempat komputer Anda dapat terhubung. Verifikasi bahwa Anda mengikuti panduan ini: + Hilangkan`distributionDomainName`,`distributionId`, dan `requestId` bidang. + Nama header, cookie, dan string kueri harus huruf kecil. Salah satu opsi untuk membuat objek acara dengan cara ini adalah membuat sampel menggunakan editor visual. Anda dapat yakin bahwa sampel diformat dengan benar. Anda kemudian dapat menyalin JSON mentah dan menempelkannya ke editor teks dan menyimpan file. Untuk informasi lebih lanjut tentang struktur suatu peristiwa, lihat[Struktur peristiwa](functions-event-structure.md). ## Uji fungsi Anda dapat menguji fungsi di CloudFront konsol atau dengan AWS Command Line Interface (AWS CLI). ------ #### [ Console ] **Untuk menguji fungsi** 1. Masuk ke CloudFront konsol di [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) dan pilih halaman **Fungsi**. 1. Pilih fungsi yang ingin Anda uji. 1. Pilih tab **Uji**. 1. Pastikan acara yang benar ditampilkan. Untuk beralih dari acara yang ditampilkan saat ini, pilih acara lain di bidang **Pilih acara uji**. 1. Pilih **fungsi Uji**. Konsol menunjukkan output fungsi, termasuk log fungsi dan pemanfaatan komputasi. ------ #### [ CLI ] Anda dapat menguji suatu fungsi dengan menggunakan **aws cloudfront test-function** perintah. **Untuk menguji fungsi** 1. Buka jendela baris perintah. 1. Jalankan perintah berikut dari direktori yang sama yang berisi file yang ditentukan. Contoh ini menggunakan `fileb://` notasi untuk meneruskan dalam file objek acara. Ini juga termasuk jeda baris untuk membuat perintah lebih mudah dibaca. ``` aws cloudfront test-function \ --name MaxAge \ --if-match ETVABCEXAMPLE \ --event-object fileb://event-maxage-test01.json \ --stage DEVELOPMENT ``` **Catatan** Anda mereferensikan fungsi dengan namanya dan ETag (dalam `if-match` parameter). Anda mereferensikan objek acara berdasarkan lokasinya di sistem file Anda. Panggung bisa `DEVELOPMENT` atau`LIVE`. Ketika perintah berhasil, Anda melihat output seperti berikut ini. ``` 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 ``` ------ **Catatan** `FunctionExecutionLogs` berisi daftar baris log yang ditulis fungsi dalam pernyataan `console.log()` (jika ada). `ComputeUtilization`berisi informasi tentang menjalankan fungsi Anda. Lihat [Memahami pemanfaatan komputasi](#compute-utilization). `FunctionOutput` berisi objek peristiwa yang dikembalikan fungsi. ## Memahami pemanfaatan komputasi **Penggunaan komputasi** adalah jumlah waktu yang dibutuhkan fungsi untuk menjalankan sebagai persentase dari waktu maksimum yang diizinkan. Misalnya, nilai 35 berarti fungsi selesai pada 35% dari waktu maksimum yang diizinkan. Jika suatu fungsi terus menerus melebihi waktu maksimum yang diizinkan, CloudFront membatasi fungsi tersebut. Daftar berikut menjelaskan kemungkinan fungsi terhambat berdasarkan nilai pemanfaatan komputasi. **Nilai pemanfaatan komputasi:** + **1 — 50** — Fungsinya nyaman di bawah waktu maksimum yang diizinkan dan harus berjalan tanpa pelambatan. + **51 — 70** — Fungsi mendekati waktu maksimum yang diizinkan. Pertimbangkan untuk mengoptimalkan kode fungsi. + **71 — 100** — Fungsi ini sangat dekat dengan atau melebihi waktu maksimum yang diizinkan. CloudFront kemungkinan akan membatasi fungsi ini jika Anda mengaitkannya dengan distribusi. # Perbarui fungsi Anda dapat memperbarui fungsi kapan saja. Perubahan dilakukan hanya pada versi fungsi yang ada di `DEVELOPMENT` panggung. Untuk menyalin pembaruan dari `DEVELOPMENT` panggung ke`LIVE`, Anda harus [mempublikasikan fungsinya](publish-function.md). Anda dapat memperbarui kode fungsi di CloudFront konsol atau dengan AWS Command Line Interface (AWS CLI). ------ #### [ Console ] **Untuk memperbarui kode fungsi** 1. Masuk ke CloudFront konsol di [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) dan pilih halaman **Fungsi**. Pilih fungsi yang akan diperbarui. 1. Pilih **Edit** dan buat perubahan berikut: + Perbarui bidang apa pun di bagian **Detail**. + Ubah atau hapus penyimpanan nilai kunci terkait. Untuk informasi selengkapnya tentang penyimpanan nilai utama, lihat[Amazon CloudFront KeyValueStore](kvs-with-functions.md). + Ubah kode fungsi. Pilih tab **Build**, buat perubahan, lalu pilih **Simpan perubahan** untuk menyimpan perubahan pada kode. ------ #### [ CLI ] **Untuk memperbarui kode fungsi** 1. Buka jendela baris perintah. 1. Jalankan perintah berikut. Contoh ini menggunakan `fileb://` notasi untuk meneruskan file. Ini juga termasuk jeda baris untuk membuat perintah lebih mudah dibaca. ``` 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 ``` **Catatan** Anda dapat mengidentifikasi fungsi dengan namanya dan ETag (dalam `if-match` parameter). Pastikan Anda menggunakan arus ETag. Anda bisa mendapatkan nilai ini dari operasi [DescribeFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeFunction.html)API. Anda harus menyertakan`function-code`, bahkan jika Anda tidak ingin mengubahnya. Hati-hati dengan`function-config`. Anda harus melewati semua yang ingin Anda simpan dalam konfigurasi. Secara khusus, tangani penyimpanan nilai kunci sebagai berikut: Untuk mempertahankan asosiasi penyimpanan nilai kunci yang ada (jika ada), tentukan nama toko yang *ada*. Untuk mengubah asosiasi, tentukan nama penyimpanan nilai kunci *baru*. Untuk menghapus asosiasi, hilangkan `KeyValueStoreAssociations` parameter. Ketika perintah berhasil, Anda melihat output seperti berikut ini. ``` 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 ``` ------ Sebagian besar informasi diulang dari permintaan. Informasi lain ditambahkan oleh CloudFront. **Catatan** `ETag`— Nilai ini berubah setiap kali Anda memodifikasi penyimpanan nilai kunci. `FunctionARN`— ARN untuk fungsi Anda CloudFront . `Stage`— Tahap untuk fungsi (`LIVE`atau`DEVELOPMENT`). `Status`— Status fungsi (`PUBLISHED`atau`UNPUBLISHED`). # Publikasikan fungsi Saat Anda mempublikasikan fungsi Anda, ini menyalin fungsi dari `DEVELOPMENT` panggung ke `LIVE` panggung. Jika perilaku cache tidak terkait dengan fungsi, mempublikasikannya memungkinkan Anda mengaitkannya dengan perilaku cache. Anda hanya dapat mengaitkan perilaku cache dengan fungsi yang ada di tahap `LIVE`. **penting** Sebelum Anda mempublikasikan, kami sarankan Anda [menguji fungsinya](test-function.md). Setelah Anda memublikasikan fungsi, semua perilaku cache yang terkait dengan fungsi tersebut secara otomatis mulai menggunakan salinan yang baru diterbitkan, segera setelah distribusi selesai digunakan. Anda dapat mempublikasikan fungsi di CloudFront konsol atau dengan AWS CLI. ------ #### [ Console ] **Untuk mempublikasikan fungsi** 1. Masuk ke CloudFront konsol di [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) dan pilih halaman **Fungsi**. 1. Pilih fungsi yang akan diperbarui. 1. Pilih tab **Publish** dan kemudian pilih **Publish**. Jika fungsi Anda sudah dilampirkan ke satu atau beberapa perilaku cache, pilih **Publikasikan dan perbarui**. 1. (Opsional) Untuk melihat distribusi yang terkait dengan fungsi, pilih ** CloudFront Distribusi terkait** untuk memperluas bagian itu. Ketika berhasil, spanduk muncul di bagian atas halaman yang mengatakan **berhasil *Function name* diterbitkan**. Anda juga dapat memilih tab **Bangun**, lalu pilih **Live** untuk melihat versi live kode fungsi. ------ #### [ CLI ] **Untuk mempublikasikan fungsi** 1. Buka jendela baris perintah. 1. Jalankan perintah **aws cloudfront publish-function** berikut. Dalam contoh, jeda baris disediakan untuk membuat contoh lebih mudah dibaca. ``` aws cloudfront publish-function \ --name MaxAge \ --if-match ETVXYZEXAMPLE ``` Ketika perintah berhasil, Anda melihat output seperti berikut ini. ``` 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 ``` ------ # Mengaitkan fungsi dengan distribusi Untuk menggunakan fungsi dengan distribusi, Anda mengaitkan fungsi dengan satu atau beberapa perilaku cache dalam distribusi. Anda dapat mengaitkan fungsi dengan beberapa perilaku cache di beberapa distribusi. Anda dapat mengaitkan fungsi dengan salah satu dari berikut ini: + Perilaku cache yang ada + Perilaku cache baru dalam distribusi yang ada + Perilaku cache baru dalam distribusi baru Ketika mengaitkan fungsi dengan perilaku cache, Anda harus memilih *Jenis peristiwa*. Jenis acara menentukan kapan CloudFront menjalankan fungsi. Anda dapat memilih jenis acara berikut: + **Permintaan penampil** - Fungsi berjalan saat CloudFront menerima permintaan dari penampil. + **Respons penampil** - Fungsi berjalan sebelum CloudFront mengembalikan respons ke penampil. Anda tidak dapat menggunakan tipe peristiwa yang menghadap *asal (permintaan asal dan *respons asal**) dengan CloudFront Functions. Sebagai gantinya, Anda dapat menggunakan Lambda @Edge. Untuk informasi selengkapnya, lihat [CloudFront peristiwa yang dapat memicu fungsi Lambda @Edge](lambda-cloudfront-trigger-events.md). **catatan** Sebelum mengaitkan fungsi, [Publikasikan](publish-function.md) ke tahap `LIVE`. Anda dapat mengaitkan fungsi dengan distribusi di CloudFront konsol atau dengan AWS Command Line Interface (AWS CLI). Prosedur berikut menunjukkan cara mengaitkan fungsi dengan perilaku cache yang ada. ------ #### [ Console ] **Untuk mengaitkan fungsi dengan perilaku cache yang ada** 1. Masuk ke CloudFront konsol di [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) dan pilih halaman **Fungsi**. 1. Pilih fungsi yang ingin Anda kaitkan. 1. Pada halaman **Fungsi**, pilih tab **Publikasikan**. 1. Pilih **fungsi Publikasikan**. 1. Pilih **Tambah asosiasi**. Pada kotak dialog yang muncul, pilih distribusi, jenis peristiwa, dan/atau perilaku cache. Untuk jenis acara, pilih kapan Anda ingin fungsi ini berjalan: + **Permintaan Penampil** - Jalankan fungsi setiap kali CloudFront menerima permintaan. + **Respons Penampil** - Jalankan fungsi setiap kali CloudFront mengembalikan respons. 1. Untuk menyimpan konfigurasi, pilih **Tambahkan asosiasi**. CloudFront mengaitkan distribusi dengan fungsi. Tunggu beberapa menit sampai distribusi terkait dapat menyelesaikan penyebaran. Anda dapat memilih **Lihat distribusi** pada halaman detail fungsi untuk memeriksa kemajuan. ------ #### [ CLI ] **Untuk mengaitkan fungsi dengan perilaku cache yang ada** 1. Buka jendela baris perintah. 1. Masukkan perintah berikut untuk menyimpan konfigurasi distribusi untuk distribusi yang perilaku cache-nya ingin Anda kaitkan dengan suatu fungsi. Perintah ini menyimpan konfigurasi distribusi ke file bernama `dist-config.yaml`. Untuk menggunakan perintah ini, lakukan hal berikut: + Ganti *`DistributionID`* dengan ID distribusi. + Jalankan perintah pada satu garis. Dalam contoh, jeda baris disediakan untuk membuat contoh lebih mudah dibaca. ``` aws cloudfront get-distribution-config \ --id DistributionID \ --output yaml > dist-config.yaml ``` Ketika perintah berhasil, AWS CLI mengembalikan tidak ada output. 1. Buka file bernama `dist-config.yaml` yang Anda buat. Edit file untuk membuat perubahan berikut. 1. Ubah nama `ETag` bidang menjadi`IfMatch`, tetapi jangan ubah nilai bidang. 1. Dalam perilaku cache, temukan objek bernama `FunctionAssociations`. Memperbarui objek ini untuk menambahkan asosiasi fungsi. Sintaks YAML untuk asosiasi fungsi terlihat seperti contoh berikut. + Contoh berikut menunjukkan jenis peristiwa permintaan penampil (pemicu). Untuk menggunakan jenis peristiwa respons penampil, ganti `viewer-request` dengan `viewer-response`. + Ganti *`arn:aws:cloudfront::111122223333:function/ExampleFunction`* dengan Amazon Resource Name (ARN) dari fungsi yang Anda kaitkan dengan perilaku cache ini. Untuk mendapatkan fungsi ARN, Anda dapat menggunakan perintah **aws cloudfront list-functions**. ``` FunctionAssociations: Items: - EventType: viewer-request FunctionARN: arn:aws:cloudfront::111122223333:function/ExampleFunction Quantity: 1 ``` 1. Setelah melakukan perubahan ini, simpan file. 1. Gunakan perintah berikut untuk memperbarui distribusi guna menambahkan asosiasi fungsi. Untuk menggunakan perintah ini, lakukan hal berikut: + Ganti *`DistributionID`* dengan ID distribusi. + Jalankan perintah pada satu garis. Dalam contoh, jeda baris disediakan untuk membuat contoh lebih mudah dibaca. ``` aws cloudfront update-distribution \ --id DistributionID \ --cli-input-yaml file://dist-config.yaml ``` Setelah perintah berhasil, Anda akan melihat output seperti berikut yang menjelaskan distribusi yang baru saja diperbarui dengan asosiasi fungsi. Contoh output berikut dipotong agar mudah dibaca. ``` 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 ``` ------ Distribusi `Status` berubah menjadi `InProgress` saat distribusi dipindahkan. Ketika konfigurasi distribusi baru mencapai lokasi CloudFront tepi, lokasi tepi itu mulai menggunakan fungsi terkait. Ketika distribusi sepenuhnya digunakan, `Status` perubahan kembali ke`Deployed`. Ini menunjukkan bahwa CloudFront fungsi terkait hidup di semua lokasi CloudFront tepi di seluruh dunia. Ini biasanya memerlukan waktu beberapa menit. # Amazon CloudFront KeyValueStore CloudFront KeyValueStore adalah datastore nilai kunci latensi rendah yang aman, global, yang memungkinkan akses baca dari dalam [CloudFront Fungsi](cloudfront-functions.md), memungkinkan logika lanjutan yang dapat disesuaikan di lokasi tepi. CloudFront Dengan CloudFront KeyValueStore, Anda membuat pembaruan untuk kode fungsi dan pembaruan data yang terkait dengan fungsi secara independen satu sama lain. Pemisahan ini menyederhanakan kode fungsi dan membuatnya mudah untuk memperbarui data tanpa perlu menyebarkan perubahan kode. **catatan** Untuk menggunakannya CloudFront KeyValueStore, CloudFront fungsi Anda harus menggunakan [JavaScript runtime 2.0](functions-javascript-runtime-20.md). Berikut ini adalah prosedur umum untuk menggunakan pasangan kunci-nilai: + Buat toko nilai kunci, dan isi dengan satu set pasangan kunci-nilai. Anda dapat menambahkan toko nilai kunci Anda ke bucket Amazon S3 atau memasukkannya secara manual. + Kaitkan penyimpanan nilai kunci dengan CloudFront fungsi Anda. + Dalam kode fungsi Anda, gunakan nama kunci untuk mengambil nilai yang terkait dengan kunci atau untuk mengevaluasi apakah ada kunci. Untuk informasi selengkapnya tentang penggunaan pasangan kunci-nilai dalam kode fungsi, dan tentang metode pembantu, lihat. [Metode pembantu untuk penyimpanan nilai kunci](functions-custom-methods.md) ## Kasus penggunaan Anda dapat menggunakan pasangan kunci-nilai untuk contoh berikut: + **Penulisan ulang atau pengalihan URL — Pasangan kunci-nilai dapat menahan penulisan** ulang atau pengalihan. URLs URLs + **Pengujian A/B dan bendera fitur** — Anda dapat membuat fungsi untuk menjalankan eksperimen dengan menetapkan persentase lalu lintas ke versi tertentu dari situs web Anda. + **Otorisasi akses** — Anda dapat menerapkan kontrol akses untuk mengizinkan atau menolak permintaan berdasarkan kriteria yang ditentukan oleh Anda dan data yang disimpan di penyimpanan nilai kunci. ## Format yang didukung untuk nilai Anda dapat menyimpan nilai dalam pasangan kunci-nilai dalam salah satu format berikut: + String + String yang dikodekan byte + JSON ## Keamanan CloudFront Fungsi dan semua data penyimpanan nilai utamanya ditangani dengan aman, sebagai berikut: + CloudFront mengenkripsi setiap penyimpanan nilai kunci saat istirahat dan selama transit (saat membaca atau menulis ke penyimpanan nilai kunci) saat Anda memanggil operasi [CloudFront KeyValueStore](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_Operations_Amazon_CloudFront_KeyValueStore.html)API. + Saat fungsi dijalankan, CloudFront dekripsi setiap pasangan kunci-nilai dalam memori di lokasi tepi. CloudFront Untuk memulai CloudFront KeyValueStore, lihat topik berikut. **Topics** + [Kasus penggunaan](#key-value-store-use-cases) + [Format yang didukung untuk nilai](#key-value-store-supported-formats) + [Keamanan](#key-value-store-security) + [Bekerja dengan toko nilai kunci](kvs-with-functions-kvs.md) + [Bekerja dengan data nilai kunci](kvs-with-functions-kvp.md) + Untuk informasi lebih lanjut tentang memulai CloudFront KeyValueStore, lihat posting CloudFront KeyValueStore AWS blog [Memperkenalkan Amazon](https://aws.amazon.com/blogs/aws/introducing-amazon-cloudfront-keyvaluestore-a-low-latency-datastore-for-cloudfront-functions/). # Bekerja dengan toko nilai kunci Anda harus membuat penyimpanan nilai kunci untuk menahan pasangan kunci-nilai yang ingin Anda gunakan di CloudFront Functions. Setelah Anda membuat penyimpanan nilai kunci dan menambahkan pasangan kunci-nilai, Anda dapat menggunakan nilai kunci dalam kode CloudFront fungsi Anda. Untuk memulai, lihat topik berikut: **Topics** + [Buat penyimpanan nilai kunci](kvs-with-functions-create.md) + [Kaitkan penyimpanan nilai kunci dengan fungsi](kvs-with-functions-associate.md) + [Perbarui penyimpanan nilai kunci](kvs-with-functions-edit.md) + [Dapatkan referensi ke penyimpanan nilai kunci](kvs-with-functions-get-reference.md) + [Hapus penyimpanan nilai kunci](kvs-with-functions-delete.md) + [Format file untuk pasangan nilai kunci](kvs-with-functions-create-s3-kvp.md) **catatan** JavaScript Runtime 2.0 menyertakan beberapa metode pembantu untuk bekerja dengan nilai-nilai kunci dalam kode fungsi. Untuk informasi selengkapnya, lihat [Metode pembantu untuk penyimpanan nilai kunci](functions-custom-methods.md). # Buat penyimpanan nilai kunci Anda dapat membuat penyimpanan nilai kunci dan pasangan nilai kunci-nya secara bersamaan. Anda juga dapat membuat penyimpanan nilai kunci kosong sekarang dan kemudian menambahkan pasangan kunci-nilai nanti. **catatan** Jika Anda menentukan sumber data dari bucket Amazon S3, Anda harus memiliki izin `s3:GetObject` dan `s3:GetBucketLocation` izin untuk bucket tersebut. Jika Anda tidak memiliki izin ini, tidak CloudFront dapat berhasil membuat penyimpanan nilai kunci Anda. Putuskan apakah Anda ingin menambahkan pasangan kunci-nilai pada saat yang sama ketika Anda membuat penyimpanan nilai kunci. Anda dapat mengimpor pasangan nilai kunci dengan menggunakan CloudFront konsol, CloudFront API, atau. AWS SDKs Namun, Anda hanya dapat mengimpor file pasangan nilai kunci saat Anda *awalnya* membuat penyimpanan nilai kunci. Untuk membuat file pasangan kunci-nilai, lihat. [Format file untuk pasangan nilai kunci](kvs-with-functions-create-s3-kvp.md) ------ #### [ Console ] **Untuk membuat penyimpanan nilai kunci** 1. Masuk ke Konsol Manajemen AWS dan buka halaman **Fungsi** di CloudFront konsol di[https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Pilih **KeyValueStores**tab, lalu pilih **Buat KeyValueStore**. 1. Masukkan nama dan deskripsi opsional untuk penyimpanan nilai kunci. 1. **URI S3** lengkap: + Jika Anda memiliki file pasangan nilai kunci, masukkan path ke bucket Amazon S3 tempat Anda menyimpan file. + Biarkan bidang ini kosong jika Anda berencana memasukkan pasangan kunci-nilai secara manual. 1. Pilih **Buat**. Penyimpanan nilai kunci sekarang ada. Halaman detail untuk penyimpanan nilai kunci baru muncul. Informasi pada halaman termasuk ID dan ARN dari penyimpanan nilai kunci. + ID adalah string acak karakter yang unik di Anda Akun AWS. + ARN memiliki sintaks ini: *Akun AWS*`:key-value-store/`*the key value stores ID* 1. Lihatlah bagian **Pasangan nilai kunci**. Jika Anda mengimpor file, bagian ini menunjukkan beberapa pasangan kunci-nilai. Anda dapat melakukan tindakan berikut: + Jika Anda mengimpor file, Anda juga dapat menambahkan lebih banyak nilai secara manual. + Jika Anda tidak mengimpor file dari bucket Amazon S3, dan jika Anda ingin menambahkan pasangan nilai kunci sekarang, Anda dapat menyelesaikan langkah berikutnya. + Anda dapat melewati langkah ini dan menambahkan pasangan kunci-nilai nanti. 1. Untuk menambahkan pasangan sekarang: 1. Pilih **Tambahkan pasangan kunci-nilai**. 1. Pilih **Tambah pasangan** dan masukkan nama dan nilai. Ulangi langkah ini untuk menambahkan lebih banyak pasangan. 1. Setelah selesai, pilih **Simpan perubahan** untuk menyimpan semua pasangan nilai kunci di penyimpanan nilai kunci. Pada kotak dialog yang muncul, pilih **Selesai**. 1. Untuk mengaitkan penyimpanan nilai kunci dengan fungsi sekarang, selesaikan bagian **Fungsi terkait**. Untuk informasi selengkapnya, lihat [Buat fungsi](create-function.md) atau [Perbarui fungsi](update-function.md). Anda juga dapat mengaitkan fungsi nanti, baik dari halaman detail penyimpanan nilai kunci ini, atau dari halaman detail fungsi. ------ #### [ AWS CLI ] **Untuk membuat penyimpanan nilai kunci** + Jalankan perintah berikut untuk membuat penyimpanan nilai kunci dan mengimpor pasangan nilai kunci dari bucket Amazon S3. ``` aws cloudfront create-key-value-store \ --name=keyvaluestore1 \ --comment="This is my key value store file" \ --import-source=SourceType=S3,SourceARN=arn:aws:s3:::amzn-s3-demo-bucket1/kvs-input.json ``` **Respons** ``` { "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 ] **Untuk membuat penyimpanan nilai kunci** 1. Gunakan [CloudFrontCreateKeyValueStore](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_CreateKeyValueStore.html)operasi. Operasi ini membutuhkan beberapa parameter: + A `name` dari penyimpan nilai kunci. + `comment`Parameter yang menyertakan komentar. + `import-source`Parameter yang memungkinkan Anda mengimpor pasangan nilai kunci dari file yang disimpan di bucket Amazon S3. Anda dapat mengimpor dari file hanya ketika Anda pertama kali membuat penyimpanan nilai kunci. Untuk informasi tentang struktur file, lihat[Format file untuk pasangan nilai kunci](kvs-with-functions-create-s3-kvp.md). Respons operasi mencakup informasi berikut: + Nilai yang diteruskan dalam permintaan, termasuk nama yang Anda tetapkan. + Data seperti waktu pembuatan. + Sebuah `ETag` (misalnya,`ETVABCEXAMPLE`), ARN yang menyertakan nama penyimpanan nilai kunci (misalnya,`arn:aws:cloudfront::123456789012:key-value-store/keyvaluestore1`). Anda akan menggunakan beberapa kombinasi dari`ETag`, ARN, dan nama untuk bekerja dengan penyimpanan nilai kunci secara terprogram. ------ ## Status penyimpanan nilai kunci Saat Anda membuat penyimpanan nilai kunci, penyimpanan data dapat memiliki nilai status berikut. **** | Nilai | Deskripsi | | --- | --- | | **Penyediaan** | Penyimpanan nilai kunci telah dibuat dan CloudFront sedang memproses sumber data yang Anda tentukan. | | **Siap** | Penyimpanan nilai kunci dibuat dan CloudFront berhasil memproses sumber data yang Anda tentukan. | | **Impor gagal** | CloudFront tidak dapat memproses sumber data yang Anda tentukan. Status ini dapat muncul jika format file Anda tidak valid atau melebihi batas ukuran. Untuk informasi selengkapnya, lihat [Format file untuk pasangan nilai kunci](kvs-with-functions-create-s3-kvp.md). | # Kaitkan penyimpanan nilai kunci dengan fungsi Setelah Anda membuat penyimpanan nilai kunci Anda, Anda dapat memperbarui fungsi Anda untuk mengaitkannya dengan penyimpanan nilai kunci Anda. Anda harus membuat asosiasi ini untuk menggunakan pasangan kunci-nilai dari toko itu dalam fungsi itu. Aturan-aturan berikut berlaku: + Sebuah fungsi hanya dapat memiliki satu penyimpanan nilai kunci + Anda dapat mengaitkan penyimpanan nilai kunci yang sama dengan beberapa fungsi ------ #### [ Console ] **Untuk mengaitkan penyimpanan nilai kunci dengan fungsi** 1. Masuk ke CloudFront konsol di [https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions) dan pilih halaman **Fungsi**. 1. Pilih nama fungsi. 1. Buka KeyValueStore bagian **Associate** dan pilih **Associate existing KeyValueStore**. 1. **Pilih penyimpanan nilai kunci yang berisi pasangan kunci-nilai dalam fungsi, lalu pilih Associate. KeyValueStore** CloudFront segera mengaitkan toko dengan fungsinya. Anda tidak perlu menyimpan fungsinya. 1. Untuk menentukan penyimpanan nilai kunci yang berbeda, pilih **Perbarui terkait KeyValueStore**, pilih nama penyimpanan nilai kunci lainnya, lalu pilih **Associate KeyValueStore**. Untuk informasi selengkapnya, lihat [Perbarui fungsi](update-function.md). ------ #### [ AWS CLI ] **Untuk mengaitkan penyimpanan nilai kunci dengan fungsi** + Jalankan perintah berikut untuk memperbarui `MaxAge` fungsi dan mengaitkan sumber daya penyimpanan nilai kunci. ``` 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 ``` + Untuk mengaitkan penyimpanan nilai kunci dengan fungsi, tentukan `KeyValueStoreAssociations` parameter dan nilai kunci menyimpan ARN. + Untuk mengubah asosiasi, tentukan ARN penyimpanan nilai kunci lainnya. + Untuk menghapus asosiasi, hapus `KeyValueStoreAssociations` parameter. Untuk informasi selengkapnya, lihat [Perbarui fungsi](update-function.md). ------ #### [ API ] **Untuk mengaitkan penyimpanan nilai kunci dengan fungsi** + Gunakan Operasi API [UpdateFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateFunction.html). Untuk informasi selengkapnya, lihat [Perbarui fungsi](update-function.md). ------ **Catatan** Jika Anda memodifikasi penyimpanan nilai kunci tanpa mengubah pasangan nilai kunci, atau jika Anda hanya memodifikasi pasangan nilai kunci di penyimpanan nilai kunci, Anda tidak perlu mengaitkan penyimpanan nilai kunci lagi. Anda juga tidak perlu mempublikasikan ulang fungsinya. Namun, kami menyarankan Anda menguji fungsi untuk memverifikasi bahwa itu berfungsi seperti yang diharapkan. Untuk informasi selengkapnya, lihat [Fungsi uji](test-function.md). Anda dapat melihat semua fungsi yang menggunakan penyimpanan nilai kunci tertentu. Di CloudFront konsol, pilih halaman detail penyimpanan nilai kunci. # Perbarui penyimpanan nilai kunci Saat memperbarui penyimpanan nilai kunci, Anda dapat mengubah pasangan nilai kunci, atau mengubah asosiasi antara penyimpanan nilai kunci dan fungsi. ------ #### [ Console ] **Untuk memperbarui penyimpanan nilai kunci** 1. Masuk ke Konsol Manajemen AWS dan buka halaman **Fungsi** di CloudFront konsol di[https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Pilih **KeyValueStores**tab. 1. Pilih penyimpanan nilai kunci yang ingin Anda perbarui. + Untuk memperbarui pasangan kunci-nilai, pilih **Edit** di bagian **Pasangan nilai kunci**. Anda dapat menambahkan atau menghapus pasangan kunci-nilai apa pun. Anda juga dapat mengubah nilai untuk pasangan kunci-nilai yang ada. Setelah Anda selesai, pilih **Simpan perubahan**. + Untuk memperbarui asosiasi untuk penyimpanan nilai kunci ini, pilih **Buka fungsi**. Untuk informasi selengkapnya, lihat [Kaitkan penyimpanan nilai kunci dengan fungsi](kvs-with-functions-associate.md). ------ #### [ AWS CLI ] **Untuk memperbarui penyimpanan nilai kunci** 1. **Mengubah pasangan kunci-nilai** — Anda dapat menambahkan lebih banyak pasangan kunci-nilai, menghapus satu atau beberapa pasangan kunci-nilai, dan mengubah nilai pasangan kunci-nilai yang ada. Untuk informasi selengkapnya, lihat [Bekerja dengan data nilai kunci](kvs-with-functions-kvp.md). 1. **Mengubah asosiasi fungsi untuk penyimpanan nilai kunci** — Untuk memperbarui fungsi asosiasi untuk penyimpanan nilai kunci, lihat[Kaitkan penyimpanan nilai kunci dengan fungsi](kvs-with-functions-associate.md). **Tip** Anda akan membutuhkan ARN dari toko nilai kunci. Untuk informasi selengkapnya, lihat [Dapatkan referensi ke penyimpanan nilai kunci](kvs-with-functions-get-reference.md). ------ #### [ API ] **Untuk memperbarui penyimpanan nilai kunci** 1. **Mengubah pasangan kunci-nilai** — Anda dapat menambahkan lebih banyak pasangan kunci-nilai, menghapus satu atau beberapa pasangan kunci-nilai, dan mengubah nilai pasangan kunci-nilai yang ada. Untuk informasi selengkapnya, lihat [Bekerja dengan data nilai kunci](kvs-with-functions-kvp.md). 1. **Mengubah asosiasi fungsi untuk penyimpanan nilai kunci** — Untuk memperbarui asosiasi fungsi untuk penyimpanan nilai kunci, gunakan operasi [UpdateFunction](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateFunction.html)API. Untuk informasi selengkapnya, lihat [Perbarui fungsi](update-function.md). **Tip** Anda akan membutuhkan ARN dari toko nilai kunci. Untuk informasi selengkapnya, lihat [Dapatkan referensi ke penyimpanan nilai kunci](kvs-with-functions-get-reference.md). ------ # Dapatkan referensi ke penyimpanan nilai kunci Untuk bekerja dengan toko nilai kunci secara terprogram, Anda memerlukan `ETag` dan nama penyimpanan nilai kunci. Untuk mendapatkan kedua nilai tersebut, Anda dapat menggunakan AWS Command Line Interface (AWS CLI) atau CloudFront API. ------ #### [ AWS CLI ] **Untuk mendapatkan referensi penyimpanan nilai kunci** 1. Untuk mengembalikan daftar penyimpanan nilai kunci, jalankan perintah berikut Temukan nama penyimpanan nilai kunci yang ingin Anda ubah. ``` aws cloudfront list-key-value-stores ``` 1. Dari respons, temukan nama penyimpanan nilai kunci yang Anda inginkan. **Respons** ``` { "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. Jalankan perintah berikut untuk mengembalikan `ETag` untuk penyimpanan nilai kunci yang ditentukan. ``` aws cloudfront describe-key-value-store \ --name=keyvaluestore1 ``` **Respons** ``` { "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 ] **Untuk mendapatkan referensi penyimpanan nilai kunci** 1. Gunakan operasi [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html)API untuk mengembalikan daftar penyimpanan nilai kunci. Temukan nama penyimpanan nilai kunci yang ingin Anda ubah. 1. Gunakan operasi [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DescribeKeyValueStore.html)API dan tentukan nama penyimpanan nilai kunci yang Anda kembalikan dari langkah sebelumnya. ------ Respons termasuk UUID, ARN dari penyimpanan nilai kunci, dan penyimpanan nilai kunci. `ETag` + An`ETag`, seperti `E3UN6WX5RRO2AG` + UUID adalah 128 bit, seperti `8aa76c93-3198-462c-aaf6-example` + ARN mencakup Akun AWS angka, konstanta`key-value-store`, dan UUID, seperti contoh berikut: `arn:aws:cloudfront::123456789012:key-value-store/8aa76c93-3198-462c-aaf6-example` Untuk informasi lebih lanjut tentang `DescribeKeyValueStore` operasi, lihat[Tentang CloudFront KeyValueStore](kvs-with-functions-kvp.md#kvs-with-functions-api-describe). # Hapus penyimpanan nilai kunci Anda dapat menghapus penyimpanan nilai kunci Anda dengan menggunakan CloudFront konsol Amazon atau API. ------ #### [ Console ] **Untuk menghapus penyimpanan nilai kunci** 1. Masuk ke Konsol Manajemen AWS dan buka halaman **Fungsi** di CloudFront konsol di[https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Pilih nama fungsi. 1. Di bawah KeyValueStore bagian **Terkait**, verifikasi apakah penyimpanan nilai kunci dikaitkan dengan fungsi tersebut. Jika ya, hapus asosiasi dengan memilih **Disassociate KeyValueStore** dan kemudian pilih **Hapus asosiasi**. 1. Di panel navigasi, pilih halaman **Fungsi** dan kemudian pilih **KeyValueStores**tab. 1. Pilih penyimpanan nilai kunci yang ingin Anda hapus dan kemudian pilih **Hapus**. ------ #### [ AWS CLI ] **Untuk menghapus penyimpanan nilai kunci** 1. Dapatkan `ETag` dan nama toko nilai kunci. Untuk informasi selengkapnya, lihat [Dapatkan referensi ke penyimpanan nilai kunci](kvs-with-functions-get-reference.md). 1. Verifikasi apakah penyimpanan nilai kunci dikaitkan dengan fungsi. Jika ya, hapus asosiasi. Untuk informasi lebih lanjut tentang kedua langkah ini, lihat[Perbarui fungsi](update-function.md). 1. Setelah Anda memiliki nama dan `ETag` penyimpanan nilai kunci dan tidak lagi terkait dengan fungsi, Anda dapat menghapusnya. Jalankan perintah berikut untuk menghapus penyimpanan nilai kunci yang ditentukan. ``` aws cloudfront delete-key-value-store \ --name=keyvaluestore1 \ --if-match=E3UN6WX5RRO2AG ``` ------ #### [ API ] **Untuk menghapus penyimpanan nilai kunci** 1. Dapatkan `ETag` dan nama toko nilai kunci. Untuk informasi selengkapnya, lihat [Dapatkan referensi ke penyimpanan nilai kunci](kvs-with-functions-get-reference.md). 1. Verifikasi apakah penyimpanan nilai kunci dikaitkan dengan fungsi. Jika ya, hapus asosiasi. Untuk informasi lebih lanjut tentang kedua langkah ini, lihat[Perbarui fungsi](update-function.md). 1. Untuk menghapus penyimpanan nilai kunci, gunakan operasi CloudFront [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DeleteKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_DeleteKeyValueStore.html)API. ------ # Format file untuk pasangan nilai kunci Saat Anda membuat file yang dikodekan UTF-8, gunakan format JSON berikut: ``` { "data":[ { "key":"key1", "value":"value" }, { "key":"key2", "value":"value" } ] } ``` File Anda tidak dapat menyertakan kunci duplikat. Jika Anda menentukan file yang tidak valid di bucket Amazon S3, Anda dapat memperbarui file tersebut untuk menghapus duplikat apa pun dan kemudian mencoba membuat penyimpanan nilai kunci Anda lagi. Untuk informasi selengkapnya, lihat [Buat penyimpanan nilai kunci](kvs-with-functions-create.md). **catatan** File untuk sumber data Anda dan pasangan nilai kunci-nya memiliki batasan berikut: Ukuran file — 5 MB Ukuran kunci - 512 karakter Ukuran nilai - 1024 karakter # Bekerja dengan data nilai kunci Topik ini menjelaskan cara menambahkan pasangan kunci-nilai ke penyimpanan nilai kunci yang ada. Untuk menyertakan pasangan kunci-nilai saat Anda awalnya membuat penyimpanan nilai kunci, lihat. [Buat penyimpanan nilai kunci](kvs-with-functions-create.md) **Topics** + [Bekerja dengan pasangan nilai kunci (konsol)](#kvs-with-functions-kvp-using-console) + [Tentang CloudFront KeyValueStore](#kvs-with-functions-api-describe) + [Bekerja dengan pasangan nilai kunci ()AWS CLI](#work-with-kvs-cli-keys) + [Bekerja dengan pasangan nilai kunci (API)](#kvs-with-functions-kvp-using-api) ## Bekerja dengan pasangan nilai kunci (konsol) Anda dapat menggunakan CloudFront konsol untuk bekerja dengan pasangan nilai kunci Anda. **Untuk bekerja dengan pasangan kunci-nilai** 1. Masuk ke Konsol Manajemen AWS dan buka halaman **Fungsi** di CloudFront konsol di[https://console.aws.amazon.com/cloudfront/v4/home#/functions](https://console.aws.amazon.com/cloudfront/v4/home#/functions). 1. Pilih **KeyValueStores**tab. 1. Pilih penyimpanan nilai kunci yang ingin Anda ubah. 1. Di bagian **Pasangan nilai kunci**, pilih **Edit**. 1. Anda dapat menambahkan pasangan kunci-nilai, menghapus pasangan kunci-nilai, atau mengubah nilai untuk pasangan kunci-nilai yang ada. 1. Setelah Anda selesai, pilih **Simpan perubahan**. ## Tentang CloudFront KeyValueStore **Tip** CloudFront KeyValueStore API adalah layanan global yang menggunakan Signature Version 4A (Sigv4a) untuk otentikasi. Menggunakan kredensi sementara dengan Sigv4a memerlukan token sesi versi 2. Untuk informasi selengkapnya, lihat [Menggunakan kredensil sementara dengan API CloudFront KeyValueStore](cloudfront-function-restrictions.md#regional-endpoint-for-key-value-store). Jika Anda menggunakan AWS Command Line Interface (AWS CLI) atau kode Anda sendiri untuk memanggil CloudFront KeyValueStore API, lihat bagian berikut. Saat Anda bekerja dengan penyimpan nilai kunci dan pasangan nilai kunci-nya, layanan yang Anda panggil bergantung pada kasus penggunaan Anda: + Untuk bekerja dengan pasangan nilai kunci di penyimpanan nilai kunci yang *ada*, gunakan layanan. CloudFront KeyValueStore + Untuk menyertakan pasangan nilai kunci di penyimpanan nilai kunci saat Anda *pertama kali* membuat penyimpanan nilai kunci, gunakan layanan. CloudFront Baik CloudFront API dan CloudFront KeyValueStore API memiliki `DescribeKeyValueStore` operasi. Anda memanggil mereka untuk alasan yang berbeda. Untuk memahami perbedaannya, lihat tabel berikut. | | API CloudFront DescribeKeyValueStore | API CloudFront KeyValueStore DescribeKeyValueStore | | --- | --- | --- | | Data tentang penyimpanan nilai kunci | Mengembalikan data, seperti status dan tanggal penyimpanan nilai kunci itu sendiri terakhir diubah. | Mengembalikan data tentang *isi* sumber daya penyimpanan — pasangan kunci-nilai di toko, dan ukuran konten. | | Data yang mengidentifikasi penyimpanan nilai kunci | Mengembalikan`ETag`, UUID, dan ARN dari penyimpanan nilai kunci. | Mengembalikan `ETag` dan ARN dari penyimpanan nilai kunci. | **Catatan** Setiap DescribeKeyValueStore operasi mengembalikan yang *berbeda*`ETag`. Itu `ETags` tidak bisa dipertukarkan. Saat Anda memanggil operasi API untuk menyelesaikan suatu tindakan, Anda harus menentukan `ETag` dari API yang sesuai. Misalnya, dalam CloudFront KeyValueStore [ DeleteKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DeleteKey.html)operasi, Anda menentukan `ETag` yang Anda kembalikan dari CloudFront KeyValueStore [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html)operasi. Saat Anda memanggil CloudFront Fungsi dengan menggunakan CloudFront KeyValueStore, nilai di penyimpanan nilai kunci tidak diperbarui atau diubah selama pemanggilan fungsi. Pembaruan diproses di antara pemanggilan fungsi. ## Bekerja dengan pasangan nilai kunci ()AWS CLI Anda dapat menjalankan AWS Command Line Interface perintah berikut untuk CloudFront KeyValueStore. **Contents** + [Daftar pasangan kunci-nilai](#kvs-cli-list-keys) + [Dapatkan pasangan kunci-nilai](#kvs-cli-get-keys) + [Jelaskan penyimpanan nilai kunci](#kvs-cli-describe-keys) + [Buat pasangan kunci-nilai](#kvs-cli-create-keys) + [Hapus pasangan kunci-nilai](#kvs-cli-delete-keys) + [Perbarui pasangan nilai kunci](#kvs-cli-update-key) ### Daftar pasangan kunci-nilai Untuk membuat daftar pasangan kunci-nilai di penyimpanan nilai kunci Anda, jalankan perintah berikut. ``` aws cloudfront-keyvaluestore list-keys \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Respons** ``` { "Items": [ { "Key": "key1", "Value": "value1" } ] } ``` ### Dapatkan pasangan kunci-nilai Untuk mendapatkan pasangan kunci-nilai di penyimpanan nilai kunci Anda, jalankan perintah berikut. ``` aws cloudfront-keyvaluestore get-key \ --key=key1 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Respons** ``` { "Key": "key1", "Value": "value1", "ItemCount": 1, "TotalSizeInBytes": 11 } ``` ### Jelaskan penyimpanan nilai kunci Untuk mendeskripsikan penyimpanan nilai kunci, jalankan perintah berikut. ``` aws cloudfront-keyvaluestore describe-key-value-store \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Respons** ``` { "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" } ``` ### Buat pasangan kunci-nilai Untuk membuat pasangan kunci-nilai di penyimpanan nilai kunci Anda, jalankan perintah berikut. ``` 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 ``` **Respons** ``` { "ETag": "KV13V1IB3VIYZZH", "ItemCount": 3, "TotalSizeInBytes": 31 } ``` ### Hapus pasangan kunci-nilai Untuk menghapus pasangan kunci-nilai, jalankan perintah berikut. ``` aws cloudfront-keyvaluestore delete-key \ --if-match=KV13V1IB3VIYZZH \ --key=key1 \ --kvs-arn=arn:aws:cloudfront::123456789012:key-value-store/37435e19-c205-4271-9e5c-example ``` **Keluaran** ``` { "ETag": "KV1VC38T7YXB528", "ItemCount": 2, "TotalSizeInBytes": 22 } ``` ### Perbarui pasangan nilai kunci Anda dapat menggunakan `update-keys` perintah untuk memperbarui lebih dari satu pasangan kunci-nilai. Misalnya, untuk menghapus pasangan kunci-nilai yang ada dan membuat yang lain, jalankan perintah berikut. ``` 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"}]' ``` **Respons** ``` { "ETag": "KV3AEGXETSR30VB", "ItemCount": 3, "TotalSizeInBytes": 28 } ``` ## Bekerja dengan pasangan nilai kunci (API) Ikuti bagian ini untuk bekerja dengan pasangan nilai kunci Anda secara terprogram. **Contents** + [Dapatkan referensi ke penyimpanan nilai kunci](#kvs-with-functions-api-ref) + [Ubah pasangan kunci-nilai di penyimpanan nilai kunci](#kvs-with-functions-api-actions) + [Contoh kode untuk CloudFront KeyValueStore](#example-code-key-value-store) ### Dapatkan referensi ke penyimpanan nilai kunci Saat Anda menggunakan CloudFront KeyValueStore API untuk memanggil operasi tulis, Anda perlu menentukan ARN dan penyimpanan `ETag` nilai kunci. Untuk mendapatkan data ini, lakukan hal berikut: **Untuk mendapatkan referensi ke penyimpanan nilai kunci** 1. Gunakan operasi [https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ListKeyValueStores.html)API untuk mendapatkan daftar penyimpanan nilai kunci. Temukan penyimpanan nilai kunci yang ingin Anda ubah. 1. Gunakan [operasi CloudFrontKeyValueStore DescribeKeyValueStore API](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DescribeKeyValueStore.html) dan tentukan penyimpanan nilai kunci dari langkah sebelumnya. Respons termasuk ARN dan penyimpanan `ETag` nilai kunci. + ARN mencakup Akun AWS angka, konstanta`key-value-store`, dan UUID, seperti contoh berikut: `arn:aws:cloudfront::123456789012:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111` + An `ETag` yang terlihat seperti contoh berikut: `ETVABCEXAMPLE2` ### Ubah pasangan kunci-nilai di penyimpanan nilai kunci Anda dapat menentukan penyimpanan nilai kunci yang berisi pasangan kunci-nilai yang ingin Anda perbarui. Lihat operasi CloudFront KeyValueStore API berikut: + [CloudFrontKeyValueStore DeleteKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_DeleteKey.html)— Menghapus pasangan kunci-nilai + [CloudFrontKeyValueStore GetKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_GetKey.html)— Mengembalikan pasangan kunci-nilai + [CloudFrontKeyValueStore ListKeys](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_ListKeys.html)— Mengembalikan daftar pasangan kunci-nilai + [CloudFrontKeyValueStore PutKey](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_PutKey.html)— Anda dapat melakukan tugas-tugas berikut: + Buat pasangan kunci-nilai dalam satu penyimpanan nilai kunci dengan menentukan nama dan nilai kunci baru. + Tetapkan nilai yang berbeda dalam pasangan kunci-nilai yang ada dengan menentukan nama kunci yang ada, dan nilai kunci baru. + [CloudFrontKeyValueStore UpdateKeys](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_kvs_UpdateKeys.html)— Anda dapat melakukan satu atau lebih tindakan berikut dalam satu all-or-nothing operasi: + Hapus satu atau lebih pasangan nilai kunci + Buat satu atau lebih pasangan kunci-nilai baru + Tetapkan nilai yang berbeda dalam satu atau lebih pasangan kunci-nilai yang ada ### Contoh kode untuk CloudFront KeyValueStore **Example** Kode berikut menunjukkan cara memanggil operasi `DescribeKeyValueStore` API untuk penyimpanan nilai kunci. ``` 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); } })(); ``` # Sesuaikan dengan Fungsi CloudFront Koneksi CloudFront Fungsi Koneksi memungkinkan Anda menulis JavaScript fungsi ringan untuk validasi sertifikat mTLS dan logika otentikasi khusus. Fungsi Koneksi Anda berjalan selama pembuatan koneksi mTLS untuk memvalidasi sertifikat klien, menerapkan aturan otentikasi khusus perangkat, dan menangani skenario pencabutan sertifikat. Lingkungan runtime Connection Functions menawarkan waktu startup submilidetik, skala segera untuk menangani jutaan koneksi per detik, dan sangat aman. Fungsi Koneksi adalah fitur asli CloudFront, yang berarti Anda dapat membangun, menguji, dan menyebarkan kode Anda sepenuhnya di dalamnya CloudFront. Saat Anda mengaitkan Fungsi Koneksi dengan CloudFront distribusi berkemampuan MTLS, CloudFront mencegat permintaan koneksi TLS di lokasi CloudFront tepi dan meneruskan informasi sertifikat ke fungsi Anda. Anda dapat memanggil Fungsi Koneksi ketika peristiwa berikut terjadi: + Selama pembentukan koneksi TLS (permintaan koneksi) - untuk koneksi TLS (mTLS) bersama Untuk informasi selengkapnya tentang Fungsi Koneksi, lihat topik berikut. **Topics** + [Ikhtisar dan alur kerja](connection-functions-overview.md) + [Konfigurasi dan batasan](connection-function-configuration-limits.md) + [Buat Fungsi CloudFront Koneksi untuk validasi TLS (penampil) bersama](create-connection-functions.md) + [Tulis kode Fungsi CloudFront Koneksi untuk validasi TLS (penampil) timbal balik](write-connection-function-code.md) + [Uji Fungsi CloudFront Koneksi sebelum penerapan](test-connection-functions.md) + [Mengaitkan Fungsi Koneksi dengan distribusi](associate-connection-functions.md) + [Menerapkan pencabutan sertifikat untuk TLS bersama (penampil) dengan Fungsi dan CloudFront KeyValueStore](implement-certificate-revocation.md) # Ikhtisar dan alur kerja CloudFront Fungsi Koneksi adalah jenis CloudFront Fungsi khusus yang berjalan selama jabat tangan TLS ketika klien mencoba membuat koneksi mTLS. Fungsi Koneksi Anda dapat mengakses informasi sertifikat klien, parameter konfigurasi mTLS, hasil pemeriksaan pencabutan sertifikat, dan alamat IP klien. Fungsi koneksi dipanggil setelah CloudFront melakukan validasi sertifikat standar (rantai kepercayaan, kedaluwarsa, verifikasi tanda tangan) tetapi dapat berjalan bahkan jika pemeriksaan pencabutan sertifikat gagal. Ini memungkinkan Anda menerapkan logika khusus untuk menangani sertifikat yang dicabut atau menambahkan kriteria validasi tambahan. Setelah Anda membuat dan memublikasikan Fungsi Koneksi, pastikan untuk menambahkan asosiasi untuk jenis peristiwa permintaan koneksi dengan distribusi berkemampuan MTLS. Hal ini membuat fungsi berjalan setiap kali klien mencoba untuk membuat koneksi mTLS dengan CloudFront. CloudFront Fungsi Koneksi mengikuti siklus hidup dua tahap yang memungkinkan Anda mengembangkan dan menguji fungsi sebelum menerapkannya ke produksi. Alur kerja ini memastikan bahwa Fungsi Koneksi Anda berfungsi dengan benar sebelum memengaruhi lalu lintas langsung. **Topics** + [Tahapan fungsi](#connection-function-stages) + [Alur kerja pengembangan](#connection-function-development-workflow) + [Perbedaan dari jenis fungsi lainnya](#connection-function-differences) ## Tahapan fungsi Fungsi koneksi ada dalam salah satu dari dua tahap: + **PENGEMBANGAN** — Fungsi dalam tahap ini dapat dimodifikasi, diuji, dan diperbarui. Gunakan tahap ini untuk menulis dan men-debug kode fungsi Anda. + **LIVE** — Fungsi pada tahap ini hanya baca dan menangani lalu lintas produksi. Anda tidak dapat memodifikasi fungsi di tahap LIVE secara langsung. Saat Anda membuat Fungsi Koneksi baru, itu dimulai pada tahap **PENGEMBANGAN**. Setelah pengujian dan validasi, Anda mempublikasikan fungsi untuk memindahkannya ke tahap **LIVE**. ## Alur kerja pengembangan Ikuti alur kerja ini untuk mengembangkan dan menerapkan Fungsi Koneksi: 1. **Buat** - Buat Fungsi Koneksi baru di tahap PENGEMBANGAN dengan kode dan konfigurasi awal Anda. 1. **Uji** — Gunakan fungsionalitas pengujian untuk memvalidasi fungsi Anda dengan contoh peristiwa koneksi sebelum penerapan. 1. **Pembaruan** - Ubah kode fungsi dan konfigurasi sesuai kebutuhan berdasarkan hasil pengujian. 1. **Publikasikan** — Ketika siap untuk produksi, publikasikan fungsi untuk memindahkannya dari pengembangan ke tahap LIVE. 1. **Associate** — Kaitkan fungsi yang dipublikasikan dengan distribusi berkemampuan MTLS Anda untuk menangani koneksi langsung. Untuk membuat perubahan pada fungsi LIVE, Anda harus memperbarui versi PENGEMBANGAN dan mempublikasikannya lagi. Ini menciptakan versi baru di panggung LIVE. ## Perbedaan dari jenis fungsi lainnya Fungsi koneksi berbeda dari permintaan penampil dan fungsi respons penampil dalam beberapa cara penting: + Fungsi koneksi berjalan setelah jabat tangan mTLS, sebelum pemrosesan HTTP terjadi + Fungsi koneksi memiliki akses ke informasi sertifikat TLS alih-alih data HTTP request/response + Fungsi koneksi hanya dapat mengizinkan atau menolak koneksi, bukan memodifikasi data HTTP + Fungsi koneksi hanya dipanggil untuk koneksi TLS baru, bukan untuk penggunaan kembali koneksi + Dimulainya kembali sesi TLS tidak didukung dengan mTL untuk memastikan validasi sertifikat terjadi pada setiap koneksi + Fungsi koneksi berjalan selain permintaan penampil standar dan fungsi respons penampil + Anda mengaitkan Fungsi Koneksi pada tingkat distribusi, bukan pada tingkat perilaku cache. + Fungsi koneksi hanya mendukung JavaScript runtime 2.0. # Konfigurasi dan batasan CloudFront Fungsi Koneksi memiliki persyaratan konfigurasi khusus dan batas layanan karena peran khusus mereka dalam validasi koneksi TLS dan persyaratan kinerja komputasi tepi. **Topics** + [Persyaratan kode fungsi](#connection-function-code-requirements) + [Batas layanan](#connection-function-service-limits) + [Opsi penyaringan fungsi](#connection-function-filtering-options) ## Persyaratan kode fungsi Fungsi koneksi memerlukan JavaScript kode yang memproses peristiwa koneksi TLS. Kode fungsi harus: + Ditulis di JavaScript + Memproses peristiwa koneksi dan membuat allow/deny keputusan + Menyelesaikan eksekusi dalam batas waktu + Menangani sertifikat dan logika validasi koneksi ## Batas layanan Fungsi koneksi tunduk pada batasan berikut: + **Ukuran fungsi** - Kode fungsi dan konfigurasi terbatas ukurannya + **Waktu eksekusi** - Fungsi memiliki batas waktu eksekusi yang ketat untuk pemrosesan koneksi TLS + **Batas asosiasi** - Setiap distribusi hanya dapat memiliki satu Fungsi Koneksi yang terkait + **Pembatasan tahap** - Hanya fungsi panggung LIVE yang dapat dikaitkan dengan distribusi ## Opsi penyaringan fungsi Saat mencantumkan Fungsi Koneksi, Anda dapat menggunakan filter berikut: + **Filter panggung** - Filter berdasarkan PENGEMBANGAN atau tahap LANGSUNG + **Filter asosiasi** — Filter berdasarkan ID distribusi atau asosiasi ID penyimpanan nilai kunci Filter ini membantu Anda mengatur dan mengelola Fungsi Koneksi di berbagai lingkungan dan kasus penggunaan. # Buat Fungsi CloudFront Koneksi untuk validasi TLS (penampil) bersama Anda membuat Fungsi CloudFront Koneksi dalam dua tahap: 1. Buat kode fungsi sebagai JavaScript. Anda dapat menggunakan contoh default dari CloudFront konsol atau menulis sendiri. Untuk informasi selengkapnya, lihat topik berikut: + Tulis kode Fungsi CloudFront Koneksi untuk validasi mTLS + CloudFront Fungsi Koneksi struktur acara dan format respons + Contoh kode fungsi koneksi 1. Gunakan CloudFront untuk membuat Fungsi Koneksi dan sertakan kode Anda. Kode ada di dalam fungsi (bukan sebagai referensi). **Topics** + [CloudFront konsol](#create-connection-function-console) + [AWS CLI](#create-connection-function-cli) ## CloudFront konsol **Untuk membuat Fungsi Koneksi** 1. Masuk ke Konsol Manajemen AWS dan buka CloudFront konsol di[https://console.aws.amazon.com/cloudfront/v4/home](https://console.aws.amazon.com/cloudfront/v4/home). 1. Pilih **Buat fungsi**. 1. Masukkan nama fungsi yang unik di dalam Akun AWS, pilih **fungsi Koneksi** sebagai jenis fungsi, lalu pilih **Lanjutkan**. 1. Halaman detail untuk Fungsi Koneksi baru muncul. **catatan** Fungsi koneksi hanya mendukung JavaScript runtime 2.0. Untuk menggunakan KeyValueStore integrasi Fungsi CloudFront Koneksi dalam fungsi, Anda harus menggunakan versi runtime ini. 1. Di bagian **Kode fungsi**, pilih tab **Build** dan masukkan kode fungsi koneksi Anda. Kode contoh yang disertakan dalam tab Build menggambarkan sintaks dasar untuk kode Fungsi Koneksi. 1. Pilih **Simpan perubahan**. 1. Jika kode Fungsi Sambungan digunakan KeyValueStore untuk pemeriksaan pencabutan sertifikat atau validasi perangkat, Anda harus mengaitkan a. KeyValueStore Anda dapat mengaitkan KeyValueStore ketika Anda pertama kali membuat fungsi. Atau, Anda dapat mengaitkannya nanti, dengan mengaitkan Fungsi Koneksi. Untuk mengaitkan KeyValueStore sekarang, ikuti langkah-langkah ini: + Buka KeyValueStore bagian **Associate** dan pilih **Associate existing KeyValueStore**. + Pilih KeyValueStore yang berisi data sertifikat untuk Fungsi Koneksi Anda, lalu pilih **Associate KeyValueStore**. CloudFront segera mengaitkan toko dengan fungsinya. Anda tidak perlu menyimpan fungsinya. ## AWS CLI Jika Anda menggunakan AWS CLI, Anda biasanya pertama membuat kode Fungsi Koneksi dalam sebuah file, dan kemudian membuat fungsi dengan AWS CLI. **Untuk membuat Fungsi Koneksi** 1. Buat kode Fungsi Koneksi dalam sebuah file, dan simpan di direktori yang dapat disambungkan oleh komputer Anda. 1. Jalankan perintah seperti yang ditunjukkan pada contoh. Contoh ini menggunakan `fileb://` notasi untuk meneruskan file. Ini juga termasuk jeda baris untuk membuat perintah lebih mudah dibaca. ``` aws cloudfront create-connection-function \ --name CertificateValidator \ --connection-function-config '{ "Comment":"Device certificate validation", "Runtime":"cloudfront-js-2.0", "KeyValueStoreAssociations":{ "Quantity":1, "Items":[{ "KeyValueStoreARN":"arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111" }] } }' \ --connection-function-code fileb://certificate-validator.js ``` **catatan** **Runtime** - Fungsi koneksi hanya mendukung JavaScript runtime 2.0 (cloudfront-js-2.0). **KeyValueStoreAssociations**— Jika Fungsi Koneksi Anda digunakan KeyValueStore untuk validasi sertifikat, Anda dapat mengaitkan KeyValueStore saat pertama kali membuat fungsi. Atau, Anda dapat mengaitkannya nanti, dengan menggunakan update-connection-function. Kuantitas selalu 1 karena setiap Fungsi Koneksi hanya dapat memiliki satu KeyValueStore yang terkait dengannya. 1. Ketika perintah berhasil, Anda melihat output seperti berikut ini. ``` ETag: ETVABCEXAMPLE ConnectionFunctionSummary: ConnectionFunctionConfig: Comment: Device certificate validation Runtime: cloudfront-js-2.0 KeyValueStoreAssociations: Quantity: 1 Items: - KeyValueStoreARN: arn:aws:cloudfront::111122223333:key-value-store/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111 ConnectionFunctionMetadata: CreatedTime: '2024-09-04T16:32:54.292000+00:00' ConnectionFunctionARN: arn:aws:cloudfront::111122223333:connection-function/CertificateValidator LastModifiedTime: '2024-09-04T16:32:54.292000+00:00' Stage: DEVELOPMENT Name: CertificateValidator Status: UNPUBLISHED Location: https://cloudfront.amazonaws.com/2020-05-31/connection-function/arn:aws:cloudfront:::connection-function/CertificateValidator ``` Sebagian besar informasi diulang dari permintaan. Informasi lain ditambahkan oleh CloudFront. **catatan** **ETag**— Nilai ini berubah setiap kali Anda memodifikasi Fungsi Koneksi. Anda memerlukan nilai ini untuk memperbarui atau mempublikasikan fungsi. **Tahap** - Fungsi koneksi baru dimulai pada tahap PENGEMBANGAN. Anda harus mempublikasikan fungsi untuk memindahkannya ke tahap LIVE sebelum mengaitkannya dengan distribusi. **Status - Status** fungsi TIDAK DIPUBLIKASIKAN sampai Anda mempublikasikannya ke panggung LIVE. # Tulis kode Fungsi CloudFront Koneksi untuk validasi TLS (penampil) timbal balik CloudFront Fungsi Koneksi memungkinkan Anda untuk menulis JavaScript fungsi ringan untuk validasi sertifikat mTLS dan logika otentikasi kustom. Kode Fungsi Koneksi Anda dapat memvalidasi sertifikat klien, menerapkan aturan otentikasi khusus perangkat, menangani skenario pencabutan sertifikat, dan membuat allow/deny keputusan untuk koneksi TLS di lokasi tepi di seluruh dunia. CloudFront Fungsi koneksi menyediakan cara yang ampuh untuk memperluas CloudFront validasi sertifikat bawaan dengan logika bisnis Anda sendiri. Tidak seperti permintaan penampil dan fungsi respons penampil yang memproses data HTTP, Fungsi Koneksi beroperasi pada lapisan TLS dan memiliki akses ke informasi sertifikat, alamat IP klien, dan detail koneksi TLS. Ini membuatnya ideal untuk menerapkan model keamanan tanpa kepercayaan, sistem otentikasi perangkat, dan kebijakan validasi sertifikat khusus yang melampaui validasi PKI standar. Kode Fungsi Koneksi Anda berjalan di lingkungan yang aman dan terisolasi dengan waktu startup submilidetik dan dapat menskalakan untuk menangani jutaan koneksi per detik. Runtime dioptimalkan untuk beban kerja validasi sertifikat dan menyediakan integrasi bawaan CloudFront KeyValueStore untuk operasi pencarian data real-time, memungkinkan skenario otentikasi canggih seperti pemeriksaan daftar pencabutan sertifikat dan validasi daftar izin perangkat. Untuk membantu Anda menulis kode Fungsi Koneksi yang efektif, lihat topik berikut. Untuk contoh kode lengkap dan step-by-step tutorial, lihat bagian tutorial dalam panduan ini dan jelajahi contoh Fungsi Koneksi yang tersedia di CloudFront konsol. **Topics** + [CloudFront Fungsi Koneksi menggunakan kasus dan tujuan](#connection-function-use-cases) + [CloudFront Fungsi Koneksi struktur acara dan format respons](#connection-function-event-structure) + [CloudFront Fitur JavaScript runtime Fungsi Koneksi](#connection-function-javascript-runtime) + [CloudFront Metode pembantu Fungsi Koneksi dan APIs](#connection-function-helper-methods) + [CloudFront KeyValueStore Integrasi Fungsi Koneksi](#connection-function-kvs-integration) + [Gunakan async dan await](#connection-function-async-await) + [Contoh kode fungsi koneksi](#connection-function-code-examples) ## CloudFront Fungsi Koneksi menggunakan kasus dan tujuan Sebelum menulis Fungsi CloudFront Koneksi Anda, tentukan dengan cermat jenis validasi sertifikat atau logika otentikasi yang perlu Anda terapkan. Fungsi koneksi dirancang untuk kasus penggunaan tertentu yang memerlukan validasi khusus di luar pemeriksaan sertifikat PKI standar. Memahami kasus penggunaan membantu Anda merancang kode efisien yang memenuhi persyaratan keamanan Anda sambil mempertahankan kinerja optimal. Kasus penggunaan Fungsi Koneksi Umum meliputi: + **Penanganan pencabutan sertifikat** — Menerapkan kebijakan khusus untuk menangani sertifikat yang dicabut, termasuk masa tenggang untuk rotasi sertifikat, pengecualian jaringan tepercaya untuk perangkat internal, atau skenario akses darurat di mana sertifikat yang dicabut mungkin memerlukan akses sementara. + **Dukungan mTLS opsional — Menangani** koneksi mTL dan non-MTL dengan kebijakan otentikasi yang berbeda, memungkinkan Anda memberikan keamanan yang ditingkatkan untuk klien yang mendukung sertifikat sambil mempertahankan kompatibilitas dengan klien lama. + **Otentikasi berbasis IP** — Gabungkan validasi sertifikat dengan pemeriksaan alamat IP klien untuk keamanan yang ditingkatkan, seperti membatasi akses dari wilayah geografis tertentu, jaringan perusahaan, atau rentang IP berbahaya yang diketahui. + Validasi **sertifikat multi-penyewa - Menerapkan aturan validasi** khusus penyewa di mana otoritas sertifikat atau kriteria validasi yang berbeda berlaku berdasarkan penerbit sertifikat klien atau atribut subjek. + **Kontrol akses berbasis waktu** - Menerapkan pembatasan berbasis waktu di mana sertifikat hanya berlaku selama jam tertentu, jendela pemeliharaan, atau periode bisnis, bahkan jika sertifikat itu sendiri belum kedaluwarsa. Fungsi koneksi berjalan setelah CloudFront melakukan validasi sertifikat standar (verifikasi rantai kepercayaan, pemeriksaan kedaluwarsa, dan validasi tanda tangan) tetapi sebelum koneksi TLS dibuat. Waktu ini memberi Anda fleksibilitas untuk menambahkan kriteria validasi kustom sambil memanfaatkan CloudFront validasi sertifikat bawaan. Fungsi Anda menerima hasil validasi standar dan dapat membuat keputusan berdasarkan informasi tentang apakah akan mengizinkan atau menolak koneksi berdasarkan kriteria standar dan khusus. Saat merancang Fungsi Koneksi Anda, pertimbangkan implikasi kinerja logika validasi Anda. Fungsi memiliki batas eksekusi 5 milidetik, sehingga operasi yang kompleks harus dioptimalkan untuk kecepatan. Gunakan KeyValueStore untuk pencarian data yang cepat daripada perhitungan yang rumit, dan struktur logika validasi Anda agar cepat gagal untuk sertifikat yang tidak valid. ## CloudFront Fungsi Koneksi struktur acara dan format respons CloudFront Fungsi Koneksi menerima struktur peristiwa yang berbeda dari permintaan penampil dan fungsi respons penampil. Alih-alih request/response data HTTP, fungsi koneksi menerima sertifikat dan informasi koneksi yang dapat Anda gunakan untuk membuat keputusan otentikasi. **Topics** + [Struktur acara untuk Fungsi Koneksi](#connection-function-event-structure-details) + [Format respons Fungsi Koneksi](#connection-function-response-format) ### Struktur acara untuk Fungsi Koneksi Fungsi Koneksi menerima objek acara yang berisi sertifikat dan informasi koneksi. Struktur acara fungsi ditunjukkan di bawah ini: ``` { "clientCertificate": { "certificates": { "leaf": { "serialNumber": "string", "issuer": "string", "subject": "string", "validity": { "notBefore": "string", "notAfter": "string", }, "sha256Fingerprint": "string" } } }, "clientIp": "string", "endpoint": "string", "distributionId": "string", "connectionId": "string" } ``` Di bawah ini adalah contoh struktur objek acara: ``` { "clientCertificate": { "certificates": { "leaf": { "serialNumber": "00:9e:2a:af:16:56:e5:47:25:7d:2e:38:c3:f9:9d:57:fa", "issuer": "C=US, O=Ram, OU=Edge, ST=WA, CN=mTLS-CA, L=Snoqualmie", "subject": "C=US, O=Ram, OU=Edge, ST=WA, CN=mTLS-CA, L=Snoqualmie", "validity": { "notBefore": "2025-09-10T23:43:10Z", "notAfter": "2055-09-11T00:43:02Z" }, "sha256Fingerprint": "_w6bJ7aOAlGOj7NUhJxTfsfee-ONg_xop3_PTgTJpqs=" } } }, "clientIp": "127.0.0.1", "endpoint": "d3lch071jze0cb.cloudfront.net", "distributionId": "E1NXS4MQZH501R", "connectionId": "NpvTe1925xfj24a67sPQr7ae42BIq03FGhJJKfrQYWZcWZFp96SIIg==" } ``` ### Format respons Fungsi Koneksi Fungsi Koneksi Anda harus mengembalikan objek respons yang menunjukkan apakah akan mengizinkan atau menolak koneksi. Gunakan metode pembantu untuk membuat keputusan koneksi: ``` function connectionHandler(connection) { // Helper methods to allow or deny connections if (/* some logic to determine if function should allow connection */) { connection.allow(); } else { connection.deny(); } } ``` Tidak seperti permintaan penampil dan fungsi respons penampil, Fungsi Koneksi tidak dapat mengubah permintaan atau tanggapan HTTP. Mereka hanya dapat mengizinkan atau menolak koneksi TLS. ## CloudFront Fitur JavaScript runtime Fungsi Koneksi CloudFront Fungsi Koneksi menggunakan CloudFront Functions JavaScript runtime 2.0, yang menyediakan lingkungan aman dan berkinerja tinggi yang secara khusus dioptimalkan untuk beban kerja validasi sertifikat. Runtime dirancang untuk memulai dalam sub-milidetik dan menangani jutaan eksekusi bersamaan di seluruh CloudFront jaringan edge global. Lingkungan runtime mencakup dukungan JavaScript bahasa yang komprehensif: + **ECMAScript Dukungan 2020 (ES11)** - JavaScript Fitur modern termasuk rantai opsional (?.) , penggabungan batal (??) , dan BigInt untuk menangani nomor seri sertifikat besar + **Objek bawaan - JavaScript Objek** standar seperti Objek, Array, JSON, Matematika, dan Tanggal + **Console logging** — Gunakan console.log () untuk men-debug dan memantau keputusan validasi sertifikat. Log tersedia secara real-time selama pengujian dan dapat membantu memecahkan masalah logika validasi dalam pengembangan + **KeyValueStore integrasi** — Akses asli CloudFront KeyValueStore untuk operasi pencarian data ultra-cepat, memungkinkan pemeriksaan pencabutan sertifikat waktu nyata, validasi daftar izin perangkat, dan pengambilan konfigurasi khusus penyewa Fungsi koneksi dioptimalkan untuk kinerja tinggi untuk skenario validasi sertifikat. Runtime secara otomatis menangani manajemen memori, pengumpulan sampah, dan pembersihan sumber daya untuk memastikan kinerja yang konsisten di jutaan koneksi bersamaan. Semua operasi dirancang untuk menjadi deterministik dan cepat, dengan KeyValueStore pencarian biasanya selesai dalam mikrodetik. Lingkungan runtime benar-benar terisolasi antara eksekusi fungsi, memastikan bahwa tidak ada kebocoran data antara koneksi klien yang berbeda. Setiap eksekusi fungsi dimulai dengan keadaan bersih dan tidak memiliki akses ke hasil eksekusi sebelumnya atau data klien dari koneksi lain. ## CloudFront Metode pembantu Fungsi Koneksi dan APIs CloudFront Fungsi Koneksi menyediakan metode pembantu khusus yang dirancang untuk menyederhanakan keputusan validasi sertifikat dan meningkatkan observabilitas. Metode ini dioptimalkan untuk alur kerja validasi koneksi dan diintegrasikan secara mulus dengan CloudFront sistem pencatatan dan pemantauan koneksi. + **connection.allow ()** - Izinkan koneksi TLS untuk melanjutkan. Metode ini memberi sinyal CloudFront untuk menyelesaikan jabat tangan TLS dan memungkinkan klien untuk membuat koneksi. Gunakan ini saat validasi sertifikat berlalu dan logika otentikasi kustom apa pun terpenuhi + **connection.deny ()** - Tolak koneksi TLS dan hentikan jabat tangan. Metode ini segera menutup koneksi dan mencegah lalu lintas HTTP mengalir. Klien akan menerima kesalahan koneksi TLS. Gunakan ini untuk sertifikat yang tidak valid, autentikasi gagal, atau pelanggaran kebijakan + **koneksi. logCustomData()** — Tambahkan data khusus ke log koneksi (hingga 800 byte teks UTF-8). Metode ini memungkinkan Anda untuk menyertakan hasil validasi, detail sertifikat, atau alasan keputusan dalam log CloudFront koneksi untuk pemantauan keamanan, audit kepatuhan, dan pemecahan masalah Metode ini menyediakan antarmuka deklaratif yang bersih untuk membuat keputusan koneksi dan mencatat informasi yang relevan untuk pemantauan dan debugging. allow/deny Pola memastikan bahwa maksud fungsi Anda jelas dan CloudFront dapat mengoptimalkan penanganan koneksi berdasarkan keputusan Anda. Data pencatatan khusus segera tersedia di log CloudFront koneksi dan dapat digunakan dengan alat analisis log untuk pemantauan keamanan dan wawasan operasional. Selalu panggil connection.allow () atau connection.deny () sebelum fungsi Anda selesai. Jika tidak ada metode yang dipanggil, CloudFront akan menolak koneksi secara default sebagai tindakan pencegahan keamanan. ## CloudFront KeyValueStore Integrasi Fungsi Koneksi CloudFront Fungsi Koneksi dapat digunakan CloudFront KeyValueStore untuk melakukan pencarian data ultra-cepat untuk skenario validasi sertifikat. KeyValueStore sangat kuat untuk Fungsi Koneksi karena menyediakan akses data global yang akhirnya konsisten dengan waktu pencarian mikrodetik di semua lokasi tepi. CloudFront Ini membuatnya ideal untuk mempertahankan daftar pencabutan sertifikat, daftar izin perangkat, konfigurasi penyewa, dan data validasi lainnya yang perlu diakses selama jabat tangan TLS. KeyValueStore integrasi dirancang khusus untuk alur kerja validasi koneksi berkinerja tinggi: + **KVShandle.exists (key)** - Periksa apakah ada kunci di tanpa mengambil nilainya. KeyValueStore Ini adalah metode yang paling efisien untuk skenario validasi biner seperti pemeriksaan pencabutan sertifikat, di mana Anda hanya perlu tahu apakah nomor seri sertifikat ada dalam daftar pencabutan + **KVShandle.get (key)** - Ambil nilai dari skenario validasi yang lebih kompleks. KeyValueStore Gunakan ini saat Anda perlu mengakses data konfigurasi, aturan validasi, atau metadata yang terkait dengan sertifikat atau pengenal perangkat KeyValueStore operasi asinkron dan harus digunakan dengan sintaks async/await. Ini KeyValueStore memiliki batas ukuran total 10MB dan mendukung hingga 10 juta pasangan nilai kunci. KeyValueStore data pada akhirnya konsisten di semua lokasi tepi, dengan pembaruan biasanya menyebar dalam hitungan detik. Untuk kinerja optimal, susun KeyValueStore kunci Anda untuk meminimalkan operasi pencarian. Gunakan nomor seri sertifikat sebagai kunci untuk pemeriksaan pencabutan sederhana, atau buat kunci komposit yang menggabungkan hash penerbit dan nomor seri untuk lingkungan multi-CA. Pertimbangkan trade-off antara kompleksitas dan KeyValueStore kapasitas utama saat merancang struktur data Anda. ## Gunakan async dan await Fungsi koneksi mendukung operasi asinkron menggunakan async/await sintaks, yang penting saat bekerja dengan KeyValueStore operasi atau tugas asinkron lainnya. async/await Pola ini memastikan bahwa fungsi Anda menunggu KeyValueStore pencarian selesai sebelum membuat keputusan koneksi, sambil mempertahankan karakteristik kinerja tinggi yang diperlukan untuk pemrosesan jabat tangan TLS. async/await Penggunaan yang tepat sangat penting untuk Fungsi Koneksi karena KeyValueStore operasi, meskipun sangat cepat, masih merupakan operasi jaringan yang memerlukan koordinasi di seluruh CloudFront infrastruktur terdistribusi. Runtime secara otomatis menangani resolusi janji dan memastikan bahwa fungsi Anda selesai dalam batas eksekusi 5 milidetik. **Example : Fungsi Koneksi Async dengan KeyValueStore** ``` import cf from 'cloudfront'; async function connectionHandler(connection) { const kvsHandle = cf.kvs(); // Async operation to check KeyValueStore for certificate revocation const isRevoked = await kvsHandle.exists(connection.clientCertificate.certificates.leaf.serialNumber); if (isRevoked) { // Log the revocation decision with certificate details connection.logCustomData(`REVOKED_CERT:${connection.clientCertificate.certificates.leaf.serialNumber}:${connection.clientCertificate.certificates.leaf.issuer}`); console.log(`Denying connection for revoked certificate: ${connection.clientCertificate.certificates.leaf.serialNumber}`); return connection.deny(); } // Log successful validation for monitoring connection.logCustomData(`VALID_CERT:${connection.clientCertificate.certificates.leaf.serialNumber}`); console.log(`Allowing connection for valid certificate: ${connection.clientCertificate.certificates.leaf.serialNumber}`); return connection.allow(); } ``` Selalu gunakan async/await saat memanggil KeyValueStore metode atau operasi asinkron lainnya. Runtime Fungsi Koneksi menangani resolusi janji secara otomatis dan memastikan alur eksekusi yang tepat dalam batasan waktu yang ketat dari pemrosesan jabat tangan TLS. Hindari menggunakan .then () atau pola panggilan balik, karena async/await memberikan penanganan kesalahan yang lebih bersih dan kinerja yang lebih baik di lingkungan Fungsi Koneksi. Saat merancang Fungsi Koneksi async, susun kode Anda untuk meminimalkan jumlah KeyValueStore operasi dan lakukan sedini mungkin dalam logika validasi Anda. Ini memastikan kinerja maksimum dan mengurangi risiko masalah batas waktu selama periode lalu lintas tinggi. Pertimbangkan untuk mengelompokkan pemeriksaan validasi terkait dan menggunakan KeyValueStore metode yang paling efisien (exists () vs get ()) untuk kasus penggunaan Anda. ## Contoh kode fungsi koneksi Contoh berikut menunjukkan pola Fungsi Koneksi umum untuk skenario validasi yang berbeda. Gunakan contoh ini sebagai titik awal untuk implementasi Fungsi Koneksi Anda sendiri. **Example : Validasi sertifikat perangkat** Contoh ini memvalidasi nomor seri perangkat dan bidang subjek sertifikat untuk perangkat IoT, konsol game, dan skenario otentikasi klien lainnya: ``` async function connectionHandler(connection) { // Custom validation: check device serial number format const serialNumber = connection.clientCertificate.certificates.leaf.serialNumber; if (!serialNumber.startsWith("DEV")) { connection.logCustomData(`INVALID_SERIAL:${serialNumber}`); return connection.deny(); } // Validate certificate subject contains required organizational unit const subject = connection.clientCertificate.certificates.leaf.subject; if (!subject.includes("OU=AuthorizedDevices")) { connection.logCustomData(`INVALID_OU:${subject}`); return connection.deny(); } // Allow connection for valid devices connection.logCustomData(`VALID_DEVICE:${serialNumber}`); return connection.allow(); } ``` Fungsi ini melakukan beberapa pemeriksaan validasi di luar validasi sertifikat standar, termasuk format nomor seri perangkat dan verifikasi unit organisasi. **Example : MTL opsional dengan otentikasi campuran** Contoh ini menangani koneksi mTLS dan non-MTLS dengan kebijakan otentikasi yang berbeda: ``` async function connectionHandler(connection) { if (connection.clientCertificate) { // mTLS connection - enhanced validation for certificate holders const subject = connection.clientCertificate.certificates.leaf.subject; connection.logCustomData(`MTLS_SUCCESS:${subject}:${connection.clientIp}`); console.log(`mTLS connection from: ${subject}`); return connection.allow(); } else { // Non-mTLS connection - apply IP-based restrictions const clientIp = connection.clientIp; // Only allow non-mTLS from specific IP ranges if (clientIp.startsWith("203.0.113.") || clientIp.startsWith("198.51.100.")) { connection.logCustomData(`NON_MTLS_ALLOWED:${clientIp}`); console.log(`Non-mTLS connection allowed from: ${clientIp}`); return connection.allow(); } connection.logCustomData(`NON_MTLS_DENIED:${clientIp}`); return connection.deny(); } } ``` Fungsi ini memberikan keamanan yang ditingkatkan untuk klien dengan sertifikat sambil mempertahankan kompatibilitas dengan klien lama dari rentang IP tepercaya. # Uji Fungsi CloudFront Koneksi sebelum penerapan Anda dapat menguji Fungsi CloudFront Koneksi pada tahap PENGEMBANGAN menggunakan operasi TestConnectionFunction API. Pengujian memungkinkan Anda memvalidasi logika fungsi Anda dengan contoh peristiwa koneksi sebelum memublikasikan ke tahap LIVE. **Topics** + [Proses pengujian](#connection-function-testing-process) + [Hasil tes](#connection-function-test-results) + [Objek uji koneksi](#connection-test-object) ## Proses pengujian Untuk menguji Fungsi Koneksi: 1. Buat Fungsi Koneksi pada tahap PENGEMBANGAN 1. Siapkan objek koneksi uji yang mewakili peristiwa koneksi TLS 1. Gunakan operasi TestConnectionFunction API untuk menjalankan fungsi Anda dengan data pengujian 1. Tinjau hasil pengujian, termasuk output fungsi, log eksekusi, dan pesan kesalahan apa pun 1. Perbarui kode fungsi Anda sesuai kebutuhan dan ulangi proses pengujian ## Hasil tes Saat Anda menguji Fungsi Koneksi, hasilnya meliputi: + **Ringkasan fungsi** — Metadata tentang fungsi yang diuji + **Pemanfaatan komputasi** - Metrik kinerja yang menunjukkan penggunaan sumber daya + **Log eksekusi** — Output konsol dari fungsi Anda, termasuk pernyataan logging + **Output fungsi** - Hasil yang dikembalikan oleh fungsi Anda + **Pesan galat** — Setiap kesalahan runtime atau pengecualian yang terjadi selama eksekusi ## Objek uji koneksi Objek uji koneksi adalah gumpalan biner (hingga 40KB) yang mewakili peristiwa koneksi TLS yang akan diproses fungsi Anda. Objek ini berisi sertifikat dan informasi koneksi yang digunakan fungsi Anda untuk membuat keputusan otentikasi. **catatan** Struktur dan format spesifik objek uji koneksi ditentukan oleh runtime Fungsi CloudFront Koneksi. Konsultasikan dokumentasi atau kontak CloudFront Fungsi AWS Dukungan untuk detail tentang pembuatan objek pengujian yang sesuai untuk kasus penggunaan Anda. Setelah membuat Fungsi Koneksi, Anda dapat: + **Uji fungsi** — Gunakan fungsionalitas pengujian di konsol atau CLI untuk memvalidasi fungsi Anda dengan contoh peristiwa koneksi. Untuk informasi selengkapnya, lihat Pengujian Fungsi Koneksi. + **Perbarui fungsi** - Ubah kode fungsi dan konfigurasi sesuai kebutuhan. Fungsi koneksi dalam tahap PENGEMBANGAN dapat diperbarui kapan saja. + **Publikasikan fungsi** — Ketika siap untuk produksi, publikasikan fungsi untuk memindahkannya dari DEVELOPMENT ke tahap LIVE. Untuk informasi selengkapnya, lihat mengaitkan Fungsi Koneksi. + **Kaitkan dengan distribusi** — Kaitkan fungsi yang diterbitkan dengan distribusi berkemampuan MTLS untuk menangani koneksi langsung. Untuk informasi selengkapnya, lihat mengaitkan fungsi koneksi. # Mengaitkan Fungsi Koneksi dengan distribusi Setelah memublikasikan Fungsi Koneksi ke tahap LIVE, Anda harus mengaitkannya dengan distribusi berkemampuan MTLS untuk menangani koneksi langsung. Fungsi koneksi dikaitkan pada tingkat distribusi, tidak seperti permintaan penampil dan fungsi respons penampil yang terkait dengan perilaku cache. **Topics** + [Persyaratan asosiasi](#connection-function-association-requirements) + [Mengatur fungsi dengan filter](#connection-function-organizing-filters) + [Pertimbangan deployment](#connection-function-deployment-considerations) ## Persyaratan asosiasi Untuk mengaitkan Fungsi Koneksi dengan distribusi: + Fungsi harus dalam tahap LIVE + Distribusi harus mengaktifkan mTL + Distribusi harus memiliki penyimpanan kepercayaan yang valid yang dikonfigurasi + Anda hanya dapat mengaitkan satu Fungsi Koneksi per distribusi ## Mengatur fungsi dengan filter CloudFront menyediakan kemampuan penyaringan untuk membantu Anda mengatur dan mengelola fungsi koneksi: + **Filter ID Distribusi** - Temukan fungsi yang terkait dengan distribusi tertentu + **Filter penyimpanan nilai kunci** - Temukan fungsi yang menggunakan penyimpanan nilai kunci tertentu untuk pencarian data + **Filter tahap** - Daftar fungsi dalam pengembangan atau tahap LIVE Gunakan filter ini saat mengelola beberapa Fungsi Koneksi di berbagai distribusi atau lingkungan pengembangan. ## Pertimbangan deployment Pertimbangkan faktor-faktor ini saat menerapkan Fungsi Koneksi: + **Penyebaran global** - Fungsi koneksi diterapkan ke semua lokasi CloudFront tepi di seluruh dunia, yang mungkin memakan waktu beberapa menit + **Manajemen versi** - Setiap versi yang diterbitkan membuat fungsi LIVE baru yang menggantikan versi sebelumnya + **Strategi rollback** - Rencanakan rollback dengan menyimpan versi kerja sebelumnya dari kode fungsi Anda + **Pengujian dalam produksi** - Pertimbangkan untuk menggunakan distribusi terpisah untuk lingkungan pementasan dan produksi # Menerapkan pencabutan sertifikat untuk TLS bersama (penampil) dengan Fungsi dan CloudFront KeyValueStore Anda dapat menggunakan Fungsi CloudFront Koneksi dengan KeyValueStore untuk menerapkan pemeriksaan pencabutan sertifikat. Ini memungkinkan Anda mempertahankan daftar nomor seri sertifikat yang dicabut dan memeriksa sertifikat klien terhadap daftar ini selama jabat tangan TLS. Untuk menerapkan pencabutan sertifikat, Anda memerlukan komponen-komponen ini: + Distribusi yang dikonfigurasi dengan mTL penampil + Sebuah KeyValueStore berisi nomor seri sertifikat yang dicabut + Fungsi Koneksi yang menanyakan status sertifikat KeyValueStore untuk memeriksa Saat klien terhubung, CloudFront validasi sertifikat terhadap trust store, lalu jalankan Fungsi Koneksi Anda. Fungsi Anda memeriksa nomor seri sertifikat terhadap KeyValueStore dan mengizinkan atau menolak koneksi. **Topics** + [Langkah 1: Buat sertifikat KeyValueStore yang dicabut](create-kvs-revoked-certificates.md) + [Langkah 2: Buat Fungsi Koneksi Pencabutan](create-revocation-connection-function.md) + [Langkah 3: Uji fungsi pencabutan Anda](test-revocation-function.md) + [Langkah 4: Kaitkan fungsi ke distribusi Anda](associate-function-distribution.md) + [Skenario pencabutan lanjutan](advanced-revocation-scenarios.md) # Langkah 1: Buat sertifikat KeyValueStore yang dicabut Buat KeyValueStore nomor seri sertifikat yang telah dicabut yang dapat diperiksa oleh Fungsi Koneksi Anda selama koneksi mTLS. Pertama, siapkan nomor seri sertifikat yang telah dicabut dalam format JSON: ``` { "data": [ { "key": "ABC123DEF456", "value": "" }, { "key": "789XYZ012GHI", "value": "" } ] } ``` Unggah file JSON ini ke bucket S3, lalu buat: KeyValueStore ``` aws s3 cp revoked-serials.json s3://your-bucket-name/revoked-serials.json aws cloudfront create-key-value-store \ --name revoked-serials-kvs \ --import-source '{ "SourceType": "S3", "SourceARN": "arn:aws:s3:::your-bucket-name/revoked-serials.json" }' ``` Tunggu KeyValueStore hingga penyediaan selesai. Periksa status dengan: ``` aws cloudfront get-key-value-store --name "revoked-serials-kvs" ``` # Langkah 2: Buat Fungsi Koneksi Pencabutan Buat Fungsi Koneksi yang memeriksa nomor seri sertifikat KeyValueStore untuk menentukan apakah sertifikat dicabut. Buat Fungsi Koneksi yang memeriksa nomor seri sertifikat terhadap KeyValueStore: ``` aws cloudfront create-connection-function \ --name "revocation-control" \ --connection-function-config file://connection-function-config.json \ --connection-function-code file://connection-function-code.txt ``` File konfigurasi menentukan KeyValueStore asosiasi: ``` { "Runtime": "cloudfront-js-2.0", "Comment": "A function that implements revocation control via KVS", "KeyValueStoreAssociations": { "Quantity": 1, "Items": [ { "KeyValueStoreArn": "arn:aws:cloudfront::account-id:key-value-store/kvs-id" } ] } } ``` Kode Fungsi Koneksi memeriksa sertifikat KeyValueStore yang dicabut: ``` import cf from 'cloudfront'; async function connectionHandler(connection) { const kvsHandle = cf.kvs(); // Get parsed client serial number from client certificate const clientSerialNumber = connection.clientCertInfo.serialNumber; // Check KVS to see if serial number exists as a key const serialNumberExistsInKvs = await kvsHandle.exists(clientSerialNumber); // Deny connection if serial number exists in KVS if (serialNumberExistsInKvs) { console.log("Connection denied - certificate revoked"); return connection.deny(); } // Allow connections that don't exist in kvs console.log("Connection allowed"); return connection.allow(); } ``` # Langkah 3: Uji fungsi pencabutan Anda Gunakan CloudFront konsol untuk menguji Fungsi Koneksi Anda dengan sertifikat sampel. Arahkan ke Fungsi Koneksi di konsol dan gunakan tab Uji. **Uji dengan sertifikat sampel** 1. Tempelkan sertifikat sampel dalam format PEM ke antarmuka pengujian 1. Secara opsional menentukan alamat IP klien untuk menguji logika berbasis IP 1. Pilih **fungsi Uji** untuk melihat hasil eksekusi 1. Tinjau log eksekusi untuk memverifikasi logika fungsi Anda Uji dengan sertifikat yang valid dan dicabut untuk memastikan fungsi Anda menangani kedua skenario dengan benar. Log eksekusi menunjukkan output console.log dan kesalahan apa pun yang terjadi selama eksekusi fungsi. # Langkah 4: Kaitkan fungsi ke distribusi Anda Setelah Anda mempublikasikan Fungsi Koneksi, kaitkan dengan distribusi berkemampuan MTLS untuk mengaktifkan pemeriksaan pencabutan sertifikat. Anda dapat mengaitkan fungsi dari halaman pengaturan distribusi atau dari tabel distribusi terkait Fungsi Koneksi. Arahkan ke pengaturan distribusi Anda, gulir ke bagian Authentication **Mutual Authentication (mTLS) Viewer**, pilih Fungsi Koneksi Anda, dan simpan perubahannya. # Skenario pencabutan lanjutan Untuk persyaratan pencabutan sertifikat yang lebih kompleks, pertimbangkan konfigurasi tambahan ini: **Topics** + [Konversi Daftar Pencabutan Sertifikat (CRL) ke format KeyValueStore](#convert-crl-kvs-format) + [Menangani beberapa Otoritas Sertifikat](#handle-multiple-cas) + [Tambahkan data khusus ke log koneksi](#add-custom-data-logs) + [Kelola pembaruan CRL](#manage-crl-updates) + [KeyValueStore Kapasitas rencana](#plan-kvs-capacity) ## Konversi Daftar Pencabutan Sertifikat (CRL) ke format KeyValueStore Jika Anda memiliki file Certificate Revocation List (CRL), Anda dapat mengonversinya ke KeyValueStore format JSON menggunakan OpenSSL dan jq: **Konversi CRL ke format KeyValueStore ** Ekstrak nomor seri dari file CRL: ``` openssl crl -text -noout -in rfc5280_CRL.crl | \ awk '/Serial Number:/ {print $3}' | \ cut -d'=' -f2 | \ sed 's/../&:/g;s/:$//' >> serialnumbers.txt ``` Konversi nomor seri ke format KeyValueStore JSON: ``` jq -R -s 'split("\n") | map(select(length > 0)) | {data: map({"key": ., "value": ""})}' \ serialnumbers.txt >> serialnumbers_kvs.json ``` Unggah file yang diformat ke S3 dan buat KeyValueStore seperti yang dijelaskan pada Langkah 1. ## Menangani beberapa Otoritas Sertifikat Jika Anda TrustStore berisi beberapa Otoritas Sertifikat (CAs), sertakan informasi penerbit dalam KeyValueStore kunci Anda untuk menghindari konflik antar sertifikat dari CAs yang berbeda yang mungkin memiliki nomor seri yang sama. Untuk skenario multi-CA, gunakan kombinasi SHA1 hash penerbit dan nomor seri sebagai kuncinya: ``` import cf from 'cloudfront'; async function connectionHandler(connection) { const kvsHandle = cf.kvs(); const clientCert = connection.clientCertInfo; // Create composite key with issuer hash and serial number const issuer = clientCert.issuer.replace(/[^a-zA-Z0-9]/g, '').substring(0, 20); const serialno = clientCert.serialNumber; const compositeKey = `${issuer}_${serialno}`; const cert_revoked = await kvsHandle.exists(compositeKey); if (cert_revoked) { console.log(`Blocking revoked cert: ${serialno} from issuer: ${issuer}`); connection.deny(); } else { connection.allow(); } } ``` **catatan** Menggunakan pengenal penerbit\$1nomor seri membuat kunci yang lebih panjang, yang dapat mengurangi jumlah total entri yang dapat Anda simpan di. KeyValueStore ## Tambahkan data khusus ke log koneksi Fungsi koneksi dapat menambahkan data khusus ke log CloudFront koneksi menggunakan logCustomData metode ini. Ini memungkinkan Anda menyertakan hasil pemeriksaan pencabutan, informasi sertifikat, atau data relevan lainnya di log Anda. ``` async function connectionHandler(connection) { const kvsHandle = cf.kvs(); const clientSerialNumber = connection.clientCertInfo.serialNumber; const serialNumberExistsInKvs = await kvsHandle.exists(clientSerialNumber); if (serialNumberExistsInKvs) { // Log revocation details to connection logs connection.logCustomData(`REVOKED:${clientSerialNumber}:DENIED`); console.log("Connection denied - certificate revoked"); return connection.deny(); } // Log successful validation connection.logCustomData(`VALID:${clientSerialNumber}:ALLOWED`); console.log("Connection allowed"); return connection.allow(); } ``` Data kustom dibatasi hingga 800 byte teks UTF-8 yang valid. Jika Anda melebihi batas ini, CloudFront potong data ke batas UTF-8 terdekat yang valid. **catatan** Pencatatan data khusus hanya berfungsi saat log koneksi diaktifkan untuk distribusi Anda. Jika log koneksi tidak dikonfigurasi, logCustomData metode ini adalah no-op. ## Kelola pembaruan CRL Otoritas Sertifikat dapat mengeluarkan dua jenis CRLs: + **Lengkap CRLs**: Berisi daftar lengkap semua sertifikat yang dicabut + **Delta CRLs**: Hanya sertifikat daftar yang dicabut sejak CRL penuh terakhir Untuk pembaruan CRL lengkap, buat yang baru KeyValueStore dengan data yang diperbarui dan alihkan asosiasi Fungsi Koneksi ke yang baru. KeyValueStore Pendekatan ini lebih sederhana daripada menghitung perbedaan dan melakukan pembaruan tambahan. Untuk pembaruan delta CRL, gunakan perintah update-keys untuk menambahkan sertifikat baru yang telah dicabut ke yang sudah ada: KeyValueStore ``` aws cloudfront update-key-value-store \ --name "revoked-serials-kvs" \ --if-match "current-etag" \ --put file://delta-revoked-serials.json ``` ## KeyValueStore Kapasitas rencana KeyValueStore memiliki batas ukuran 5 MB dan mendukung hingga 10 juta pasangan nilai kunci. Rencanakan kapasitas daftar pencabutan Anda berdasarkan format kunci dan ukuran data Anda: + **Nomor seri saja**: Penyimpanan yang efisien untuk pemeriksaan pencabutan sederhana + **Pengidentifikasi penerbit\$1nomor seri**: Kunci yang lebih panjang untuk lingkungan multi-CA Untuk daftar pencabutan besar, pertimbangkan untuk menerapkan pendekatan berjenjang di mana Anda memelihara terpisah KeyValueStores untuk kategori sertifikat atau periode waktu yang berbeda. # Sesuaikan di tepi dengan Lambda @Edge Lambda @Edge adalah perpanjangan dari. AWS Lambda Lambda @Edge adalah layanan komputasi yang memungkinkan Anda menjalankan fungsi yang menyesuaikan konten yang diberikan Amazon. CloudFront Anda dapat membuat fungsi Node.js atau Python di konsol Lambda dalam satu Wilayah AWS, US East (Virginia N.). Setelah membuat fungsi, Anda dapat menambahkan pemicu menggunakan konsol CloudFront atau konsol Lambda sehingga fungsi berjalan AWS di lokasi yang lebih dekat dengan penampil, tanpa menyediakan atau mengelola server. Secara opsional, Anda dapat menggunakan operasi Lambda CloudFront dan API untuk mengatur fungsi dan pemicu Anda secara terprogram. Lambda@Edge menskalakan secara otomatis, dari beberapa permintaan per hari menjadi ribuan per detik. Memproses permintaan di AWS lokasi yang lebih dekat dengan penampil alih-alih di server asal secara signifikan mengurangi latensi dan meningkatkan pengalaman pengguna. **catatan** Lambda @Edge tidak didukung dengan permintaan gRPC. Untuk informasi lebih lanjut. lihat. [Menggunakan gRPC dengan distribusi CloudFront](distribution-using-grpc.md) **Topics** + [Bagaimana Lambda @Edge bekerja dengan permintaan dan tanggapan](lambda-edge-event-request-response.md) + [Cara menggunakan Lambda @Edge](lambda-edge-ways-to-use.md) + [Memulai dengan fungsi Lambda @Edge (konsol)](lambda-edge-how-it-works.md) + [Siapkan izin dan peran IAM untuk Lambda @Edge](lambda-edge-permissions.md) + [Tulis dan buat fungsi Lambda @Edge](lambda-edge-create-function.md) + [Tambahkan pemicu untuk fungsi Lambda @Edge](lambda-edge-add-triggers.md) + [Uji dan debug fungsi Lambda @Edge](lambda-edge-testing-debugging.md) + [Hapus fungsi dan replika Lambda @Edge](lambda-edge-delete-replicas.md) + [Struktur acara Lambda @Edge](lambda-event-structure.md) + [Bekerja dengan permintaan dan tanggapan](lambda-generating-http-responses.md) + [Lambda @Edge contoh fungsi](lambda-examples.md) # Bagaimana Lambda @Edge bekerja dengan permintaan dan tanggapan Saat Anda mengaitkan CloudFront distribusi dengan fungsi Lambda @Edge, CloudFront mencegat permintaan dan respons di lokasi tepi. CloudFront Anda dapat menjalankan fungsi Lambda ketika CloudFront peristiwa berikut terjadi: + Saat CloudFront menerima permintaan dari penampil (permintaan penampil) + Sebelum CloudFront meneruskan permintaan ke asal (permintaan asal) + Ketika CloudFront menerima respons dari asal (respons asal) + Sebelum CloudFront mengembalikan respons ke penampil (respons penampil) Jika Anda menggunakan AWS WAF, permintaan penampil Lambda @Edge dijalankan setelah AWS WAF aturan apa pun diterapkan. Untuk informasi selengkapnya, lihat [Bekerja dengan permintaan dan tanggapan](lambda-generating-http-responses.md) dan [Struktur acara Lambda @Edge](lambda-event-structure.md). # Cara menggunakan Lambda @Edge Ada banyak kegunaan untuk pemrosesan Lambda @Edge dengan CloudFront distribusi Amazon Anda, seperti contoh berikut: + Fungsi Lambda dapat memeriksa cookie dan menulis ulang URLs sehingga pengguna melihat versi situs yang berbeda untuk pengujian. A/B + CloudFront dapat mengembalikan objek yang berbeda ke pemirsa berdasarkan perangkat yang mereka gunakan dengan memeriksa `User-Agent` header, yang mencakup informasi tentang perangkat. Misalnya, CloudFront dapat mengembalikan gambar yang berbeda berdasarkan ukuran layar perangkat mereka. Demikian pula, fungsi tersebut dapat mempertimbangkan nilai `Referer` header dan menyebabkan CloudFront mengembalikan gambar ke bot yang memiliki resolusi terendah yang tersedia. + Atau Anda dapat memeriksa cookie untuk kriteria lainnya. Misalnya, di situs web ritel yang menjual pakaian, jika Anda menggunakan cookie untuk menunjukkan warna mana yang dipilih pengguna untuk jaket, fungsi Lambda dapat mengubah permintaan sehingga CloudFront mengembalikan gambar jaket dalam warna yang dipilih. + Fungsi Lambda dapat menghasilkan respons HTTP saat permintaan CloudFront penampil atau peristiwa permintaan asal terjadi. + Fungsi dapat memeriksa header atau token otorisasi, dan menyisipkan header untuk mengontrol akses ke konten Anda sebelum CloudFront meneruskan permintaan ke asal Anda. + Fungsi Lambda juga dapat melakukan panggilan jaringan ke sumber daya eksternal untuk mengonfirmasi kredensial pengguna, atau mengambil konten tambahan untuk menyesuaikan respons. Untuk informasi selengkapnya, termasuk kode contoh, lihat[Lambda @Edge contoh fungsi](lambda-examples.md). Untuk informasi selengkapnya tentang pengaturan Lambda @Edge di konsol, lihat. [Tutorial: Buat fungsi Lambda @Edge dasar (konsol)](lambda-edge-how-it-works-tutorial.md) # Memulai dengan fungsi Lambda @Edge (konsol) Dengan Lambda @Edge, Anda dapat menggunakan CloudFront pemicu untuk menjalankan fungsi Lambda. Saat Anda mengaitkan CloudFront distribusi dengan fungsi Lambda, CloudFront [mencegat permintaan dan respons di lokasi CloudFront tepi dan](https://docs.aws.amazon.com/lambda/latest/dg/lambda-edge.html) menjalankan fungsi tersebut. Fungsi Lambda dapat meningkatkan keamanan atau menyesuaikan informasi yang dekat dengan pemirsa Anda untuk meningkatkan kinerja. Daftar berikut memberikan ikhtisar dasar tentang cara membuat dan menggunakan fungsi Lambda dengan. CloudFront **Ikhtisar: Membuat dan menggunakan fungsi Lambda dengan CloudFront** 1. Buat fungsi Lambda di Wilayah AS Timur (Virginia N.). 1. Simpan dan publikasikan versi bernomor dari fungsi tersebut. Jika ingin mengubah fungsi, Anda harus mengedit versi \$1LATEST dari fungsi di Wilayah Timur AS (N. Virginia). Kemudian, sebelum Anda mengaturnya agar berfungsi CloudFront, Anda menerbitkan versi bernomor baru. 1. Kaitkan fungsi dengan perilaku CloudFront distribusi dan cache. Kemudian tentukan satu atau lebih CloudFront peristiwa (*pemicu*) yang menyebabkan fungsi dijalankan. Misalnya, Anda dapat membuat pemicu untuk fungsi yang akan dijalankan saat CloudFront menerima permintaan dari penampil. 1. Saat Anda membuat pemicu, Lambda membuat replika fungsi di AWS lokasi di seluruh dunia. **Tip** Untuk informasi selengkapnya, lihat [membuat dan memperbarui fungsi](lambda-edge-create-function.md), [struktur acara](lambda-event-structure.md), dan [menambahkan CloudFront pemicu.](lambda-edge-add-triggers.md) Anda juga dapat menemukan lebih banyak ide dan mendapatkan sampel kode di [Lambda @Edge contoh fungsi](lambda-examples.md). Untuk step-by-step tutorial, lihat topik berikut: **Topics** + [Tutorial: Buat fungsi Lambda @Edge dasar (konsol)](lambda-edge-how-it-works-tutorial.md) # Tutorial: Buat fungsi Lambda @Edge dasar (konsol) Tutorial ini menunjukkan kepada Anda bagaimana memulai dengan Lambda @Edge dengan membuat dan mengonfigurasi contoh fungsi Node.js yang berjalan di. CloudFront Contoh ini menambahkan header keamanan HTTP ke respons saat CloudFront mengambil file. (Ini dapat meningkatkan keamanan dan privasi untuk situs web.) Anda tidak memerlukan situs web Anda sendiri untuk tutorial ini. Namun, ketika Anda memilih untuk membuat solusi Lambda @Edge Anda sendiri, Anda mengikuti langkah-langkah serupa dan memilih dari opsi yang sama. **Topics** + [Langkah 1: Mendaftar untuk Akun AWS](#lambda-edge-how-it-works-tutorial-AWS) + [Langkah 2: Buat CloudFront distribusi](#lambda-edge-how-it-works-tutorial-cloudfront) + [Langkah 3: Buat fungsi Anda](#lambda-edge-how-it-works-tutorial-create-function) + [Langkah 4: Tambahkan CloudFront pemicu untuk menjalankan fungsi](#lambda-edge-how-it-works-tutorial-add-trigger) + [Langkah 5: Verifikasi bahwa fungsi berjalan](#lambda-edge-how-it-works-tutorial-verify) + [Langkah 6: Memecahkan masalah](#lambda-edge-how-it-works-tutorial-troubleshoot) + [Langkah 7: Bersihkan sumber daya contoh Anda](#lambda-edge-how-it-works-tutorial-cleanup-resources) + [Informasi Terkait](#lambda-edge-how-it-works-tutorial-resources) ## Langkah 1: Mendaftar untuk Akun AWS Jika Anda belum melakukannya, daftar untuk Akun AWS. Untuk informasi selengkapnya, lihat [Mendaftar untuk Akun AWS](setting-up-cloudfront.md#sign-up-for-aws). ## Langkah 2: Buat CloudFront distribusi Sebelum membuat contoh fungsi Lambda@Edge, Anda harus memiliki CloudFront yang dapat dikerjakan, yang mencakup asal muasal untuk menyajikan konten. Untuk contoh ini, Anda membuat CloudFront distribusi yang menggunakan bucket Amazon S3 sebagai asal distribusi. Jika Anda sudah memiliki lingkungan untuk digunakan, Anda dapat melewati langkah ini. **Untuk membuat CloudFront distribusi dengan asal Amazon S3** 1. Buat bucket Amazon S3 dengan satu atau dua file, seperti file citra, untuk konten sampel. Untuk bantuan, ikuti langkah dalam [Unggah konten Anda ke Amazon S3](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/GettingStarted.html#GettingStartedUploadContent). Pastikan Anda mengatur izin untuk memberikan akses baca publik ke objek dalam keranjang Anda. 1. Buat CloudFront distribusi dan tambahkan bucket S3 Anda sebagai asal, dengan mengikuti langkah-langkah di [Buat distribusi CloudFront web](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/GettingStarted.html#GettingStartedCreateDistribution). Jika Anda sudah memiliki distribusi, Anda dapat menambahkan bucket sebagai asal distribusi tersebut. **Tip** Catat ID distribusi Anda. Kemudian dalam tutorial ini ketika Anda menambahkan CloudFront pemicu untuk fungsi Anda, Anda harus memilih ID untuk distribusi Anda dalam daftar dropdown—misalnya,. `E653W22221KDDL` ## Langkah 3: Buat fungsi Anda Pada langkah ini, Anda membuat fungsi Lambda dari templat cetak biru di konsol Lambda. Fungsi menambahkan kode untuk memperbarui header keamanan di CloudFront distribusi. **Untuk membuat fungsi Lambda** 1. Masuk ke Konsol Manajemen AWS dan buka AWS Lambda konsol di[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). **penting** **Pastikan Anda berada di AS-Timur-1 (Virginia **N.) ( Wilayah AWS us-east-1).**** Anda harus berada di Wilayah ini untuk membuat fungsi Lambda@Edge. 1. Pilih **Buat fungsi**. 1. Pada halaman **fungsi Buat**, pilih **Gunakan cetak biru**, lalu filter untuk CloudFront cetak biru dengan memasukkan di bidang pencarian. **cloudfront** **catatan** CloudFront **cetak biru hanya tersedia di Wilayah AS-Timur-1 (**Virginia N.) (us-east-1).**** 1. Pilih cetak biru **header Modify HTTP response** sebagai template untuk fungsi Anda. 1. Masukkan informasi tentang fungsi Anda berikut ini: + **Nama fungsi** — Masukkan nama untuk fungsi Anda. + **Peran eksekusi** - Pilih cara mengatur izin untuk fungsi Anda. Untuk menggunakan templat kebijakan izin Lambda @Edge dasar yang direkomendasikan, pilih **Buat peran baru dari AWS ** templat kebijakan. + **Nama peran** — Masukkan nama untuk peran yang dibuat oleh templat kebijakan. + **Templat kebijakan** — Lambda secara otomatis menambahkan templat kebijakan **Izin Lambda @Edge** Dasar karena Anda memilih CloudFront cetak biru sebagai dasar fungsi Anda. Templat kebijakan ini menambahkan izin peran eksekusi yang memungkinkan CloudFront untuk menjalankan fungsi Lambda untuk Anda CloudFront di lokasi di seluruh dunia. Untuk informasi selengkapnya, lihat [Siapkan izin dan peran IAM untuk Lambda @Edge](lambda-edge-permissions.md). 1. Pilih **Buat fungsi** di bagian bawah halaman. 1. **Di panel **Deploy to Lambda** @Edge yang muncul, pilih Batal.** (Untuk tutorial ini, Anda harus memodifikasi kode fungsi sebelum menerapkan fungsi ke Lambda @Edge.) 1. Gulir ke bawah ke bagian **Sumber kode** halaman. 1. Ganti kode templat dengan fungsi yang memodifikasi header keamanan yang dikembalikan oleh Anda. Misalnya, Anda dapat menggunakan kode yang serupa dengan yang berikut ini: ``` 'use strict'; export const handler = (event, context, callback) => { //Get contents of response const response = event.Records[0].cf.response; const headers = response.headers; //Set new headers headers['strict-transport-security'] = [{key: 'Strict-Transport-Security', value: 'max-age= 63072000; includeSubdomains; preload'}]; headers['content-security-policy'] = [{key: 'Content-Security-Policy', value: "default-src 'none'; img-src 'self'; script-src 'self'; style-src 'self'; object-src 'none'"}]; headers['x-content-type-options'] = [{key: 'X-Content-Type-Options', value: 'nosniff'}]; headers['x-frame-options'] = [{key: 'X-Frame-Options', value: 'DENY'}]; headers['x-xss-protection'] = [{key: 'X-XSS-Protection', value: '1; mode=block'}]; headers['referrer-policy'] = [{key: 'Referrer-Policy', value: 'same-origin'}]; //Return modified response callback(null, response); }; ``` 1. Pilih **File**, **Simpan** untuk menyimpan kode yang diperbarui. 1. Pilih **Deploy**. Lanjutkan ke bagian berikutnya untuk menambahkan CloudFront pemicu untuk menjalankan fungsi. ## Langkah 4: Tambahkan CloudFront pemicu untuk menjalankan fungsi Sekarang Anda memiliki fungsi Lambda untuk memperbarui header keamanan, konfigurasikan CloudFront memicu untuk menjalankan fungsi Anda untuk menambahkan header dalam respons apa pun yang CloudFront dari tempat awal distribusi Anda. **Untuk mengkonfigurasi CloudFront pemicu untuk fungsi Anda** 1. Di konsol Lambda, pada halaman **Ikhtisar fungsi** untuk fungsi Anda, pilih **Tambah** pemicu. 1. Untuk **konfigurasi Trigger**, pilih **CloudFront**. 1. Pilih **Terapkan ke Lambda @Edge**. 1. Di panel **Deploy to Lambda** @Edge, **di bawah pemicu CloudFront Konfigurasi**, masukkan informasi berikut: + **Distribusi** — ID CloudFront distribusi untuk dikaitkan dengan fungsi Anda. Dalam daftar dropdown, pilih ID distribusi. + **Perilaku cache** — Perilaku cache yang digunakan dengan pemicu. Untuk contoh ini, biarkan nilai disetel ke **\$1**, yang berarti perilaku cache default distribusi Anda. Untuk informasi selengkapnya, lihat [Pengaturan perilaku cache](DownloadDistValuesCacheBehavior.md) dalam topik [Semua referensi pengaturan distribusi](distribution-web-values-specify.md). + **CloudFront event** - Pemicu yang menentukan kapan fungsi Anda berjalan. Kami ingin fungsi header keamanan berjalan setiap kali CloudFront mengembalikan respons dari asal. Dalam daftar dropdown, pilih Respons **asal**. Untuk informasi selengkapnya, lihat [Tambahkan pemicu untuk fungsi Lambda @Edge](lambda-edge-add-triggers.md). 1. Pilih kotak **centang Konfirmasi penerapan ke Lambda** @Edge. 1. Pilih **Deploy** untuk menambahkan pemicu dan mereplikasi fungsi ke AWS lokasi di seluruh dunia. 1. Tunggu fungsi mereplikasi. Ini biasanya memerlukan waktu beberapa menit. Anda dapat memeriksa untuk melihat apakah replikasi selesai oleh [menuju ke CloudFront konsol](https://console.aws.amazon.com/cloudfront/v4/home) dan melihat distribusi Anda. Tunggu status distribusi berubah dari **Deploying** ke tanggal dan waktu, yang berarti bahwa fungsi Anda telah direplikasi. Untuk memverifikasi bahwa fungsi bekerja, ikuti langkah-langkah di bagian berikutnya. ## Langkah 5: Verifikasi bahwa fungsi berjalan Sekarang setelah Anda membuat fungsi Lambda dan mengonfigurasi pemicu untuk menjalankannya untuk CloudFront distribusi, periksa untuk memastikan bahwa fungsi tersebut memenuhi apa yang Anda harapkan. Dalam contoh ini, kami memeriksa header HTTP yang CloudFront kembali, untuk memastikan bahwa judul keamanan ditambahkan. **Untuk memverifikasi bahwa fungsi Lambda@Edge Anda menambahkan header keamanan** 1. Dalam peramban, masukkan URL untuk file dalam buket S3. Misalnya, Anda mungkin menggunakan URL yang serupa dengan `https://d111111abcdef8.cloudfront.net/image.jpg`. Untuk informasi selengkapnya tentang nama CloudFront domain yang akan digunakan dalam URL file, lihat[Sesuaikan format URL untuk file di CloudFront](LinkFormat.md). 1. Buka bilah alat Pengembang Web browser Anda. Misalnya, di jendela browser Anda di Chrome, buka menu konteks (klik kanan), lalu pilih **Periksa**. 1. Pilih **Jaringan** tab. 1. Muat ulang halaman untuk menampilkan citra Anda, lalu pilih permintaan HTTP di panel kiri. Anda melihat header HTTP yang ditampilkan dalam panel terpisah. 1. Lihat daftar header HTTP untuk memverifikasi bahwa header keamanan yang diharapkan disertakan dalam daftar. Misalnya, Anda mungkin melihat header yang mirip dengan yang ditampilkan di screenshot berikut. ![\[Daftar header HTTP dengan header keamanan yang diharapkan disorot.\]](http://docs.aws.amazon.com/id_id/AmazonCloudFront/latest/DeveloperGuide/images/lambda-at-edge-security-headers-list.png) Jika header keamanan disertakan dalam daftar header Anda, bagus\$1 Anda telah berhasil membuat fungsi Lambda@Edge pertama Anda. Jika CloudFront mengembalikan kesalahan atau ada masalah lain, lanjutkan ke langkah berikutnya untuk memecahkan masalah. ## Langkah 6: Memecahkan masalah Jika CloudFront mengembalikan kesalahan atau tidak menambahkan header keamanan seperti yang diharapkan, Anda dapat menyelidiki eksekusi fungsi Anda dengan melihat CloudWatch Log. Pastikan untuk menggunakan log yang disimpan di AWS lokasi yang paling dekat dengan lokasi di mana fungsi dijalankan. Misalnya, jika Anda melihat file dari London, coba ubah Wilayah dalam CloudWatch konsol ke Eropa (London). **Untuk memeriksa CloudWatch log untuk fungsi Lambda @Edge Anda** 1. Masuk ke Konsol Manajemen AWS dan buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Perubahan **Wilayah** ke lokasi yang ditampilkan saat Anda melihat file di browser Anda. Di sinilah fungsi beroperasi. 1. Di panel kiri, pilih **Log** untuk melihat log untuk distribusi Anda. Untuk informasi selengkapnya, lihat [Pantau CloudFront metrik dengan Amazon CloudWatch](monitoring-using-cloudwatch.md). ## Langkah 7: Bersihkan sumber daya contoh Anda Jika Anda membuat bucket dan CloudFront distribusi Amazon S3 hanya untuk tutorial ini, hapus AWS sumber daya yang Anda alokasikan sehingga Anda tidak lagi dikenakan biaya. Setelah Anda menghapus AWS sumber daya, konten apa pun yang Anda tambahkan tidak lagi tersedia. **Tugas** + [Hapus ember S3](#lambda-edge-how-it-works-tutorial-delete-bucket) + [Hapus fungsi Lambda](#lambda-edge-how-it-works-tutorial-delete-function) + [Hapus CloudFront distribusi](#lambda-edge-how-it-works-tutorial-delete-distribution) ### Hapus ember S3 Sebelum Anda menghapus buket Amazon S3, pastikan pembuatan log dinonaktifkan untuk buket. Jika tidak, AWS terus menulis log ke bucket Anda saat Anda menghapusnya. **Untuk menonaktifkan pembuatan log untuk bucket** 1. Buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 1. Pilih keranjang Anda, lalu pilih **Properti**. 1. Dari **Properti**, pilih **Pencatatan**. 1. Hapus kotak centang **Diaktifkan**. 1. Pilih **Simpan**. Sekarang, Anda dapat menghapus bucket Anda. Untuk informasi selengkapnya, lihat [Menghapus bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html) di *Panduan Pengguna Konsol Layanan Penyimpanan Sederhana Amazon*. ### Hapus fungsi Lambda Untuk instruksi untuk menghapus asosiasi fungsi Lambda dan opsional fungsi itu sendiri, lihat. [Hapus fungsi dan replika Lambda @Edge](lambda-edge-delete-replicas.md) ### Hapus CloudFront distribusi Sebelum Anda menghapus CloudFront distribusi, Anda harus menonaktifkannya. Distribusi yang dinonaktifkan tidak lagi berfungsi, dan tidak dikenakan biaya. Anda dapat mengaktifkan distribusi yang dinonaktifkan kapan saja. Setelah Anda menghapus distribusi yang dinonaktifkan, maka tidak lagi tersedia. **Untuk menonaktifkan dan menghapus CloudFront distribusi** 1. Buka CloudFront konsol di[https://console.aws.amazon.com/cloudfront/v4/home](https://console.aws.amazon.com/cloudfront/v4/home). 1. Pilih distribusi yang ingin Anda nonaktifkan, lalu pilih **Nonaktifkan**. 1. Saat diminta untuk mengonfirmasi, pilih **Ya, Nonaktifkan**. 1. Pilih distribusi yang dinonaktifkan, lalu pilih **Hapus**. 1. Saat diminta konfirmasi, pilih **Ya, Hapus**. ## Informasi Terkait Sekarang, setelah Anda memiliki gagasan dasar tentang cara kerja fungsi Lambda@Edge, pelajari lebih lanjut dengan membaca hal berikut: + [Lambda @Edge contoh fungsi](lambda-examples.md) + [Praktik Terbaik Desain Lambda @Edge](https://aws.amazon.com/blogs/networking-and-content-delivery/lambdaedge-design-best-practices/) + [Mengurangi Latensi dan Menggeser Komputasi ke Edge dengan Lambda @Edge](https://aws.amazon.com/blogs/networking-and-content-delivery/reducing-latency-and-shifting-compute-to-the-edge-with-lambdaedge/) # Siapkan izin dan peran IAM untuk Lambda @Edge Untuk mengonfigurasi Lambda @Edge, Anda harus memiliki izin dan peran IAM berikut untuk: AWS Lambda + [Izin IAM](#lambda-edge-permissions-required) — Izin ini memungkinkan Anda membuat fungsi Lambda dan mengaitkannya dengan distribusi Anda. CloudFront + [Peran eksekusi fungsi Lambda (peran](#lambda-edge-permissions-function-execution) IAM) — Prinsipal layanan Lambda mengasumsikan peran ini untuk menjalankan fungsi Anda. + [Peran terkait layanan untuk Lambda @Edge](#using-service-linked-roles-lambda-edge) — Peran terkait layanan memungkinkan spesifik untuk Layanan AWS mereplikasi fungsi Lambda ke dan mengaktifkan penggunaan file log. Wilayah AWS CloudWatch CloudFront ## Izin IAM diperlukan untuk mengaitkan fungsi Lambda @Edge dengan distribusi CloudFront Selain izin IAM yang Anda perlukan untuk Lambda, Anda memerlukan izin berikut untuk mengaitkan fungsi Lambda dengan distribusi: CloudFront + `lambda:GetFunction`— Memberikan izin untuk mendapatkan informasi konfigurasi untuk fungsi Lambda Anda dan URL yang telah ditentukan sebelumnya untuk mengunduh file `.zip` yang berisi fungsi tersebut. + `lambda:EnableReplication*`— Memberikan izin ke kebijakan sumber daya sehingga layanan replikasi Lambda bisa mendapatkan kode fungsi dan konfigurasi. + `lambda:DisableReplication*`— Memberikan izin ke kebijakan sumber daya sehingga layanan replikasi Lambda dapat menghapus fungsi. **penting** Anda harus menambahkan tanda bintang (`*`) di akhir `lambda:EnableReplication*` dan `lambda:DisableReplication*` tindakan. + Untuk sumber daya, tentukan ARN dari versi fungsi yang ingin Anda jalankan ketika suatu CloudFront peristiwa terjadi, seperti contoh berikut: `arn:aws:lambda:us-east-1:123456789012:function:TestFunction:2` + `iam:CreateServiceLinkedRole`— Memberikan izin untuk membuat peran terkait layanan yang digunakan Lambda @Edge untuk mereplikasi fungsi Lambda. CloudFront Setelah Anda mengonfigurasi Lambda @Edge untuk pertama kalinya, peran terkait layanan akan dibuat secara otomatis untuk Anda. Anda tidak perlu menambahkan izin ini ke distribusi lain yang menggunakan Lambda @Edge. + `cloudfront:UpdateDistribution`atau `cloudfront:CreateDistribution` — Memberikan izin untuk memperbarui atau membuat distribusi. Untuk informasi selengkapnya, lihat topik berikut: + [Identity and Access Management untuk Amazon CloudFront](security-iam.md) + *Izin [akses sumber daya Lambda di Panduan Pengembang](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role)AWS Lambda * ## Peran eksekusi fungsi untuk prinsipal layanan Anda harus membuat peran IAM yang dapat diasumsikan oleh kepala sekolah `lambda.amazonaws.com` dan `edgelambda.amazonaws.com` layanan ketika mereka menjalankan fungsi Anda. **Tip** Saat membuat fungsi di konsol Lambda, Anda dapat memilih untuk membuat peran eksekusi baru dengan menggunakan templat AWS kebijakan. Langkah ini *secara otomatis* menambahkan izin Lambda @Edge yang diperlukan untuk menjalankan fungsi Anda. Lihat [Langkah 5 dalam Tutorial: Membuat fungsi Lambda @Edge sederhana](lambda-edge-how-it-works-tutorial.md#lambda-edge-how-it-works-tutorial-create-function). Untuk informasi selengkapnya tentang membuat peran IAM secara manual, lihat [Membuat peran dan melampirkan kebijakan (konsol)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions_create-policies.html) di Panduan Pengguna *IAM*. **Example Contoh: Kebijakan kepercayaan peran** Anda dapat menambahkan peran ini di bawah tab **Trust Relationship** di konsol IAM. Jangan tambahkan kebijakan ini di bawah tab **Izin**. **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com", "edgelambda.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] } ``` *Untuk informasi selengkapnya tentang izin yang perlu Anda berikan ke peran eksekusi, lihat Izin [akses sumber daya Lambda](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role) di AWS Lambda Panduan Pengembang.* **Catatan** Secara default, setiap kali CloudFront peristiwa memicu fungsi Lambda, data ditulis CloudWatch ke Log. Jika Anda ingin menggunakan log ini, peran eksekusi memerlukan izin untuk menulis data ke CloudWatch Log. Anda dapat menggunakan standar AWSLambdaBasicExecutionRole untuk memberikan izin ke peran eksekusi. Untuk informasi selengkapnya tentang CloudWatch Log, lihat[Log fungsi tepi](edge-functions-logs.md). Jika kode fungsi Lambda Anda mengakses AWS sumber daya lain, seperti membaca objek dari bucket S3, peran eksekusi memerlukan izin untuk melakukan tindakan tersebut. ## Peran terkait layanan untuk Lambda @Edge [Lambda @Edge menggunakan peran terkait layanan IAM.](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) Peran yang terhubung dengan layanan adalah jenis peran IAM unik yang terhubung langsung ke layanan. Peran yang ditautkan dengan layanan ditentukan sebelumnya oleh layanan dan mencakup semua izin yang diperlukan layanan untuk menghubungi layanan AWS lainnya atas nama Anda. Lambda @Edge menggunakan peran terkait layanan IAM berikut: + **AWSServiceRoleForLambdaReplicator**— Lambda @Edge menggunakan peran ini untuk memungkinkan Lambda @Edge mereplikasi fungsi ke. Wilayah AWS Saat Anda pertama kali menambahkan pemicu Lambda @Edge CloudFront, peran bernama dibuat AWSServiceRoleForLambdaReplicator secara otomatis untuk memungkinkan Lambda @Edge mereplikasi fungsi. Wilayah AWS Peran ini diperlukan untuk menggunakan fungsi Lambda @Edge. ARN untuk AWSServiceRoleForLambdaReplicator peran tersebut terlihat seperti contoh berikut: `arn:aws:iam::123456789012:role/aws-service-role/replicator.lambda.amazonaws.com/AWSServiceRoleForLambdaReplicator` + **AWSServiceRoleForCloudFrontLogger**— CloudFront menggunakan peran ini untuk mendorong file log ke dalam CloudWatch. Anda dapat menggunakan file log untuk men-debug kesalahan validasi Lambda @Edge. AWSServiceRoleForCloudFrontLoggerPeran dibuat secara otomatis saat Anda menambahkan asosiasi fungsi Lambda @Edge CloudFront untuk memungkinkan mendorong file log kesalahan Lambda @Edge ke. CloudWatch ARN untuk AWSServiceRoleForCloudFrontLogger peran yang terlihat seperti ini: `arn:aws:iam::account_number:role/aws-service-role/logger.cloudfront.amazonaws.com/AWSServiceRoleForCloudFrontLogger` Peran yang terhubung dengan layanan memudahkan pengaturan dan penggunaan Lambda@Edge karena Anda tidak perlu menambahkan izin yang diperlukan secara manual. Lambda@Edge mendefinisikan izin peran yang terhubung ke layanan, dan hanya Lambda@Edge yang dapat memegang peran tersebut. Izin yang ditentukan mencakup kebijakan kepercayaan dan kebijakan izin. Kebijakan izin tidak dapat dilampirkan ke entitas IAM lainnya. Anda harus menghapus sumber daya terkait CloudFront atau Lambda @Edge sebelum dapat menghapus peran terkait layanan. Ini membantu melindungi sumber daya Lambda @Edge Anda sehingga Anda tidak menghapus peran terkait layanan yang masih diperlukan untuk mengakses sumber daya aktif. Untuk mengetahui informasi selengkapnya tentang peran terkait layanan, lihat [Peran terkait layanan untuk CloudFront](security_iam_service-with-iam.md#security_iam_service-with-iam-roles-service-linked). ### Izin peran terkait layanan untuk Lambda @Edge Lambda @Edge menggunakan dua peran terkait layanan, bernama dan. **AWSServiceRoleForLambdaReplicator**AWSServiceRoleForCloudFrontLogger**** Bagian berikut menjelaskan izin untuk masing-masing peran ini. **Contents** + [Izin peran terkait layanan untuk replikator Lambda](#slr-permissions-lambda-replicator) + [Izin peran terkait layanan untuk logger CloudFront](#slr-permissions-cloudfront-logger) #### Izin peran terkait layanan untuk replikator Lambda Peran terkait layanan ini memungkinkan Lambda mereplikasi fungsi Lambda @Edge. Wilayah AWS Peran terkait layanan AWSServiceRoleForLambdaReplicator memercayai layanan `replicator.lambda.amazonaws.com` untuk menjalankan peran. Kebijakan izin peran memungkinkan Lambda@Edge menyelesaikan tindakan berikut pada sumber daya yang ditentukan: + `lambda:CreateFunction` pada `arn:aws:lambda:*:*:function:*` + `lambda:DeleteFunction` pada `arn:aws:lambda:*:*:function:*` + `lambda:DisableReplication` pada `arn:aws:lambda:*:*:function:*` + `iam:PassRole` pada `all AWS resources` + `cloudfront:ListDistributionsByLambdaFunction` pada `all AWS resources` #### Izin peran terkait layanan untuk logger CloudFront Peran terkait layanan ini memungkinkan CloudFront untuk mendorong file log ke dalam CloudWatch sehingga Anda dapat men-debug kesalahan validasi Lambda @Edge. Peran terkait layanan AWSServiceRoleForCloudFrontLogger memercayai layanan `logger.cloudfront.amazonaws.com` untuk menjalankan peran. Kebijakan izin peran memungkinkan Lambda @Edge menyelesaikan tindakan berikut pada sumber daya yang ditentukan: `arn:aws:logs:*:*:log-group:/aws/cloudfront/*` + `logs:CreateLogGroup` `` + `logs:CreateLogStream` + `logs:PutLogEvents` Anda harus mengonfigurasi izin untuk mengizinkan entitas IAM (seperti pengguna, grup, atau peran) untuk menghapus peran yang ditautkan oleh layanan Lambda@Edge. Untuk informasi selengkapnya, lihat [Izin peran terkait layanan](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) dalam *Panduan Pengguna IAM*. ### Membuat peran terkait layanan untuk Lambda @Edge Anda biasanya tidak membuat peran terkait layanan secara manual untuk Lambda@Edge. Layanan ini membuat peran untuk Anda secara otomatis dalam skenario berikut: + Saat pertama kali membuat pemicu, layanan akan membuat AWSServiceRoleForLambdaReplicator peran (jika belum ada). Peran ini memungkinkan Lambda untuk mereplikasi fungsi Lambda @Edge ke. Wilayah AWS Jika Anda menghapus peran layanan yang ditautkan, peran tersebut akan dibuat lagi saat Anda menambahkan pemicu baru untuk Lambda@Edge dalam distribusi. + Saat Anda memperbarui atau membuat CloudFront distribusi yang memiliki asosiasi Lambda @Edge, layanan akan membuat AWSServiceRoleForCloudFrontLogger peran (jika peran tersebut belum ada). Peran ini memungkinkan CloudFront untuk mendorong file log Anda ke CloudWatch. Jika Anda menghapus peran terkait layanan, peran akan dibuat lagi saat Anda memperbarui atau membuat CloudFront distribusi yang memiliki asosiasi Lambda @Edge. Untuk membuat peran terkait layanan ini secara manual, Anda dapat menjalankan perintah AWS Command Line Interface (AWS CLI) berikut: **Untuk membuat AWSServiceRoleForLambdaReplicator peran** + Jalankan perintah berikut. ``` aws iam create-service-linked-role --aws-service-name replicator.lambda.amazonaws.com ``` **Untuk membuat AWSServiceRoleForCloudFrontLogger peran** + Jalankan perintah berikut. ``` aws iam create-service-linked-role --aws-service-name logger.cloudfront.amazonaws.com ``` ### Mengedit peran terkait layanan Lambda @Edge Lambda @Edge tidak mengizinkan Anda mengedit AWSServiceRoleForLambdaReplicator atau peran yang ditautkan AWSServiceRoleForCloudFrontLogger layanan. Setelah layanan membuat peran terkait layanan, Anda tidak dapat mengubah nama peran karena berbagai entitas mungkin mereferensikan peran tersebut. Namun, Anda dapat menggunakan IAM untuk mengedit deskripsi peran. Untuk informasi selengkapnya, lihat [Mengedit peran terkait layanan](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) dalam *Panduan Pengguna IAM*. ### Didukung Wilayah AWS untuk peran terkait layanan Lambda @Edge CloudFront mendukung penggunaan peran terkait layanan untuk Lambda @Edge sebagai berikut: Wilayah AWS + AS Timur (Virginia Utara)–`us-east-1` + AS Timur (Ohio)–`us-east-2` + AS Barat (California Utara)–`us-west-1` + AS Barat (Oregon)–`us-west-2` + Asia Pasifik (Mumbai)–`ap-south-1` + Asia Pasifik (Seoul)–`ap-northeast-2` + Asia Pasifik (Singapura)–`ap-southeast-1` + Asia Pasifik (Sydney)–`ap-southeast-2` + Asia Pasifik (Tokyo) – `ap-northeast-1` + Eropa (Frankfurt) – `eu-central-1` + Eropa (Irlandia)–`eu-west-1` + Eropa (London) – `eu-west-2` + Amerika Selatan (São Paulo) – `sa-east-1` # Tulis dan buat fungsi Lambda @Edge Untuk menggunakan Lambda @Edge, Anda *menulis* kode untuk fungsi Anda AWS Lambda . Untuk membantu Anda menulis fungsi Lambda @Edge, lihat sumber daya berikut: + [Struktur acara Lambda @Edge](lambda-event-structure.md)— Memahami struktur acara yang akan digunakan dengan Lambda @Edge. + [Lambda @Edge contoh fungsi](lambda-examples.md)— Contoh fungsi, seperti A/B pengujian dan menghasilkan pengalihan HTTP. Model pemrograman untuk menggunakan Node.js atau Python dengan Lambda @Edge sama dengan menggunakan Lambda dalam file. Wilayah AWS*Untuk informasi selengkapnya, lihat [Membangun fungsi Lambda dengan Node.js](https://docs.aws.amazon.com/lambda/latest/dg/lambda-nodejs.html) atau Membangun [fungsi Lambda dengan Python](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html) di Panduan Pengembang.AWS Lambda * Dalam fungsi Lambda @Edge Anda, sertakan `callback` parameter dan kembalikan objek yang berlaku untuk peristiwa permintaan atau respons: + **Minta acara** – Sertakan `cf.request` keberatan dalam respons. Jika Anda menghasilkan respons, sertakan `cf.response` keberatan dalam respons. Untuk informasi selengkapnya, lihat [Hasilkan respons HTTP dalam pemicu permintaan](lambda-generating-http-responses.md#lambda-generating-http-responses-in-requests). + **Peristiwa tanggapan** – Sertakan `cf.response` keberatan dalam respons. Setelah Anda menulis kode Anda sendiri atau menggunakan salah satu contoh, Anda kemudian membuat fungsi di Lambda. Untuk membuat fungsi atau mengedit yang sudah ada, lihat topik berikut: **Topics** + [Buat fungsi Lambda @Edge](lambda-edge-create-in-lambda-console.md) + [Edit fungsi Lambda](lambda-edge-edit-function.md) *Setelah Anda membuat fungsi di Lambda, Anda mengatur Lambda untuk menjalankan fungsi berdasarkan CloudFront peristiwa tertentu, yang disebut pemicu.* Untuk informasi selengkapnya, lihat [Tambahkan pemicu untuk fungsi Lambda @Edge](lambda-edge-add-triggers.md). # Buat fungsi Lambda @Edge AWS Lambda Untuk mengatur menjalankan fungsi Lambda yang didasarkan pada CloudFront peristiwa, ikuti prosedur ini. **Untuk membuat fungsi Lambda@Edge** 1. Masuk ke Konsol Manajemen AWS dan buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Jika Anda sudah memiliki satu atau beberapa fungsi Lambda, pilih **Buat fungsi**. Jika Anda tidak memiliki fungsi apa pun, pilih **Mulai Sekarang**. 1. Pada daftar Wilayah di bagian atas halaman, pilih **AS Timur (N. Virginia)**. 1. Buat fungsi menggunakan kode Anda sendiri atau buat fungsi dimulai dengan CloudFront cetak biru. + Untuk membuat fungsi menggunakan kode Anda sendiri, pilih **Penulis dari awal**. + **Untuk menampilkan daftar cetak biru CloudFront, masukkan **cloudfront** di bidang filter, lalu pilih Enter.** Jika Anda menemukan cetak biru yang ingin digunakan, pilih nama cetak biru tersebut. 1. Di **Informasi dasar** , tentukan nilai-nilai berikut: 1. **Nama** — Masukkan nama untuk fungsi Anda. 1. **Peran** — Untuk memulai dengan cepat, pilih **Buat peran baru dari templat**. Anda juga dapat **memilih Pilih peran yang ada** atau **Buat peran khusus**, lalu ikuti petunjuk untuk melengkapi informasi untuk bagian ini. 1. **Nama peran** — Masukkan nama untuk peran tersebut. 1. **Templat kebijakan** — Pilih izin **Lambda Edge Dasar**. 1. Jika Anda memilih **Penulis dari awal** dalam langkah 4, lompat ke langkah 7. Jika Anda memilih cetak biru di langkah 4, bagian **cloudfront** memungkinkan Anda membuat satu pemicu, yang mengaitkan fungsi ini dengan cache dalam distribusi dan peristiwa. CloudFront CloudFront Kami sarankan Anda memilih **Hapus** pada titik ini, jadi tidak ada pemicu untuk fungsi saat dibuat. Kemudian Anda dapat menambahkan pemicu nanti. **Tip** Kami menyarankan Anda menguji dan men-debug fungsi sebelum menambahkan pemicu. Jika Anda menambahkan pemicu sekarang, fungsi akan berjalan segera setelah Anda membuat fungsi dan selesai mereplikasi ke AWS lokasi di seluruh dunia, dan distribusi yang sesuai diterapkan. 1. Pilih **Buat fungsi**. Lambda membuat dua versi fungsi Anda: \$1LATEST dan Versi 1. Anda dapat mengedit versi \$1LATEST saja, tetapi konsol awalnya menampilkan Versi 1. 1. Untuk mengedit fungsi, pilih **Versi 1** di dekat bagian atas halaman, di bawah ARN untuk fungsi . Lalu, pada **Versi** pilih, pilih **\$1LATEST**. (Jika Anda meninggalkan fungsi dan kemudian kembali, label tombol adalah **Pengukur**.) 1. Di **Konfigurasi** pilih tab yang sesuai **Jenis entri kode**. Kemudian ikuti perintah untuk mengedit atau mengunggah kode Anda. 1. Untuk **Waktu pengoperasian**, pilih nilai berdasarkan kode fungsi Anda. 1. Di **Tanda** , tambahkan tag yang berlaku. 1. Pilih **Tindakan**, lalu pilih **Terbitkan versi baru**. 1. Masukkan deskripsi untuk versi baru fungsi. 1. Pilih **Terbitkan**. 1. Uji dan jalankan debug fungsinya. *Untuk informasi selengkapnya tentang pengujian di konsol Lambda, lihat [Memanggil fungsi Lambda menggunakan konsol di Panduan Pengembang](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html#get-started-invoke-manually).AWS Lambda * 1. Saat Anda siap menjalankan fungsi untuk CloudFront acara, publikasikan versi lain dan edit fungsi untuk menambahkan pemicu. Untuk informasi selengkapnya, lihat [Tambahkan pemicu untuk fungsi Lambda @Edge](lambda-edge-add-triggers.md). # Edit fungsi Lambda Setelah Anda membuat fungsi Lambda @Edge, Anda dapat menggunakan konsol Lambda untuk mengeditnya. **Catatan** Versi asli diberi label \$1LATEST. Anda dapat mengedit versi \$1LATEST saja. Setiap kali Anda mengedit versi \$1LATEST, Anda harus menerbitkan versi bernomor baru. Anda tidak dapat membuat pemicu untuk \$1LATEST. Saat Anda menerbitkan versi baru suatu fungsi, Lambda tidak otomatis menyalin pemicu dari versi sebelumnya ke versi baru. Anda harus mereproduksi pemicu untuk versi baru. Saat Anda menambahkan pemicu untuk suatu CloudFront peristiwa ke suatu fungsi, jika sudah ada pemicu untuk distribusi, perilaku cache, dan peristiwa yang sama untuk versi sebelumnya dari fungsi yang sama, Lambda menghapus pemicu dari versi sebelumnya. Setelah Anda membuat pembaruan pada CloudFront distribusi, seperti menambahkan pemicu, Anda harus menunggu perubahan menyebar ke lokasi tepi sebelum fungsi yang Anda tentukan dalam pemicu akan berfungsi. **Untuk mengedit fungsi Lambda** 1. Masuk ke Konsol Manajemen AWS dan buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Pada daftar Wilayah di bagian atas halaman, pilih **AS Timur (N. Virginia)**. 1. Dalam daftar fungsi, pilih nama fungsi. Secara default, konsol menampilkan versi \$1LATEST. Anda dapat melihat versi sebelumnya (pilih **Pengukur**), tetapi Anda hanya dapat mengedit \$1LATEST. 1. Di **Kode** , untuk **Jenis entri kode**, pilih untuk mengedit kode di browser, mengunggah file .zip, atau mengunggah file dari Amazon S3. 1. Pilih salah satu **Simpan** atau **Simpan dan uji**. 1. Pilih **Tindakan**, dan pilih **Terbitkan versi baru**. 1. Di **Terbitkan versi baru dari \$1LATEST** kotak dialog, masukkan deskripsi versi baru. Uraian ini muncul dalam daftar versi, bersama dengan nomor versi yang dibuat secara otomatis. 1. Pilih **Terbitkan**. Versi baru secara otomatis menjadi versi terbaru. Nomor versi muncul pada **Versi** di sudut kiri atas halaman. **catatan** Jika Anda belum menambahkan pemicu untuk fungsi Anda, lihat[Tambahkan pemicu untuk fungsi Lambda @Edge](lambda-edge-add-triggers.md). 1. Pilih **Pemicu** tab. 1. Pilih **Tambahkan pemicu**. 1. Di **Tambahkan pemicu** kotak dialog, pilih kotak titik-titik, lalu pilih **CloudFront**. **catatan** Jika Anda telah membuat satu atau beberapa pemicu untuk suatu fungsi, CloudFront adalah layanan default. 1. Tentukan nilai berikut untuk menunjukkan kapan Anda ingin fungsi Lambda menjalankan. 1. **ID Distribusi** — Pilih ID distribusi yang ingin Anda tambahkan pemicu. 1. **Perilaku cache** - Pilih perilaku cache yang menentukan objek yang ingin Anda jalankan fungsinya. 1. **CloudFront event** — Pilih CloudFront acara yang menyebabkan fungsi dijalankan. 1. **Aktifkan pemicu dan replikasi** - Pilih kotak centang ini sehingga Lambda mereplikasi fungsi secara global. Wilayah AWS 1. Pilih **Kirim**. 1. Untuk menambahkan lebih banyak pemicu untuk fungsi ini, ulangi langkah 10 hingga 13. *Untuk informasi selengkapnya tentang menguji dan men-debug fungsi di konsol Lambda, [lihat Memanggil fungsi Lambda menggunakan](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html#get-started-invoke-manually) konsol di Panduan Pengembang.AWS Lambda * Saat Anda siap menjalankan fungsi untuk CloudFront acara, publikasikan versi lain dan edit fungsi untuk menambahkan pemicu. Untuk informasi selengkapnya, lihat [Tambahkan pemicu untuk fungsi Lambda @Edge](lambda-edge-add-triggers.md). # Tambahkan pemicu untuk fungsi Lambda @Edge Pemicu Lambda @Edge adalah salah satu kombinasi dari CloudFront distribusi, perilaku cache, dan peristiwa yang menyebabkan fungsi dijalankan. Misalnya, Anda dapat membuat pemicu yang menyebabkan fungsi dijalankan saat CloudFront menerima permintaan dari penampil untuk perilaku cache tertentu yang Anda siapkan untuk distribusi Anda. Anda dapat menentukan satu atau lebih CloudFront pemicu. **Tip** Saat membuat CloudFront distribusi, Anda menentukan setelan yang memberi tahu CloudFront cara merespons saat menerima permintaan yang berbeda. Pengaturan default disebut *perilaku cache default* untuk distribusi. Anda dapat mengatur perilaku cache tambahan yang menentukan cara CloudFront merespons dalam keadaan tertentu, misalnya, saat menerima permintaan untuk jenis file tertentu. Untuk informasi selengkapnya, lihat [Pengaturan perilaku cache](DownloadDistValuesCacheBehavior.md). Saat pertama kali membuat fungsi Lambda, Anda hanya dapat menentukan *satu* pemicu. Anda dapat menambahkan lebih banyak pemicu ke fungsi yang sama nanti dengan menggunakan konsol Lambda atau dengan mengedit distribusi di CloudFront konsol. + Konsol Lambda berfungsi dengan baik jika Anda ingin menambahkan lebih banyak pemicu ke fungsi untuk distribusi yang sama. CloudFront + CloudFront Konsol bisa lebih baik jika Anda ingin menambahkan pemicu untuk beberapa distribusi karena lebih mudah untuk menemukan distribusi yang ingin Anda perbarui. Anda juga dapat memperbarui CloudFront pengaturan lain secara bersamaan. **Topics** + [CloudFront peristiwa yang dapat memicu fungsi Lambda @Edge](lambda-cloudfront-trigger-events.md) + [Pilih acara untuk memicu fungsi](lambda-how-to-choose-event.md) + [Tambahkan pemicu ke fungsi Lambda @Edge](lambda-edge-add-triggers-console.md) # CloudFront peristiwa yang dapat memicu fungsi Lambda @Edge Untuk setiap perilaku cache dalam CloudFront distribusi Amazon, Anda dapat menambahkan hingga empat pemicu (asosiasi) yang menyebabkan fungsi Lambda dijalankan saat peristiwa CloudFront tertentu terjadi. CloudFront pemicu dapat didasarkan pada salah satu dari empat CloudFront peristiwa, seperti yang ditunjukkan pada diagram berikut. ![\[Grafik konseptual yang menunjukkan bagaimana peristiwa CloudFront pemicu untuk fungsi Lambda terintegrasi dengan. CloudFront\]](http://docs.aws.amazon.com/id_id/AmazonCloudFront/latest/DeveloperGuide/images/cloudfront-events-that-trigger-lambda-functions.png) CloudFront Peristiwa yang dapat digunakan untuk memicu fungsi Lambda @Edge adalah sebagai berikut: **Permintaan penampil** Fungsi dijalankan ketika CloudFront menerima permintaan dari penampil, sebelum memeriksa untuk melihat apakah objek yang diminta ada dalam CloudFront cache. Fungsi tidak dijalankan dalam kasus berikut: + Saat mengambil halaman kesalahan kustom. + Ketika CloudFront secara otomatis mengalihkan permintaan HTTP ke HTTPS (ketika nilai [Kebijakan protokol penampil](DownloadDistValuesCacheBehavior.md#DownloadDistValuesViewerProtocolPolicy) adalah **Redirect HTTP ke** HTTPS). **Permintaan asal** Fungsi dijalankan *hanya* ketika CloudFront meneruskan permintaan ke asal Anda. Ketika objek yang diminta ada di CloudFront cache, fungsi tidak dijalankan. **Respons asal** Fungsi mengeksekusi setelah CloudFront menerima respon dari asal dan sebelum cache objek dalam respon. Perhatikan bahwa fungsi menjalankan bahkan jika kesalahan dikembalikan dari asal. Fungsi tidak dijalankan dalam kasus berikut: + Ketika file yang diminta dalam CloudFront cache dan tidak kedaluwarsa. + Saat respons dihasilkan dari fungsi yang dipicu oleh peristiwa permintaan asal. **Respons penampil** Fungsi menjalankan sebelum mengembalikan file yang diminta ke penampil. Perhatikan bahwa fungsi dijalankan terlepas dari apakah file sudah dalam CloudFront cache. Fungsi tidak dijalankan dalam kasus berikut: + Saat asal mengembalikan kode status HTTP sebesar 400 atau lebih. + Saat halaman kesalahan kustom dikembalikan. + Saat respons dihasilkan dari fungsi yang dipicu oleh peristiwa permintaan penampil. + Ketika CloudFront secara otomatis mengalihkan permintaan HTTP ke HTTPS (ketika nilai [Kebijakan protokol penampil](DownloadDistValuesCacheBehavior.md#DownloadDistValuesViewerProtocolPolicy) adalah **Redirect HTTP ke** HTTPS). Saat Anda menambahkan beberapa pemicu ke perilaku cache yang sama, Anda dapat menggunakannya untuk menjalankan fungsi yang sama atau menjalankan fungsi yang berbeda untuk setiap pemicu. Anda juga dapat mengaitkan fungsi yang sama dengan lebih dari satu distribusi. **catatan** Ketika sebuah CloudFront peristiwa memicu eksekusi fungsi Lambda, fungsi harus *selesai* CloudFront sebelum dapat melanjutkan. Misalnya, jika fungsi Lambda dipicu oleh peristiwa permintaan CloudFront penampil, tidak CloudFront akan mengembalikan respons ke penampil atau meneruskan permintaan ke asal hingga fungsi Lambda selesai berjalan. Ini berarti bahwa setiap permintaan yang memicu fungsi Lambda meningkatkan latensi untuk permintaan, jadi Anda ingin fungsi tersebut dijalankan secepat mungkin. # Pilih acara untuk memicu fungsi Saat Anda memutuskan CloudFront acara mana yang ingin Anda gunakan untuk memicu fungsi Lambda, pertimbangkan hal berikut: **Saya CloudFront ingin menyimpan objek yang diubah oleh fungsi Lambda** Untuk cache objek yang telah dimodifikasi oleh fungsi Lambda sehingga CloudFront dapat melayani objek dari lokasi tepi saat diminta berikutnya, gunakan *permintaan asal* atau peristiwa *respons asal*. Ini mengurangi beban dari awal, mengurangi latensi untuk permintaan berikutnya, dan mengurangi biaya dari invoking Lambda@Edge pada permintaan berikutnya. Misalnya, jika Anda ingin menambahkan, menghapus, atau mengubah header untuk objek yang dikembalikan oleh asal dan Anda CloudFront ingin menyimpan hasil cache, gunakan peristiwa respons asal. **Saya ingin fungsi dijalankan untuk setiap permintaan** Untuk menjalankan fungsi untuk setiap permintaan yang CloudFront diterima untuk distribusi, gunakan *permintaan penampil* atau peristiwa *respons penampil*. Permintaan asal dan kejadian respons asal hanya terjadi ketika objek yang diminta tidak di-cache di lokasi tepi dan CloudFront meneruskan permintaan ke asal. **Saya ingin fungsinya mengubah kunci cache** Untuk mengubah nilai yang Anda gunakan sebagai dasar untuk caching, gunakan acara *permintaan penampil*. Misalnya, jika fungsi mengubah URL untuk menyertakan singkatan bahasa pada jalur (misalnya, karena pengguna memilih bahasa dari daftar tarik turun), gunakan acara permintaan penampil: + **URL dalam permintaan penampil** - https://example.com/en/ index.html + **URL ketika permintaan berasal dari alamat IP di Jerman** https://example.com/de/ - index.html Anda juga menggunakan acara permintaan pemirsa jika Anda menyimpan cache berdasarkan cookie atau header permintaan. Jika fungsi mengubah cookie atau header, konfigurasikan CloudFront untuk meneruskan bagian permintaan yang berlaku ke asal. Untuk informasi selengkapnya, lihat topik berikut: + [Konten cache berdasarkan cookie](Cookies.md) + [Konten cache berdasarkan header permintaan](header-caching.md) **Fungsi mempengaruhi respon dari asal** Untuk mengubah permintaan dengan cara yang memengaruhi respons dari asal, gunakan peristiwa *permintaan asal*. Biasanya, sebagian besar peristiwa permintaan pemirsa tidak diteruskan ke asal. CloudFront menanggapi permintaan dengan objek yang sudah ada di cache tepi. Jika fungsi mengubah permintaan berdasarkan peristiwa permintaan asal, CloudFront cache respons ke permintaan asal yang diubah. # Tambahkan pemicu ke fungsi Lambda @Edge Anda dapat menggunakan AWS Lambda konsol atau CloudFront konsol Amazon untuk menambahkan pemicu ke fungsi Lambda @Edge Anda. **penting** Anda dapat membuat pemicu hanya untuk versi bernomor dari fungsi Anda (bukan **\$1LATEST**). ------ #### [ Lambda console ] **Untuk menambahkan pemicu CloudFront acara ke fungsi Lambda @Edge** 1. Masuk ke Konsol Manajemen AWS dan buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Pada daftar Wilayah di bagian atas halaman, pilih **AS Timur (N. Virginia)**. 1. Di **Fungsi** , pilih nama fungsi yang ingin Anda tambahkan pemicunya. 1. Pada halaman **Ikhtisar fungsi**, pilih tab **Versi**. 1. Pilih versi yang ingin Anda tambahkan pemicu. Setelah memilih versi, nama tombol berubah menjadi **Versi: \$1LATEST** atau **Versi:** *nomor versi*. 1. Pilih **Pemicu** tab. 1. Pilih **Tambahkan pemicu**. 1. Untuk **konfigurasi Trigger**, **pilih Pilih sumber****cloudfront**, masukkan, lalu pilih **CloudFront**. **catatan** Jika Anda sudah membuat satu atau lebih pemicu, CloudFront adalah layanan default. 1. Tentukan nilai berikut untuk menunjukkan kapan Anda ingin fungsi Lambda menjalankan. 1. **Distribusi** - Pilih distribusi yang ingin Anda tambahkan pemicu. 1. **Perilaku cache** - Pilih perilaku cache yang menentukan objek yang ingin Anda jalankan fungsinya. **catatan** Jika Anda menentukan `*` untuk perilaku cache, fungsi Lambda menerapkan perilaku cache default. 1. **CloudFront event** — Pilih CloudFront acara yang menyebabkan fungsi dijalankan. 1. **Sertakan isi** - Pilih kotak centang ini jika Anda ingin mengakses badan permintaan dalam fungsi Anda. 1. **Konfirmasikan penerapan ke Lambda** @Edge — Pilih kotak centang ini AWS Lambda sehingga mereplikasi fungsi ke global. Wilayah AWS 1. Pilih **Tambahkan**. Fungsi mulai memproses permintaan untuk CloudFront peristiwa yang ditentukan saat CloudFront distribusi yang diperbarui diterapkan. Untuk menentukan apakah distribusi diterapkan, pilih **Distribusi** dalam panel navigasi. Ketika distribusi diterapkan, nilai kolom **Status** untuk distribusi berubah dari **Deploying ke tanggal dan waktu penerapan**. ------ #### [ CloudFront console ] **Untuk menambahkan pemicu CloudFront acara ke fungsi Lambda @Edge** 1. Dapatkan ARN dari fungsi Lambda yang ingin Anda tambahkan pemicu untuk: 1. Masuk ke Konsol Manajemen AWS dan buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Pada daftar Wilayah di bagian atas halaman, pilih **AS Timur (N. Virginia)**. 1. Dalam daftar fungsi, pilih nama fungsi yang ingin Anda tambahkan pemicunya. 1. Pada halaman **Ikhtisar fungsi**, pilih tab **Versi**, dan pilih versi bernomor yang ingin Anda tambahkan pemicu. 1. Pilih **Salin ARN** tombol untuk menyalin ARN ke clipboard Anda. ARN untuk fungsi Lambda terlihat seperti ini: `arn:aws:lambda:us-east-1:123456789012:function:TestFunction:2` Nomor di bagian akhir (**2** dalam contoh ini) adalah nomor versi fungsi. 1. Buka CloudFront konsol di[https://console.aws.amazon.com/cloudfront/v4/home](https://console.aws.amazon.com/cloudfront/v4/home). 1. Dalam daftar distribusi, pilih ID distribusi yang ingin Anda tambahkan pemicunya. 1. Pilih **Perilaku** tab. 1. Pilih perilaku cache yang ingin Anda tambahkan pemicu, lalu pilih **Edit**. 1. Untuk **asosiasi Fungsi**, dalam daftar **Jenis fungsi**, pilih **Lambda @Edge** untuk saat Anda ingin menjalankan fungsi: untuk permintaan penampil, respons penampil, permintaan asal, atau respons asal. Untuk informasi selengkapnya, lihat [Pilih acara untuk memicu fungsi](lambda-how-to-choose-event.md). 1. Di kotak teks **Fungsi ARN/Nama**, tempel ARN dari fungsi Lambda yang ingin Anda jalankan saat acara yang dipilih terjadi. Ini adalah nilai yang Anda salin dari konsol Lambda. 1. Pilih **Sertakan** isi jika Anda ingin mengakses badan permintaan dalam fungsi Anda. Jika Anda hanya ingin mengganti badan permintaan, Anda tidak perlu memilih opsi ini. 1. Untuk menjalankan fungsi yang sama untuk lebih banyak jenis acara, ulangi langkah 6 dan 7. 1. Pilih **Simpan perubahan**. 1. Untuk menambahkan pemicu ke lebih banyak perilaku cache untuk distribusi ini, ulangi langkah 5 hingga 10. Fungsi mulai memproses permintaan untuk CloudFront peristiwa yang ditentukan saat CloudFront distribusi yang diperbarui diterapkan. Untuk menentukan apakah distribusi diterapkan, pilih **Distribusi** dalam panel navigasi. Saat distribusi diterapkan, nilai kolom **Status** untuk distribusi berubah dari **Deploying ke waktu dan tanggal penerapan**. ------ # Uji dan debug fungsi Lambda @Edge Penting untuk menguji kode fungsi Lambda @Edge Anda secara mandiri, untuk memastikan bahwa itu menyelesaikan tugas yang dimaksudkan, dan untuk melakukan pengujian integrasi, untuk memastikan bahwa fungsi berfungsi dengan benar. CloudFront Selama pengujian integrasi atau setelah fungsi Anda di-deploy, Anda mungkin perlu men-debug CloudFront kesalahan, seperti kesalahan HTTP 5xx. Kesalahan dapat menjadi respons tidak valid yang dikembalikan dari fungsi Lambda, kesalahan eksekusi saat fungsi dipicu, atau kesalahan akibat perotasian eksekusi oleh layanan Lambda. Bagian-bagian dalam topik ini membagikan strategi untuk menentukan jenis kegagalan mana yang menjadi masalahnya, kemudian langkah-langkah yang dapat Anda ambil untuk memperbaiki masalah. **catatan** Saat Anda meninjau file CloudWatch log atau metrik saat Anda memecahkan masalah kesalahan, ketahuilah bahwa kesalahan tersebut ditampilkan atau disimpan di lokasi Wilayah AWS terdekat dengan lokasi di mana fungsi dijalankan. Jadi, jika Anda memiliki situs web atau aplikasi web dengan pengguna di Britania Raya, dan Anda memiliki fungsi Lambda yang terkait dengan distribusi Anda, misalnya, Anda harus mengubah Wilayah untuk CloudWatch melihat metrik atau file log untuk London. Wilayah AWS Untuk informasi selengkapnya, lihat [Tentukan Wilayah Lambda @Edge](#lambda-edge-testing-debugging-determine-region). **Topics** + [Uji fungsi Lambda @Edge Anda](#lambda-edge-testing-debugging-test-function) + [Identifikasi kesalahan fungsi Lambda @Edge di CloudFront](#lambda-edge-identifying-function-errors) + [Memecahkan masalah respons fungsi Lambda @Edge yang tidak valid (kesalahan validasi)](#lambda-edge-testing-debugging-troubleshooting-invalid-responses) + [Memecahkan masalah kesalahan eksekusi fungsi Lambda @Edge](#lambda-edge-testing-debugging-execution-errors) + [Tentukan Wilayah Lambda @Edge](#lambda-edge-testing-debugging-determine-region) + [Tentukan apakah akun Anda mendorong log ke CloudWatch](#lambda-edge-testing-debugging-cloudwatch-logs-enabled) ## Uji fungsi Lambda @Edge Anda Terdapat dua langkah untuk menguji fungsi Lambda Anda: pengujian mandiri dan pengujian integrasi. **Uji fungsionalitas mandiri** Sebelum Anda menambahkan fungsi Lambda CloudFront, pastikan untuk menguji fungsionalitas terlebih dahulu dengan menggunakan kemampuan pengujian di konsol Lambda atau dengan menggunakan metode lain. *Untuk informasi selengkapnya tentang pengujian di konsol Lambda, lihat [Memanggil fungsi Lambda menggunakan konsol di Panduan Pengembang](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html#get-started-invoke-manually).AWS Lambda * **Uji operasi fungsi Anda di CloudFront** Penting untuk menyelesaikan pengujian integrasi, di mana fungsi Anda dikaitkan dengan distribusi dan berjalan berdasarkan CloudFront peristiwa. Pastikan bahwa fungsi dipicu untuk acara yang tepat, dan mengembalikan respons yang valid dan benar untuk CloudFront. Misalnya, pastikan bahwa struktur acara sudah benar, bahwa hanya header yang valid yang disertakan, dan sebagainya. Saat Anda mengulangi pengujian integrasi dengan fungsi Anda di konsol Lambda, lihat langkah-langkah dalam tutorial Lambda @Edge saat Anda memodifikasi kode atau mengubah CloudFront pemicu yang memanggil fungsi Anda. Misalnya, pastikan bahwa Anda bekerja dalam versi bernomor dari fungsi Anda, seperti yang dijelaskan dalam langkah tutorial ini: [Langkah 4: Tambahkan CloudFront pemicu untuk menjalankan fungsi](lambda-edge-how-it-works-tutorial.md#lambda-edge-how-it-works-tutorial-add-trigger). Saat Anda membuat perubahan dan menerapkannya, ketahuilah bahwa fungsi dan CloudFront pemicu Anda yang diperbarui akan memakan waktu beberapa menit untuk mereplikasi di semua Wilayah. Ini biasanya memerlukan waktu beberapa menit, tetapi dapat memakan waktu hingga 15 menit. Anda dapat memeriksa untuk melihat apakah replikasi selesai dengan pergi ke CloudFront konsol dan melihat distribusi Anda. **Untuk memeriksa apakah replikasi Anda telah selesai digunakan** 1. Buka CloudFront konsol di[https://console.aws.amazon.com/cloudfront/v4/home](https://console.aws.amazon.com/cloudfront/v4/home). 1. Pilih nama distribusi. 1. Periksa status distribusi yang akan diubah dari **Sedang Berlangsung** kembali ke **Diterapkan**, yang berarti fungsi Anda telah direplikasi. Kemudian ikuti langkah-langkah di bagian berikutnya untuk memverifikasi bahwa fungsi berfungsi. Ketahuilah bahwa pengujian di konsol hanya memvalidasi logika fungsi Anda, dan tidak menerapkan kuota layanan apa pun (sebelumnya dikenal sebagai batas) yang khusus untuk Lambda @Edge. ## Identifikasi kesalahan fungsi Lambda @Edge di CloudFront Setelah Anda memverifikasi bahwa logika fungsi Anda berfungsi dengan benar, Anda mungkin masih melihat kesalahan HTTP 5xx saat fungsi Anda berjalan. CloudFront Kesalahan HTTP 5xx dapat dikembalikan karena berbagai alasan, yang dapat mencakup kesalahan fungsi Lambda atau masalah lain di dalamnya. CloudFront + Jika Anda menggunakan fungsi Lambda @Edge, Anda dapat menggunakan grafik di CloudFront konsol untuk membantu melacak penyebab kesalahan, lalu bekerja untuk memperbaikinya. Misalnya, Anda dapat melihat apakah kesalahan HTTP 5xx disebabkan oleh CloudFront atau oleh fungsi Lambda, dan kemudian, untuk fungsi tertentu, Anda dapat melihat file log terkait untuk menyelidiki masalah tersebut. + Untuk memecahkan masalah kesalahan HTTP secara umum di CloudFront, lihat langkah-langkah pemecahan masalah dalam topik berikut:. [Memecahkan masalah kode status respons kesalahan di CloudFront](troubleshooting-response-errors.md) ### Apa yang menyebabkan kesalahan fungsi Lambda @Edge di CloudFront Ada beberapa alasan mengapa fungsi Lambda dapat menyebabkan kesalahan HTTP 5xx, dan langkah-langkah pemecahan masalah yang harus Anda ambil bergantung pada jenis kesalahan. Kesalahan dapat dikategorikan sebagai berikut: **Kesalahan eksekusi fungsi Lambda** Kesalahan eksekusi terjadi ketika CloudFront tidak mendapatkan respons dari Lambda karena ada pengecualian yang tidak tertangani dalam fungsi atau ada kesalahan dalam kode. Misalnya, jika kode menyertakan callback(Kesalahan). **Respons fungsi Lambda yang tidak valid dikembalikan ke CloudFront** Setelah fungsi berjalan, CloudFront menerima respons dari Lambda. Kesalahan dikembalikan jika struktur objek tanggapan tidak sesuai dengan [Struktur acara Lambda @Edge](lambda-event-structure.md), atau respons berisi header yang tidak valid atau kolom tidak valid lainnya. **Eksekusi di CloudFront dibatasi karena kuota layanan Lambda (sebelumnya dikenal sebagai batas)** Eksekusi throttle layanan Lambda di setiap Wilayah, dan menghasilkan kesalahan jika Anda melebihi kuota. Untuk informasi selengkapnya, lihat [Kuotas di Lambda@Edge](cloudfront-limits.md#limits-lambda-at-edge). ### Cara menentukan jenis kegagalan Untuk membantu Anda memutuskan di mana harus fokus saat Anda men-debug dan bekerja untuk menyelesaikan kesalahan yang dikembalikan oleh CloudFront, akan sangat membantu untuk mengidentifikasi CloudFront mengapa mengembalikan kesalahan HTTP. Untuk memulai, Anda dapat menggunakan grafik yang disediakan di bagian **Pemantauan** CloudFront konsol di Konsol Manajemen AWS. Untuk informasi selengkapnya tentang melihat grafik di bagian **Pemantauan** CloudFront konsol, lihat[Pantau CloudFront metrik dengan Amazon CloudWatch](monitoring-using-cloudwatch.md). Grafik berikut akan sangat membantu ketika Anda ingin melacak apakah kesalahan dikembalikan oleh asal atau fungsi Lambda, dan untuk mempersempit jenis masalah ketika itu adalah kesalahan dari fungsi Lambda. **Grafik harga kesalahan** Salah satu grafik yang dapat Anda lihat pada **Ikhtisar** untuk setiap distribusi Anda adalah **Tingkat kesalahan** grafik. Grafik ini menampilkan tingkat kesalahan sebagai persentase dari total permintaan yang datang ke distribusi Anda. Grafik menunjukkan tingkat kesalahan total, total 4xx kesalahan, total 5xx kesalahan, dan total 5xx kesalahan dari fungsi Lambda. Berdasarkan jenis dan volume kesalahan, Anda dapat mengambil langkah untuk menyelidiki dan memecahkan masalah penyebab. ![\[Grafik tingkat kesalahan untuk CloudFront distribusi\]](http://docs.aws.amazon.com/id_id/AmazonCloudFront/latest/DeveloperGuide/images/Distribution-error-rate-pct-full.png) + Jika Anda melihat kesalahan Lambda, Anda dapat menyelidiki lebih lanjut dengan melihat jenis kesalahan tertentu yang dikembalikan oleh fungsi tersebut. **Kesalahan Lambda@Edge** tab menyertakan grafik yang mengategorikan kesalahan fungsi berdasarkan jenis untuk membantu Anda menemukan masalah dari fungsi tertentu. + Jika Anda melihat CloudFront kesalahan, Anda dapat memecahkan masalah dan bekerja untuk memperbaiki kesalahan asal atau mengubah konfigurasi Anda CloudFront . Untuk informasi selengkapnya, lihat [Memecahkan masalah kode status respons kesalahan di CloudFront](troubleshooting-response-errors.md). **Grafik kesalahan pelaksanaan dan respons fungsi tidak valid** **Kesalahan Lambda@Edge** tab mencakup grafik yang mengkategorikan kesalahan Lambda@Edge untuk distribusi tertentu, berdasarkan jenis. Misalnya, satu grafik menunjukkan semua kesalahan eksekusi oleh Wilayah AWS. Untuk mempermudah pemecahan masalah, Anda dapat mencari masalah tertentu dengan membuka dan memeriksa file log untuk fungsi tertentu berdasarkan Wilayah. **Untuk melihat file log untuk fungsi tertentu menurut Wilayah** 1. **Pada tab **kesalahan Lambda @Edge**, di bawah **fungsi Lambda @Edge** Terkait, pilih nama fungsi, lalu pilih Lihat metrik.** 1. Selanjutnya, pada halaman dengan nama fungsi Anda, di sudut kanan atas, pilih **Lihat log fungsi**, lalu pilih Wilayah. Misalnya, jika Anda melihat masalah dalam grafik **Kesalahan** untuk Wilayah AS Barat (Oregon), pilih Wilayah itu dari daftar tarik-turun. Ini membuka CloudWatch konsol Amazon. 1. Di CloudWatch konsol untuk Wilayah itu, di bawah **Aliran log**, pilih aliran log untuk melihat peristiwa fungsi tersebut. Selain itu, baca bagian berikut dalam bab ini untuk rekomendasi lebih lanjut tentang pemecahan masalah dan memperbaiki kesalahan. **Grafik trotel** **Kesalahan Lambda@Edge** juga mencakup **Trotel** grafik. Terkadang, layanan Lambda merombak invokasi fungsi Anda dengan basis per Wilayah, jika Anda mencapai kuota konkurensi regional (sebelumnya disebut batas). Jika Anda melihat kesalahan yang melebihi, fungsi Anda telah mencapai kuota yang dikenakan layanan Lambda pada eksekusi di Wilayah. Untuk informasi lebih lanjut, termasuk cara meminta peningkatan kuota, lihat [Kuotas di Lambda@Edge](cloudfront-limits.md#limits-lambda-at-edge). ![\[Grafik throttle untuk eksekusi fungsi Lambda @Edge.\]](http://docs.aws.amazon.com/id_id/AmazonCloudFront/latest/DeveloperGuide/images/Lambda-throttles-page.png) Sebagai contoh tentang cara menggunakan informasi ini dalam mengatasi masalah kesalahan HTTP, lihat [Empat langkah untuk melakukan debug pengiriman konten Anda di AWS](https://aws.amazon.com/blogs/networking-and-content-delivery/four-steps-for-debugging-your-content-delivery-on-aws/). ## Memecahkan masalah respons fungsi Lambda @Edge yang tidak valid (kesalahan validasi) Jika Anda mengidentifikasi bahwa masalah Anda adalah kesalahan validasi Lambda, itu berarti fungsi Lambda Anda mengembalikan respons yang tidak valid. CloudFront Ikuti panduan di bagian ini untuk mengambil langkah-langkah untuk meninjau fungsi Anda dan memastikan bahwa respons Anda sesuai dengan CloudFront persyaratan. CloudFront memvalidasi respons dari fungsi Lambda dengan dua cara: + **Respon Lambda harus sesuai dengan struktur objek yang diperlukan.** Contoh struktur objek yang buruk mencakup hal berikut: JSON yang tidak dapat dipisahkan, kolom wajib yang hilang, dan objek tidak valid dalam respons. Untuk informasi lebih lanjut, lihat [Struktur acara Lambda @Edge](lambda-event-structure.md). + **Respons harus menyertakan hanya nilai objek yang valid.** Kesalahan akan terjadi jika respons mencakup objek valid tetapi memiliki nilai yang tidak didukung. Contohnya meliputi yang berikut ini: menambahkan atau memperbarui header yang masuk daftar tidak diizinkan atau hanya baca (lihat [Pembatasan pada fungsi edge](edge-functions-restrictions.md)), melebihi ukuran izi maksimum (lihat dalam *Pembatasan Ukuran Respons yang Dihasilkan* dalam topic [Kesalahan](lambda-generating-http-responses.md#lambda-generating-http-responses-errors) Lambda@Edge) dan karakter atau nilai tidak valid (lihat [Struktur acara Lambda @Edge](lambda-event-structure.md)). Ketika Lambda mengembalikan respons yang tidak valid CloudFront, pesan kesalahan ditulis ke file log yang CloudFront mendorong ke CloudWatch Wilayah tempat fungsi Lambda dijalankan. Ini adalah perilaku default untuk mengirim file log CloudWatch ketika ada respons yang tidak valid. Namun, jika Anda mengaitkan fungsi Lambda CloudFront sebelum fungsionalitas dirilis, fungsi tersebut mungkin tidak diaktifkan untuk fungsi Anda. Untuk informasi lebih lanjut, lihat *Tentukan apakah Akun Anda Mendorong Log ke CloudWatch* nanti dalam topik. CloudFront mendorong file log ke Wilayah yang sesuai dengan tempat fungsi Anda dijalankan, di grup log yang terkait dengan distribusi Anda. Grup log memiliki format berikut:`/aws/cloudfront/LambdaEdge/DistributionId`, di *DistributionId* mana ID distribusi Anda. Untuk menentukan Wilayah tempat Anda dapat menemukan file CloudWatch log, lihat *Menentukan Wilayah Lambda @Edge* nanti dalam topik ini. Jika kesalahan dapat direproduksi, Anda dapat membuat permintaan baru yang menghasilkan kesalahan dan kemudian menemukan id permintaan dalam CloudFront respons gagal (`X-Amz-Cf-Id`header) untuk menemukan satu kegagalan dalam file log. Entri file log mencakup informasi yang dapat membantu Anda mengidentifikasi mengapa kesalahan dikembalikan, dan juga mencantumkan id permintaan Lambda yang sesuai sehingga Anda dapat menganalisis akar masalah dalam konteks permintaan tunggal. Jika kesalahan terputus-putus, Anda dapat menggunakan log CloudFront akses untuk menemukan id permintaan untuk permintaan yang gagal, dan kemudian mencari CloudWatch log untuk pesan kesalahan yang sesuai. Untuk informasi lebih lanjut, lihat bagian sebelumnya, *Menentukan Jenis Kegagalan*. ## Memecahkan masalah kesalahan eksekusi fungsi Lambda @Edge Jika masalahnya adalah kesalahan eksekusi Lambda, akan sangat membantu untuk membuat pernyataan logging untuk fungsi Lambda, untuk menulis pesan ke file CloudWatch log yang memantau eksekusi fungsi Anda CloudFront dan menentukan apakah berfungsi seperti yang diharapkan. Kemudian Anda dapat mencari pernyataan tersebut di file CloudWatch log untuk memverifikasi bahwa fungsi Anda berfungsi. **catatan** Bahkan jika Anda belum mengubah fungsi Lambda@Edge Anda, pembaruan pada lingkungan pelaksanaan fungsi Lambda dapat memengaruhinya dan dapat mengembalikan kesalahan pelaksanaan. Untuk informasi tentang pengujian dan migrasi ke versi yang lebih baru, lihat [Pembaruan mendatang untuk lingkungan eksekusi AWS Lambda dan AWS Lambda @Edge](https://aws.amazon.com/blogs/compute/upcoming-updates-to-the-aws-lambda-execution-environment/). ## Tentukan Wilayah Lambda @Edge Untuk melihat Wilayah tempat fungsi Lambda @Edge Anda menerima lalu lintas, lihat metrik untuk fungsi di CloudFront konsol di. Konsol Manajemen AWS Metrik ditampilkan untuk setiap AWS Wilayah. Di halaman yang sama, Anda dapat memilih Wilayah dan melihat file log untuk Wilayah tersebut sehingga Anda dapat menyelidiki masalah. Anda harus meninjau file CloudWatch log di AWS Wilayah yang benar untuk melihat file log yang dibuat saat CloudFront menjalankan fungsi Lambda Anda. Untuk informasi selengkapnya tentang melihat grafik di bagian **Pemantauan** CloudFront konsol, lihat[Pantau CloudFront metrik dengan Amazon CloudWatch](monitoring-using-cloudwatch.md). ## Tentukan apakah akun Anda mendorong log ke CloudWatch Secara default, CloudFront memungkinkan pencatatan respons fungsi Lambda yang tidak valid, dan mendorong file log ke CloudWatch dengan menggunakan salah satu file. [Peran terkait layanan untuk Lambda @Edge](lambda-edge-permissions.md#using-service-linked-roles-lambda-edge) Jika Anda memiliki fungsi Lambda @Edge yang Anda tambahkan CloudFront sebelum fitur log respons fungsi Lambda yang tidak valid dirilis, logging diaktifkan saat Anda memperbarui konfigurasi Lambda @Edge Anda, misalnya, dengan menambahkan pemicu. CloudFront Anda dapat memverifikasi bahwa mendorong file log ke CloudWatch diaktifkan untuk akun Anda dengan melakukan hal berikut: + **Periksa untuk melihat apakah log muncul CloudWatch** — Pastikan Anda melihat di Wilayah tempat fungsi Lambda @Edge dijalankan. Untuk informasi selengkapnya, lihat [Tentukan Wilayah Lambda @Edge](#lambda-edge-testing-debugging-determine-region). + **Tentukan apakah peran terkait layanan terkait ada di akun Anda di IAM —** Anda harus memiliki peran `AWSServiceRoleForCloudFrontLogger` IAM di akun Anda. Untuk informasi selengkapnya tentang peran ini, silakan lihat [Peran terkait layanan untuk Lambda @Edge](lambda-edge-permissions.md#using-service-linked-roles-lambda-edge). # Hapus fungsi dan replika Lambda @Edge Anda dapat menghapus fungsi Lambda @Edge hanya ketika replika fungsi telah dihapus oleh. CloudFront Replika fungsi Lambda secara otomatis dihapus dalam situasi berikut: + Setelah Anda menghapus kaitan terakhir untuk fungsi dari semua CloudFront distribusi. Jika lebih dari satu distribusi menggunakan fungsi, replika akan dihapus hanya setelah Anda menghapus asosiasi fungsi dari distribusi terakhir. + Setelah Anda menghapus distribusi terakhir yang terkait dengan fungsi tersebut. Replika biasanya dihapus dalam beberapa jam. Anda tidak dapat menghapus replika fungsi Lambda@Edge secara manual. Ini membantu mencegah situasi di mana replika dihapus yang masih digunakan, yang akan mengakibatkan kesalahan. **Awas** Jangan membuat aplikasi yang menggunakan replika fungsi Lambda @Edge di luar. CloudFront Replika ini dihapus saat asosiasi mereka dengan distribusi dihapus, atau saat distribusi itu sendiri dihapus. Replika yang aplikasi luarnya mungkin akan dihapus tanpa peringatan, sehingga menyebabkannya gagal. **Untuk menghapus asosiasi fungsi Lambda @Edge dari distribusi CloudFront** 1. Masuk ke Konsol Manajemen AWS dan buka CloudFront konsol di[https://console.aws.amazon.com/cloudfront/v4/home](https://console.aws.amazon.com/cloudfront/v4/home). 1. Pilih ID distribusi dengan asosiasi fungsi Lambda @Edge yang ingin Anda hapus. 1. Pilih **Perilaku** tab. 1. **Pilih perilaku cache yang memiliki asosiasi fungsi Lambda @Edge yang ingin Anda hapus, lalu pilih Edit.** 1. Di bawah **Asosiasi fungsi**, **Jenis fungsi**, pilih **Tidak ada asosiasi** untuk menghapus asosiasi fungsi Lambda @Edge. 1. Pilih **Simpan perubahan**. Setelah menghapus asosiasi fungsi Lambda @Edge dari CloudFront distribusi, Anda dapat menghapus fungsi Lambda atau versi fungsi dari. AWS Lambda Tunggu beberapa jam setelah menghapus asosiasi fungsi sehingga replika fungsi Lambda @Edge dapat dibersihkan. Setelah itu, Anda dapat menghapus fungsi dengan menggunakan konsol Lambda,, AWS CLI Lambda API, atau SDK. AWS Anda juga dapat menghapus *versi* tertentu dari fungsi Lambda jika versi tersebut tidak memiliki CloudFront distribusi yang terkait dengannya. Setelah menghapus semua asosiasi untuk versi fungsi Lambda, tunggu beberapa jam. Kemudian Anda dapat menghapus versi fungsi. # Struktur acara Lambda @Edge Topik berikut menjelaskan objek peristiwa permintaan dan respons yang CloudFront diteruskan ke fungsi Lambda @Edge saat dipicu. **Topics** + [Pemilihan asal dinamis](#lambda-event-content-based-routing) + [Permintaan acara](#lambda-event-structure-request) + [Peristiwa respon](#lambda-event-structure-response) ## Pemilihan asal dinamis Anda dapat menggunakan [pola jalur dalam perilaku cache](DownloadDistValuesCacheBehavior.md#DownloadDistValuesPathPattern) untuk merutekan permintaan ke asal berdasarkan jalur dan nama objek yang diminta, seperti `images/*.jpg`. Menggunakan Lambda@Edge, Anda juga dapat merutekan permintaan ke asal berdasarkan karakteristik lain, seperti nilai-nilai dalam header permintaan. Ada sejumlah cara agar pemilihan asal dinamis ini dapat berguna. Misalnya, Anda dapat mendistribusikan permintaan lintas asal-usul di area geografis yang berbeda untuk membantu menyeimbangkan beban global. Atau Anda dapat secara selektif merutekan permintaan ke asal-usul berbeda yang masing-masing melayani fungsi tertentu: penanganan bot, optimalisasi SEO, autentikasi, dan sebagainya. Untuk contoh kode yang mendemonstrasikan cara menggunakan fitur ini, lihat [Pemilihan asal dinamis berbasis konten - contoh](lambda-examples.md#lambda-examples-content-based-routing-examples). Dalam peristiwa permintaan CloudFront asal, `origin` objek dalam struktur peristiwa berisi informasi tentang asal yang akan diarahkan ke permintaan, berdasarkan pola jalur. Anda dapat memperbarui nilai di `origin` mengajukan keberatan untuk mengirimkan permintaan ke negara asal yang berbeda. Saat Anda memperbarui `origin` objek, Anda tidak perlu menentukan asal dalam distribusi. Anda juga dapat mengganti objek asal Amazon S3 dengan objek asal kustom, dan sebaliknya. Namun, Anda hanya dapat menentukan asal tunggal per permintaan; asal kustom atau asal Amazon S3, tetapi tidak keduanya. ## Permintaan acara Topik berikut menunjukkan struktur objek yang CloudFront diteruskan ke fungsi Lambda untuk acara [permintaan penampil dan asal](lambda-cloudfront-trigger-events.md). Contoh-contoh ini menunjukkan `GET` tanpa isi. Berikut ini contoh adalah daftar semua bidang yang mungkin muncul dalam peristiwa permintaan penampil dan asal. **Topics** + [Contoh permintaan penampil](#example-viewer-request) + [Contoh permintaan asal](#example-origin-request) + [Permintaan bidang acara](#request-event-fields) ### Contoh permintaan penampil Contoh berikut menunjukkan objek acara permintaan penampil. ``` { "Records": [ { "cf": { "config": { "distributionDomainName": "d111111abcdef8.cloudfront.net", "distributionId": "EDFDVBD6EXAMPLE", "eventType": "viewer-request", "requestId": "4TyzHTaYWb1GX1qTfsHhEqV6HUDd_BzoBZnwfnvQc_1oF26ClkoUSEQ==" }, "request": { "clientIp": "203.0.113.178", "headers": { "host": [ { "key": "Host", "value": "d111111abcdef8.cloudfront.net" } ], "user-agent": [ { "key": "User-Agent", "value": "curl/7.66.0" } ], "accept": [ { "key": "accept", "value": "*/*" } ] }, "method": "GET", "querystring": "", "uri": "/" } } } ] } ``` ### Contoh permintaan asal Contoh berikut menunjukkan objek peristiwa permintaan asal usul. ``` { "Records": [ { "cf": { "config": { "distributionDomainName": "d111111abcdef8.cloudfront.net", "distributionId": "EDFDVBD6EXAMPLE", "eventType": "origin-request", "requestId": "4TyzHTaYWb1GX1qTfsHhEqV6HUDd_BzoBZnwfnvQc_1oF26ClkoUSEQ==" }, "request": { "clientIp": "203.0.113.178", "headers": { "x-forwarded-for": [ { "key": "X-Forwarded-For", "value": "203.0.113.178" } ], "user-agent": [ { "key": "User-Agent", "value": "Amazon CloudFront" } ], "via": [ { "key": "Via", "value": "2.0 2afae0d44e2540f472c0635ab62c232b.cloudfront.net (CloudFront)" } ], "host": [ { "key": "Host", "value": "example.org" } ], "cache-control": [ { "key": "Cache-Control", "value": "no-cache" } ] }, "method": "GET", "origin": { "custom": { "customHeaders": {}, "domainName": "example.org", "keepaliveTimeout": 5, "path": "", "port": 443, "protocol": "https", "readTimeout": 30, "responseCompletionTimeout": 30, "sslProtocols": [ "TLSv1", "TLSv1.1", "TLSv1.2" ] } }, "querystring": "", "uri": "/" } } } ] } ``` ### Permintaan bidang acara Meminta data objek peristiwa dimuat dalam dua subobjek: `config` (`Records.cf.config`) and `request` (`Records.cf.request`). Daftar berikut menjelaskan setiap bidang subobject. #### Bidang di objek konfigurasi Daftar berikut menjelaskan bidang dalam `config` objek (`Records.cf.config`). **`distributionDomainName` (hanya baca)** Nama domain distribusi yang terkait dengan permintaan. **`distributionID` (hanya baca)** ID distribusi yang terkait dengan permintaan. **`eventType` (hanya baca)** Jenis pemicu yang terkait dengan permintaan: `viewer-request` atau`origin-request`. **`requestId` (hanya baca)** String terenkripsi yang secara unik mengidentifikasi permintaan. viewer-to-CloudFront `requestId`Nilai juga muncul di log CloudFront akses sebagai`x-edge-request-id`. Untuk informasi selengkapnya, lihat [Akses log (log standar)](AccessLogs.md) dan [Bidang file log](standard-logs-reference.md#BasicDistributionFileFormat). #### Bidang di objek permintaan Daftar berikut menjelaskan bidang dalam `request` objek (`Records.cf.request`). **`clientIp` (hanya baca)** Alamat IP penampil yang membuat permintaan. Jika penampil menggunakan proksi HTTP atau penyeimbang beban untuk mengirim permintaan, nilainya adalah alamat IP proksi atau pengimbang beban. **header (baca/tulis)** Header pada permintaan. Perhatikan hal-hal berikut: + Kunci dalam `headers` objek adalah versi huruf kecil nama header HTTP standar. Menggunakan tombol huruf kecil memberi Anda akses huruf kecil ke nilai header. + Setiap objek header (misalnya, `headers["accept"]` atau `headers["host"]`) adalah serangkaian pasangan utama-nilai. Untuk header tertentu, larik berisi satu pasangan nilai kunci untuk setiap nilai dalam permintaan. + `key`berisi nama case-sensitive dari header seperti yang muncul dalam permintaan HTTP; misalnya,,, `Host``User-Agent`, `X-Forwarded-For``Cookie`, dan sebagainya. + `value` berisi nilai header sebagaimana muncul dalam permintaan HTTP. + Ketika fungsi Lambda Anda menambahkan atau memodifikasi header permintaan dan Anda tidak menyertakan bidang header`key`, Lambda @Edge secara otomatis menyisipkan header `key` menggunakan nama header yang Anda berikan. Terlepas dari bagaimana Anda telah memformat nama header, kunci header yang dimasukkan secara otomatis diformat dengan kapitalisasi awal untuk setiap bagian, dipisahkan oleh tanda hubung (-). Misalnya, Anda dapat menambahkan header seperti berikut, tanpa header `key`: ``` "user-agent": [ { "value": "ExampleCustomUserAgent/1.X.0" } ] ``` Dalam contoh ini, Lambda@Edge secara otomatis memasukkan `"key": "User-Agent"`. Untuk informasi tentang pembatasan penggunaan header, lihat [Pembatasan pada fungsi edge](edge-functions-restrictions.md). **`method` (hanya baca)** Metode HTTP permintaan. **`querystring` (baca/tulis)** String kueri, jika ada, dalam permintaan. Jika permintaan tidak menyertakan string kueri, objek acara masih menyertakan `querystring` dengan nilai kosong. Untuk informasi selengkapnya tentang string kueri, lihat [Konten cache berdasarkan parameter string kueri](QueryStringParameters.md). **`uri` (baca/tulis)** Jalur relatif objek yang diminta. Jika fungsi Lambda Anda memodifikasi `uri` perhatikan hal-hal berikut: + `uri` nilai harus dimulai dengan garis miring ke depan (/). + Saat fungsi mengubah `uri` yang mengubah objek yang diminta oleh penampil. + Ketika fungsi mengubah `uri` nilai, *itu tidak* mengubah perilaku cache untuk permintaan atau asal permintaan yang dikirim. **`body` (baca/tulis)** Isi permintaan HTTP. `body` struktur dapat memuat kolom berikut: **`inputTruncated` (hanya baca)** Bendera Boolean yang menunjukkan apakah tubuh dijejali Lambda@Edge. Untuk informasi selengkapnya, lihat [Pembatasan pada isi permintaan dengan opsi sertakan isi](lambda-at-edge-function-restrictions.md#lambda-at-edge-restrictions-request-body). **`action` (baca/tulis)** Tindakan yang ingin Anda lakukan dengan tubuh. Opsi untuk `action` adalah sebagai berikut: + `read-only:` Ini adalah pengaturan default. Saat mengembalikan respons dari fungsi Lambda, jika `action` adalah hanya baca, Lambda@Edge mengabaikan setiap perubahan pada `encoding` atau `data`. + `replace:` Tentukan ini saat Anda ingin mengganti tubuh yang dikirim ke asal. **`encoding` (baca/tulis)** Pengodean untuk tubuh. Saat Lambda@Edge mengekspos tubuh ke fungsi Lambda, pertama-tama tubuh berubah menjadi base64-encoding. Jika Anda memilih `replace` untuk `action` untuk mengganti tubuh, Anda dapat memilih untuk menggunakan pengodean `base64` (default) atau `text`. Jika Anda menentukan `encoding` sebagai `base64` tetapi tubuh tidak validbase64, CloudFront mengembalikan kesalahan. **`data` (baca/tulis)** Isi konten permintaan. **`origin` (baca/tulis) (hanya peristiwa awal)** Asal pengiriman permintaan ke. `origin`Struktur harus berisi *tepat satu asal*, yang dapat berupa asal khusus atau asal Amazon S3. Bergantung pada jenis asal yang Anda tentukan (asal kustom atau Amazon S3), Anda harus menentukan bidang berikut dalam permintaan Anda: **`customHeaders` (baca/tulis) (kustom dan berasal dari Amazon S3)** (Opsional) Anda dapat menyertakan header khusus dengan permintaan dengan menentukan nama header dan pasangan nilai untuk setiap header kustom. Anda tidak dapat menambahkan header yang tidak diizinkan, dan header dengan nama yang sama tidak dapat hadir. `Records.cf.request.headers` [Catatan tentang header permintaan](#request-event-fields-request-headers) juga berlaku untuk header kustom. Untuk informasi lebih lanjut, lihat [Header khusus yang tidak CloudFront dapat ditambahkan ke permintaan asal](add-origin-custom-headers.md#add-origin-custom-headers-denylist) dan [Pembatasan pada fungsi edge](edge-functions-restrictions.md). **`domainName` (baca/tulis) (kustom dan berasal dari Amazon S3)** Nama domain asal. Nama domain tidak bisa kosong. + **Untuk asal kustom** – Tentukan nama domain DNS, seperti `www.example.com`. Nama domain tidak dapat menyertakan titik dua (:), dan tidak bisa menjadi alamat IP. Nama domain dapat terdiri dari hingga 253 karakter. + **Untuk asal Amazon S3** – Tentukan nama domain DNS bucket Amazon S3, seperti `amzn-s3-demo-bucket.s3.eu-west-1.amazonaws.com`. Nama bisa sampai 128 karakter dan harus berupa huruf kecil. **`path` (baca/tulis) (kustom dan berasal dari Amazon S3)** Jalur direktori di tempat asal permintaan harus menemukan konten. Jalur harus dimulai dengan garis miring (/) tetapi tidak boleh diakhiri dengan satu (misalnya, seharusnya tidak diakhiri dengan`example-path/`). Hanya untuk asal kustom, alur harus dienkode URL dan memiliki panjang maksimum 255 karakter. **`keepaliveTimeout` (baca/tulis) (hanya asal sesuai undang-undang)** Berapa lama, dalam hitungan detik, yang CloudFront harus mencoba mempertahankan koneksi ke asal setelah menerima paket terakhir dari respons. Nilainya harus berupa angka dari 1-120, inklusif. **`port` (baca/tulis) (hanya asal sesuai undang-undang)** Port yang CloudFront harus terhubung ke asal kustom Anda. Port harus 80, 443, atau nomor dalam kisaran 1024–65535, termasuk. **`protocol` (baca/tulis) (hanya asal sesuai undang-undang)** Protokol koneksi yang CloudFront harus digunakan saat menghubungkan ke asal Anda. Nilai dapat berupa `http` atau `https`. **`readTimeout` (baca/tulis) (kustom dan berasal dari Amazon S3)** Berapa lama, dalam hitungan detik, CloudFront harus menunggu tanggapan setelah mengirim permintaan ke asal Anda. Ini juga menentukan berapa lama CloudFront harus menunggu setelah menerima paket tanggapan sebelum menerima paket berikutnya. Nilainya harus berupa angka dari 1-120, inklusif. Jika Anda membutuhkan kuota yang lebih tinggi, lihat [Batas waktu respons per asal](cloudfront-limits.md#limits-web-distributions). **`responseCompletionTimeout` (baca/tulis) (kustom dan berasal dari Amazon S3)** Waktu (dalam detik) permintaan dari CloudFront ke asal dapat tetap terbuka dan menunggu tanggapan. Jika respons lengkap tidak diterima dari asal saat ini, CloudFront akhiri koneksi. Nilai untuk `responseCompletionTimeout` harus sama dengan atau lebih besar dari nilai untuk`readTimeout`. Jika Anda menetapkan nilai ini ke 0, itu akan menghapus nilai sebelumnya yang Anda tetapkan dan kembali ke default. Anda juga dapat melakukannya dengan menghapus `responseCompletionTimeout` bidang dari permintaan acara. **`sslProtocols` (baca/tulis) (hanya asal sesuai undang-undang)** SSL/TLS Protokol minimum yang CloudFront dapat digunakan saat membuat koneksi HTTPS dengan asal Anda. Nilai dapat berupa: `TLSv1.2`, `TLSv1.1`, `TLSv1`, atau `SSLv3`. **`authMethod` (baca/tulis) (hanya asal-usul Amazon S3)** Jika Anda menggunakan [identitas akses asal (OAI)](private-content-restricting-access-to-s3.md#private-content-restricting-access-to-s3-oai), setel bidang ini ke`origin-access-identity`. Jika Anda tidak menggunakan OAI, atur ke`none`. Jika Anda mengatur `authMethod` untuk `origin-access-identity`, ada beberapa persyaratan: + Anda harus menentukan `region` (lihat bidang berikut). + Anda harus menggunakan OAI yang sama ketika Anda mengubah permintaan dari satu asal Amazon S3 ke yang lain. + Anda tidak dapat menggunakan OAI saat mengubah permintaan dari asal kustom ke asal Amazon S3. Bidang ini tidak mendukung [kontrol akses asal (OAC)](private-content-restricting-access-to-s3.md). **`region` (baca/tulis) (hanya asal-usul Amazon S3)** AWS Wilayah ember Amazon S3 Anda. Ini hanya diperlukan ketika Anda mengatur `authMethod` untuk `origin-access-identity`. ## Peristiwa respon Topik berikut menunjukkan struktur objek yang CloudFront diteruskan ke fungsi Lambda untuk [penampil dan peristiwa respons asal](lambda-cloudfront-trigger-events.md). Berikut ini contoh adalah daftar semua bidang yang mungkin muncul di penampil dan kejadian respons asal. **Topics** + [Contoh respon asal](#lambda-event-structure-response-origin) + [Contoh respons penampil](#lambda-event-structure-response-viewer) + [Bidang acara respons](#response-event-fields) ### Contoh respon asal Contoh berikut menunjukkan objek peristiwa respons asal usul. ``` { "Records": [ { "cf": { "config": { "distributionDomainName": "d111111abcdef8.cloudfront.net", "distributionId": "EDFDVBD6EXAMPLE", "eventType": "origin-response", "requestId": "4TyzHTaYWb1GX1qTfsHhEqV6HUDd_BzoBZnwfnvQc_1oF26ClkoUSEQ==" }, "request": { "clientIp": "203.0.113.178", "headers": { "x-forwarded-for": [ { "key": "X-Forwarded-For", "value": "203.0.113.178" } ], "user-agent": [ { "key": "User-Agent", "value": "Amazon CloudFront" } ], "via": [ { "key": "Via", "value": "2.0 8f22423015641505b8c857a37450d6c0.cloudfront.net (CloudFront)" } ], "host": [ { "key": "Host", "value": "example.org" } ], "cache-control": [ { "key": "Cache-Control", "value": "no-cache" } ] }, "method": "GET", "origin": { "custom": { "customHeaders": {}, "domainName": "example.org", "keepaliveTimeout": 5, "path": "", "port": 443, "protocol": "https", "readTimeout": 30, "responseCompletionTimeout": 30, "sslProtocols": [ "TLSv1", "TLSv1.1", "TLSv1.2" ] } }, "querystring": "", "uri": "/" }, "response": { "headers": { "access-control-allow-credentials": [ { "key": "Access-Control-Allow-Credentials", "value": "true" } ], "access-control-allow-origin": [ { "key": "Access-Control-Allow-Origin", "value": "*" } ], "date": [ { "key": "Date", "value": "Mon, 13 Jan 2020 20:12:38 GMT" } ], "referrer-policy": [ { "key": "Referrer-Policy", "value": "no-referrer-when-downgrade" } ], "server": [ { "key": "Server", "value": "ExampleCustomOriginServer" } ], "x-content-type-options": [ { "key": "X-Content-Type-Options", "value": "nosniff" } ], "x-frame-options": [ { "key": "X-Frame-Options", "value": "DENY" } ], "x-xss-protection": [ { "key": "X-XSS-Protection", "value": "1; mode=block" } ], "content-type": [ { "key": "Content-Type", "value": "text/html; charset=utf-8" } ], "content-length": [ { "key": "Content-Length", "value": "9593" } ] }, "status": "200", "statusDescription": "OK" } } } ] } ``` ### Contoh respons penampil Contoh berikut menunjukkan objek acara respons penampil. ``` { "Records": [ { "cf": { "config": { "distributionDomainName": "d111111abcdef8.cloudfront.net", "distributionId": "EDFDVBD6EXAMPLE", "eventType": "viewer-response", "requestId": "4TyzHTaYWb1GX1qTfsHhEqV6HUDd_BzoBZnwfnvQc_1oF26ClkoUSEQ==" }, "request": { "clientIp": "203.0.113.178", "headers": { "host": [ { "key": "Host", "value": "d111111abcdef8.cloudfront.net" } ], "user-agent": [ { "key": "User-Agent", "value": "curl/7.66.0" } ], "accept": [ { "key": "accept", "value": "*/*" } ] }, "method": "GET", "querystring": "", "uri": "/" }, "response": { "headers": { "access-control-allow-credentials": [ { "key": "Access-Control-Allow-Credentials", "value": "true" } ], "access-control-allow-origin": [ { "key": "Access-Control-Allow-Origin", "value": "*" } ], "date": [ { "key": "Date", "value": "Mon, 13 Jan 2020 20:14:56 GMT" } ], "referrer-policy": [ { "key": "Referrer-Policy", "value": "no-referrer-when-downgrade" } ], "server": [ { "key": "Server", "value": "ExampleCustomOriginServer" } ], "x-content-type-options": [ { "key": "X-Content-Type-Options", "value": "nosniff" } ], "x-frame-options": [ { "key": "X-Frame-Options", "value": "DENY" } ], "x-xss-protection": [ { "key": "X-XSS-Protection", "value": "1; mode=block" } ], "age": [ { "key": "Age", "value": "2402" } ], "content-type": [ { "key": "Content-Type", "value": "text/html; charset=utf-8" } ], "content-length": [ { "key": "Content-Length", "value": "9593" } ] }, "status": "200", "statusDescription": "OK" } } } ] } ``` ### Bidang acara respons Data objek peristiwa respons dimuat dalam tiga subobjek: `config` (`Records.cf.config`), `request` (`Records.cf.request`), dan `response` (`Records.cf.response`). Untuk informasi lebih lanjut tentang bidang di objek permintaan, lihat [Bidang di objek permintaan](#request-event-fields-request). Daftar berikut menjelaskan bidang dalam `config` dan `response` subobjects. #### Bidang di objek konfigurasi Daftar berikut menjelaskan bidang dalam `config` objek (`Records.cf.config`). **`distributionDomainName` (hanya baca)** Nama domain distribusi yang terkait dengan respons. **`distributionID` (hanya baca)** ID distribusi yang terkait dengan respons. **`eventType` (hanya baca)** Jenis pemicu yang terkait dengan respons: `origin-response` atau`viewer-response`. **`requestId` (hanya baca)** String terenkripsi yang secara unik mengidentifikasi viewer-to-CloudFront permintaan yang terkait dengan respons ini. `requestId`Nilai juga muncul di log CloudFront akses sebagai`x-edge-request-id`. Untuk informasi selengkapnya, lihat [Akses log (log standar)](AccessLogs.md) dan [Bidang file log](standard-logs-reference.md#BasicDistributionFileFormat). #### Bidang di objek respons Daftar berikut menjelaskan bidang dalam `response` objek (`Records.cf.response`). Untuk informasi tentang penggunaan fungsi Lambda@Edge untuk membuat respons HTTP, lihat [Hasilkan respons HTTP dalam pemicu permintaan](lambda-generating-http-responses.md#lambda-generating-http-responses-in-requests). **`headers` (baca/tulis)** Header dalam respons. Perhatikan hal-hal berikut: + Kunci dalam `headers` objek adalah versi huruf kecil nama header HTTP standar. Menggunakan tombol huruf kecil memberi Anda akses huruf kecil ke nilai header. + Setiap objek header (misalnya, `headers["content-type"]` atau `headers["content-length"]`) adalah serangkaian pasangan utama-nilai. Untuk header tertentu, larik berisi satu pasangan nilai kunci untuk setiap nilai dalam respons. + `key`berisi nama case-sensitive header seperti yang muncul dalam respons HTTP; misalnya,,, `Content-Type` `Content-Length``Cookie`, dan sebagainya. + `value` berisi nilai header sebagaimana muncul dalam respons HTTP. + Ketika fungsi Lambda Anda menambahkan atau memodifikasi header respons dan Anda tidak menyertakan bidang header`key`, Lambda @Edge secara otomatis menyisipkan header `key` menggunakan nama header yang Anda berikan. Terlepas dari bagaimana Anda telah memformat nama header, kunci header yang dimasukkan secara otomatis diformat dengan kapitalisasi awal untuk setiap bagian, dipisahkan oleh tanda hubung (-). Misalnya, Anda dapat menambahkan header seperti berikut, tanpa header `key`: ``` "content-type": [ { "value": "text/html;charset=UTF-8" } ] ``` Dalam contoh ini, Lambda@Edge secara otomatis memasukkan `"key": "Content-Type"`. Untuk informasi tentang pembatasan penggunaan header, lihat [Pembatasan pada fungsi edge](edge-functions-restrictions.md). **`status`** Kode status HTTP dari respons. **`statusDescription`** Deskripsi status HTTP untuk respons. # Bekerja dengan permintaan dan tanggapan Untuk menggunakan permintaan dan tanggapan Lambda @Edge, lihat topik berikut: **Topics** + [Gunakan fungsi Lambda @Edge dengan failover asal](#lambda-and-origin-failover) + [Hasilkan respons HTTP dalam pemicu permintaan](#lambda-generating-http-responses-in-requests) + [Perbarui tanggapan HTTP di pemicu respons asal](#lambda-updating-http-responses) + [Akses badan permintaan dengan memilih opsi include body](#lambda-include-body-access) ## Gunakan fungsi Lambda @Edge dengan failover asal Anda dapat menggunakan fungsi Lambda @Edge dengan CloudFront distribusi yang telah Anda atur dengan grup asal, misalnya, untuk failover asal yang Anda konfigurasikan untuk membantu memastikan ketersediaan tinggi. Untuk menggunakan fungsi Lambda dengan kelompok asal, tentukan fungsi dalam permintaan asal atau pemicu respons asal untuk kelompok asal saat Anda membuat perilaku cache. Untuk informasi selengkapnya, lihat berikut ini: + **Buat grup asal:** [Buat grup asal](high_availability_origin_failover.md#concept_origin_groups.creating) + **Bagaimana asal failover bekerja dengan Lambda@Edge:** [Gunakan failover asal dengan fungsi Lambda@Edge](high_availability_origin_failover.md#concept_origin_groups.lambda) ## Hasilkan respons HTTP dalam pemicu permintaan Saat CloudFront menerima permintaan, Anda dapat menggunakan fungsi Lambda untuk menghasilkan respons HTTP yang CloudFront kembali langsung ke penampil tanpa meneruskan respons ke asal. Membuat respons HTTP mengurangi beban pada asal mula, dan biasanya juga mengurangi latensi bagi penampil. Beberapa skenario umum untuk menghasilkan tanggapan HTTP mencakup hal berikut: + Mengembalikan halaman web kecil ke penampil + Mengembalikan kode status HTTP 301 atau 302 untuk mengarahkan pengguna ke halaman web lain + Mengembalikan kode status HTTP 401 ke penampil saat pengguna belum mengautentikasi Fungsi Lambda@Edge dapat menghasilkan respons HTTP saat CloudFront peristiwa yang terjadi: **Peristiwa permintaan penampil** Saat fungsi dipicu oleh peristiwa permintaan penampil, CloudFront mengembalikan respons ke penampil dan tidak menyimpannya di cache. **Acara permintaan asal** Saat fungsi dipicu oleh peristiwa permintaan asal, CloudFront periksa cache tepi untuk respons yang sebelumnya dihasilkan oleh fungsi tersebut. + Jika respons ada di cache, fungsi tidak dijalankan dan CloudFront mengembalikan respons cache ke penampil. + Jika respons tidak ada dalam cache, fungsi akan dijalankan, CloudFront mengembalikan respons ke penampil, dan juga menyimpan datanya. Untuk melihat beberapa kode sampel untuk menghasilkan respons HTTP, lihat [Lambda @Edge contoh fungsi](lambda-examples.md). Anda juga dapat mengganti respons HTTP dalam pemicu respons. Untuk informasi selengkapnya, lihat [Perbarui tanggapan HTTP di pemicu respons asal](#lambda-updating-http-responses). ### Model pemrograman Bagian ini menjelaskan model pemrograman untuk menggunakan Lambda@Edge untuk menghasilkan respons HTTP. **Topics** + [Objek respons](#lambda-generating-http-responses-object) + [Kesalahan](#lambda-generating-http-responses-errors) + [Bidang yang diperlukan](#lambda-generating-http-responses-required-fields) #### Objek respons Tanggapan yang Anda kembalikan sebagai `result` parameter dari `callback` harus memiliki struktur berikut (perhatikan bahwa hanya `status` bidang wajib diisi). ``` const response = { body: 'content', bodyEncoding: 'text' | 'base64', headers: { 'header name in lowercase': [{ key: 'header name in standard case', value: 'header value' }], ... }, status: 'HTTP status code (string)', statusDescription: 'status description' }; ``` Objek respons dapat mencakup nilai-nilai berikut: **`body`** Tubuh, jika ada, yang CloudFront ingin Anda kembalikan dalam respons yang dihasilkan. **`bodyEncoding`** Pengodean untuk nilai yang Anda tentukan dalam `body`. Satu-satunya pengodean yang valid adalah `text` dan `base64`. Jika Anda memasukkan `body` dalam `response` objek tetapi dihilangkan`bodyEncoding`, CloudFront perlakukan tubuh sebagai teks. Jika Anda menentukan `bodyEncoding` sebagai `base64` tetapi bagian tubuh tidak valid dasar64, CloudFront mengembalikan kesalahan. **`headers`** Header yang CloudFront ingin Anda kembalikan dalam respons yang dihasilkan. Perhatikan hal-hal berikut: + Kunci dalam `headers` objek adalah versi huruf kecil nama header HTTP standar. Menggunakan tombol huruf kecil memberi Anda akses huruf kecil ke nilai header. + Setiap header (misalnya, `headers["accept"]` atau `headers["host"]`) adalah serangkaian pasangan kunci. Untuk header tertentu, larik berisi satu pasangan nilai kunci untuk setiap nilai dalam respons yang dihasilkan. + `key` (opsional) adalah nama judul yang peka terhadap kasus sebagaimana muncul dalam permintaan HTTP; misalnya, `accept` atau `host`. + Tentukan `value` sebagai nilai header. + Jika Anda tidak menyertakan bagian kunci header dari pasangan nilai kunci, Lambda@Edge secara otomatis memasukkan kunci header menggunakan nama header yang Anda berikan. Terlepas dari bagaimana Anda telah memformat nama header, kunci header yang disisipkan secara otomatis diformat dengan kapitalisasi awal untuk setiap bagian, dipisahkan oleh tanda hubung (-). Misalnya, Anda dapat menambahkan header seperti berikut, tanpa tombol header: `'content-type': [{ value: 'text/html;charset=UTF-8' }]` Dalam contoh ini, Lambda@Edge membuat tombol header berikut: `Content-Type`. Untuk informasi tentang pembatasan penggunaan header, lihat [Pembatasan pada fungsi edge](edge-functions-restrictions.md). **`status`** Kode status HTTP. Berikan kode status sebagai string. CloudFront menggunakan kode status yang disediakan untuk hal-hal berikut: + Kembalikan dalam respons + Cache di cache CloudFront tepi, ketika respons dihasilkan oleh fungsi yang dipicu oleh peristiwa permintaan asal + Masuk CloudFront [Akses log (log standar)](AccessLogs.md) Jika `status` nilainya tidak antara 200 dan 599, CloudFront mengembalikan kesalahan ke penampil. **`statusDescription`** Deskripsi yang CloudFront ingin Anda kembalikan dalam respons, untuk menyertai kode status HTTP. Anda tidak perlu menggunakan deskripsi standar, seperti `OK` untuk kode status HTTP sebesar 200. #### Kesalahan Berikut ini adalah kemungkinan kesalahan untuk respons HTTP yang dihasilkan. **Respon Berisi Tubuh dan Menentukan 204 (Tidak Ada Konten) untuk Status** Ketika fungsi dipicu oleh permintaan penampil, CloudFront mengembalikan kode status HTTP 502 (Bad Gateway) ke penampil ketika kedua hal berikut ini benar: + Nilai dari `status` adalah 204 (Tidak Ada Konten) + Jawaban mencakup nilai untuk `body` Ini karena Lambda@Edge mengenakan pembatasan opsional yang ditemukan dalam RFC 2616, yang menyatakan bahwa `HTTP 204` respons tidak harus berisi isi pesan. **Pembatasan Ukuran Respons yang Dihasilkan** Ukuran maksimum respons yang dihasilkan oleh fungsi Lambda tergantung pada peristiwa yang memicu fungsi: + **Peristiwa permintaan penampil** – 40 KB + **Acara permintaan asal** – 1 MB Jika respons lebih besar dari ukuran yang diizinkan, CloudFront mengembalikan kode status HTTP 502 (Bad Gateway) ke penampil. #### Bidang yang diperlukan `status` bidang wajib diisi. Semua kolom lain bersifat opsional. ## Perbarui tanggapan HTTP di pemicu respons asal Saat CloudFront menerima respons HTTP dari server asal, jika ada pemicu respons asal yang terkait dengan perilaku cache, Anda dapat memodifikasi respons HTTP untuk mengganti apa yang dikembalikan dari asal. Beberapa skenario umum untuk memperbarui respons HTTP mencakup hal berikut: + Mengubah status untuk mengatur kode status HTTP 200 dan membuat konten tubuh statis untuk kembali ke penampil ketika asal mengembalikan kode status kesalahan (4xx atau 5xx). Untuk kode sampel, lihat [Contoh: Gunakan pemicu respons asal untuk memperbarui kode status kesalahan ke 200](lambda-examples.md#lambda-examples-custom-error-static-body). + Mengubah status untuk mengatur kode status HTTP 301 atau HTTP 302, untuk mengarahkan pengguna ke situs web lain saat asal mengembalikan kode status kesalahan (4xx atau 5xx). Untuk kode sampel, lihat [Contoh: Gunakan pemicu respons asal untuk memperbarui kode status kesalahan ke 302](lambda-examples.md#lambda-examples-custom-error-new-site). **catatan** Fungsi harus mengembalikan nilai status antara `200` dan `599` (inklusif), jika tidak CloudFront mengembalikan kesalahan ke penampil. Anda juga dapat mengganti respons HTTP di penampil dan peristiwa permintaan asal. Untuk informasi selengkapnya, lihat [Hasilkan respons HTTP dalam pemicu permintaan](#lambda-generating-http-responses-in-requests). Saat Anda bekerja dengan respons HTTP, Lambda @Edge tidak mengekspos badan yang dikembalikan oleh server asal ke pemicu respons asal. Anda dapat membuat badan konten statis dengan mengaturnya ke nilai yang diinginkan, atau menghapus tubuh di dalam fungsi dengan mengatur nilai yang akan kosong. Jika Anda tidak memperbarui bidang isi dalam fungsi Anda, badan asli yang dikembalikan oleh server asal dikembalikan ke penampil. ## Akses badan permintaan dengan memilih opsi include body Anda dapat memilih untuk menggunakan Lambda@Edge mengekspos tubuh dalam permintaan metode HTTP yang dapat ditulis (POST, PUT, DELETE, dan seterusnya), sehingga Anda dapat mengaksesnya dalam fungsi Lambda Anda. Anda dapat memilih akses hanya-baca, atau Anda dapat menentukan bahwa Anda akan mengganti isi. Untuk mengaktifkan opsi ini, pilih **Sertakan Tubuh** saat membuat CloudFront untuk fungsi Anda yang digunakan untuk permintaan pemirsa atau acara permintaan asal. Untuk informasi lebih lanjut, lihat [Tambahkan pemicu untuk fungsi Lambda @Edge](lambda-edge-add-triggers.md), atau untuk mempelajari penggunaan **Sertakan Tubuh** dengan fungsi Anda, lihat [Struktur acara Lambda @Edge](lambda-event-structure.md). Skenario saat Anda mungkin ingin menggunakan fitur ini meliputi hal berikut: + Memproses formulir web, seperti formulir “hubungi kami”, tanpa mengirim data input pelanggan kembali ke server asal. + Mengumpulkan data beacon web yang dikirim oleh browser penampil dan memprosesnya di tepi. Untuk kode sampel, lihat [Lambda @Edge contoh fungsi](lambda-examples.md). **catatan** Jika badan permintaan berukuran besar, Lambda@Edge akan memotongnya. Untuk informasi terperinci tentang ukuran dan pemotongan maksimum, lihat [Pembatasan pada isi permintaan dengan opsi sertakan isi](lambda-at-edge-function-restrictions.md#lambda-at-edge-restrictions-request-body). # Lambda @Edge contoh fungsi Lihat contoh berikut untuk menggunakan fungsi Lambda dengan Amazon. CloudFront **catatan** Jika Anda memilih runtime Node.js 18 atau yang lebih baru untuk fungsi Lambda @Edge Anda, `index.mjs` file dibuat untuk Anda secara otomatis. Untuk menggunakan contoh kode berikut, ganti nama `index.mjs` file menjadi `index.js` sebagai gantinya. **Topics** + [Contoh Umum](#lambda-examples-general-examples) + [Hasilkan tanggapan - contoh](#lambda-examples-generated-response-examples) + [String kueri - contoh](#lambda-examples-query-string-examples) + [Personalisasi konten berdasarkan header negara atau jenis perangkat - contoh](#lambda-examples-redirecting-examples) + [Pemilihan asal dinamis berbasis konten - contoh](#lambda-examples-content-based-routing-examples) + [Perbarui status kesalahan - contoh](#lambda-examples-update-error-status-examples) + [Akses badan permintaan - contoh](#lambda-examples-access-request-body-examples) ## Contoh Umum Contoh berikut menunjukkan cara umum untuk menggunakan Lambda @Edge di. CloudFront **Topics** + [Contoh: A/B pengujian](#lambda-examples-a-b-testing) + [Contoh: Ganti header respons](#lambda-examples-overriding-response-header) ### Contoh: A/B pengujian Anda dapat menggunakan contoh berikut untuk menguji dua versi citra yang berbeda tanpa membuat pengalihan atau mengubah URL. Contoh ini membaca cookie di permintaan penampil dan memodifikasi URL permintaan dengan sesuai. Jika penampil tidak mengirim cookie dengan salah satu nilai yang diharapkan, contoh secara acak menetapkan penampil ke salah satu. URLs ------ #### [ Node.js ] ``` 'use strict'; exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; const headers = request.headers; if (request.uri !== '/experiment-pixel.jpg') { // do not process if this is not an A-B test request callback(null, request); return; } const cookieExperimentA = 'X-Experiment-Name=A'; const cookieExperimentB = 'X-Experiment-Name=B'; const pathExperimentA = '/experiment-group/control-pixel.jpg'; const pathExperimentB = '/experiment-group/treatment-pixel.jpg'; /* * Lambda at the Edge headers are array objects. * * Client may send multiple Cookie headers, i.e.: * > GET /viewerRes/test HTTP/1.1 * > User-Agent: curl/7.18.1 (x86_64-unknown-linux-gnu) libcurl/7.18.1 OpenSSL/1.0.1u zlib/1.2.3 * > Cookie: First=1; Second=2 * > Cookie: ClientCode=abc * > Host: example.com * * You can access the first Cookie header at headers["cookie"][0].value * and the second at headers["cookie"][1].value. * * Header values are not parsed. In the example above, * headers["cookie"][0].value is equal to "First=1; Second=2" */ let experimentUri; if (headers.cookie) { for (let i = 0; i < headers.cookie.length; i++) { if (headers.cookie[i].value.indexOf(cookieExperimentA) >= 0) { console.log('Experiment A cookie found'); experimentUri = pathExperimentA; break; } else if (headers.cookie[i].value.indexOf(cookieExperimentB) >= 0) { console.log('Experiment B cookie found'); experimentUri = pathExperimentB; break; } } } if (!experimentUri) { console.log('Experiment cookie has not been found. Throwing dice...'); if (Math.random() < 0.75) { experimentUri = pathExperimentA; } else { experimentUri = pathExperimentB; } } request.uri = experimentUri; console.log(`Request uri set to "${request.uri}"`); callback(null, request); }; ``` ------ #### [ Python ] ``` import json import random def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] headers = request['headers'] if request['uri'] != '/experiment-pixel.jpg': # Not an A/B Test return request cookieExperimentA, cookieExperimentB = 'X-Experiment-Name=A', 'X-Experiment-Name=B' pathExperimentA, pathExperimentB = '/experiment-group/control-pixel.jpg', '/experiment-group/treatment-pixel.jpg' ''' Lambda at the Edge headers are array objects. Client may send multiple cookie headers. For example: > GET /viewerRes/test HTTP/1.1 > User-Agent: curl/7.18.1 (x86_64-unknown-linux-gnu) libcurl/7.18.1 OpenSSL/1.0.1u zlib/1.2.3 > Cookie: First=1; Second=2 > Cookie: ClientCode=abc > Host: example.com You can access the first Cookie header at headers["cookie"][0].value and the second at headers["cookie"][1].value. Header values are not parsed. In the example above, headers["cookie"][0].value is equal to "First=1; Second=2" ''' experimentUri = "" for cookie in headers.get('cookie', []): if cookieExperimentA in cookie['value']: print("Experiment A cookie found") experimentUri = pathExperimentA break elif cookieExperimentB in cookie['value']: print("Experiment B cookie found") experimentUri = pathExperimentB break if not experimentUri: print("Experiment cookie has not been found. Throwing dice...") if random.random() < 0.75: experimentUri = pathExperimentA else: experimentUri = pathExperimentB request['uri'] = experimentUri print(f"Request uri set to {experimentUri}") return request ``` ------ ### Contoh: Ganti header respons Contoh berikut menunjukkan cara mengubah nilai header respons berdasarkan nilai header lain. ------ #### [ Node.js ] ``` export const handler = async (event) => { const response = event.Records[0].cf.response; const headers = response.headers; const headerNameSrc = 'X-Amz-Meta-Last-Modified'; const headerNameDst = 'Last-Modified'; if (headers[headerNameSrc.toLowerCase()]) { headers[headerNameDst.toLowerCase()] = [{ key: headerNameDst, value: headers[headerNameSrc.toLowerCase()][0].value, }]; console.log(`Response header "${headerNameDst}" was set to ` + `"${headers[headerNameDst.toLowerCase()][0].value}"`); } return response; }; ``` ------ #### [ Python ] ``` import json def lambda_handler(event, context): response = event['Records'][0]['cf']['response'] headers = response['headers'] header_name_src = 'X-Amz-Meta-Last-Modified' header_name_dst = 'Last-Modified' if headers.get(header_name_src.lower()): headers[header_name_dst.lower()] = [{ 'key': header_name_dst, 'value': headers[header_name_src.lower()][0]['value'] }] print(f'Response header "{header_name_dst}" was set to ' f'"{headers[header_name_dst.lower()][0]["value"]}"') return response ``` ------ ## Hasilkan tanggapan - contoh Contoh berikut menunjukkan bagaimana Anda dapat menggunakan Lambda @Edge untuk menghasilkan tanggapan. **Topics** + [Contoh: Sajikan konten statis (respons yang dihasilkan)](#lambda-examples-static-web-server) + [Contoh: Menghasilkan pengalihan HTTP (respons yang dihasilkan)](#lambda-examples-http-redirect) ### Contoh: Sajikan konten statis (respons yang dihasilkan) Contoh berikut menunjukkan cara menggunakan fungsi Lambda untuk melayani konten situs web statis, yang mengurangi beban pada server asal dan mengurangi latensi keseluruhan. **catatan** Anda dapat membuat tanggapan HTTP untuk permintaan penampil dan peristiwa permintaan asal. Untuk informasi selengkapnya, lihat [Hasilkan respons HTTP dalam pemicu permintaan](lambda-generating-http-responses.md#lambda-generating-http-responses-in-requests). Anda juga dapat mengganti atau menghapus isi respons HTTP dalam peristiwa respons asal. Untuk informasi selengkapnya, lihat [Perbarui tanggapan HTTP di pemicu respons asal](lambda-generating-http-responses.md#lambda-updating-http-responses). ------ #### [ Node.js ] ``` 'use strict'; const content = ` <\!DOCTYPE html>Hello from Lambda@Edge!
`; exports.handler = (event, context, callback) => { /* * Generate HTTP OK response using 200 status code with HTML body. */ const response = { status: '200', statusDescription: 'OK', headers: { 'cache-control': [{ key: 'Cache-Control', value: 'max-age=100' }], 'content-type': [{ key: 'Content-Type', value: 'text/html' }] }, body: content, }; callback(null, response); }; ``` ------ #### [ Python ] ``` import json CONTENT = """ <\!DOCTYPE html>Hello from Lambda@Edge!
""" def lambda_handler(event, context): # Generate HTTP OK response using 200 status code with HTML body. response = { 'status': '200', 'statusDescription': 'OK', 'headers': { 'cache-control': [ { 'key': 'Cache-Control', 'value': 'max-age=100' } ], "content-type": [ { 'key': 'Content-Type', 'value': 'text/html' } ] }, 'body': CONTENT } return response ``` ------ ### Contoh: Menghasilkan pengalihan HTTP (respons yang dihasilkan) Contoh berikut ini menunjukkan cara membuat pengalihan HTTP. **catatan** Anda dapat membuat tanggapan HTTP untuk permintaan penampil dan peristiwa permintaan asal. Untuk informasi selengkapnya, lihat [Hasilkan respons HTTP dalam pemicu permintaan](lambda-generating-http-responses.md#lambda-generating-http-responses-in-requests). ------ #### [ Node.js ] ``` 'use strict'; exports.handler = (event, context, callback) => { /* * Generate HTTP redirect response with 302 status code and Location header. */ const response = { status: '302', statusDescription: 'Found', headers: { location: [{ key: 'Location', value: 'https://docs.aws.amazon.com/lambda/latest/dg/lambda-edge.html', }], }, }; callback(null, response); }; ``` ------ #### [ Python ] ``` def lambda_handler(event, context): # Generate HTTP redirect response with 302 status code and Location header. response = { 'status': '302', 'statusDescription': 'Found', 'headers': { 'location': [{ 'key': 'Location', 'value': 'https://docs.aws.amazon.com/lambda/latest/dg/lambda-edge.html' }] } } return response ``` ------ ## String kueri - contoh Contoh berikut menunjukkan cara Anda dapat menggunakan Lambda @Edge dengan string kueri. **Topics** + [Contoh: Tambahkan header berdasarkan parameter string kueri](#lambda-examples-header-based-on-query-string) + [Contoh: Normalisasi parameter string kueri untuk meningkatkan rasio hit cache](#lambda-examples-normalize-query-string-parameters) + [Contoh: Mengarahkan pengguna yang tidak diautentikasi ke halaman login](#lambda-examples-redirect-to-signin-page) ### Contoh: Tambahkan header berdasarkan parameter string kueri Contoh berikut menunjukkan cara mendapatkan pasangan nilai kunci dari parameter string pencarian, kemudian menambahkan header berdasarkan nilai tersebut. ------ #### [ Node.js ] ``` 'use strict'; const querystring = require('querystring'); exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; /* When a request contains a query string key-value pair but the origin server * expects the value in a header, you can use this Lambda function to * convert the key-value pair to a header. Here's what the function does: * 1. Parses the query string and gets the key-value pair. * 2. Adds a header to the request using the key-value pair that the function got in step 1. */ /* Parse request querystring to get javascript object */ const params = querystring.parse(request.querystring); /* Move auth param from querystring to headers */ const headerName = 'Auth-Header'; request.headers[headerName.toLowerCase()] = [{ key: headerName, value: params.auth }]; delete params.auth; /* Update request querystring */ request.querystring = querystring.stringify(params); callback(null, request); }; ``` ------ #### [ Python ] ``` from urllib.parse import parse_qs, urlencode def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] ''' When a request contains a query string key-value pair but the origin server expects the value in a header, you can use this Lambda function to convert the key-value pair to a header. Here's what the function does: 1. Parses the query string and gets the key-value pair. 2. Adds a header to the request using the key-value pair that the function got in step 1. ''' # Parse request querystring to get dictionary/json params = {k : v[0] for k, v in parse_qs(request['querystring']).items()} # Move auth param from querystring to headers headerName = 'Auth-Header' request['headers'][headerName.lower()] = [{'key': headerName, 'value': params['auth']}] del params['auth'] # Update request querystring request['querystring'] = urlencode(params) return request ``` ------ ### Contoh: Normalisasi parameter string kueri untuk meningkatkan rasio hit cache Contoh berikut menunjukkan cara meningkatkan rasio hit cache Anda dengan membuat perubahan berikut pada string kueri sebelum CloudFront meneruskan permintaan ke asal Anda: + Berikan kombinasi nilai kunci dengan nama parameter. + Ubah kasus pasangan yang bernilai kunci menjadi huruf kecil. Untuk informasi selengkapnya, lihat [Konten cache berdasarkan parameter string kueri](QueryStringParameters.md). ------ #### [ Node.js ] ``` 'use strict'; const querystring = require('querystring'); exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; /* When you configure a distribution to forward query strings to the origin and * to cache based on an allowlist of query string parameters, we recommend * the following to improve the cache-hit ratio: * - Always list parameters in the same order. * - Use the same case for parameter names and values. * * This function normalizes query strings so that parameter names and values * are lowercase and parameter names are in alphabetical order. * * For more information, see: * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/QueryStringParameters.html */ console.log('Query String: ', request.querystring); /* Parse request query string to get javascript object */ const params = querystring.parse(request.querystring.toLowerCase()); const sortedParams = {}; /* Sort param keys */ Object.keys(params).sort().forEach(key => { sortedParams[key] = params[key]; }); /* Update request querystring with normalized */ request.querystring = querystring.stringify(sortedParams); callback(null, request); }; ``` ------ #### [ Python ] ``` from urllib.parse import parse_qs, urlencode def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] ''' When you configure a distribution to forward query strings to the origin and to cache based on an allowlist of query string parameters, we recommend the following to improve the cache-hit ratio: Always list parameters in the same order. - Use the same case for parameter names and values. This function normalizes query strings so that parameter names and values are lowercase and parameter names are in alphabetical order. For more information, see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/QueryStringParameters.html ''' print("Query string: ", request["querystring"]) # Parse request query string to get js object params = {k : v[0] for k, v in parse_qs(request['querystring'].lower()).items()} # Sort param keys sortedParams = sorted(params.items(), key=lambda x: x[0]) # Update request querystring with normalized request['querystring'] = urlencode(sortedParams) return request ``` ------ ### Contoh: Mengarahkan pengguna yang tidak diautentikasi ke halaman login Contoh berikut menunjukkan cara mengalihkan pengguna ke halaman masuk jika mereka belum memasukkan kredensial mereka. ------ #### [ Node.js ] ``` 'use strict'; function parseCookies(headers) { const parsedCookie = {}; if (headers.cookie) { headers.cookie[0].value.split(';').forEach((cookie) => { if (cookie) { const parts = cookie.split('='); parsedCookie[parts[0].trim()] = parts[1].trim(); } }); } return parsedCookie; } exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; const headers = request.headers; /* Check for session-id in request cookie in viewer-request event, * if session-id is absent, redirect the user to sign in page with original * request sent as redirect_url in query params. */ /* Check for session-id in cookie, if present then proceed with request */ const parsedCookies = parseCookies(headers); if (parsedCookies && parsedCookies['session-id']) { callback(null, request); return; } /* URI encode the original request to be sent as redirect_url in query params */ const encodedRedirectUrl = encodeURIComponent(`https://${headers.host[0].value}${request.uri}?${request.querystring}`); const response = { status: '302', statusDescription: 'Found', headers: { location: [{ key: 'Location', value: `https://www.example.com/signin?redirect_url=${encodedRedirectUrl}`, }], }, }; callback(null, response); }; ``` ------ #### [ Python ] ``` import urllib def parseCookies(headers): parsedCookie = {} if headers.get('cookie'): for cookie in headers['cookie'][0]['value'].split(';'): if cookie: parts = cookie.split('=') parsedCookie[parts[0].strip()] = parts[1].strip() return parsedCookie def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] headers = request['headers'] ''' Check for session-id in request cookie in viewer-request event, if session-id is absent, redirect the user to sign in page with original request sent as redirect_url in query params. ''' # Check for session-id in cookie, if present, then proceed with request parsedCookies = parseCookies(headers) if parsedCookies and parsedCookies['session-id']: return request # URI encode the original request to be sent as redirect_url in query params redirectUrl = "https://%s%s?%s" % (headers['host'][0]['value'], request['uri'], request['querystring']) encodedRedirectUrl = urllib.parse.quote_plus(redirectUrl.encode('utf-8')) response = { 'status': '302', 'statusDescription': 'Found', 'headers': { 'location': [{ 'key': 'Location', 'value': 'https://www.example.com/signin?redirect_url=%s' % encodedRedirectUrl }] } } return response ``` ------ ## Personalisasi konten berdasarkan header negara atau jenis perangkat - contoh Contoh berikut menunjukkan bagaimana Anda dapat menggunakan Lambda @Edge untuk menyesuaikan perilaku berdasarkan lokasi atau jenis perangkat yang digunakan oleh penampil. **Topics** + [Contoh: Mengarahkan permintaan penampil ke URL khusus negara](#lambda-examples-redirect-based-on-country) + [Contoh: Sajikan berbagai versi objek berdasarkan perangkat](#lambda-examples-vary-on-device-type) ### Contoh: Mengarahkan permintaan penampil ke URL khusus negara Contoh berikut menunjukkan cara membuat respons pengalihan HTTP dengan URL khusus negara dan mengembalikan respons ke penampil. Ini berguna saat Anda ingin memberikan tanggapan khusus negara. Sebagai contoh: + Jika Anda memiliki subdomain spesifik negara, seperti kami.example.com dan tw.example.com, Anda dapat membuat respons pengalihan saat penampil meminta contoh.com. + Jika Anda melakukan streaming video tetapi tidak memiliki hak untuk melakukan streaming konten di negara tertentu, Anda dapat mengarahkan pengguna di negara tersebut ke halaman yang menjelaskan mengapa mereka tidak dapat melihat video tersebut. Perhatikan hal-hal berikut: + Anda harus mengonfigurasi distribusi Anda ke cache berdasarkan `CloudFront-Viewer-Country` header. Untuk informasi selengkapnya, lihat [Cache berdasarkan header permintaan yang dipilih](DownloadDistValuesCacheBehavior.md#DownloadDistValuesForwardHeaders). + CloudFront menambahkan `CloudFront-Viewer-Country` header setelah acara permintaan penampil. Untuk menggunakan contoh ini, Anda harus membuat pemicu untuk kejadian permintaan asal. ------ #### [ Node.js ] ``` 'use strict'; /* This is an origin request function */ exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; const headers = request.headers; /* * Based on the value of the CloudFront-Viewer-Country header, generate an * HTTP status code 302 (Redirect) response, and return a country-specific * URL in the Location header. * NOTE: 1. You must configure your distribution to cache based on the * CloudFront-Viewer-Country header. For more information, see * https://docs.aws.amazon.com/console/cloudfront/cache-on-selected-headers * 2. CloudFront adds the CloudFront-Viewer-Country header after the viewer * request event. To use this example, you must create a trigger for the * origin request event. */ let url = 'https://example.com/'; if (headers['cloudfront-viewer-country']) { const countryCode = headers['cloudfront-viewer-country'][0].value; if (countryCode === 'TW') { url = 'https://tw.example.com/'; } else if (countryCode === 'US') { url = 'https://us.example.com/'; } } const response = { status: '302', statusDescription: 'Found', headers: { location: [{ key: 'Location', value: url, }], }, }; callback(null, response); }; ``` ------ #### [ Python ] ``` # This is an origin request function def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] headers = request['headers'] ''' Based on the value of the CloudFront-Viewer-Country header, generate an HTTP status code 302 (Redirect) response, and return a country-specific URL in the Location header. NOTE: 1. You must configure your distribution to cache based on the CloudFront-Viewer-Country header. For more information, see https://docs.aws.amazon.com/console/cloudfront/cache-on-selected-headers 2. CloudFront adds the CloudFront-Viewer-Country header after the viewer request event. To use this example, you must create a trigger for the origin request event. ''' url = 'https://example.com/' viewerCountry = headers.get('cloudfront-viewer-country') if viewerCountry: countryCode = viewerCountry[0]['value'] if countryCode == 'TW': url = 'https://tw.example.com/' elif countryCode == 'US': url = 'https://us.example.com/' response = { 'status': '302', 'statusDescription': 'Found', 'headers': { 'location': [{ 'key': 'Location', 'value': url }] } } return response ``` ------ ### Contoh: Sajikan berbagai versi objek berdasarkan perangkat Contoh berikut ini menunjukkan cara menyajikan versi objek berbeda berdasarkan jenis perangkat yang digunakan pengguna, misalnya, perangkat seluler atau tablet. Perhatikan hal-hal berikut: + Anda harus mengonfigurasi distribusi Anda ke cache berdasarkan `CloudFront-Is-*-Viewer` yang berbeda. Untuk informasi selengkapnya, lihat [Cache berdasarkan header permintaan yang dipilih](DownloadDistValuesCacheBehavior.md#DownloadDistValuesForwardHeaders). + CloudFront menambahkan `CloudFront-Is-*-Viewer` header setelah acara permintaan penampil. Untuk menggunakan contoh ini, Anda harus membuat pemicu untuk kejadian permintaan asal. ------ #### [ Node.js ] ``` 'use strict'; /* This is an origin request function */ exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; const headers = request.headers; /* * Serve different versions of an object based on the device type. * NOTE: 1. You must configure your distribution to cache based on the * CloudFront-Is-*-Viewer headers. For more information, see * the following documentation: * https://docs.aws.amazon.com/console/cloudfront/cache-on-selected-headers * https://docs.aws.amazon.com/console/cloudfront/cache-on-device-type * 2. CloudFront adds the CloudFront-Is-*-Viewer headers after the viewer * request event. To use this example, you must create a trigger for the * origin request event. */ const desktopPath = '/desktop'; const mobilePath = '/mobile'; const tabletPath = '/tablet'; const smarttvPath = '/smarttv'; if (headers['cloudfront-is-desktop-viewer'] && headers['cloudfront-is-desktop-viewer'][0].value === 'true') { request.uri = desktopPath + request.uri; } else if (headers['cloudfront-is-mobile-viewer'] && headers['cloudfront-is-mobile-viewer'][0].value === 'true') { request.uri = mobilePath + request.uri; } else if (headers['cloudfront-is-tablet-viewer'] && headers['cloudfront-is-tablet-viewer'][0].value === 'true') { request.uri = tabletPath + request.uri; } else if (headers['cloudfront-is-smarttv-viewer'] && headers['cloudfront-is-smarttv-viewer'][0].value === 'true') { request.uri = smarttvPath + request.uri; } console.log(`Request uri set to "${request.uri}"`); callback(null, request); }; ``` ------ #### [ Python ] ``` # This is an origin request function def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] headers = request['headers'] ''' Serve different versions of an object based on the device type. NOTE: 1. You must configure your distribution to cache based on the CloudFront-Is-*-Viewer headers. For more information, see the following documentation: https://docs.aws.amazon.com/console/cloudfront/cache-on-selected-headers https://docs.aws.amazon.com/console/cloudfront/cache-on-device-type 2. CloudFront adds the CloudFront-Is-*-Viewer headers after the viewer request event. To use this example, you must create a trigger for the origin request event. ''' desktopPath = '/desktop'; mobilePath = '/mobile'; tabletPath = '/tablet'; smarttvPath = '/smarttv'; if 'cloudfront-is-desktop-viewer' in headers and headers['cloudfront-is-desktop-viewer'][0]['value'] == 'true': request['uri'] = desktopPath + request['uri'] elif 'cloudfront-is-mobile-viewer' in headers and headers['cloudfront-is-mobile-viewer'][0]['value'] == 'true': request['uri'] = mobilePath + request['uri'] elif 'cloudfront-is-tablet-viewer' in headers and headers['cloudfront-is-tablet-viewer'][0]['value'] == 'true': request['uri'] = tabletPath + request['uri'] elif 'cloudfront-is-smarttv-viewer' in headers and headers['cloudfront-is-smarttv-viewer'][0]['value'] == 'true': request['uri'] = smarttvPath + request['uri'] print("Request uri set to %s" % request['uri']) return request ``` ------ ## Pemilihan asal dinamis berbasis konten - contoh Contoh berikut menunjukkan bagaimana Anda dapat menggunakan Lambda @Edge untuk merutekan ke asal yang berbeda berdasarkan informasi dalam permintaan. **Topics** + [Contoh: Menggunakan pemicu permintaan asal untuk mengubah dari asal kustom ke asal Amazon S3](#lambda-examples-content-based-S3-origin-based-on-query) + [Contoh: Gunakan pemicu permintaan asal untuk mengubah Wilayah asal Amazon S3](#lambda-examples-content-based-S3-origin-request-trigger) + [Contoh: Menggunakan pemicu permintaan asal untuk mengubah dari asal Amazon S3 ke asal kustom](#lambda-examples-content-based-custom-origin-request-trigger) + [Contoh: Gunakan pemicu permintaan asal untuk mentransfer lalu lintas secara bertahap dari satu bucket Amazon S3 ke bucket lainnya](#lambda-examples-content-based-gradual-traffic-transfer) + [Contoh: Gunakan pemicu permintaan asal untuk mengubah nama domain asal berdasarkan header negara](#lambda-examples-content-based-geo-header) ### Contoh: Menggunakan pemicu permintaan asal untuk mengubah dari asal kustom ke asal Amazon S3 Fungsi ini mendemonstrasikan bagaimana pemicu permintaan asal dapat digunakan untuk mengubah dari asal kustom ke asal Amazon S3 dari mana konten diambil, berdasarkan properti permintaan. ------ #### [ Node.js ] ``` 'use strict'; const querystring = require('querystring'); exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; /** * Reads query string to check if S3 origin should be used, and * if true, sets S3 origin properties. */ const params = querystring.parse(request.querystring); if (params['useS3Origin']) { if (params['useS3Origin'] === 'true') { const s3DomainName = 'amzn-s3-demo-bucket.s3.amazonaws.com'; /* Set S3 origin fields */ request.origin = { s3: { domainName: s3DomainName, region: '', authMethod: 'origin-access-identity', path: '', customHeaders: {} } }; request.headers['host'] = [{ key: 'host', value: s3DomainName}]; } } callback(null, request); }; ``` ------ #### [ Python ] ``` from urllib.parse import parse_qs def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] ''' Reads query string to check if S3 origin should be used, and if true, sets S3 origin properties ''' params = {k: v[0] for k, v in parse_qs(request['querystring']).items()} if params.get('useS3Origin') == 'true': s3DomainName = 'amzn-s3-demo-bucket.s3.amazonaws.com' # Set S3 origin fields request['origin'] = { 's3': { 'domainName': s3DomainName, 'region': '', 'authMethod': 'origin-access-identity', 'path': '', 'customHeaders': {} } } request['headers']['host'] = [{'key': 'host', 'value': s3DomainName}] return request ``` ------ ### Contoh: Gunakan pemicu permintaan asal untuk mengubah Wilayah asal Amazon S3 Fungsi ini menunjukkan bagaimana pemicu permintaan asal dapat digunakan untuk mengubah asal Amazon S3 dari mana konten diambil, berdasarkan properti permintaan. Dalam contoh ini, kami menggunakan nilai `CloudFront-Viewer-Country` header untuk memperbarui nama domain bucket S3 ke bucket di Wilayah yang lebih dekat dengan penampil. Ini dapat berguna dalam beberapa cara: + Ini mengurangi keterlambatan saat Wilayah yang ditentukan lebih dekat ke negara penampil. + Ini menyediakan kedaulatan data dengan memastikan bahwa data dilayani dari asal yang berada di negara yang sama dengan asal permintaan tersebut. Untuk menggunakan contoh ini, Anda harus melakukan hal berikut: + Konfigurasikan distribusi Anda ke cache berdasarkan `CloudFront-Viewer-Country` header. Untuk informasi selengkapnya, lihat [Cache berdasarkan header permintaan yang dipilih](DownloadDistValuesCacheBehavior.md#DownloadDistValuesForwardHeaders). + Buat pemicu untuk fungsi ini di acara permintaan asal. CloudFrontmenambahkan `CloudFront-Viewer-Country` header setelah peristiwa permintaan penampil, jadi untuk menggunakan contoh ini, Anda harus memastikan bahwa fungsi tersebut dijalankan untuk permintaan asal. **catatan** Kode contoh berikut menggunakan identitas akses asal (OAI) yang sama untuk semua bucket S3 yang Anda gunakan untuk asal Anda. Untuk informasi selengkapnya, lihat [Identitas akses asal](private-content-restricting-access-to-s3.md#private-content-restricting-access-to-s3-oai). ------ #### [ Node.js ] ``` 'use strict'; exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; /** * This blueprint demonstrates how an origin-request trigger can be used to * change the origin from which the content is fetched, based on request properties. * In this example, we use the value of the CloudFront-Viewer-Country header * to update the S3 bucket domain name to a bucket in a Region that is closer to * the viewer. * * This can be useful in several ways: * 1) Reduces latencies when the Region specified is nearer to the viewer's * country. * 2) Provides data sovereignty by making sure that data is served from an * origin that's in the same country that the request came from. * * NOTE: 1. You must configure your distribution to cache based on the * CloudFront-Viewer-Country header. For more information, see * https://docs.aws.amazon.com/console/cloudfront/cache-on-selected-headers * 2. CloudFront adds the CloudFront-Viewer-Country header after the viewer * request event. To use this example, you must create a trigger for the * origin request event. */ const countryToRegion = { 'DE': 'eu-central-1', 'IE': 'eu-west-1', 'GB': 'eu-west-2', 'FR': 'eu-west-3', 'JP': 'ap-northeast-1', 'IN': 'ap-south-1' }; if (request.headers['cloudfront-viewer-country']) { const countryCode = request.headers['cloudfront-viewer-country'][0].value; const region = countryToRegion[countryCode]; /** * If the viewer's country is not in the list you specify, the request * goes to the default S3 bucket you've configured. */ if (region) { /** * If you've set up OAI, the bucket policy in the destination bucket * should allow the OAI GetObject operation, as configured by default * for an S3 origin with OAI. Another requirement with OAI is to provide * the Region so it can be used for the SIGV4 signature. Otherwise, the * Region is not required. */ request.origin.s3.region = region; const domainName = `amzn-s3-demo-bucket-in-${region}.s3.${region}.amazonaws.com`; request.origin.s3.domainName = domainName; request.headers['host'] = [{ key: 'host', value: domainName }]; } } callback(null, request); }; ``` ------ #### [ Python ] ``` def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] ''' This blueprint demonstrates how an origin-request trigger can be used to change the origin from which the content is fetched, based on request properties. In this example, we use the value of the CloudFront-Viewer-Country header to update the S3 bucket domain name to a bucket in a Region that is closer to the viewer. This can be useful in several ways: 1) Reduces latencies when the Region specified is nearer to the viewer's country. 2) Provides data sovereignty by making sure that data is served from an origin that's in the same country that the request came from. NOTE: 1. You must configure your distribution to cache based on the CloudFront-Viewer-Country header. For more information, see https://docs.aws.amazon.com/console/cloudfront/cache-on-selected-headers 2. CloudFront adds the CloudFront-Viewer-Country header after the viewer request event. To use this example, you must create a trigger for the origin request event. ''' countryToRegion = { 'DE': 'eu-central-1', 'IE': 'eu-west-1', 'GB': 'eu-west-2', 'FR': 'eu-west-3', 'JP': 'ap-northeast-1', 'IN': 'ap-south-1' } viewerCountry = request['headers'].get('cloudfront-viewer-country') if viewerCountry: countryCode = viewerCountry[0]['value'] region = countryToRegion.get(countryCode) # If the viewer's country in not in the list you specify, the request # goes to the default S3 bucket you've configured if region: ''' If you've set up OAI, the bucket policy in the destination bucket should allow the OAI GetObject operation, as configured by default for an S3 origin with OAI. Another requirement with OAI is to provide the Region so it can be used for the SIGV4 signature. Otherwise, the Region is not required. ''' request['origin']['s3']['region'] = region domainName = 'amzn-s3-demo-bucket-in-{0}.s3.{0}.amazonaws.com'.format(region) request['origin']['s3']['domainName'] = domainName request['headers']['host'] = [{'key': 'host', 'value': domainName}] return request ``` ------ ### Contoh: Menggunakan pemicu permintaan asal untuk mengubah dari asal Amazon S3 ke asal kustom Fungsi ini menunjukkan bagaimana pemicu permintaan asal dapat digunakan untuk mengubah asal kustom dari mana konten diambil, berdasarkan sifat permintaan. ------ #### [ Node.js ] ``` 'use strict'; const querystring = require('querystring'); exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; /** * Reads query string to check if custom origin should be used, and * if true, sets custom origin properties. */ const params = querystring.parse(request.querystring); if (params['useCustomOrigin']) { if (params['useCustomOrigin'] === 'true') { /* Set custom origin fields*/ request.origin = { custom: { domainName: 'www.example.com', port: 443, protocol: 'https', path: '', sslProtocols: ['TLSv1', 'TLSv1.1'], readTimeout: 5, keepaliveTimeout: 5, customHeaders: {} } }; request.headers['host'] = [{ key: 'host', value: 'www.example.com'}]; } } callback(null, request); }; ``` ------ #### [ Python ] ``` from urllib.parse import parse_qs def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] # Reads query string to check if custom origin should be used, and # if true, sets custom origin properties params = {k: v[0] for k, v in parse_qs(request['querystring']).items()} if params.get('useCustomOrigin') == 'true': # Set custom origin fields request['origin'] = { 'custom': { 'domainName': 'www.example.com', 'port': 443, 'protocol': 'https', 'path': '', 'sslProtocols': ['TLSv1', 'TLSv1.1'], 'readTimeout': 5, 'keepaliveTimeout': 5, 'customHeaders': {} } } request['headers']['host'] = [{'key': 'host', 'value': 'www.example.com'}] return request ``` ------ ### Contoh: Gunakan pemicu permintaan asal untuk mentransfer lalu lintas secara bertahap dari satu bucket Amazon S3 ke bucket lainnya Fungsi ini menunjukkan bagaimana Anda dapat secara bertahap mentransfer lalu lintas dari satu bucket Amazon S3 ke bucket lain dengan cara yang terkontrol. ------ #### [ Node.js ] ``` 'use strict'; function getRandomInt(min, max) { /* Random number is inclusive of min and max*/ return Math.floor(Math.random() * (max - min + 1)) + min; } exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; const BLUE_TRAFFIC_PERCENTAGE = 80; /** * This Lambda function demonstrates how to gradually transfer traffic from * one S3 bucket to another in a controlled way. * We define a variable BLUE_TRAFFIC_PERCENTAGE which can take values from * 1 to 100. If the generated randomNumber less than or equal to BLUE_TRAFFIC_PERCENTAGE, traffic * is re-directed to blue-bucket. If not, the default bucket that we've configured * is used. */ const randomNumber = getRandomInt(1, 100); if (randomNumber <= BLUE_TRAFFIC_PERCENTAGE) { const domainName = 'blue-bucket.s3.amazonaws.com'; request.origin.s3.domainName = domainName; request.headers['host'] = [{ key: 'host', value: domainName}]; } callback(null, request); }; ``` ------ #### [ Python ] ``` import math import random def getRandomInt(min, max): # Random number is inclusive of min and max return math.floor(random.random() * (max - min + 1)) + min def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] BLUE_TRAFFIC_PERCENTAGE = 80 ''' This Lambda function demonstrates how to gradually transfer traffic from one S3 bucket to another in a controlled way. We define a variable BLUE_TRAFFIC_PERCENTAGE which can take values from 1 to 100. If the generated randomNumber less than or equal to BLUE_TRAFFIC_PERCENTAGE, traffic is re-directed to blue-bucket. If not, the default bucket that we've configured is used. ''' randomNumber = getRandomInt(1, 100) if randomNumber <= BLUE_TRAFFIC_PERCENTAGE: domainName = 'blue-bucket.s3.amazonaws.com' request['origin']['s3']['domainName'] = domainName request['headers']['host'] = [{'key': 'host', 'value': domainName}] return request ``` ------ ### Contoh: Gunakan pemicu permintaan asal untuk mengubah nama domain asal berdasarkan header negara Fungsi ini menunjukkan bagaimana Anda dapat mengubah nama domain asal berdasarkan `CloudFront-Viewer-Country` header, sehingga konten disajikan dari asal yang lebih dekat ke negara pemirsa. Mengimplementasikan fungsi ini untuk distribusi Anda dapat memiliki keuntungan seperti berikut ini: + Mengurangi keterlambatan jika Wilayah yang ditentukan lebih dekat dengan negara penampil + Memberikan kedaulatan data dengan memastikan bahwa data tersebut berasal dari negara yang sama dengan negara asal permintaan Perhatikan bahwa untuk mengaktifkan fungsi ini, Anda harus mengonfigurasi distribusi Anda ke cache berdasarkan `CloudFront-Viewer-Country` header. Untuk informasi selengkapnya, lihat [Cache berdasarkan header permintaan yang dipilih](DownloadDistValuesCacheBehavior.md#DownloadDistValuesForwardHeaders). ------ #### [ Node.js ] ``` 'use strict'; exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; if (request.headers['cloudfront-viewer-country']) { const countryCode = request.headers['cloudfront-viewer-country'][0].value; if (countryCode === 'GB' || countryCode === 'DE' || countryCode === 'IE' ) { const domainName = 'eu.example.com'; request.origin.custom.domainName = domainName; request.headers['host'] = [{key: 'host', value: domainName}]; } } callback(null, request); }; ``` ------ #### [ Python ] ``` def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] viewerCountry = request['headers'].get('cloudfront-viewer-country') if viewerCountry: countryCode = viewerCountry[0]['value'] if countryCode == 'GB' or countryCode == 'DE' or countryCode == 'IE': domainName = 'eu.example.com' request['origin']['custom']['domainName'] = domainName request['headers']['host'] = [{'key': 'host', 'value': domainName}] return request ``` ------ ## Perbarui status kesalahan - contoh Contoh berikut memberikan panduan bagaimana Anda dapat menggunakan Lambda @Edge untuk mengubah status kesalahan yang dikembalikan ke pengguna. **Topics** + [Contoh: Gunakan pemicu respons asal untuk memperbarui kode status kesalahan ke 200](#lambda-examples-custom-error-static-body) + [Contoh: Gunakan pemicu respons asal untuk memperbarui kode status kesalahan ke 302](#lambda-examples-custom-error-new-site) ### Contoh: Gunakan pemicu respons asal untuk memperbarui kode status kesalahan ke 200 Fungsi ini menunjukkan bagaimana Anda dapat memperbarui status respons menjadi 200 dan menghasilkan konten tubuh statis untuk kembali ke penampil dalam skenario berikut: + Fungsi dipicu dalam respons asal. + Status respons dari server asal adalah kode status kesalahan (4xx atau 5xx). ------ #### [ Node.js ] ``` 'use strict'; exports.handler = (event, context, callback) => { const response = event.Records[0].cf.response; /** * This function updates the response status to 200 and generates static * body content to return to the viewer in the following scenario: * 1. The function is triggered in an origin response * 2. The response status from the origin server is an error status code (4xx or 5xx) */ if (response.status >= 400 && response.status <= 599) { response.status = 200; response.statusDescription = 'OK'; response.body = 'Body generation example'; } callback(null, response); }; ``` ------ #### [ Python ] ``` def lambda_handler(event, context): response = event['Records'][0]['cf']['response'] ''' This function updates the response status to 200 and generates static body content to return to the viewer in the following scenario: 1. The function is triggered in an origin response 2. The response status from the origin server is an error status code (4xx or 5xx) ''' if int(response['status']) >= 400 and int(response['status']) <= 599: response['status'] = 200 response['statusDescription'] = 'OK' response['body'] = 'Body generation example' return response ``` ------ ### Contoh: Gunakan pemicu respons asal untuk memperbarui kode status kesalahan ke 302 Fungsi ini menunjukkan cara Anda dapat memperbarui kode status HTTP ke 302 untuk mengalihkan ke jalur lain (perilaku kesalahan) yang memiliki asal berbeda yang dikonfigurasi. Perhatikan hal-hal berikut: + Fungsi dipicu dalam respons asal. + Status respons dari server asal adalah kode status kesalahan (4xx atau 5xx). ------ #### [ Node.js ] ``` 'use strict'; exports.handler = (event, context, callback) => { const response = event.Records[0].cf.response; const request = event.Records[0].cf.request; /** * This function updates the HTTP status code in the response to 302, to redirect to another * path (cache behavior) that has a different origin configured. Note the following: * 1. The function is triggered in an origin response * 2. The response status from the origin server is an error status code (4xx or 5xx) */ if (response.status >= 400 && response.status <= 599) { const redirect_path = `/plan-b/path?${request.querystring}`; response.status = 302; response.statusDescription = 'Found'; /* Drop the body, as it is not required for redirects */ response.body = ''; response.headers['location'] = [{ key: 'Location', value: redirect_path }]; } callback(null, response); }; ``` ------ #### [ Python ] ``` def lambda_handler(event, context): response = event['Records'][0]['cf']['response'] request = event['Records'][0]['cf']['request'] ''' This function updates the HTTP status code in the response to 302, to redirect to another path (cache behavior) that has a different origin configured. Note the following: 1. The function is triggered in an origin response 2. The response status from the origin server is an error status code (4xx or 5xx) ''' if int(response['status']) >= 400 and int(response['status']) <= 599: redirect_path = '/plan-b/path?%s' % request['querystring'] response['status'] = 302 response['statusDescription'] = 'Found' # Drop the body as it is not required for redirects response['body'] = '' response['headers']['location'] = [{'key': 'Location', 'value': redirect_path}] return response ``` ------ ## Akses badan permintaan - contoh Contoh berikut menunjukkan bagaimana Anda dapat menggunakan Lambda @Edge untuk bekerja dengan permintaan POST. **catatan** Untuk menggunakan contoh ini, Anda harus mengaktifkan opsi *include body* dalam asosiasi fungsi Lambda distribusi. Ini tidak diaktifkan secara default. Untuk mengaktifkan pengaturan ini di CloudFront konsol, pilih kotak centang untuk **Sertakan Tubuh** di Asosiasi **Fungsi Lambda**. Untuk mengaktifkan setelan ini di CloudFront API atau dengan CloudFormation, setel `IncludeBody` bidang ke `true` in`LambdaFunctionAssociation`. **Topics** + [Contoh: Gunakan pemicu permintaan untuk membaca formulir HTML](#lambda-examples-access-request-body-examples-read) + [Contoh: Gunakan pemicu permintaan untuk memodifikasi formulir HTML](#lambda-examples-access-request-body-examples-replace) ### Contoh: Gunakan pemicu permintaan untuk membaca formulir HTML Fungsi ini menunjukkan bagaimana Anda dapat memproses isi permintaan POST yang dibuat oleh formulir HTML (formulir web), seperti formulir “hubungi kami”. Misalnya, Anda mungkin memiliki formulir HTML seperti berikut ini: ``` ``` Untuk fungsi contoh berikut, fungsi harus dipicu dalam CloudFront permintaan penampil atau permintaan asal. ------ #### [ Node.js ] ``` 'use strict'; const querystring = require('querystring'); /** * This function demonstrates how you can read the body of a POST request * generated by an HTML form (web form). The function is triggered in a * CloudFront viewer request or origin request event type. */ exports.handler = (event, context, callback) => { const request = event.Records[0].cf.request; if (request.method === 'POST') { /* HTTP body is always passed as base64-encoded string. Decode it. */ const body = Buffer.from(request.body.data, 'base64').toString(); /* HTML forms send the data in query string format. Parse it. */ const params = querystring.parse(body); /* For demonstration purposes, we only log the form fields here. * You can put your custom logic here. For example, you can store the * fields in a database, such as Amazon DynamoDB, and generate a response * right from your Lambda@Edge function. */ for (let param in params) { console.log(`For "${param}" user submitted "${params[param]}".\n`); } } return callback(null, request); }; ``` ------ #### [ Python ] ``` import base64 from urllib.parse import parse_qs ''' Say there is a POST request body generated by an HTML such as: ''' ''' This function demonstrates how you can read the body of a POST request generated by an HTML form (web form). The function is triggered in a CloudFront viewer request or origin request event type. ''' def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] if request['method'] == 'POST': # HTTP body is always passed as base64-encoded string. Decode it body = base64.b64decode(request['body']['data']) # HTML forms send the data in query string format. Parse it params = {k: v[0] for k, v in parse_qs(body).items()} ''' For demonstration purposes, we only log the form fields here. You can put your custom logic here. For example, you can store the fields in a database, such as Amazon DynamoDB, and generate a response right from your Lambda@Edge function. ''' for key, value in params.items(): print("For %s use submitted %s" % (key, value)) return request ``` ------ ### Contoh: Gunakan pemicu permintaan untuk memodifikasi formulir HTML Fungsi ini menunjukkan bagaimana Anda dapat memodifikasi isi permintaan POST yang dibuat oleh formulir HTML (formulir web). Fungsi ini dipicu dalam permintaan CloudFront penampil atau permintaan asal. ------ #### [ Node.js ] ``` 'use strict'; const querystring = require('querystring'); exports.handler = (event, context, callback) => { var request = event.Records[0].cf.request; if (request.method === 'POST') { /* Request body is being replaced. To do this, update the following /* three fields: * 1) body.action to 'replace' * 2) body.encoding to the encoding of the new data. * * Set to one of the following values: * * text - denotes that the generated body is in text format. * Lambda@Edge will propagate this as is. * base64 - denotes that the generated body is base64 encoded. * Lambda@Edge will base64 decode the data before sending * it to the origin. * 3) body.data to the new body. */ request.body.action = 'replace'; request.body.encoding = 'text'; request.body.data = getUpdatedBody(request); } callback(null, request); }; function getUpdatedBody(request) { /* HTTP body is always passed as base64-encoded string. Decode it. */ const body = Buffer.from(request.body.data, 'base64').toString(); /* HTML forms send data in query string format. Parse it. */ const params = querystring.parse(body); /* For demonstration purposes, we're adding one more param. * * You can put your custom logic here. For example, you can truncate long * bodies from malicious requests. */ params['new-param-name'] = 'new-param-value'; return querystring.stringify(params); } ``` ------ #### [ Python ] ``` import base64 from urllib.parse import parse_qs, urlencode def lambda_handler(event, context): request = event['Records'][0]['cf']['request'] if request['method'] == 'POST': ''' Request body is being replaced. To do this, update the following three fields: 1) body.action to 'replace' 2) body.encoding to the encoding of the new data. Set to one of the following values: text - denotes that the generated body is in text format. Lambda@Edge will propagate this as is. base64 - denotes that the generated body is base64 encoded. Lambda@Edge will base64 decode the data before sending it to the origin. 3) body.data to the new body. ''' request['body']['action'] = 'replace' request['body']['encoding'] = 'text' request['body']['data'] = getUpdatedBody(request) return request def getUpdatedBody(request): # HTTP body is always passed as base64-encoded string. Decode it body = base64.b64decode(request['body']['data']) # HTML forms send data in query string format. Parse it params = {k: v[0] for k, v in parse_qs(body).items()} # For demonstration purposes, we're adding one more param # You can put your custom logic here. For example, you can truncate long # bodies from malicious requests params['new-param-name'] = 'new-param-value' return urlencode(params) ``` ------ # Pembatasan pada fungsi edge Topik berikut menjelaskan batasan yang berlaku untuk CloudFront Fungsi dan Lambda @Edge. Beberapa batasan berlaku untuk semua fungsi tepi, sementara yang lain hanya berlaku untuk CloudFront Fungsi atau Lambda @Edge. Setiap topik memberikan informasi terperinci tentang batasan dan kendala yang harus Anda pertimbangkan saat mengembangkan dan menerapkan fungsi edge. CloudFront Memahami batasan ini membantu Anda memastikan bahwa fungsi edge Anda beroperasi seperti yang diharapkan dan mematuhi fitur yang didukung. **Topics** + [Pembatasan pada semua fungsi edge](edge-function-restrictions-all.md) + [Pembatasan CloudFront Fungsi](cloudfront-function-restrictions.md) + [Pembatasan Lambda@Edge](lambda-at-edge-function-restrictions.md) Untuk informasi tentang kuota (sebelumnya disebut sebagai batas), lihat [Kuota pada Fungsi CloudFront](cloudfront-limits.md#limits-functions) dan [Kuotas di Lambda@Edge](cloudfront-limits.md#limits-lambda-at-edge). # Pembatasan pada semua fungsi edge Pembatasan berikut berlaku untuk semua fungsi edge, baik CloudFront Fungsi maupun Lambda @Edge. **Topics** + [Akun AWS kepemilikan](#function-restrictions-account-ownership) + [Menggabungkan CloudFront Fungsi dengan Lambda @Edge](#function-restrictions-combining-functions) + [Kode status HTTP](#function-restrictions-status-codes) + [Header HTTP](#function-restrictions-headers) + [String pertanyaan](#function-restrictions-query-strings) + [URI](#function-restrictions-uri) + [URI, string kueri, dan pengkodean header](#function-restrictions-encoding) + [Streaming Microsoft yang Lancar](#function-restrictions-microsoft-smooth-streaming) + [Penandaan](#function-restrictions-tagging) ## Akun AWS kepemilikan Untuk mengaitkan fungsi tepi dengan CloudFront distribusi, fungsi dan distribusi harus dimiliki oleh yang sama Akun AWS. ## Menggabungkan CloudFront Fungsi dengan Lambda @Edge Untuk perilaku cache tertentu, pembatasan berikut berlaku: + Setiap jenis kejadian (permintaan penampil, permintaan asal, respons asal, dan respons penampil) hanya dapat memiliki satu asosiasi fungsi edge. + Anda tidak dapat menggabungkan CloudFront Fungsi dan Lambda @Edge dalam acara penampil (permintaan penampil dan respons penampil). Semua kombinasi fungsi edge lainnya diperbolehkan. Tabel berikut menjelaskan kombinasi yang diizinkan. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonCloudFront/latest/DeveloperGuide/edge-function-restrictions-all.html) ## Kode status HTTP CloudFront tidak memanggil fungsi tepi untuk peristiwa respons penampil saat asal mengembalikan kode status HTTP 400 atau lebih tinggi. Fungsi Lambda@Edge untuk peristiwa respons asal dipanggil untuk *semua*respons asal, termasuk saat asal mengembalikan kode status HTTP 400 atau lebih tinggi. Untuk informasi selengkapnya, lihat [Perbarui tanggapan HTTP di pemicu respons asal](lambda-generating-http-responses.md#lambda-updating-http-responses). ## Header HTTP Header HTTP tertentu tidak diizinkan, yang berarti mereka tidak terkena fungsi tepi dan fungsi tidak dapat menambahkannya. Header lainnya hanya baca, yang berarti fungsi dapat membacanya tetapi tidak dapat menambahkan, memodifikasi, atau menghapusnya. **Topics** + [Header yang diizinkan](#function-restrictions-disallowed-headers) + [Header hanya-baca](#function-restrictions-read-only-headers) ### Header yang diizinkan Header HTTP berikut tidak terkena fungsi edge, dan fungsi tidak dapat menambahkannya. Jika fungsi Anda menambahkan salah satu header ini, itu gagal CloudFront validasi dan CloudFront mengembalikan kode status HTTP 502 (Bad Gateway) ke penampil. + `Connection` + `Expect` + `Keep-Alive` + `Proxy-Authenticate` + `Proxy-Authorization` + `Proxy-Connection` + `Trailer` + `Upgrade` + `X-Accel-Buffering` + `X-Accel-Charset` + `X-Accel-Limit-Rate` + `X-Accel-Redirect` + `X-Amz-Cf-*` + `X-Amzn-Auth` + `X-Amzn-Cf-Billing` + `X-Amzn-Cf-Id` + `X-Amzn-Cf-Xff` + `X-Amzn-Errortype` + `X-Amzn-Fle-Profile` + `X-Amzn-Header-Count` + `X-Amzn-Header-Order` + `X-Amzn-Lambda-Integration-Tag` + `X-Amzn-RequestId` + `X-Cache` + `X-Edge-*` + `X-Forwarded-Proto` + `X-Real-IP` ### Header hanya-baca Header berikut ini hanya untuk dibaca. Fungsi Anda dapat membacanya dan menggunakannya sebagai input ke logika fungsi, tetapi tidak dapat mengubah nilainya. Jika fungsi Anda menambahkan atau mengedit header hanya-baca, permintaan gagal CloudFront validasi dan CloudFront mengembalikan kode status HTTP 502 (Bad Gateway) ke penampil. #### Header hanya-baca dalam peristiwa permintaan penampil Header berikut ini hanya-baca di peristiwa permintaan penampil. + `CDN-Loop` + `Content-Length` + `Host` + `Transfer-Encoding` + `Via` #### Header hanya-baca dalam peristiwa permintaan asal (hanya Lambda@Edge) Header berikut hanya-baca dalam peristiwa permintaan asal, yang hanya ada di Lambda@Edge. + `Accept-Encoding` + `CDN-Loop` + `Content-Length` + `If-Modified-Since` + `If-None-Match` + `If-Range` + `If-Unmodified-Since` + `Transfer-Encoding` + `Via` #### Header hanya-baca dalam peristiwa respons asal (hanya Lambda@Edge) Header berikut hanya-baca dalam peristiwa respon asal, yang hanya ada di Lambda@Edge. + `Transfer-Encoding` + `Via` #### Header hanya-baca dalam peristiwa respons penampil Header berikut hanya-baca dalam peristiwa respons penampil untuk Fungsi CloudFront dan Lambda @Edge. + `Warning` + `Via` Header berikut hanya-baca dalam peristiwa respons penampil untuk Lambda @Edge. + `Content-Length` + `Content-Encoding` + `Transfer-Encoding` ## String pertanyaan Pembatasan berikut berlaku untuk fungsi yang membaca, memperbarui, atau membuat string kueri dalam permintaan URI. + (Lambda@Edge saja) Untuk mengakses string kueri dalam permintaan asal atau fungsi respons asal, kebijakan cache atau kebijakan permintaan asal harus disetel ke **semua** untuk **string kueri**. + Sebuah fungsi dapat membuat atau memperbarui string kueri untuk permintaan penampil dan peristiwa permintaan asal (peristiwa permintaan asal hanya ada di Lambda@Edge). + Sebuah fungsi dapat membaca string kueri, tetapi tidak dapat membuat atau memperbarui satu, untuk respons asal dan peristiwa respons penampil (peristiwa respons asal hanya ada di Lambda@Edge). + Jika fungsi membuat atau memperbarui string kueri, pembatasan berikut berlaku: + String kueri tidak dapat menyertakan spasi, karakter kontrol, atau pengenal fragmen ()`#`. + Ukuran total URI, termasuk string kueri, harus kurang dari 8.192 karakter. + Kami sarankan Anda menggunakan persen pengkodean untuk URI dan string kueri. Untuk informasi selengkapnya, lihat [URI, string kueri, dan pengkodean header](#function-restrictions-encoding). ## URI Jika sebuah fungsi mengubah URI untuk permintaan, hal itu tidak mengubah perilaku cache untuk permintaan tersebut atau asal permintaan tersebut yang diteruskan. Ukuran total URI, termasuk string kueri, harus kurang dari 8.192 karakter. ## URI, string kueri, dan pengkodean header Nilai untuk URI, string kueri, dan header yang diteruskan ke fungsi edge dikodekan UTF-8. Fungsi Anda harus menggunakan pengkodean UTF-8 untuk URI, string kueri, dan nilai header yang dikembalikan. Pengkodean persen kompatibel dengan pengkodean UTF-8. Daftar berikut menjelaskan cara CloudFront menangani pengkodean untuk URI, string kueri, dan header: + Ketika nilai dalam permintaan dikodekan UTF-8, teruskan nilai CloudFront ke fungsi Anda tanpa mengubahnya. + Ketika nilai dalam permintaan dikodekan [ISO-8859-1, CloudFront konversi nilai ke UTF-8 encoding](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) sebelum meneruskannya ke fungsi Anda. + Ketika nilai dalam permintaan dikodekan menggunakan beberapa pengkodean karakter lain, CloudFront asumsikan bahwa mereka dikodekan ISO-8859-1 dan mencoba mengonversi dari ISO-8859-1 ke UTF-8. **penting** Karakter yang dikonversi mungkin merupakan interpretasi yang tidak akurat dari nilai-nilai dalam permintaan asli. Hal ini dapat menyebabkan fungsi atau asal Anda memberi hasil yang tidak diinginkan. Nilai untuk URI, string kueri, dan header yang CloudFront diteruskan ke asal Anda bergantung pada apakah suatu fungsi mengubah nilai: + Jika fungsi tidak mengubah URI, string kueri, atau header, CloudFront teruskan nilai yang diterimanya dalam permintaan ke asal Anda. + Jika fungsi mengubah URI, string kueri, atau header, CloudFront teruskan nilai yang dikodekan UTF-8. ## Streaming Microsoft yang Lancar Anda tidak dapat menggunakan fungsi edge dengan CloudFront distribusi yang Anda gunakan untuk streaming file media yang telah Anda transkode ke dalam format Microsoft Smooth Streaming. ## Penandaan Anda tidak dapat menambahkan tag ke fungsi tepi. Untuk informasi selengkapnya tentang penandaan CloudFront, lihat[Menandai distribusi](tagging.md). # Pembatasan CloudFront Fungsi Pembatasan berikut hanya berlaku untuk CloudFront Fungsi. **Contents** + [Beberapa catatan](#cloudfront-function-restrictions-logs) + [Isi permintaan](#cloudfront-function-restrictions-request-body) + [Menggunakan kredensil sementara dengan API CloudFront KeyValueStore](#regional-endpoint-for-key-value-store) + [Waktu Aktif](#cloudfront-function-runtime-restrictions) + [Hitung pemanfaatan](#cloudfront-function-restrictions-compute-utilization) Untuk informasi tentang kuota (sebelumnya disebut sebagai batas), lihat. [Kuota pada Fungsi CloudFront](cloudfront-limits.md#limits-functions) ## Beberapa catatan Log fungsi di CloudFront Fungsi terpotong pada 10 KB. ## Isi permintaan CloudFront Fungsi tidak dapat mengakses isi permintaan HTTP. ## Menggunakan kredensil sementara dengan API CloudFront KeyValueStore Anda dapat menggunakan AWS Security Token Service (AWS STS) untuk menghasilkan kredensil keamanan sementara (juga dikenal sebagai *token sesi*). Token sesi memungkinkan Anda untuk sementara mengambil peran AWS Identity and Access Management (IAM) sehingga Anda dapat mengakses Layanan AWS. Untuk memanggil [CloudFront KeyValueStore API](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_Operations_Amazon_CloudFront_KeyValueStore.html), gunakan titik akhir *Regional* AWS STS untuk mengembalikan token sesi *versi 2*. Jika Anda menggunakan endpoint *global* for AWS STS (`sts.amazonaws.com`), AWS STS akan menghasilkan token sesi *versi 1*, yang tidak didukung oleh Signature Version 4A (Sigv4a). Akibatnya, Anda akan menerima kesalahan otentikasi. Untuk memanggil CloudFront KeyValueStore API, Anda dapat menggunakan opsi berikut: **AWS CLI dan AWS SDKs** Anda dapat mengonfigurasi AWS CLI atau AWS SDK untuk menggunakan titik AWS STS akhir Regional. Untuk informasi selengkapnya, lihat [Titik akhir AWS STS regional](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sts-regionalized-endpoints.html) di *AWS SDK dan* Panduan Referensi Alat. Untuk informasi selengkapnya tentang AWS STS titik akhir yang tersedia, lihat [Wilayah dan titik akhir](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html#id_credentials_region-endpoints) di Panduan Pengguna *IAM*. **SAML ** Anda dapat mengkonfigurasi SAFL untuk menggunakan AWS STS endpoint Regional. Untuk informasi selengkapnya, lihat [Cara menggunakan titik akhir SAM regional untuk posting blog failover](https://aws.amazon.com/blogs/security/how-to-use-regional-saml-endpoints-for-failover/). **API `SetSecurityTokenServicePreferences`** Alih-alih menggunakan AWS STS titik akhir Regional, Anda dapat mengonfigurasi titik akhir global AWS STS untuk mengembalikan token sesi versi 2. Untuk melakukannya, gunakan operasi [SetSecurityTokenServicePreferences](https://docs.aws.amazon.com/IAM/latest/APIReference/API_SetSecurityTokenServicePreferences.html)API untuk mengonfigurasi Anda Akun AWS. **Example Contoh: perintah IAM CLI** ``` aws iam set-security-token-service-preferences --global-endpoint-token-version v2Token ``` Kami menyarankan Anda menggunakan titik akhir AWS STS Regional alih-alih opsi ini. Titik akhir regional memberikan ketersediaan dan skenario failover yang lebih tinggi. **Penyedia identitas khusus** Jika Anda menggunakan penyedia identitas khusus yang melakukan federasi dan mengambil peran, gunakan salah satu opsi sebelumnya untuk sistem penyedia identitas induk yang bertanggung jawab untuk membuat token sesi. ## Waktu Aktif Lingkungan runtime CloudFront Functions tidak mendukung evaluasi kode dinamis, dan membatasi akses ke jaringan, sistem file, variabel lingkungan, dan timer. Untuk informasi selengkapnya, lihat [Fitur yang dibatasi](functions-javascript-runtime-10.md#writing-functions-javascript-features-restricted-features). **catatan** Untuk menggunakannya CloudFront KeyValueStore, CloudFront fungsi Anda harus menggunakan [JavaScript runtime 2.0](functions-javascript-runtime-20.md). ## Hitung pemanfaatan CloudFront Fungsi memiliki batas waktu yang dibutuhkan untuk menjalankan, diukur sebagai *pemanfaatan komputasi*. Pemanfaatan komputasi adalah angka antara 0 dan 100 yang menunjukkan jumlah waktu yang fungsi butuhkan untuk berjalan sebagai persentase dari waktu maksimum yang diizinkan. Misalnya, pemanfaatan komputasi 35 berarti bahwa fungsi selesai pada 35% dari waktu maksimum yang diizinkan. Saat Anda [menguji fungsi](test-function.md), Anda dapat melihat nilai pemanfaatan komputasi dalam output dari peristiwa uji. Untuk fungsi produksi, Anda dapat melihat [metrik pemanfaatan komputasi](viewing-cloudfront-metrics.md#monitoring-console.cloudfront-functions) pada [halaman Pemantauan di CloudFront konsol](https://console.aws.amazon.com/cloudfront/v4/home?#/monitoring), atau di. CloudWatch # Pembatasan Lambda@Edge Pembatasan berikut hanya berlaku untuk Lambda@Edge. **Contents** + [Resolusi DNS](#lambda-at-edge-restrictions-dns) + [Kode status HTTP](#lambda-at-edge-restrictions-status-codes) + [Versi fungsi Lambda](#lambda-at-edge-restrictions-version) + [Wilayah Lambda](#lambda-at-edge-restrictions-region) + [Izin peran Lambda](#lambda-at-edge-restrictions-role-permissions) + [Fitur Lambda](#lambda-at-edge-restrictions-features) + [Waktu aktif yang didukung](#lambda-at-edge-restrictions-runtime) + [CloudFront header](#lambda-at-edge-restrictions-cloudfront-headers) + [Pembatasan pada isi permintaan dengan opsi sertakan isi](#lambda-at-edge-restrictions-request-body) + [Batas waktu respons dan batas waktu tetap hidup (hanya asal khusus)](#timeout-for-lambda-edge-functions) Untuk informasi tentang kuota, lihat[Kuotas di Lambda@Edge](cloudfront-limits.md#limits-lambda-at-edge). ## Resolusi DNS CloudFront melakukan resolusi DNS pada nama domain asal *sebelum* menjalankan fungsi permintaan asal Anda Lambda @Edge. Jika layanan DNS untuk domain Anda mengalami masalah dan tidak CloudFront dapat menyelesaikan nama domain untuk mendapatkan alamat IP, fungsi Lambda @Edge Anda tidak akan dipanggil. CloudFrontakan mengembalikan [kode status HTTP 502 (Bad Gateway)](http-502-bad-gateway.md) ke klien. Untuk informasi selengkapnya, lihat [Kesalahan DNS () `NonS3OriginDnsError`](http-502-bad-gateway.md#http-502-dns-error). Jika logika fungsi Anda memodifikasi nama domain asal, CloudFront akan melakukan resolusi DNS lain pada nama domain yang diperbarui setelah fungsi selesai dijalankan. Untuk informasi selengkapnya tentang mengelola failover DNS, lihat [Mengonfigurasi failover DNS](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring.html) di Panduan Pengembang *Amazon Route 53*. ## Kode status HTTP Fungsi Lambda @Edge untuk peristiwa respons penampil tidak dapat mengubah kode status HTTP respons, terlepas dari apakah respons berasal dari asal atau cache. CloudFront ## Versi fungsi Lambda Anda harus menggunakan versi bernomor dari fungsi Lambda, bukan `$LATEST` atau alias. ## Wilayah Lambda Fungsi Lambda harus di Wilayah US East (N. Virginia). ## Izin peran Lambda Peran eksekusi IAM yang terkait dengan fungsi Lambda harus mengizinkan layanan utama `lambda.amazonaws.com` dan `edgelambda.amazonaws.com` untuk menjalankan peran tersebut. Untuk informasi selengkapnya, lihat [Siapkan izin dan peran IAM untuk Lambda @Edge](lambda-edge-permissions.md). ## Fitur Lambda Fitur Lambda berikut tidak didukung oleh Lambda@Edge: + [Konfigurasi manajemen runtime Lambda selain Auto (](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-update.html#runtime-management-controls)**default)** + Konfigurasi fungsi Lambda Anda untuk mengakses sumber daya di dalam VPC Anda + [Lambda berfungsi antrian surat mati](https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#dlq) + [Variabel lingkungan Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html) (kecuali untuk variabel lingkungan cadangan, yang didukung secara otomatis) + Lambda berfungsi dengan [Mengelola AWS Lambda dependensi](https://docs.aws.amazon.com/lambda/latest/dg/chapter-layers.html) dengan lapisan + [Menggunakan AWS X-Ray](https://docs.aws.amazon.com/lambda/latest/dg/lambda-x-ray.html) + Konkurensi terprovisi Lambda **catatan** Fungsi Lambda @Edge memiliki kemampuan [konkurensi Regional](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html) yang sama dengan semua fungsi Lambda. Untuk informasi selengkapnya, lihat [Kuotas di Lambda@Edge](cloudfront-limits.md#limits-lambda-at-edge). + [Buat fungsi Lambda menggunakan gambar kontainer](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html) + [Fungsi Lambda yang menggunakan arsitektur arm64](https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html) + Lambda berfungsi dengan penyimpanan fana lebih dari 512 MB + Menggunakan [kunci terkelola pelanggan untuk mengenkripsi paket penerapan.zip Anda](https://docs.aws.amazon.com/lambda/latest/dg/encrypt-zip-package.html) ## Waktu aktif yang didukung Lambda @Edge mendukung runtime Node.js dan Python versi terbaru. *Untuk daftar versi yang didukung dan tanggal penghentian masa depannya, lihat [Runtime yang didukung](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtimes-supported) di Panduan Pengembang.AWS Lambda * **Tip** Sebagai praktik terbaik, gunakan versi terbaru dari runtime yang disediakan untuk peningkatan kinerja dan fitur baru. Anda tidak dapat membuat atau memperbarui fungsi dengan versi Node.js yang tidak digunakan lagi. Anda hanya dapat mengaitkan fungsi yang ada dengan versi ini dengan CloudFront distribusi. Fungsi dengan versi ini yang terkait dengan distribusi akan terus berjalan. Namun, kami menyarankan Anda memindahkan fungsi Anda ke versi Node.js yang lebih baru. Untuk informasi selengkapnya, [lihat kebijakan penghentian waktu](https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html) proses di *Panduan AWS Lambda Pengembang dan jadwal rilis* [Node.js](https://github.com/nodejs/Release#release-schedule) pada. GitHub ## CloudFront header Fungsi Lambda @Edge dapat membaca, mengedit, menghapus, atau menambahkan CloudFront header apa pun yang tercantum di. [Tambahkan header CloudFront permintaan](adding-cloudfront-headers.md) **Catatan** Jika Anda CloudFront ingin menambahkan header ini, Anda harus mengonfigurasi CloudFront untuk menambahkannya dengan menggunakan [kebijakan cache atau kebijakan](controlling-the-cache-key.md) [permintaan asal](controlling-origin-requests.md). CloudFront menambahkan header *setelah* peristiwa permintaan penampil, yang berarti header tidak tersedia untuk fungsi Lambda @Edge dalam permintaan penampil. Header hanya tersedia untuk fungsi Lambda @Edge dalam permintaan asal dan respons asal. Jika permintaan penampil menyertakan header yang memiliki nama ini, dan Anda mengonfigurasi CloudFront untuk menambahkan header ini menggunakan [kebijakan cache atau kebijakan](controlling-the-cache-key.md) [permintaan asal](controlling-origin-requests.md), maka CloudFront timpa nilai header yang ada dalam permintaan penampil. Fungsi yang menghadap pemirsa melihat nilai header dari permintaan penampil, sementara fungsi yang menghadap ke asal melihat nilai header yang ditambahkan. CloudFront Jika fungsi permintaan penampil menambahkan `CloudFront-Viewer-Country` header, itu gagal validasi dan CloudFront mengembalikan kode status HTTP 502 (Bad Gateway) ke penampil. ## Pembatasan pada isi permintaan dengan opsi sertakan isi Saat Anda memilih opsi **Sertakan Tubuh** untuk mengekspos badan permintaan ke fungsi Lambda @Edge Anda, informasi dan batas ukuran berikut berlaku untuk bagian tubuh yang diekspos atau diganti. + CloudFront selalu base64 mengkodekan badan permintaan sebelum memaparkannya ke Lambda @Edge. + Jika badan permintaan besar, CloudFront potong sebelum memaparkannya ke Lambda @Edge, sebagai berikut: + Untuk peristiwa permintaan penampil, isi dipotong pada 40 KB. + Untuk peristiwa permintaan asal, isi dipotong pada 1 MB. + Jika Anda mengakses isi permintaan sebagai hanya-baca, CloudFront kirimkan badan permintaan asli lengkap ke asal. + Jika fungsi Lambda @Edge Anda menggantikan badan permintaan, batas ukuran berikut berlaku untuk badan yang dikembalikan fungsi: + Jika fungsi Lambda@Edge mengembalikan isi sebagai teks biasa: + Untuk acara permintaan pemirsa, batas isi adalah 40 KB. + Untuk acara permintaan asal, batas isi adalah 1 MB. + Jika fungsi Lambda@Edge mengembalikan isi sebagai terks berenkode base64: + Untuk acara permintaan pemirsa, batas isi adalah 53,2 KB. + Untuk acara permintaan asal, batas isi adalah 1,33 MB. **catatan** Jika fungsi Lambda @Edge Anda mengembalikan badan yang melebihi batas ini, permintaan Anda akan gagal dengan kode status HTTP 502 (). [Kesalahan validasi Lambda](http-502-bad-gateway.md#http-502-lambda-validation-error) Kami menyarankan Anda memperbarui fungsi Lambda @Edge Anda sehingga tubuh tidak melebihi batas ini. ## Batas waktu respons dan batas waktu tetap hidup (hanya asal khusus) Jika Anda menggunakan fungsi Lambda @Edge untuk mengatur batas waktu respons atau batas waktu keep-alive untuk asal distribusi, verifikasi bahwa Anda menentukan nilai yang dapat didukung oleh asal Anda. Lihat informasi yang lebih lengkap di [Tanggapan dan kuota batas waktu tetap hidup](DownloadDistValuesOrigin.md#response-keep-alive-timeout-quota).