Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Tutorial: Menggunakan pemetaan sumber peristiwa MSK Amazon untuk menjalankan fungsi Lambda Dalam tutorial ini, Anda akan melakukan hal berikut: + Buat fungsi Lambda di AWS akun yang sama dengan cluster MSK Amazon yang ada. + Konfigurasikan jaringan dan otentikasi untuk Lambda untuk berkomunikasi dengan Amazon MSK. + Siapkan pemetaan sumber peristiwa MSK Lambda Amazon, yang menjalankan fungsi Lambda Anda saat peristiwa muncul di topik. Setelah Anda selesai dengan langkah-langkah ini, ketika acara dikirim ke Amazon MSK, Anda akan dapat mengatur fungsi Lambda untuk memproses peristiwa tersebut secara otomatis dengan kode Lambda kustom Anda sendiri. **Apa yang dapat Anda lakukan dengan fitur ini?** **Contoh solusi: Gunakan pemetaan sumber acara MSK untuk memberikan skor langsung kepada pelanggan Anda.** Pertimbangkan skenario berikut: Perusahaan Anda menghosting aplikasi web tempat pelanggan Anda dapat melihat informasi tentang acara langsung, seperti permainan olahraga. Pembaruan informasi dari game disediakan untuk tim Anda melalui topik Kafka di Amazon MSK. Anda ingin merancang solusi yang menggunakan pembaruan dari topik MSK untuk memberikan tampilan terbaru dari acara langsung kepada pelanggan di dalam aplikasi yang Anda kembangkan. Anda telah memutuskan pendekatan desain berikut: Aplikasi klien Anda akan berkomunikasi dengan backend tanpa server yang dihosting. AWS Klien akan terhubung melalui sesi websocket menggunakan Amazon API Gateway WebSocket API. Dalam solusi ini, Anda memerlukan komponen yang membaca peristiwa MSK, melakukan beberapa logika khusus untuk mempersiapkan peristiwa tersebut untuk lapisan aplikasi dan kemudian meneruskan informasi tersebut ke API Gateway API. Anda dapat mengimplementasikan komponen ini dengan AWS Lambda, dengan menyediakan logika kustom Anda dalam fungsi Lambda, lalu memanggilnya dengan pemetaan sumber peristiwa MSK AWS Lambda Amazon. Untuk informasi selengkapnya tentang penerapan solusi menggunakan Amazon API Gateway WebSocket API, lihat [tutorial WebSocket API](https://docs.aws.amazon.com/apigateway/latest/developerguide/websocket-api-chat-app.html) di dokumentasi API Gateway. ## Prasyarat AWS Akun dengan sumber daya yang telah dikonfigurasi berikut: **Untuk memenuhi prasyarat ini, kami sarankan mengikuti [Memulai menggunakan Amazon MSK di dokumentasi MSK Amazon](https://docs.aws.amazon.com//msk/latest/developerguide/getting-started.html).** + Cluster MSK Amazon. Lihat [Membuat klaster MSK Amazon](https://docs.aws.amazon.com//msk/latest/developerguide/create-cluster.html) di *Memulai menggunakan Amazon MSK*. + Konfigurasi berikut: + Pastikan **autentikasi berbasis peran IAM** **Diaktifkan di pengaturan keamanan klaster** Anda. Ini meningkatkan keamanan Anda dengan membatasi fungsi Lambda Anda untuk hanya mengakses sumber daya MSK Amazon yang diperlukan. Ini diaktifkan secara default pada kluster MSK Amazon baru. + Pastikan **akses Publik** tidak aktif di pengaturan jaringan cluster Anda. Membatasi akses klaster MSK Amazon Anda ke internet meningkatkan keamanan Anda dengan membatasi berapa banyak perantara yang menangani data Anda. Ini diaktifkan secara default pada kluster MSK Amazon baru. + Topik Kafka di cluster MSK Amazon Anda untuk digunakan untuk solusi ini. Lihat [Membuat topik](https://docs.aws.amazon.com//msk/latest/developerguide/create-topic.html) di *Memulai menggunakan Amazon MSK*. + Host admin Kafka disiapkan untuk mengambil informasi dari cluster Kafka Anda dan mengirim acara Kafka ke topik Anda untuk pengujian, seperti instans Amazon EC2 dengan CLI admin Kafka dan perpustakaan Amazon MSK IAM diinstal. Lihat [Membuat mesin klien](https://docs.aws.amazon.com//msk/latest/developerguide/create-client-machine.html) di *Memulai menggunakan Amazon MSK*. Setelah Anda menyiapkan sumber daya ini, kumpulkan informasi berikut dari AWS akun Anda untuk mengonfirmasi bahwa Anda siap untuk melanjutkan. + Nama cluster MSK Amazon Anda. Anda dapat menemukan informasi ini di konsol MSK Amazon. + Cluster UUID, bagian dari ARN untuk cluster MSK Amazon Anda, yang dapat Anda temukan di konsol MSK Amazon. Ikuti prosedur di [Daftar klaster](https://docs.aws.amazon.com/msk/latest/developerguide/msk-list-clusters.html) di dokumentasi MSK Amazon untuk menemukan informasi ini. + Grup keamanan yang terkait dengan kluster MSK Amazon Anda. Anda dapat menemukan informasi ini di konsol MSK Amazon. Dalam langkah-langkah berikut, lihat ini sebagai milik Anda*clusterSecurityGroups*. + Id dari VPC Amazon yang berisi kluster MSK Amazon Anda. Anda dapat menemukan informasi ini dengan mengidentifikasi subnet yang terkait dengan cluster MSK Amazon Anda di konsol MSK Amazon, lalu mengidentifikasi VPC Amazon yang terkait dengan subnet di Konsol VPC Amazon. + Nama topik Kafka yang digunakan dalam solusi Anda. Anda dapat menemukan informasi ini dengan menghubungi cluster MSK Amazon Anda dengan Kafka `topics` CLI dari host admin Kafka Anda. Untuk informasi selengkapnya tentang topik CLI, lihat [Menambahkan dan menghapus topik dalam dokumentasi](https://kafka.apache.org/documentation/#basic_ops_add_topic) Kafka. + Nama grup konsumen untuk topik Kafka Anda, cocok untuk digunakan oleh fungsi Lambda Anda. Grup ini dapat dibuat secara otomatis oleh Lambda, jadi Anda tidak perlu membuatnya dengan Kafka CLI. Jika Anda perlu mengelola grup konsumen Anda, untuk mempelajari lebih lanjut tentang CLI kelompok konsumen, [lihat Mengelola Grup Konsumen](https://kafka.apache.org/documentation/#basic_ops_consumer_group) di dokumentasi Kafka. Izin berikut di AWS akun Anda: + Izin untuk membuat dan mengelola fungsi Lambda. + Izin untuk membuat kebijakan IAM dan mengaitkannya dengan fungsi Lambda Anda. + Izin untuk membuat titik akhir VPC Amazon dan mengubah konfigurasi jaringan di VPC Amazon yang menghosting kluster MSK Amazon Anda. ### Instal AWS Command Line Interface Jika Anda belum menginstal AWS Command Line Interface, ikuti langkah-langkah di [Menginstal atau memperbarui versi terbaru AWS CLI untuk menginstalnya](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). Tutorial ini membutuhkan terminal baris perintah atau shell untuk menjalankan perintah. Di Linux dan macOS, gunakan shell dan manajer paket pilihan Anda. **catatan** Di Windows, beberapa perintah Bash CLI yang biasa Anda gunakan dengan Lambda (`zip`seperti) tidak didukung oleh terminal bawaan sistem operasi. Untuk mendapatkan versi terintegrasi Windows dari Ubuntu dan Bash, [instal Windows Subsystem untuk](https://docs.microsoft.com/en-us/windows/wsl/install-win10) Linux. ## Konfigurasikan konektivitas jaringan untuk Lambda untuk berkomunikasi dengan Amazon MSK Gunakan AWS PrivateLink untuk menghubungkan Lambda dan Amazon MSK. Anda dapat melakukannya dengan membuat antarmuka titik akhir VPC Amazon di konsol VPC Amazon. Untuk informasi selengkapnya tentang konfigurasi jaringan, lihat[Mengonfigurasi kluster MSK Amazon dan jaringan VPC Amazon untuk Lambda](with-msk-cluster-network.md). Ketika pemetaan sumber peristiwa MSK Amazon berjalan atas nama fungsi Lambda, ia mengasumsikan peran eksekusi fungsi Lambda. Peran IAM ini mengizinkan pemetaan untuk mengakses sumber daya yang diamankan oleh IAM, seperti kluster MSK Amazon Anda. Meskipun komponen berbagi peran eksekusi, pemetaan MSK Amazon dan fungsi Lambda Anda memiliki persyaratan konektivitas terpisah untuk tugasnya masing-masing, seperti yang ditunjukkan pada diagram berikut. ![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/msk_tut_network.png) Pemetaan sumber acara Anda milik grup keamanan klaster MSK Amazon Anda. Pada langkah jaringan ini, buat titik akhir VPC Amazon dari VPC cluster MSK Amazon Anda untuk menghubungkan pemetaan sumber peristiwa ke layanan Lambda dan STS. Amankan titik akhir ini untuk menerima lalu lintas dari grup keamanan klaster MSK Amazon Anda. Kemudian, sesuaikan grup keamanan cluster MSK Amazon untuk memungkinkan pemetaan sumber peristiwa berkomunikasi dengan cluster MSK Amazon. Anda dapat mengonfigurasi langkah-langkah berikut menggunakan file Konsol Manajemen AWS. **Untuk mengonfigurasi antarmuka titik akhir Amazon VPC untuk menghubungkan Lambda dan Amazon MSK** 1. Buat grup keamanan untuk antarmuka Anda titik akhir Amazon VPC,*endpointSecurityGroup*, yang memungkinkan lalu lintas TCP masuk pada 443 dari. *clusterSecurityGroups* Ikuti prosedur di [Buat grup keamanan](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/working-with-security-groups.html#creating-security-group) di dokumentasi Amazon EC2 untuk membuat grup keamanan. Kemudian, ikuti prosedur di [Tambahkan aturan ke grup keamanan](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule) di dokumentasi Amazon EC2 untuk menambahkan aturan yang sesuai. **Buat grup keamanan dengan informasi berikut:** Saat menambahkan aturan masuk Anda, buat aturan untuk setiap grup keamanan di*clusterSecurityGroups*. Untuk setiap aturan: + Untuk **Type**, pilih **HTTPS**. + Untuk **Sumber**, pilih salah satu dari*clusterSecurityGroups*. 1. Buat titik akhir yang menghubungkan layanan Lambda ke VPC Amazon yang berisi kluster MSK Amazon Anda. Ikuti prosedur di [Buat titik akhir antarmuka](https://docs.aws.amazon.com//vpc/latest/privatelink/create-interface-endpoint.html). **Buat titik akhir antarmuka dengan informasi berikut:** + Untuk **nama Layanan**, pilih`com.amazonaws.regionName.lambda`, di mana *regionName* host fungsi Lambda Anda. + Untuk **VPC, pilih VPC** Amazon yang berisi kluster MSK Amazon Anda. + Untuk **grup Keamanan**, pilih*endpointSecurityGroup*, yang Anda buat sebelumnya. + Untuk **Subnet**, pilih subnet yang meng-host cluster MSK Amazon Anda. + Untuk **Kebijakan**, berikan dokumen kebijakan berikut, yang mengamankan titik akhir untuk digunakan oleh kepala layanan Lambda untuk tindakan tersebut. `lambda:InvokeFunction` ``` { "Statement": [ { "Action": "lambda:InvokeFunction", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com" ] }, "Resource": "*" } ] } ``` + Pastikan **Aktifkan nama DNS** tetap disetel. 1. Buat titik akhir yang menghubungkan AWS STS layanan ke VPC Amazon yang berisi kluster MSK Amazon Anda. Ikuti prosedur di [Buat titik akhir antarmuka](https://docs.aws.amazon.com//vpc/latest/privatelink/create-interface-endpoint.html). **Buat titik akhir antarmuka dengan informasi berikut:** + Untuk **nama Layanan**, pilih AWS STS. + Untuk **VPC, pilih VPC** Amazon yang berisi kluster MSK Amazon Anda. + Untuk **grup Keamanan**, pilih*endpointSecurityGroup*. + Untuk **Subnet**, pilih subnet yang meng-host cluster MSK Amazon Anda. + Untuk **Kebijakan**, berikan dokumen kebijakan berikut, yang mengamankan titik akhir untuk digunakan oleh kepala layanan Lambda untuk tindakan tersebut. `sts:AssumeRole` ``` { "Statement": [ { "Action": "sts:AssumeRole", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com" ] }, "Resource": "*" } ] } ``` + Pastikan **Aktifkan nama DNS** tetap disetel. 1. Untuk setiap grup keamanan yang terkait dengan kluster MSK Amazon Anda, yaitu*clusterSecurityGroups*, izinkan hal berikut: + Izinkan semua lalu lintas TCP masuk dan keluar pada 9098 ke semua*clusterSecurityGroups*, termasuk di dalam dirinya sendiri. + Izinkan semua lalu lintas TCP keluar pada 443. Beberapa lalu lintas ini diizinkan oleh aturan grup keamanan default, jadi jika klaster Anda dilampirkan ke satu grup keamanan, dan grup tersebut memiliki aturan default, aturan tambahan tidak diperlukan. Untuk menyesuaikan aturan grup keamanan, ikuti prosedur di [Tambahkan aturan ke grup keamanan](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule) di dokumentasi Amazon EC2. **Tambahkan aturan ke grup keamanan Anda dengan informasi berikut:** + Untuk setiap aturan masuk atau aturan keluar untuk port 9098, sediakan + Untuk **Jenis**, pilih **TCP Kustom**. + Untuk **jangkauan Port**, sediakan 9098. + Untuk **Sumber**, berikan salah satu dari*clusterSecurityGroups*. + **Untuk setiap aturan masuk untuk port 443, untuk **Type**, pilih HTTPS.** ## Buat peran IAM untuk dibaca Lambda dari topik MSK Amazon Anda Identifikasi persyaratan autentikasi untuk dibaca Lambda dari topik MSK Amazon Anda, lalu tentukan dalam kebijakan. Buat peran,*lambdaAuthRole*, yang mengizinkan Lambda untuk menggunakan izin tersebut. Otorisasi tindakan di klaster MSK Amazon Anda menggunakan tindakan `kafka-cluster` IAM. Kemudian, beri wewenang kepada Lambda untuk melakukan tindakan Amazon `kafka` MSK dan Amazon EC2 yang diperlukan untuk menemukan dan terhubung ke kluster MSK Amazon Anda, serta CloudWatch tindakan agar Lambda dapat mencatat apa yang telah dilakukannya. **Untuk menjelaskan persyaratan autentikasi agar Lambda dapat dibaca dari Amazon MSK** 1. Tulis dokumen kebijakan IAM (dokumen JSON),*clusterAuthPolicy*, yang memungkinkan Lambda membaca dari topik Kafka Anda di kluster MSK Amazon Anda menggunakan grup konsumen Kafka Anda. Lambda membutuhkan kelompok konsumen Kafka untuk diatur saat membaca. Ubah template berikut agar selaras dengan prasyarat Anda: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "kafka-cluster:Connect", "kafka-cluster:DescribeGroup", "kafka-cluster:AlterGroup", "kafka-cluster:DescribeTopic", "kafka-cluster:ReadData", "kafka-cluster:DescribeClusterDynamicConfiguration" ], "Resource": [ "arn:aws:kafka:us-east-1:111122223333:cluster/mskClusterName/cluster-uuid", "arn:aws:kafka:us-east-1:111122223333:topic/mskClusterName/cluster-uuid/mskTopicName", "arn:aws:kafka:us-east-1:111122223333:group/mskClusterName/cluster-uuid/mskGroupName" ] } ] } ``` ------ Untuk informasi lebih lanjut, konsultasikan[Mengonfigurasi izin Lambda untuk pemetaan sumber acara MSK Amazon](with-msk-permissions.md). Saat menulis kebijakan Anda: + Ganti *us-east-1* dan *111122223333* dengan Wilayah AWS dan Akun AWS dari kluster MSK Amazon Anda. + Untuk*mskClusterName*, berikan nama cluster MSK Amazon Anda. + Untuk*cluster-uuid*, berikan UUID di ARN untuk cluster MSK Amazon Anda. + Untuk*mskTopicName*, berikan nama topik Kafka Anda. + Untuk*mskGroupName*, berikan nama grup konsumen Kafka Anda. 1. Identifikasi MSK Amazon, Amazon EC2, CloudWatch dan izin yang diperlukan Lambda untuk menemukan dan menghubungkan kluster MSK Amazon Anda, dan mencatat peristiwa tersebut. Kebijakan `AWSLambdaMSKExecutionRole` terkelola secara permisif mendefinisikan izin yang diperlukan. Gunakan dalam langkah-langkah berikut. Dalam lingkungan produksi, nilai `AWSLambdaMSKExecutionRole` untuk membatasi kebijakan peran eksekusi Anda berdasarkan prinsip hak istimewa terkecil, lalu tulis kebijakan untuk peran Anda yang menggantikan kebijakan terkelola ini. Untuk detail tentang bahasa kebijakan IAM, lihat dokumentasi [IAM](https://docs.aws.amazon.com//iam/). Sekarang setelah Anda menulis dokumen kebijakan Anda, buat kebijakan IAM sehingga Anda dapat melampirkannya ke peran Anda. Anda dapat melakukan ini menggunakan konsol dengan prosedur berikut. **Untuk membuat kebijakan IAM dari dokumen kebijakan Anda** 1. Masuk ke Konsol Manajemen AWS dan buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Di panel navigasi sebelah kiri, pilih **Kebijakan**. 1. Pilih **Buat kebijakan**. 1. Di bagian **Editor kebijakan**, pilih opsi **JSON**. 1. Tempel*clusterAuthPolicy*. 1. Setelah selesai menambahkan izin ke kebijakan, pilih **Berikutnya**. 1. Pada halaman **Tinjau dan buat**, ketik **Nama Kebijakan** dan **Deskripsi** (opsional) untuk kebijakan yang Anda buat. Tinjau **Izin yang ditentukan dalam kebijakan ini** untuk melihat izin yang diberikan oleh kebijakan Anda. 1. Pilih **Buat kebijakan** untuk menyimpan kebijakan baru Anda. Untuk informasi selengkapnya, lihat [Membuat kebijakan IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/access_policies_create.html) di dokumentasi IAM. Sekarang setelah Anda memiliki kebijakan IAM yang sesuai, buat peran dan lampirkan padanya. Anda dapat melakukan ini menggunakan konsol dengan prosedur berikut. **Untuk membuat peran eksekusi di konsol IAM** 1. Buka [Halaman peran](https://console.aws.amazon.com/iam/home#/roles) di konsol IAM. 1. Pilih **Buat peran**. 1. Di bawah **Jenis entitas tepercaya**, pilih **AWS layanan**. 1. Di bawah **Kasus penggunaan**, pilih **Lambda**. 1. Pilih **Berikutnya**. 1. Pilih kebijakan berikut: + *clusterAuthPolicy* + `AWSLambdaMSKExecutionRole` 1. Pilih **Berikutnya**. 1. Untuk **nama Peran**, *lambdaAuthRole* masukkan lalu pilih **Buat peran**. Untuk informasi selengkapnya, lihat [Mendefinisikan izin fungsi Lambda dengan peran pelaksanaan](lambda-intro-execution-role.md). ## Buat fungsi Lambda untuk membaca dari topik MSK Amazon Anda Buat fungsi Lambda yang dikonfigurasi untuk menggunakan peran IAM Anda. Anda dapat membuat fungsi Lambda menggunakan konsol. **Untuk membuat fungsi Lambda menggunakan konfigurasi autentikasi Anda** 1. Buka konsol Lambda dan pilih **Buat fungsi** dari header. 1. Pilih **Penulis dari awal**. 1. Untuk **nama Fungsi**, berikan nama yang sesuai pilihan Anda. 1. Untuk **Runtime**, pilih versi **terbaru yang didukung** `Node.js` untuk menggunakan kode yang disediakan dalam tutorial ini. 1. Pilih **Ubah peran eksekusi default**. 1. Pilih **Gunakan peran yang ada**. 1. Untuk **peran yang ada**, pilih*lambdaAuthRole*. Dalam lingkungan produksi, Anda biasanya perlu menambahkan kebijakan lebih lanjut ke peran eksekusi untuk fungsi Lambda Anda untuk memproses peristiwa MSK Amazon Anda secara bermakna. Untuk informasi selengkapnya tentang menambahkan kebijakan ke peran Anda, lihat [Menambahkan atau menghapus izin identitas](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console) dalam dokumentasi IAM. ## Buat pemetaan sumber acara ke fungsi Lambda Anda Pemetaan sumber peristiwa MSK Amazon Anda memberi layanan Lambda informasi yang diperlukan untuk memanggil Lambda Anda saat peristiwa MSK Amazon yang sesuai terjadi. Anda dapat membuat pemetaan MSK Amazon menggunakan konsol. Buat pemicu Lambda, lalu pemetaan sumber peristiwa diatur secara otomatis. **Untuk membuat pemicu Lambda (dan pemetaan sumber peristiwa)** 1. Arahkan ke halaman ikhtisar fungsi Lambda Anda. 1. Di bagian ikhtisar fungsi, pilih **Tambahkan pemicu** di kiri bawah. 1. Di menu tarik-turun **Pilih sumber**, pilih **Amazon** MSK. 1. Jangan mengatur **otentikasi.** 1. Untuk **klaster MSK**, pilih nama klaster Anda. 1. Untuk **ukuran Batch**, masukkan 1. Langkah ini membuat fitur ini lebih mudah untuk diuji, dan bukan merupakan nilai ideal dalam produksi. 1. Untuk **nama Topik**, berikan nama topik Kafka Anda. 1. Untuk **ID grup Konsumen**, berikan id grup konsumen Kafka Anda. ## Perbarui fungsi Lambda Anda untuk membaca data streaming Anda Lambda memberikan informasi tentang peristiwa Kafka melalui parameter metode acara. Untuk contoh struktur acara MSK Amazon, lihat[Contoh peristiwa](with-msk.md#msk-sample-event). Setelah Anda memahami cara menafsirkan peristiwa MSK Amazon yang diteruskan Lambda, Anda dapat mengubah kode fungsi Lambda Anda untuk menggunakan informasi yang mereka berikan. Berikan kode berikut ke fungsi Lambda Anda untuk mencatat konten acara MSK Lambda Amazon untuk tujuan pengujian: ------ #### [ .NET ] **SDK untuk .NET** Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Mengkonsumsi acara MSK Amazon dengan Lambda menggunakan.NET. ``` using System.Text; using Amazon.Lambda.Core; using Amazon.Lambda.KafkaEvents; // Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class. [assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))] namespace MSKLambda; public class Function { /// The event for the Lambda function handler to process. /// The ILambdaContext that provides methods for logging and describing the Lambda environment. /// public void FunctionHandler(KafkaEvent evnt, ILambdaContext context) { foreach (var record in evnt.Records) { Console.WriteLine("Key:" + record.Key); foreach (var eventRecord in record.Value) { var valueBytes = eventRecord.Value.ToArray(); var valueText = Encoding.UTF8.GetString(valueBytes); Console.WriteLine("Message:" + valueText); } } } } ``` ------ #### [ Go ] **SDK untuk Go V2** Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Mengkonsumsi acara MSK Amazon dengan Lambda menggunakan Go. ``` package main import ( "encoding/base64" "fmt" "github.com/aws/aws-lambda-go/events" "github.com/aws/aws-lambda-go/lambda" ) func handler(event events.KafkaEvent) { for key, records := range event.Records { fmt.Println("Key:", key) for _, record := range records { fmt.Println("Record:", record) decodedValue, _ := base64.StdEncoding.DecodeString(record.Value) message := string(decodedValue) fmt.Println("Message:", message) } } } func main() { lambda.Start(handler) } ``` ------ #### [ Java ] **SDK untuk Java 2.x** Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Mengkonsumsi acara MSK Amazon dengan Lambda menggunakan Java. ``` import com.amazonaws.services.lambda.runtime.Context; import com.amazonaws.services.lambda.runtime.RequestHandler; import com.amazonaws.services.lambda.runtime.events.KafkaEvent; import com.amazonaws.services.lambda.runtime.events.KafkaEvent.KafkaEventRecord; import java.util.Base64; import java.util.Map; public class Example implements RequestHandler { @Override public Void handleRequest(KafkaEvent event, Context context) { for (Map.Entry> entry : event.getRecords().entrySet()) { String key = entry.getKey(); System.out.println("Key: " + key); for (KafkaEventRecord record : entry.getValue()) { System.out.println("Record: " + record); byte[] value = Base64.getDecoder().decode(record.getValue()); String message = new String(value); System.out.println("Message: " + message); } } return null; } } ``` ------ #### [ JavaScript ] **SDK untuk JavaScript (v3)** Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Mengkonsumsi acara MSK Amazon dengan menggunakan JavaScript Lambda. ``` exports.handler = async (event) => { // Iterate through keys for (let key in event.records) { console.log('Key: ', key) // Iterate through records event.records[key].map((record) => { console.log('Record: ', record) // Decode base64 const msg = Buffer.from(record.value, 'base64').toString() console.log('Message:', msg) }) } } ``` Mengkonsumsi acara MSK Amazon dengan menggunakan TypeScript Lambda. ``` import { MSKEvent, Context } from "aws-lambda"; import { Buffer } from "buffer"; import { Logger } from "@aws-lambda-powertools/logger"; const logger = new Logger({ logLevel: "INFO", serviceName: "msk-handler-sample", }); export const handler = async ( event: MSKEvent, context: Context ): Promise => { for (const [topic, topicRecords] of Object.entries(event.records)) { logger.info(`Processing key: ${topic}`); // Process each record in the partition for (const record of topicRecords) { try { // Decode the message value from base64 const decodedMessage = Buffer.from(record.value, 'base64').toString(); logger.info({ message: decodedMessage }); } catch (error) { logger.error('Error processing event', { error }); throw error; } }; } } ``` ------ #### [ PHP ] **SDK untuk PHP** Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Mengkonsumsi acara MSK Amazon dengan Lambda menggunakan PHP. ``` logger = $logger; } /** * @throws JsonException * @throws \Bref\Event\InvalidLambdaEvent */ public function handle(mixed $event, Context $context): void { $kafkaEvent = new KafkaEvent($event); $this->logger->info("Processing records"); $records = $kafkaEvent->getRecords(); foreach ($records as $record) { try { $key = $record->getKey(); $this->logger->info("Key: $key"); $values = $record->getValue(); $this->logger->info(json_encode($values)); foreach ($values as $value) { $this->logger->info("Value: $value"); } } catch (Exception $e) { $this->logger->error($e->getMessage()); } } $totalRecords = count($records); $this->logger->info("Successfully processed $totalRecords records"); } } $logger = new StderrLogger(); return new Handler($logger); ``` ------ #### [ Python ] **SDK untuk Python (Boto3)** Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Mengkonsumsi acara MSK Amazon dengan Lambda menggunakan Python. ``` import base64 def lambda_handler(event, context): # Iterate through keys for key in event['records']: print('Key:', key) # Iterate through records for record in event['records'][key]: print('Record:', record) # Decode base64 msg = base64.b64decode(record['value']).decode('utf-8') print('Message:', msg) ``` ------ #### [ Ruby ] **SDK untuk Ruby** Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Mengkonsumsi acara MSK Amazon dengan Lambda menggunakan Ruby. ``` require 'base64' def lambda_handler(event:, context:) # Iterate through keys event['records'].each do |key, records| puts "Key: #{key}" # Iterate through records records.each do |record| puts "Record: #{record}" # Decode base64 msg = Base64.decode64(record['value']) puts "Message: #{msg}" end end end ``` ------ #### [ Rust ] **SDK for Rust** Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Mengkonsumsi acara MSK Amazon dengan Lambda menggunakan Rust. ``` use aws_lambda_events::event::kafka::KafkaEvent; use lambda_runtime::{run, service_fn, tracing, Error, LambdaEvent}; use base64::prelude::*; use serde_json::{Value}; use tracing::{info}; /// Pre-Requisites: /// 1. Install Cargo Lambda - see https://www.cargo-lambda.info/guide/getting-started.html /// 2. Add packages tracing, tracing-subscriber, serde_json, base64 /// /// This is the main body for the function. /// Write your code inside it. /// There are some code example in the following URLs: /// - https://github.com/awslabs/aws-lambda-rust-runtime/tree/main/examples /// - https://github.com/aws-samples/serverless-rust-demo/ async fn function_handler(event: LambdaEvent) -> Result { let payload = event.payload.records; for (_name, records) in payload.iter() { for record in records { let record_text = record.value.as_ref().ok_or("Value is None")?; info!("Record: {}", &record_text); // perform Base64 decoding let record_bytes = BASE64_STANDARD.decode(record_text)?; let message = std::str::from_utf8(&record_bytes)?; info!("Message: {}", message); } } Ok(().into()) } #[tokio::main] async fn main() -> Result<(), Error> { // required to enable CloudWatch error logging by the runtime tracing::init_default_subscriber(); info!("Setup CW subscriber!"); run(service_fn(function_handler)).await } ``` ------ Anda dapat memberikan kode fungsi ke Lambda Anda menggunakan konsol. **Untuk memperbarui kode fungsi menggunakan editor kode konsol** 1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) konsol Lambda dan pilih fungsi Anda. 1. Pilih tab **Kode**. 1. Di panel **Sumber kode**, pilih file kode sumber Anda dan edit di editor kode terintegrasi. 1. Di bagian **DEPLOY**, pilih **Deploy** untuk memperbarui kode fungsi Anda: ![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png) ## Uji fungsi Lambda Anda untuk memverifikasi bahwa itu terhubung ke topik MSK Amazon Anda Anda sekarang dapat memverifikasi apakah Lambda Anda sedang dipanggil oleh sumber peristiwa dengan memeriksa CloudWatch log peristiwa atau tidak. **Untuk memverifikasi apakah fungsi Lambda Anda sedang dipanggil** 1. Gunakan host admin Kafka Anda untuk menghasilkan acara Kafka menggunakan CLI`kafka-console-producer`. Untuk informasi lebih lanjut, lihat [Menulis beberapa peristiwa ke dalam topik](https://kafka.apache.org/documentation/#quickstart_send) dalam dokumentasi Kafka. Kirim peristiwa yang cukup untuk mengisi batch yang ditentukan oleh ukuran batch untuk pemetaan sumber peristiwa yang ditentukan pada langkah sebelumnya, atau Lambda akan menunggu informasi lebih lanjut untuk dipanggil. 1. Jika fungsi Anda berjalan, Lambda menulis apa yang terjadi. CloudWatch Di konsol, navigasikan ke halaman detail fungsi Lambda Anda. 1. Pilih tab **Konfigurasi**. 1. Dari sidebar, pilih **Alat pemantauan dan operasi**. 1. Identifikasi **grup CloudWatch log** di bawah **konfigurasi Logging**. Grup log harus dimulai dengan`/aws/lambda`. Pilih tautan ke grup log. 1. Di CloudWatch konsol, periksa peristiwa Log untuk **peristiwa log** yang dikirim Lambda ke aliran log. Identifikasi apakah ada peristiwa log yang berisi pesan dari acara Kafka Anda, seperti pada gambar berikut. Jika ada, Anda telah berhasil menghubungkan fungsi Lambda ke Amazon MSK dengan pemetaan sumber peristiwa Lambda. ![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/msk_tut_log.png)