Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Tutorial: Utilizzo di uno strumento di mappatura dell'origine degli eventi Amazon MSK per richiamare una funzione Lambda In questo tutorial verranno eseguite le seguenti operazioni: + Crea una funzione Lambda nello stesso AWS account di un cluster Amazon MSK esistente. + Configura la rete e l'autenticazione per consentire a Lambda di comunicare con Amazon MSK. + Configura uno strumento di mappatura dell'origine degli eventi Lambda Amazon MSK, che esegue la funzione Lambda quando gli eventi vengono visualizzati nell'argomento. Dopo aver completato questi passaggi, quando gli eventi vengono inviati ad Amazon MSK, potrai configurare una funzione Lambda per elaborare tali eventi automaticamente con il tuo codice Lambda personalizzato. **Cosa puoi fare con questa funzionalità?** **Soluzione di esempio: utilizza uno strumento di mappatura dell'origine degli eventi MSK per fornire risultati in tempo reale ai tuoi clienti.** Considera lo scenario seguente: la tua azienda ospita un'applicazione Web in cui i clienti possono visualizzare informazioni sugli eventi dal vivo, come le partite sportive. Gli aggiornamenti delle informazioni dal gioco vengono forniti al tuo team tramite un argomento Kafka su Amazon MSK. Vuoi progettare una soluzione che utilizzi gli aggiornamenti dell'argomento MSK per fornire una visione aggiornata dell'evento dal vivo ai clienti all'interno di un'applicazione da te sviluppata. Hai deciso il seguente approccio di progettazione: le tue applicazioni client comunicheranno con un backend serverless ospitato in AWS. I client si connetteranno tramite sessioni websocket utilizzando l'API Amazon WebSocket API Gateway. In questa soluzione, è necessario un componente che legga gli eventi MSK, esegua una logica personalizzata per preparare tali eventi per il livello dell'applicazione e quindi inoltri tali informazioni all'API Gateway. Puoi implementare questo componente con AWS Lambda, fornendo la tua logica personalizzata in una funzione Lambda, quindi chiamandolo con una mappatura dell'origine degli eventi AWS Lambda Amazon MSK. Per ulteriori informazioni sull'implementazione di soluzioni utilizzando l'API Amazon WebSocket API Gateway, consulta [i tutorial sulle WebSocket API nella documentazione](https://docs.aws.amazon.com/apigateway/latest/developerguide/websocket-api-chat-app.html) di API Gateway. ## Prerequisiti Un AWS account con le seguenti risorse preconfigurate: **Per soddisfare questi prerequisiti, ti consigliamo di consultare la sezione [Guida introduttiva all'uso di Amazon MSK](https://docs.aws.amazon.com//msk/latest/developerguide/getting-started.html) nella documentazione di Amazon MSK.** + UN cluster Amazon MSK. Consulta [Creare un cluster Amazon MSK](https://docs.aws.amazon.com//msk/latest/developerguide/create-cluster.html) in *Guida introduttiva all'uso di Amazon MSK*. + La seguente configurazione: + Assicurati che l'**autenticazione basata sui ruoli IAM** sia **abilitata** nelle impostazioni di sicurezza del cluster. Ciò aumenta la sicurezza limitando la funzione Lambda al solo accesso alle risorse Amazon MSK necessarie. Questa funzionalità è abilitata per impostazione predefinita per i nuovi cluster Amazon MSK. + Assicurati che l'**accesso pubblico** sia disattivato nelle impostazioni di rete del cluster. Limitare l'accesso a Internet del cluster Amazon MSK migliora la sicurezza limitando il numero di intermediari che gestiscono i dati. Questa funzionalità è abilitata per impostazione predefinita per i nuovi cluster Amazon MSK. + Un argomento Kafka nel tuo cluster Amazon MSK da utilizzare per questa soluzione. Consulta [Creare un argomento](https://docs.aws.amazon.com//msk/latest/developerguide/create-topic.html) in *Guida introduttiva all'uso di Amazon MSK*. + Un host di amministrazione Kafka configurato per recuperare informazioni dal tuo cluster Kafka e inviare eventi Kafka al tuo argomento per i test, ad esempio un'istanza Amazon EC2 con la CLI di amministrazione Kafka e la libreria IAM Amazon MSK installate. Consulta [Creare una macchina client](https://docs.aws.amazon.com//msk/latest/developerguide/create-client-machine.html) in *Guida introduttiva all'uso di Amazon MSK*. Dopo aver configurato queste risorse, raccogli le seguenti informazioni dal tuo AWS account per confermare che sei pronto a continuare. + Il nome del cluster Amazon MSK. È possibile trovare queste informazioni nella console Amazon MSK. + L'UUID del cluster, parte dell'ARN per il tuo cluster Amazon MSK, che puoi trovare nella console Amazon MSK. Segui le procedure in [Elencare i cluster](https://docs.aws.amazon.com/msk/latest/developerguide/msk-list-clusters.html) nella documentazione di Amazon MSK per trovare queste informazioni. + I gruppi di sicurezza associati al cluster Amazon MSK. È possibile trovare queste informazioni nella console Amazon MSK. Nei passaggi seguenti, definiscile come tue*clusterSecurityGroups*. + L'ID Amazon VPC contenente il cluster Amazon MSK. Puoi trovare queste informazioni identificando le sottoreti associate al tuo cluster Amazon MSK nella console Amazon MSK, quindi identificando l'Amazon VPC associato alla sottorete nella console Amazon VPC. + Il nome dell'argomento Kafka usato nella tua soluzione. Puoi trovare queste informazioni chiamando il tuo cluster Amazon MSK con l'`topics` CLI di Kafka dal tuo host di amministrazione Kafka. Per ulteriori informazioni sugli argomenti della CLI, consulta [Aggiungere e rimuovere argomenti](https://kafka.apache.org/documentation/#basic_ops_add_topic) nella documentazione di Kafka. + Il nome di un gruppo di consumer per l'argomento Kafka, adatto all'uso con la funzione Lambda. Questo gruppo può essere creato automaticamente da Lambda, quindi non devi crearlo con la CLI Kafka. Se devi gestire i tuoi gruppi di consumer, per saperne di più sulla CLI dei gruppi di consumer, consulta [Gestione dei gruppi di consumer](https://kafka.apache.org/documentation/#basic_ops_consumer_group) nella documentazione di Kafka. Le seguenti autorizzazioni nel tuo AWS account: + Autorizzazione per creare e gestire una funzione Lambda. + Autorizzazione per creare policy IAM e associarle alla funzione Lambda. + Autorizzazione a creare endpoint Amazon VPC e modificare la configurazione di rete nell'Amazon VPC che ospita il cluster Amazon MSK. ### Installa il AWS Command Line Interface Se non l'hai ancora installato AWS Command Line Interface, segui i passaggi indicati in [Installazione o aggiornamento della versione più recente di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) per installarlo. Per eseguire i comandi nel tutorial, sono necessari un terminale a riga di comando o una shell (interprete di comandi). In Linux e macOS, utilizza la shell (interprete di comandi) e il gestore pacchetti preferiti. **Nota** Su Windows, alcuni comandi della CLI Bash utilizzati comunemente con Lambda (ad esempio, `zip`) non sono supportati dai terminali integrati del sistema operativo. Per ottenere una versione integrata su Windows di Ubuntu e Bash, [installa il sottosistema Windows per Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10). ## Configurare la connettività di rete per consentire a Lambda di comunicare con Amazon MSK AWS PrivateLink Usalo per connettere Lambda e Amazon MSK. È possibile farlo creando endpoint Amazon VPC di interfaccia nella console Amazon VPC. Per ulteriori informazioni sui problemi di configurazioni di rete, consulta [Configurazione del cluster Amazon MSK e della rete Amazon VPC per Lambda](with-msk-cluster-network.md). Quando uno strumento di mappatura dell'origine degli eventi Amazon MSK viene eseguita per conto di una funzione Lambda, assume il ruolo di esecuzione della funzione Lambda. Questo ruolo IAM autorizza la mappatura per accedere a risorse protette da IAM, come il cluster Amazon MSK. Sebbene i componenti condividano un ruolo di esecuzione, la mappatura Amazon MSK e la funzione Lambda hanno requisiti di connettività separati per le rispettive attività, come illustrato nel diagramma seguente. ![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/msk_tut_network.png) Lo strumento di mappatura dell'origine degli eventi appartiene al gruppo di sicurezza del cluster Amazon MSK. In questa fase di networking, crea endpoint Amazon VPC dal tuo VPC del cluster Amazon MSK per connettere lo strumento di mappatura dell'origine degli eventi ai servizi Lambda e STS. Proteggi questi endpoint per accettare il traffico proveniente dal tuo gruppo di sicurezza del cluster Amazon MSK. Quindi, modifica i gruppi di sicurezza del cluster Amazon MSK per consentire allo strumento di mappatura dell'origine degli eventi di comunicare con il cluster Amazon MSK. Puoi configurare la procedura seguente utilizzando la Console di gestione AWS. **Per configurare gli endpoint Amazon VPC di interfaccia per connettere Lambda e Amazon MSK** 1. Crea un gruppo di sicurezza per gli endpoint Amazon VPC della tua interfaccia*endpointSecurityGroup*, che consenta il traffico TCP in entrata su 443 da. *clusterSecurityGroups* Segui la procedura in [Creare un gruppo di sicurezza](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/working-with-security-groups.html#creating-security-group) nella documentazione di Amazon EC2 per creare un gruppo di sicurezza. Quindi, segui la procedura in [Aggiungere regole a un gruppo di sicurezza](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule) nella documentazione di Amazon EC2 per aggiungere le regole appropriate. **Crea un gruppo di sicurezza con le seguenti informazioni:** Quando aggiungi le regole in entrata, crea una regola per ogni gruppo di sicurezza in. *clusterSecurityGroups* Per ogni regola: + Per **Tipo**, seleziona **HTTPS**. + Per **Origine**, seleziona uno dei. *clusterSecurityGroups* 1. Crea un endpoint che connette il servizio Lambda all'Amazon VPC contenente il cluster Amazon MSK. Segui la procedura riportata in [Creare un endpoint di interfaccia](https://docs.aws.amazon.com//vpc/latest/privatelink/create-interface-endpoint.html). **Crea un endpoint di interfaccia con le seguenti informazioni:** + Per **Nome servizio**, seleziona`com.amazonaws.regionName.lambda`, dove *regionName* ospita la funzione Lambda. + Per **VPC**, seleziona l'Amazon VPC contenente il cluster Amazon MSK. + Per i **gruppi di sicurezza**, seleziona*endpointSecurityGroup*, che hai creato in precedenza. + Per **Sottoreti**, seleziona le sottoreti che ospitano il tuo cluster Amazon MSK. + Per **Policy**, fornisci il seguente documento di policy, che protegge l'endpoint per l'utilizzo da parte del responsabile del servizio Lambda per l'azione `lambda:InvokeFunction`. ``` { "Statement": [ { "Action": "lambda:InvokeFunction", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com" ] }, "Resource": "*" } ] } ``` + Assicurati **Abilita nome DNS** rimanga impostato. 1. Crea un endpoint che collega il AWS STS servizio all'Amazon VPC contenente il tuo cluster Amazon MSK. Segui la procedura riportata in [Creare un endpoint di interfaccia](https://docs.aws.amazon.com//vpc/latest/privatelink/create-interface-endpoint.html). **Crea un endpoint di interfaccia con le seguenti informazioni:** + Per **Nome del servizio**, seleziona. AWS STS + Per **VPC**, seleziona l'Amazon VPC contenente il cluster Amazon MSK. + Per i **gruppi di sicurezza**, selezionare*endpointSecurityGroup*. + Per **Sottoreti**, seleziona le sottoreti che ospitano il tuo cluster Amazon MSK. + Per **Policy**, fornisci il seguente documento di policy, che protegge l'endpoint per l'utilizzo da parte del responsabile del servizio Lambda per l'azione `sts:AssumeRole`. ``` { "Statement": [ { "Action": "sts:AssumeRole", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com" ] }, "Resource": "*" } ] } ``` + Assicurati **Abilita nome DNS** rimanga impostato. 1. Per ogni gruppo di sicurezza associato al tuo cluster Amazon MSK, ovvero in*clusterSecurityGroups*, consenti quanto segue: + Consenti tutto il traffico TCP in entrata e in uscita su 9098 verso tutti, anche all'interno di *clusterSecurityGroups* se stesso. + Consenti tutto il traffico TCP in uscita su 443. Parte di questo traffico è consentito dalle regole predefinite del gruppo di sicurezza, quindi se il cluster è collegato a un singolo gruppo di sicurezza e tale gruppo ha regole predefinite, non sono necessarie regole aggiuntive. Per ottimizzare le regole del gruppo di sicurezza, segui la procedura in [Aggiungere regole a un gruppo di sicurezza](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule) nella documentazione di Amazon EC2. **Aggiungi le regole ai tuoi gruppi di sicurezza con le seguenti informazioni:** + Per ogni regola in entrata o in uscita per la porta 9098, fornisci + Per **Type (Tipo)** seleziona **Custom TCP (TCP personalizzato)**. + Per **Intervallo di porte**, specifica 9098. + Per **Source, fornisci** uno dei. *clusterSecurityGroups* + Per ogni regola in entrata per la porta 443, per **Tipo**, seleziona **HTTPS**. ## Crea un ruolo IAM perché Lambda legga dal tuo argomento Amazon MSK Identifica i requisiti di autenticazione perché Lambda legga dall'argomento di Amazon MSK, quindi definiscili in una policy. Crea un ruolo che autorizzi *lambdaAuthRole* Lambda a utilizzare tali autorizzazioni. Autorizza le azioni sul tuo cluster Amazon MSK utilizzando azioni `kafka-cluster` IAM. Quindi, autorizza Lambda a eseguire le azioni di Amazon `kafka` MSK e Amazon EC2 necessarie per scoprire e connettersi al tuo cluster Amazon MSK, nonché le CloudWatch azioni in modo che Lambda possa registrare ciò che ha fatto. **Per descrivere i requisiti di autenticazione perché Lambda legga da Amazon MSK** 1. Scrivi un documento di policy IAM (un documento JSON)*clusterAuthPolicy*, che consenta a Lambda di leggere il tuo argomento Kafka nel tuo cluster Amazon MSK utilizzando il tuo gruppo di consumatori Kafka. Lambda richiede che durante la lettura sia impostato un gruppo di consumer Kafka. Modifica il seguente modello per allinearlo ai tuoi prerequisiti: ------ #### [ 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" ] } ] } ``` ------ Per ulteriori informazioni, consulta [Configurazione delle autorizzazioni Lambda per le mappature delle sorgenti degli eventi Amazon MSK](with-msk-permissions.md). Quando scrivi la tua policy: + Sostituisci *us-east-1* e *111122223333* con Regione AWS e Account AWS del tuo cluster Amazon MSK. + Per*mskClusterName*, fornisci il nome del tuo cluster Amazon MSK. + Per*cluster-uuid*, fornisci l'UUID nell'ARN per il tuo cluster Amazon MSK. + Per*mskTopicName*, fornisci il nome del tuo argomento su Kafka. + Per*mskGroupName*, fornisci il nome del tuo gruppo di consumatori Kafka. 1. Identifica Amazon MSK, Amazon EC2 CloudWatch e le autorizzazioni necessarie a Lambda per rilevare e connettere il tuo cluster Amazon MSK e registrare tali eventi. La policy gestita da `AWSLambdaMSKExecutionRole` definisce in modo permissivo le autorizzazioni richieste. Utilizzalo nelle fasi seguenti. In un ambiente di produzione, valuta `AWSLambdaMSKExecutionRole` per limitare la policy del ruolo di esecuzione in base al principio del privilegio minimo, quindi scrivi una policy per il tuo ruolo che sostituisca questa policy gestita. Per i dettagli sul linguaggio della policy IAM, consulta la [documentazione IAM](https://docs.aws.amazon.com//iam/). Ora che hai scritto il tuo documento di policy, crea una policy IAM in modo da poterla collegare al tuo ruolo. È possibile effettuare tale operazione mediante la console utilizzando la seguente procedura. **Per creare una policy IAM dal documento della policy** 1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 1. Nel riquadro di navigazione a sinistra, seleziona **Policies (Policy)**. 1. Scegli **Crea policy**. 1. Nella sezione **Editor di policy**, scegli l'opzione **JSON**. 1. Incolla*clusterAuthPolicy*. 1. Una volta terminata l'aggiunta delle autorizzazioni alla policy, scegli **Successivo**. 1. Nella pagina **Verifica e crea**, digita i valori per **Nome policy** e **Descrizione** (facoltativa) per la policy che si sta creando. Rivedi **Autorizzazioni definite in questa policy** per visualizzare le autorizzazioni concesse dalla policy. 1. Seleziona **Crea policy** per salvare la nuova policy. Per ulteriori informazioni, consulta [Creazione di policy IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/access_policies_create.html) nella documentazione di IAM. Ora che disponi delle policy IAM appropriate, crea un ruolo e associale ad esso. È possibile effettuare tale operazione mediante la console utilizzando la seguente procedura. **Per creare un ruolo di esecuzione nella console IAM** 1. Aprire la pagina [Roles (Ruoli)](https://console.aws.amazon.com/iam/home#/roles) nella console IAM. 1. Scegli **Crea ruolo**. 1. In **Tipo di entità attendibile**, scegli **Servizio AWS **. 1. In **Use case** (Caso d'uso), scegli **Lambda**. 1. Scegli **Next (Successivo)**. 1. Selezionare le seguenti policy: + *clusterAuthPolicy* + `AWSLambdaMSKExecutionRole` 1. Scegli **Next (Successivo)**. 1. Per **Nome ruolo**, inserisci *lambdaAuthRole* e quindi scegli **Crea ruolo**. Per ulteriori informazioni, consulta [Definizione delle autorizzazioni della funzione Lambda con un ruolo di esecuzione](lambda-intro-execution-role.md). ## Creare una funzione Lambda per leggere dal tuo argomento Amazon MSK Crea una funzione Lambda configurata per utilizzare il tuo ruolo IAM. È possibile creare la funzione Lambda utilizzando la console. **Per creare una funzione Lambda utilizzando la tua configurazione di autenticazione** 1. Apri la console Lambda e seleziona **Crea funzione** dall'intestazione. 1. Scegli **Crea da zero**. 1. Per **Nome della funzione**, fornisci un nome appropriato a tua scelta. 1. Per **Runtime**, scegli l'**ultima versione supportata** di `Node.js` per utilizzare il codice fornito in questo tutorial. 1. Scegli **Cambia ruolo di esecuzione predefinito**. 1. Seleziona **Utilizza un ruolo esistente**. 1. Per **Ruolo esistente**, seleziona*lambdaAuthRole*. In un ambiente di produzione, in genere è necessario aggiungere ulteriori policy al ruolo di esecuzione per la funzione Lambda per elaborare in modo significativo gli eventi Amazon MSK. Per ulteriori informazioni sull'aggiunta di policy al tuo ruolo, consulta [Aggiungere o rimuovere le autorizzazioni di identità](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console) nella documentazione IAM. ## Creare uno strumento di mappatura dell'origine degli eventi sulla funzione Lambda Lo strumento di mappatura dell'origine degli eventi Amazon MSK fornisce al servizio Lambda le informazioni necessarie per richiamare Lambda quando si verificano gli eventi Amazon MSK appropriati. Puoi creare una mappatura Amazon MSK utilizzando la console. Crea un trigger Lambda, quindi lo strumento di mappatura dell'origine degli eventi viene impostato automaticamente. **Per creare un trigger Lambda (e uno strumento di mappatura dell'origine degli eventi)** 1. Vai alla pagina della panoramica della tua funzione Lambda. 1. Nella sezione della panoramica della funzione, scegli **Aggiungi trigger** in basso a sinistra. 1. Nel menu a discesa **Seleziona un'origine**, seleziona **Amazon MSK**. 1. Non impostare l'**autenticazione**. 1. Per **Cluster MSK** seleziona il nome del cluster. 1. Per **Dimensioni del batch**, immetti 1. Questo passaggio semplifica il test di questa funzionalità e non rappresenta un valore ideale nella produzione. 1. Per **Nome argomento**, fornisci il nome del tuo argomento Kafka. 1. Per l'**ID del gruppo di consumer**, fornisci l'ID del tuo gruppo di consumer Kafka. ## Aggiornare la funzione Lambda per leggere i dati di streaming Lambda fornisce informazioni sugli eventi di Kafka tramite il parametro event method. Per una struttura di esempio di un evento Amazon MSK, consulta [Esempio di evento](with-msk.md#msk-sample-event). Dopo aver capito come interpretare gli eventi Amazon MSK inoltrati da Lambda, puoi modificare il codice della funzione Lambda per utilizzare le informazioni fornite. Fornisci il seguente codice alla tua funzione Lambda per registrare il contenuto di un evento Lambda Amazon MSK a scopo di test: ------ #### [ .NET ] **SDK per .NET** C'è altro da fare GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Utilizzo di un evento Amazon MSK con Lambda tramite .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 per Go V2** C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Utilizzo di un evento Amazon MSK con Lambda tramite 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 per Java 2.x** C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Utilizzo di un evento Amazon MSK con Lambda tramite 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 per JavaScript (v3)** C'è altro da fare. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Consumo di un evento Amazon MSK con JavaScript Lambda utilizzando. ``` 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) }) } } ``` Consumo di un evento Amazon MSK con TypeScript Lambda utilizzando. ``` 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 per PHP** C'è altro da fare. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Utilizzo di un evento Amazon MSK con Lambda tramite 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 per Python (Boto3)** C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Utilizzo di un evento Amazon MSK con Lambda tramite 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 per Ruby** C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Utilizzo di un evento Amazon MSK con Lambda tramite 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 per Rust** C'è altro da fare. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda). Utilizzo di un evento Amazon MSK con Lambda tramite 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 } ``` ------ È possibile fornire il codice della funzione a Lambda utilizzando la console. **Aggiornamento del codice della funzione utilizzando l'editor di codice della console** 1. Apri la [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda e scegli la tua funzione. 1. Scegli la scheda **Codice**. 1. Nel riquadro **Origine del codice**, seleziona il tuo file di codice sorgente e modificalo nell'editor di codice integrato. 1. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione: ![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png) ## Testa la tua funzione Lambda per verificare che sia connessa al tuo argomento Amazon MSK Ora puoi verificare se la tua Lambda viene richiamata o meno dall'origine dell'evento CloudWatch controllando i registri degli eventi. **Per verificare se la funzione Lambda viene richiamata** 1. Usa il tuo host di amministrazione Kafka per generare eventi Kafka utilizzando la CLI `kafka-console-producer`. Per ulteriori informazioni, consulta [Scrivere alcuni eventi nell'argomento](https://kafka.apache.org/documentation/#quickstart_send) della documentazione di Kafka. Invia un numero sufficiente di eventi per riempire il batch definito dalla dimensione del batch per lo strumento di mappatura dell'origine degli eventi definito nel passaggio precedente, altrimenti Lambda aspetterà che vengano richiamate ulteriori informazioni. 1. Se la funzione viene eseguita, Lambda scrive cosa è successo a. CloudWatch Nella console, passa alla pagina dei dettagli della funzione Lambda. 1. Selezionare la scheda **Configurazione**. 1. Dalla barra laterale, seleziona **Strumenti di monitoraggio e operazioni**. 1. Identifica il **gruppo di CloudWatch log** in **Logging configuration.** Il gruppo di log dovrebbe iniziare con `/aws/lambda`. Scegli il link del gruppo di log. 1. Nella CloudWatch console, controlla gli eventi di **registro per gli eventi** di registro che Lambda ha inviato al flusso di log. Identifica se ci sono eventi del log contenenti il messaggio del tuo evento Kafka, come nell'immagine seguente. In tal caso, hai collegato correttamente una funzione Lambda ad Amazon MSK con uno strumento di mappatura dell'origine degli eventi Lambda. ![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/msk_tut_log.png)