Compartilhar via


Usar o avaliador do feed de alterações

APLICA-SE A: NoSQL

Este artigo descreve como você pode monitorar o progresso das instâncias do processador do feed de alterações ao ler o feed de alterações.

Por que o progresso do monitoramento é importante?

O processador do feed de alterações funciona como um ponteiro que avança no feed de alterações e entrega as alterações a uma implementação de representante.

A implantação do processador do feed de alterações pode processar alterações a uma taxa específica com base em seus recursos disponíveis, como CPU, memória, rede e assim por diante.

Se essa taxa for mais lenta do que a taxa em que as alterações ocorrem no contêiner do Azure Cosmos DB, o processador começará a ficar para trás.

A identificação desse cenário ajuda a entender se precisamos dimensionar nossa implantação do processador do feed de alterações.

Implementar o avaliador do feed de alterações

Como um modelo de push para notificações automáticas

Assim como o processador do feed de alterações, o avaliador do feed de alterações pode funcionar como um modelo de push. O avaliador mede a diferença entre o último item processado (definido pelo estado do contêiner de concessões) e a alteração mais recente no contêiner e efetuará push desse valor a um representante. O intervalo no qual a medição é feita também pode ser personalizado com um valor padrão de 5 segundos.

Por exemplo, se o processador do feed estiver usando o modo de última versão e for definido assim:

Container leaseContainer = client.GetContainer(databaseId, Program.leasesContainer);
Container monitoredContainer = client.GetContainer(databaseId, Program.monitoredContainer);
ChangeFeedProcessor changeFeedProcessor = monitoredContainer
    .GetChangeFeedProcessorBuilder<ToDoItem>("changeFeedEstimator", Program.HandleChangesAsync)
        .WithInstanceName("consoleHost")
        .WithLeaseContainer(leaseContainer)
        .Build();

A maneira correta de inicializar um avaliador para medir esse processador é usar GetChangeFeedEstimatorBuilder desta forma:

ChangeFeedProcessor changeFeedEstimator = monitoredContainer
    .GetChangeFeedEstimatorBuilder("changeFeedEstimator", Program.HandleEstimationAsync, TimeSpan.FromMilliseconds(1000))
    .WithLeaseContainer(leaseContainer)
    .Build();

Em que o processador e o avaliador compartilham o mesmo leaseContainer e o mesmo nome.

Os outros dois parâmetros são o representante, que receberá um número que representa o número de alterações pendentes para serem lidas pelo processador e o intervalo de tempo no qual você deseja que essa medida seja feita.

Um exemplo de um representante que recebe a estimativa é:

static async Task HandleEstimationAsync(long estimation, CancellationToken cancellationToken)
{
    if (estimation > 0)
    {
        Console.WriteLine($"\tEstimator detected {estimation} items pending to be read by the Processor.");
    }

    await Task.Delay(0);
}

Envie essa estimativa para sua solução de monitoramento e use-a para entender como o progresso está se comportando ao longo do tempo.

Como uma estimativa detalhada sob demanda

Em contraste com o modelo de push, há uma alternativa que permite obter a estimativa sob demanda. Esse modelo também fornece informações mais detalhadas:

  • O retardo estimado por concessão.
  • A instância proprietária de cada concessão e que as processa, de modo que você possa identificar se há um problema em uma instância.

Se o processador do feed de alterações for definido assim:

Container leaseContainer = client.GetContainer(databaseId, Program.leasesContainer);
Container monitoredContainer = client.GetContainer(databaseId, Program.monitoredContainer);
ChangeFeedProcessor changeFeedProcessor = monitoredContainer
    .GetChangeFeedProcessorBuilder<ToDoItem>("changeFeedEstimator", Program.HandleChangesAsync)
        .WithInstanceName("consoleHost")
        .WithLeaseContainer(leaseContainer)
        .Build();

Você poderá criar o avaliador com a mesma configuração de concessão:

ChangeFeedEstimator changeFeedEstimator = monitoredContainer
    .GetChangeFeedEstimator("changeFeedEstimator", leaseContainer);

Além disso, sempre que quiser, com a frequência necessária, você poderá obter a estimativa detalhada:

Console.WriteLine("Checking estimation...");
using FeedIterator<ChangeFeedProcessorState> estimatorIterator = changeFeedEstimator.GetCurrentStateIterator();
while (estimatorIterator.HasMoreResults)
{
    FeedResponse<ChangeFeedProcessorState> states = await estimatorIterator.ReadNextAsync();
    foreach (ChangeFeedProcessorState leaseState in states)
    {
        string host = leaseState.InstanceName == null ? $"not owned by any host currently" : $"owned by host {leaseState.InstanceName}";
        Console.WriteLine($"Lease [{leaseState.LeaseToken}] {host} reports {leaseState.EstimatedLag} as estimated lag.");
    }
}

Cada ChangeFeedProcessorState conterá as informações de concessão e retardo, além de indicar a instância atual que é proprietária dela.

Implantação do avaliador

O avaliador do feed de alterações não precisa ser implantado como parte do processador do feed de alterações, nem fazer parte do mesmo projeto. É recomendável implantar o avaliador em uma instância independente dos processadores. Uma única instância do avaliador pode acompanhar o progresso de todas as concessões e instâncias na implantação do processador do feed de alterações.

Cada estimativa consome unidades de solicitação de seus contêineres monitorados e de concessão. Uma frequência de 1 minuto entre eles é um bom começo, quanto menor a frequência, mais altas as unidades de solicitação consumidas.

Modos do feed de alterações aceitos

O avaliador de feed de alterações pode ser usado no modo de versão mais recente e modo de todas as versões e exclusões. Em ambos os modos, a estimativa fornecida não tem a garantia de ser uma contagem exata de alterações pendentes a serem processadas.

Recursos adicionais

Próximas etapas

Agora continue para saber mais sobre o processador do feed de alterações no seguinte artigo: