Melhorias de escalabilidade ao processar o Apache Kafka com o AWS Lambda

Mapeamento da fonte de eventos do AWS Lambda

Para obter mais informações sobre como usar o Lambda para processar streams do Kafka, consulte o guia de aprendizado.

Escalabilidade e produtividade

O Kafka usa partições para aumentar a taxa de transferência e distribuir a carga de registros para todos os corretores em um cluster.

O recurso de mapeamento da fonte de eventos do Lambda inclui pollers e processadores. Os pollers têm consumidores que leem registros das partições de Kafka. Os responsáveis pelo poller enviam aos processadores que agrupam os registros e invocam sua função.

Quando você cria um mapeamento de origem de eventos do Kafka, o Lambda aloca consumidores para processar todas as partições no tópico do Kafka. Anteriormente, a Lambda alocava no mínimo um processador para um consumidor.

Escalabilidade inicial anterior do Lambda

Com essas melhorias de escalabilidade, o Lambda aloca vários processadores para melhorar o processamento. Isso reduz a possibilidade de uma única invocação desacelerar todo o fluxo de processamento.

Escalabilidade inicial atualizada do Lambda

Cada consumidor envia registros para vários processadores em execução em paralelo para lidar com o aumento das cargas de trabalho. Os registros em cada partição são atribuídos somente a um único processador para manter a ordem.

O Lambda aumenta ou diminui automaticamente o número de consumidores e processadores com base na carga de trabalho. O Lambda faz uma amostra do atraso de compensação do consumidor de todas as partições no tópico a cada minuto. Se o atraso estiver aumentando, isso significa que o Lambda não consegue acompanhar o processamento dos registros da partição.

O algoritmo de escalabilidade considera o atraso de compensação atual e também a taxa de novas mensagens adicionadas ao tópico. O Lambda pode atingir o número máximo de consumidores em três minutos para reduzir o atraso de compensação o mais rápido possível. O Lambda também está reduzindo o comportamento de redução de escala para garantir que os registros sejam processados mais rapidamente e a latência seja reduzida, especialmente para cargas de trabalho intermitentes.

O total de processadores para todos os pollers só pode ser ampliado até o número total de partições no tópico.

Após invocações bem-sucedidas, o pesquisador submete periodicamente as compensações aos respectivos corretores.

Escalabilidade adicional do Lambda

Você pode monitorar a produtividade do seu tópico do Kafka usando as métricas de consumo consumer_lag e consumer_offset.

Para verificar quantas invocações de função ocorrem em paralelo, você também pode monitorar as métricas de simultaneidade da sua função. A simultaneidade é aproximadamente igual ao número total de processadores em todos os pollers, dependendo da atividade do processador. Por exemplo, se três pollers tiverem cinco processadores em execução para um determinado ESM, a simultaneidade da função seria de aproximadamente 15 (5 + 5 + 5).

Vendo a escalabilidade aprimorada em ação

Há vários padrões Serverless que você pode usar para processar fluxos do Kafka usando o Lambda. Para configurar o Amazon MSK Serverless, siga as instruções no repositório do GitHub:

1. Crie um exemplo de tópico Amazon MSK Serverless com 1000 partições.

./kafka-topics.sh --create --bootstrap-server "{bootstrap-server}" --command-config client.properties --replication-factor 3 --partitions 1000 --topic msk-1000p

for x in {1..13000000}; do echo $(uuidgen -r),message_$x; done | ./kafka-console-producer.sh --broker-list "{bootstrap-server}" --topic msk-1000p --producer.config client.properties --property parse.key=true --property key.separator=, --producer-property acks=all

import json
import base64
import time

def lambda_handler(event, context):
    # Define a variable to keep track of the number of the message in the batch of messages
    i=1
    # Looping through the map for each key (combination of topic and partition)
    for record in event['records']:
        for messages in event['records'][record]:
            print("********************")
            print("Record number: " + str(i))
            print("Topic: " + str(messages['topic']))
            print("Partition: " + str(messages['partition']))
            print("Offset: " + str(messages['offset']))
            print("Timestamp: " + str(messages['timestamp']))
            print("TimestampType: " + str(messages['timestampType']))
            if None is not messages.get('key'):
                b64decodedKey=base64.b64decode(messages['key'])
                decodedKey=b64decodedKey.decode('ascii')
            else:
                decodedKey="null"
            if None is not messages.get('value'):
                b64decodedValue=base64.b64decode(messages['value'])
                decodedValue=b64decodedValue.decode('ascii')
            else:
                decodedValue="null"
            print("Key = " + str(decodedKey))
            print("Value = " + str(decodedValue))
            i=i+1
            time.sleep(0.1)
    return {
        'statusCode': 200,
    }

Gráfico de melhoria do escalonamento automático do Lambda

Aumento da produtividade do processamento de dados

É importante que sua função consiga acompanhar a taxa de tráfego. Um atraso crescente de compensação significa que o processamento da função não consegue acompanhar o ritmo. Se a idade for alta em relação ao período de retenção da transmissão, você poderá perder dados à medida que os registros expirarem da transmissão.

Esse valor geralmente não deve exceder 50% do período de retenção do stream. Quando o valor atinge 100% do período de retenção do stream, os dados são perdidos. Uma solução temporária é aumentar o tempo de retenção do fluxo. Isso lhe dá mais tempo para resolver o problema antes de perder dados.

Há várias maneiras de melhorar a produtividade do processamento.

1. Evite processar registros desnecessários usando a filtragem de conteúdo para controlar quais registros o Lambda envia para sua função. Isso ajuda a reduzir o tráfego para sua função, simplifica o código e reduz o custo geral.
2. O Lambda aloca processadores em todos os pollers com base no número de partições até o máximo de uma função Lambda simultânea por partição. Você pode aumentar o número de funções de processamento do Lambda aumentando o número de partições.
3. Para funções de computação intensiva, você pode aumentar a memória alocada para sua função, o que também aumenta a quantidade de CPU virtual disponível. Isso pode ajudar a reduzir a duração de uma função de processamento.
4. O Lambda pesquisa Kafka com um tamanho de lote configurável de registros. Você pode aumentar o tamanho do lote para processar mais registros em uma única invocação. Isso pode melhorar o tempo de processamento e reduzir os custos, principalmente se sua função tiver um tempo de inicialização maior. Um tamanho de lote maior aumenta a latência para processar o primeiro registro no lote, mas potencialmente diminui a latência para processar o último registro no lote. Há uma compensação entre custo e latência ao otimizar a capacidade de uma partição, e a decisão depende das necessidades de sua carga de trabalho.
5. Garanta que seus produtores distribuam uniformemente os registros entre as partições usando uma estratégia eficaz de chave de partição. Uma carga de trabalho fica desequilibrada quando uma única chave domina outras chaves, criando uma partição ativa, o que afeta a taxa de transferência.

Consulte Aumentar a produtividade do processamento de dados para obter algumas orientações adicionais.

Conclusão

Hoje, o AWS Lambda está aprimorando o comportamento de escalabilidade automática ao processar dados de fontes de eventos do Apache Kafka. O Lambda está aumentando o número padrão de consumidores iniciais, melhorando a rapidez com que eles aumentam a escala e garantindo que eles não diminuam a escala muito rapidamente. Não há nenhuma ação adicional que você deva realizar e não há custo adicional.

Você pode explorar as melhorias de escalabilidade com suas cargas de trabalho existentes ou implantar um cluster Amazon MSK e experimentar um dos padrões para medir o tempo de processamento.

Para explorar o uso do Lambda para processar streams do Kafka, consulte o guia de aprendizado.

Para obter mais recursos de aprendizado Serverless, visite Serverless Land.