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à.
# Configurare il connettore del lavabo EventBridge Kafka per MSK Connect
Questo argomento mostra come configurare il connettore [EventBridge Kafka sink per MSK Connect](https://github.com/awslabs/eventbridge-kafka-connector). [Questo connettore consente di inviare eventi dal cluster MSK ai bus degli eventi. EventBridge ](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-bus.html) Questo argomento descrive il processo di creazione delle risorse richieste e di configurazione del connettore per consentire un flusso di dati senza interruzioni tra Kafka e. EventBridge
**Topics**
+ [
## Prerequisiti
](#mkc-eb-kafka-prerequisites)
+ [
## Configurare le risorse necessarie per MSK Connect
](#mkc-eb-kafka-set-up-resources)
+ [
## Crea il connettore
](#mkc-eb-kafka-create-connector)
+ [
## Invia messaggi a Kafka
](#mkc-eb-kafka-send-json-encoded-messages)
## Prerequisiti
Prima di distribuire il connettore, assicurati di disporre delle seguenti risorse:
+ Cluster **Amazon MSK: un cluster MSK** attivo per la produzione e l'utilizzo di messaggi Kafka.
+ **Amazon EventBridge Event Bus**: un bus di EventBridge eventi per ricevere eventi sugli argomenti di Kafka.
+ **Ruoli IAM**: crea ruoli IAM con le autorizzazioni necessarie per MSK Connect e il EventBridge connettore.
+ [Accesso a Internet pubblico](msk-connect-internet-access.md) da MSK Connect o da un endpoint EventBridge di [interfaccia VPC creato](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-related-service-vpc.html) nel VPC e nella sottorete del cluster MSK. Ciò consente di evitare di attraversare la rete Internet pubblica e di non richiedere gateway NAT.
+ Una [macchina client](create-serverless-cluster-client.md), come un'istanza Amazon EC2 o [AWS CloudShell](https://aws.amazon.com/cloudshell/), per creare argomenti e inviare record a Kafka.
## Configurare le risorse necessarie per MSK Connect
Si crea un ruolo IAM per il connettore, quindi si crea il connettore. Crei anche una EventBridge regola per filtrare gli eventi Kafka inviati al bus degli EventBridge eventi.
**Topics**
+ [
### Ruolo IAM per il connettore
](#mkc-eb-kafka-iam-role-connector)
+ [
### Una EventBridge regola per gli eventi in arrivo
](#mkc-eb-kafka-create-rule)
### Ruolo IAM per il connettore
Il ruolo IAM associato al connettore deve disporre dell'[PutEvents](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-permissions-reference.html)autorizzazione per consentire l'invio di eventi a EventBridge. Il seguente esempio di policy IAM ti concede l'autorizzazione a inviare eventi a un bus di eventi denominato. `example-event-bus` Assicurati di sostituire la risorsa ARN nell'esempio seguente con l'ARN del tuo event bus.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"events:PutEvents"
],
"Resource": "arn:aws:events:us-east-1:123456789012:event-bus/example-event-bus"
}
]
}
```
------
Inoltre, devi assicurarti che il tuo ruolo IAM per il connettore contenga la seguente politica di attendibilità.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "kafkaconnect.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
### Una EventBridge regola per gli eventi in arrivo
Crei [regole](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-rules.html) che abbinano gli eventi in entrata ai criteri relativi ai dati degli eventi, noti come pattern di [https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns.html](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns.html). [Con un pattern di eventi, è possibile definire i criteri per filtrare gli eventi in arrivo e determinare quali eventi devono attivare una particolare regola e successivamente essere indirizzati a un obiettivo designato.](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-targets.html) Il seguente esempio di schema di eventi corrisponde agli eventi di Kafka inviati al bus degli eventi. EventBridge
```
{
"detail": {
"topic": ["msk-eventbridge-tutorial"]
}
}
```
Di seguito è riportato un esempio di evento inviato da Kafka all' EventBridge utilizzo del connettore Kafka sink.
```
{
"version": "0",
"id": "dbc1c73a-c51d-0c0e-ca61-ab9278974c57",
"account": "123456789012",
"time": "2025-03-26T10:15:00Z",
"region": "us-east-1",
"detail-type": "msk-eventbridge-tutorial",
"source": "kafka-connect.msk-eventbridge-tutorial",
"resources": [],
"detail": {
"topic": "msk-eventbridge-tutorial",
"partition": 0,
"offset": 0,
"timestamp": 1742984100000,
"timestampType": "CreateTime",
"headers": [],
"key": "order-1",
"value": {
"orderItems": [
"item-1",
"item-2"
],
"orderCreatedTime": "Wed Mar 26 10:15:00 UTC 2025"
}
}
}
```
Nella EventBridge console, [create una regola](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule.html) sul bus degli eventi utilizzando questo modello di esempio e specificate un obiettivo, ad esempio un gruppo Logs. CloudWatch La EventBridge console configurerà automaticamente la politica di accesso necessaria per il gruppo CloudWatch Logs.
## Crea il connettore
Nella sezione seguente, si crea e si distribuisce il [connettore EventBridge Kafka sink](https://github.com/awslabs/eventbridge-kafka-connector) utilizzando il. Console di gestione AWS
**Topics**
+ [
### Passaggio 1: scarica il connettore
](#mkc-eb-kafka-download-connector)
+ [
### Fase 2: creare un bucket Amazon S3
](#mkc-eb-kafka-s3-bucket-create)
+ [
### Fase 3: Creare un plugin in MSK Connect
](#mkc-eb-kafka-create-plugin)
+ [
### Passaggio 4: creazione del connettore
](#mkc-eb-kafka-create-connector)
### Passaggio 1: scarica il connettore
Scarica l'ultimo EventBridge Connector Sink JAR dalla [pagina delle GitHub versioni](https://github.com/awslabs/eventbridge-kafka-connector/releases) del connettore EventBridge Kafka. Ad esempio, per scaricare la versione v1.4.1, scegli il link al file JAR per scaricare il `kafka-eventbridge-sink-with-dependencies.jar` connettore. Quindi, salva il file in una posizione preferita sul tuo computer.
### Fase 2: creare un bucket Amazon S3
1. Per archiviare il file JAR in Amazon S3 per utilizzarlo con MSK Connect, apri Console di gestione AWS e scegli Amazon S3.
1. Nella console Amazon S3, scegli **Crea bucket e inserisci un nome di bucket** univoco. Ad esempio, **amzn-s3-demo-bucket1-eb-connector**.
1. Scegli una regione appropriata per il tuo bucket Amazon S3. Assicurati che corrisponda alla regione in cui è distribuito il cluster MSK.
1. Per **le impostazioni di Bucket**, mantieni le selezioni predefinite o modificale secondo necessità.
1. Seleziona **Crea bucket**.
1. Carica il file JAR nel bucket Amazon S3.
### Fase 3: Creare un plugin in MSK Connect
1. Aprire Console di gestione AWS, quindi passare a **MSK Connect**.
1. Nel riquadro di navigazione a sinistra, scegliete **Plugin personalizzati**.
1. Scegli **Crea plug-in**, quindi inserisci il **nome del plug-in**. Ad esempio, **eventbridge-sink-plugin**.
1. Per la **posizione personalizzata del plug-in**, incolla l'**URL dell'oggetto S3**.
1. Aggiungi una descrizione opzionale per il plugin.
1. Scegli **Crea plugin**.
Dopo aver creato il plug-in, è possibile utilizzarlo per configurare e distribuire il connettore EventBridge Kafka in MSK Connect.
### Passaggio 4: creazione del connettore
Prima di creare il connettore, consigliamo di creare l'argomento Kafka richiesto per evitare errori nel connettore. Per creare l'argomento, utilizzate il computer client.
1. Nel riquadro sinistro della console MSK, scegli **Connettori**, quindi scegli **Crea connettore**.
1. Nell'elenco dei plugin, scegli **eventbridge-sink-plugin**, quindi scegli **Avanti**.
1. Per il nome del connettore, immettete**EventBridgeSink**.
1. Nell'elenco dei cluster, scegliete il vostro cluster MSK.
1. Copia la seguente configurazione per il connettore e incollala nel campo Configurazione del **connettore**
Se necessario, sostituite i segnaposto nella seguente configurazione.
+ Rimuovi `aws.eventbridge.endpoint.uri` se il cluster MSK dispone di un accesso pubblico a Internet.
+ Se si utilizza PrivateLink per connettersi in modo sicuro da MSK a EventBridge, sostituire la parte DNS successiva `https://` con il nome DNS privato corretto dell'endpoint di interfaccia VPC (opzionale) per quello creato in precedenza. EventBridge
+ Sostituisci l'ARN del bus di EventBridge eventi nella seguente configurazione con l'ARN del tuo bus di eventi.
+ Aggiorna tutti i valori specifici della regione.
```
{
"connector.class": "software.amazon.event.kafkaconnector.EventBridgeSinkConnector",
"aws.eventbridge.connector.id": "msk-eventbridge-tutorial",
"topics": "msk-eventbridge-tutorial",
"tasks.max": "1",
"aws.eventbridge.endpoint.uri": "https://events.us-east-1.amazonaws.com",
"aws.eventbridge.eventbus.arn": "arn:aws:events:us-east-1:123456789012:event-bus/example-event-bus",
"value.converter.schemas.enable": "false",
"value.converter": "org.apache.kafka.connect.json.JsonConverter",
"aws.eventbridge.region": "us-east-1",
"auto.offset.reset": "earliest",
"key.converter": "org.apache.kafka.connect.storage.StringConverter"
}
```
Per ulteriori informazioni sulla configurazione dei connettori, vedere. [eventbridge-kafka-connector](https://github.com/awslabs/eventbridge-kafka-connector)
Se necessario, modificate le impostazioni per i lavoratori e la scalabilità automatica. Consigliamo inoltre di utilizzare l'ultima versione disponibile (consigliata) di Apache Kafka Connect dal menu a discesa. In **Autorizzazioni di accesso**, usa il ruolo creato in precedenza. Si consiglia inoltre di abilitare la registrazione a CloudWatch per l'osservabilità e la risoluzione dei problemi. Modifica le altre impostazioni opzionali, come i tag, in base alle tue esigenze. Quindi, distribuisci il connettore e attendi che lo stato passi allo stato In esecuzione.
## Invia messaggi a Kafka
È possibile configurare le codifiche dei messaggi, come Apache Avro e JSON, specificando diversi convertitori utilizzando le impostazioni `value.converter` e, facoltativamente, disponibili in Kafka Connect. `key.converter`
[connector example](#connector-ex)In questo argomento è configurato per funzionare con messaggi con codifica JSON, come indicato dall'uso di for. `org.apache.kafka.connect.json.JsonConverter` `value converter` Quando il connettore è in stato di esecuzione, invia i record all'argomento `msk-eventbridge-tutorial` Kafka dal tuo computer client.