Fluxos do Apache Kafka como origem no EventBridge Pipes

O Apache Kafka é uma plataforma de streaming de eventos de código aberto que é compatível com workloads, como pipelines de dados e análises de streaming. É possível usar o Amazon Managed Streaming for Apache Kafka (Amazon MSK) ou um cluster do Apache Kafka autogerenciado. Na terminologia da AWS, um cluster autogerenciado se refere a qualquer cluster do Apache Kafka não hospedado pela AWS. Isso inclui tanto os clusters que você gerencia quanto os hospedados por um provedor terceirizado, como Confluent Cloud, CloudKarafka ou Redpanda.

Para obter mais informações sobre outras opções da AWS para hospedagem de cluster, consulte Best Practices for Running Apache Kafka on AWS no AWS Big Data Blog.

O Apache Kafka como origem opera de forma semelhante ao uso do Amazon Simple Queue Service (Amazon SQS) ou do Amazon Kinesis. O EventBridge pesquisa internamente por novas mensagens da origem do evento e invoca, de forma síncrona, o destino. O EventBridge lê as mensagens em lotes e fornece estas para a sua função como uma carga útil de eventos. O tamanho máximo do lote é configurável. (O valor padrão é de 100 mensagens.)

Para origens de eventos baseadas em Apache Kafka, o EventBridge oferece suporte a parâmetros de controle de processamento, como janelas de processamento de lotes e tamanho do lote.

O EventBridge envia o lote de mensagens no parâmetro de evento ao invocar seu pipe. O payload do evento contém uma matriz de mensagens. Cada item da matriz contém detalhes do tópico do Apache Kafka e do identificador de partição do Apache Kafka, juntamente com um carimbo de data/hora e uma mensagem codificada em base64.

Eventos de exemplo

O exemplo de evento a seguir mostra as informações recebidas pelo pipe. É possível usar esse evento para criar e filtrar seus padrões de eventos ou para definir a transformação de entrada. Nem todos os campos podem ser filtrados. Para mais informações sobre quais campos podem ser filtrados, consulte Filtragem de eventos no 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
        ]
      }
    ]
  }
]

Autenticação de clusters do Apache Kafka

O EventBridge Pipes é compatível com vários métodos para autenticar com seu cluster Apache Kafka autogerenciado. Configure o cluster Apache Kafka para utilizar um dos métodos de autenticação compatíveis. Para obter mais informações sobre a segurança do Apache Kafka, consulte a seção Segurança da documentação do Apache Kafka.

Acesso à VPC

Se estiver usando um ambiente do Apache Kafka autogerenciado em que apenas os usuários do Apache Kafka de sua VPC têm acesso a seus agentes do Apache Kafka, será necessário configurar a Amazon Virtual Private Cloud (Amazon VPC) na origem do Apache Kafka.

Autenticação SASL/SCRAM

O EventBridge Pipes é compatível com autenticação Simple Authentication e Security Layer/Salted Challenge Response Authentication Mechanism (SASL/SCRAM) com criptografia Transport Layer Security (TLS). O EventBridge Pipes envia as credenciais criptografadas para autenticar com o cluster. Para obter mais informações sobre a autenticação do SASL/SCRAM, consulte RFC 5802.

O EventBridge Pipes é compatível com autenticação SASL/PLAIN com criptografia TLS. Com a autenticação SASL/PLAIN, o EventBridge envia credenciais como texto simples (não criptografado) ao servidor.

Para a autenticação SASL, armazene as credenciais de login como um segredo no AWS Secrets Manager.

Autenticação TLS mútua

O TLS mútuo (mTLS) fornece autenticação bidirecional entre o cliente e o servidor. O cliente envia um certificado ao servidor para que o servidor verifique o cliente, e o servidor envia um certificado ao cliente para que o cliente verifique o servidor.

No Apache Kafka autogerenciado, o EventBridge atua como cliente. É configurado um certificado de cliente (como um segredo no Secrets Manager) para autenticar o EventBridge Pipes com os agentes do Apache Kafka. O certificado do servidor deve ser assinado por uma autoridade de certificação (CA) no armazenamento de confiança da .

O cluster do Apache Kafka envia um certificado de servidor ao EventBridge Pipes para autenticar os agentes do Apache Kafka com o EventBridge Pipes. O certificado do servidor pode ser um certificado CA público ou um certificado de CA privado/autoassinado. O certificado CA público deve ser assinado por uma autoridade de certificação (CA) que esteja no repositório de confiança do EventBridge Pipes. Para um certificado CA privado/autoassinado, configure o certificado CA raiz do servidor (como um segredo no Secrets Manager). O EventBridge Pipes usa o certificado raiz para verificar os agentes do Apache Kafka.

Para obter mais informações sobre o mTLS, consulte Introdução à autenticação TLS mútua para o Amazon MSK como origem.

Configurar o segredo do certificado do cliente

O segredo CLIENT_CERTIFICATE_TLS_AUTH requer um campo de certificado e um campo de chave privada. Para uma chave privada criptografada, o segredo requer uma senha de chave privada. Tanto o certificado como a chave privada devem estar no formato PEM.

O campo certificate (certificado) deve conter uma lista de certificados, começando pelo certificado do cliente, seguido por quaisquer certificados intermediários e terminando com o certificado raiz. Cada certificado deve iniciar em uma nova linha com a seguinte estrutura:

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

O Secrets Manager oferece suporte a segredos de até 65.536 bytes, que é espaço suficiente para cadeias de certificados longas.

A chave privada deve estar no formato PKCS #8, com a seguinte estrutura:

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

Para uma chave privada criptografada, use a seguinte estrutura:

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

O exemplo a seguir exibe o conteúdo de um segredo para autenticação mTLS usando uma chave privada criptografada. Para uma chave privada criptografada, inclua a senha de chave privada no segredo.

{
 "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-----"
}  

Configurar o segredo do certificado CA raiz do servidor

Este segredo é criado se seus agentes do Apache Kafka usarem criptografia TLS com certificados assinados por uma CA privada. É possível usar criptografia TLS para autenticação de VPC, SASL/SCRAM, SASL/PLAIN ou mTLS.

O segredo do certificado CA raiz do servidor requer um campo que contenha o certificado CA raiz do agente do Apache Kafka no formato PEM. O exemplo a seguir exibe a estrutura do segredo.

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

Configuração de rede

Se estiver usando um ambiente do Apache Kafka autogerenciado que usa conectividade de VPC privada, o EventBridge deverá ter acesso aos recursos da Amazon Virtual Private Cloud (Amazon VPC) associados aos seus agentes do Apache Kafka.

Configure os grupos de segurança da Amazon VPC com as seguintes regras (no mínimo):

Ajuste de escala automático do consumidor com origens do Apache Kafka

Ao criar inicialmente uma origem de eventos do Apache Kafka, o EventBridge aloca um consumidor para processar todas as partições no tópico do Apache Kafka. Cada consumidor conta com vários processadores em execução em paralelo para lidar com um aumento de workloads. O EventBridge aumenta ou reduz a escala verticalmente automaticamente do número de consumidores com base na workload. Para preservar a ordenação de mensagens em cada partição, o número máximo de consumidores é um consumidor por partição no tópico.

A cada um minuto, o EventBridge avalia o atraso de compensação do consumidor de todas as partições do tópico. Se o atraso for muito alto, a partição está recebendo mensagens mais rápido do que o EventBridge pode processá-las. Se necessário, o EventBridge adiciona ou remove os consumidores do tópico. O processo de escalabilidade de adicionar ou remover consumidores ocorre em até três minutos após a avaliação.

Se seu destino estiver sobrecarregado, o EventBridge reduz o número de consumidores. Essa ação reduz a workload na função, reduzindo o número de mensagens que os consumidores podem recuperar e enviar para a função.