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à.

Streaming di Apache Kafka come sorgente

Apache Kafka è una piattaforma di streaming di eventi open source che supporta carichi di lavoro come pipeline di dati e analisi dei dati di streaming. Puoi utilizzare Amazon Managed Streaming for Apache Kafka (Amazon MSK) o un cluster Apache Kafka autogestito. In AWS terminologia, un cluster autogestito si riferisce a qualsiasi cluster Apache Kafka non ospitato da. AWS Ciò include sia i cluster gestiti dall'utente, sia quelli ospitati da un provider di terze parti, ad esempio, o. Confluent CloudCloudKarafkaRedpanda

Per ulteriori informazioni su altre opzioni di AWS hosting per il tuo cluster, consulta le migliori pratiche per l'esecuzione di Apache Kafka AWS sul AWS blog Big Data.

Apache Kafka come sorgente funziona in modo simile all'utilizzo di Amazon Simple Queue Service (Amazon SQS) o Amazon Kinesis. EventBridgeesegue internamente il polling per individuare nuovi messaggi dall'origine e quindi richiama in modo sincrono la destinazione. EventBridge legge i messaggi in batch e li fornisce alla funzione come payload di eventi. La dimensione massima del batch è configurabile. (L'impostazione predefinita è 100 messaggi.)

Per i sorgenti basati su Apache Kafka, EventBridge supporta i parametri di controllo dell'elaborazione, come le finestre di batch e la dimensione del batch.

EventBridge invia il batch di messaggi nel parametro dell'evento quando richiama la pipe. Il payload evento contiene un array di messaggi. Ogni elemento dell'array contiene i dettagli dell'argomento Apache Kafka e dell'identificatore di partizione Apache Kafka, insieme a un timestamp e a un messaggio con codifica base64.

Eventi di esempio

L'evento di esempio seguente mostra le informazioni ricevute dalla pipe. È possibile utilizzare questo evento per creare e filtrare i modelli di eventi o per definire la trasformazione degli input. Non tutti i campi possono essere filtrati. Per ulteriori informazioni su quali campi è possibile filtrare, consulta Filtraggio Amazon EventBridge Pipes.

[
  {
    "eventSource": "SelfManagedKafka",
    "bootstrapServers": "b-2.demo-cluster-1.a1bcde.c1.kafka.us-east-1.amazonaws.com:9092,b-1.demo-cluster-1.a1bcde.c1.kafka.us-east-1.amazonaws.com:9092",
    "eventSourceKey": "mytopic-0",
    "topic": "mytopic",
    "partition": 0,
    "offset": 15,
    "timestamp": 1545084650987,
    "timestampType": "CREATE_TIME",
    "key":"abcDEFghiJKLmnoPQRstuVWXyz1234==", 
    "value":"SGVsbG8sIHRoaXMgaXMgYSB0ZXN0Lg==",
    "headers": [
      {
        "headerKey": [
          104,
          101,
          97,
          100,
          101,
          114,
          86,
          97,
          108,
          117,
          101
        ]
      }
    ]
  }
]

Autenticazione con il cluster Apache Kafka

EventBridge Pipes supporta diversi metodi di autenticazione con il cluster Apache Kafka autogestito. Assicurati di configurare il cluster Apache Kafka per utilizzare uno di questi metodi di autenticazione supportati. Per ulteriori informazioni sulla sicurezza con Apache Kafka, consulta la sezione Sicurezza della documentazione di Apache Kafka.

Accesso VPC

Se utilizzi un ambiente Apache Kafka autogestito in cui solo gli utenti Apache Kafka all'interno del tuo VPC hanno accesso ai tuoi broker Apache Kafka, devi configurare Amazon Virtual Private Cloud (Amazon VPC) nel sorgente Apache Kafka.

Autenticazione SASL/SCRAM

EventBridge Pipes supporta l'autenticazione SASL/SCRAM (Simple Authentication and Security Layer/Salted Challenge Response Authentication Mechanism) con crittografia Transport Layer Security (TLS). EventBridge Pipes invia le credenziali crittografate per l'autenticazione con il cluster. Per ulteriori informazioni sull'autenticazione SASL/SCRAM, consultare RFC 5802.

EventBridge Pipes supporta l'autenticazione SASL/PLAIN con crittografia TLS. Con l'autenticazione SASL/PLAIN, EventBridge Pipes invia le credenziali come testo non crittografato al server.

Per l'autenticazione SASL, è necessario archiviare le credenziali di accesso come segreto in AWS Secrets Manager.

Autenticazione TLS reciproca

MTLS (Mutual TLS) fornisce l'autenticazione bidirezionale tra client e server. Il client invia un certificato al server affinché il server verifichi il client e il server invia un certificato al client affinché il client verifichi il server.

In Apache Kafka autogestito, Pipes funge da client. EventBridge Configurate un certificato client (come segreto in Secrets Manager) per autenticare EventBridge Pipes con i vostri broker Apache Kafka. Il certificato client deve essere firmato da un'autorità di certificazione (CA) presente nel trust store del server.

Il cluster Apache Kafka invia un certificato server a Pipes per autenticare i broker Apache Kafka con EventBridge Pipes. EventBridge Il certificato del server può essere un certificato CA pubblico o un certificato CA/autofirmato privato. Il certificato CA pubblico deve essere firmato da una CA presente nel trust store di Pipes. EventBridge Per un certificato CA privato/autofirmato, si configura il certificato CA principale del server (come segreto in Secrets Manager). EventBridge Pipes utilizza il certificato root per verificare i broker Apache Kafka.

Per ulteriori informazioni su mTLS, consulta Introduzione all'autenticazione Mutual TLS per Amazon MSK come origine.

Configurazione del segreto del certificato client

Il segreto CLIENT_CERTIFICATE_TLS_AUTH richiede un campo certificato e un campo chiave privata. Per una chiave privata crittografata, il segreto richiede una password per chiave privata. Il certificato e la chiave privata devono essere in formato PEM.

Il campo certificato deve contenere un elenco di certificati, a partire dal certificato client, seguito da qualsiasi certificato intermedio, per finire con il certificato root. Ogni certificato deve iniziare su una nuova riga con la struttura seguente:

-----BEGIN CERTIFICATE-----  
        <certificate contents>
-----END CERTIFICATE-----      

Secrets Manager supporta segreti fino a 65.536 byte, che è uno spazio sufficiente per lunghe catene di certificati.

La chiave privata deve essere in formato PKCS #8, con la struttura seguente:

-----BEGIN PRIVATE KEY-----  
         <private key contents>
-----END PRIVATE KEY-----            

Per una chiave privata crittografata, utilizza la struttura seguente:

-----BEGIN ENCRYPTED PRIVATE KEY-----  
          <private key contents>
-----END ENCRYPTED PRIVATE KEY-----           

Nell'esempio seguente viene mostrato il contenuto di un segreto per l'autenticazione mTLS utilizzando una chiave privata crittografata. Per una chiave privata crittografata, includere la password per chiave privata nel segreto.

{
 "privateKeyPassword": "testpassword",
 "certificate": "-----BEGIN CERTIFICATE-----
MIIE5DCCAsygAwIBAgIRAPJdwaFaNRrytHBto0j5BA0wDQYJKoZIhvcNAQELBQAw
...
j0Lh4/+1HfgyE2KlmII36dg4IMzNjAFEBZiCRoPimO40s1cRqtFHXoal0QQbIlxk
cmUuiAii9R0=
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIFgjCCA2qgAwIBAgIQdjNZd6uFf9hbNC5RdfmHrzANBgkqhkiG9w0BAQsFADBb
...
rQoiowbbk5wXCheYSANQIfTZ6weQTgiCHCCbuuMKNVS95FkXm0vqVD/YpXKwA/no
c8PH3PSoAaRwMMgOSA2ALJvbRz8mpg==
-----END CERTIFICATE-----",
 "privateKey": "-----BEGIN ENCRYPTED PRIVATE KEY-----
MIIFKzBVBgkqhkiG9w0BBQ0wSDAnBgkqhkiG9w0BBQwwGgQUiAFcK5hT/X7Kjmgp
...
QrSekqF+kWzmB6nAfSzgO9IaoAaytLvNgGTckWeUkWn/V0Ck+LdGUXzAC4RxZnoQ
zp2mwJn2NYB7AZ7+imp0azDZb+8YG2aUCiyqb6PnnA==
-----END ENCRYPTED PRIVATE KEY-----"
}  

Configurazione del segreto del certificato CA root del server

Questo segreto viene creato se i broker Apache Kafka utilizzano la crittografia TLS con certificati firmati da una CA privata. È possibile utilizzare la crittografia TLS per l'autenticazione VPC, SASL/SCRAM, SASL/PLAIN o mTLS.

Il segreto del certificato CA root del server richiede un campo che contiene il certificato CA root del broker Kafka in formato PEM. Il seguente esempio illustra la struttura del segreto.

{
     "certificate": "-----BEGIN CERTIFICATE-----       
  MIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx
  EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT
  HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs
  ZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dG...
  -----END CERTIFICATE-----"      

Configurazione della rete

Se utilizzi un ambiente Apache Kafka autogestito che utilizza la connettività VPC privata, EventBridge devi avere accesso alle risorse Amazon Virtual Private Cloud (Amazon VPC) associate ai tuoi broker Apache Kafka.

È necessario configurare i gruppi di sicurezza Amazon VPC con le seguenti regole (come requisito minimo):

Scalabilità automatica per i consumatori con sorgenti Apache Kafka

Quando crei inizialmente un sorgente Apache Kafka, EventBridge assegna un consumatore all'elaborazione di tutte le partizioni nell'argomento Kafka. Ogni consumatore ha più processori in esecuzione in parallelo per gestire carichi di lavoro più elevati. Inoltre, aumenta o riduce EventBridge automaticamente il numero di consumatori, in base al carico di lavoro. Per preservare l'ordinamento dei messaggi in ogni partizione, il numero massimo di consumatori è un consumatore per ogni partizione dell'argomento.

A intervalli di un minuto, EventBridge valuta il ritardo di compensazione tra i consumatori di tutte le partizioni dell'argomento. Se il ritardo è troppo elevato, la partizione riceve i messaggi più velocemente di quanto possa elaborarli. EventBridge Se necessario, EventBridge aggiunge o rimuove utenti dall'argomento. Il processo di dimensionamento di aggiunta o rimozione dei consumatori avviene entro tre minuti dalla valutazione.

Se il target è sovraccarico, EventBridge riduce il numero di consumatori. Questa operazione riduce il carico di lavoro sulla funzione riducendo il numero di messaggi che i consumer possono recuperare e inviare alla funzione.