Por que os limites de concorrência adaptativos funcionam melhor do que os limites fixos de taxa de requisições para operações de longa execução.
por Heqing Ya, Tan Zhang, Ankit Batra e Abhishek Rai
Como parte da equipe de Plataforma de Computação do Databricks, transformamos a infraestrutura de nuvem em clusters prontos para executar as cargas de trabalho dos clientes. Nosso trabalho diário inclui o provisionamento de máquinas virtuais e a coordenação da criação de clusters na AWS, no Azure e no Google Cloud. Nosso objetivo é manter esses sistemas disponíveis, permitindo que os clientes usem o máximo de capacidade que pudermos fornecer com segurança.
Nesta publicação, vamos explorar por que os limites fixos de taxa de solicitações podem ser insuficientes para essas operações de longa duração, como os limites de concorrência adaptativos ajudam e o que aprendemos ao aplicá-los à criação de clusters para a computação clássica do Databricks. Você não precisa saber nada disso para usar o Databricks, mas, se tiver curiosidade sobre o que acontece por trás da inicialização de um cluster do Databricks Runtime, junte-se a nós para dar uma olhada nos bastidores.
Historicamente, protegíamos o sistema com limites fixos de taxa de solicitações, testados contra diferentes padrões de carga e cenários de falha. Dimensionávamos nossos serviços principalmente adicionando recursos e ajustando os limites por cliente.
A combinação de cargas de trabalho e falhas de dependência tornou esses limites cada vez mais difíceis de testar e ajustar. Limites conservadores rejeitavam solicitações de clientes, apesar da capacidade ociosa, mas continuavam aceitando solicitações quando nossos serviços ou dependências, como provedores de nuvem, ficavam lentos. Os engenheiros reduziam manualmente os limites para aliviar a carga durante incidentes e os aumentavam novamente após a recuperação.
Os limites de concorrência adaptativos levam em conta tanto o trabalho inacabado quanto a saúde mutável do sistema. Eles permitem que mais trabalho seja iniciado quando há capacidade disponível e reduzem o ritmo quando o sistema enfrenta dificuldades, ajudando o serviço a progredir com menos ajustes manuais. Um limite máximo fixo de taxa de solicitações de API permanece como uma barreira de proteção final contra tráfego de entrada excepcionalmente alto.
Pense em nossa plataforma de computação como uma cozinha, cujo objetivo é servir o máximo de pedidos que seus cozinheiros e equipamentos conseguem aguentar. O gerente publica uma regra fixa: aceite no máximo dez novos pedidos por minuto, aconteça o que acontecer no fogão.
Mesmo com capacidade de cozimento ociosa, a regra rejeita pedidos. Quando um forno quebra, a cozinha continua aceitando pedidos mais rápido do que os cozinheiros restantes e os equipamentos conseguem finalizá-los. O gerente precisa continuar reescrevendo a placa todas as vezes.
Uma cozinha melhor mantém uma fila curta e limita quantas refeições estão sendo preparadas ao mesmo tempo. Se um forno quebra, menos refeições começam; à medida que a capacidade retorna, mais podem começar. Os pedidos podem esperar brevemente, mas apenas enquanto ainda houver tempo para servi-los.
Para operações de longa duração, uma taxa fixa de solicitações é um modelo deficiente de capacidade. O objetivo é permitir que os clientes operem a todo vapor quando a capacidade permitir, e depois desacelerar o suficiente para manter o trabalho útil avançando durante a degradação.
Uma chamada de API pode iniciar muito mais trabalho do que o manipulador executa sozinho. Para a criação de clusters, o manipulador valida a solicitação, registra um item de trabalho e retorna. Um fluxo de trabalho em segundo plano coordena serviços, atualiza o estado e provisiona recursos, como máquinas virtuais de nuvem. Essas operações são concluídas de forma assíncrona, e sua duração depende da integridade e da capacidade de suas dependências. A chamada de API pode levar milissegundos; o fluxo de trabalho em si pode levar minutos.
Um limitador de taxa de solicitações no ponto de entrada da API define um limite máximo de solicitações por janela de tempo. Isso é útil para aplicar cotas, evitar abusos e proteger os recursos usados para lidar com chamadas de API.
Um limite fixo de taxa de solicitações é mais fácil de ajustar quando a capacidade disponível e o trabalho por trás de cada solicitação permanecem razoavelmente previsíveis. A criação de clusters torna ambos difíceis: uma solicitação pode provisionar algumas VMs e outra, muitas mais, enquanto a integridade do provedor de nuvem altera o tempo necessário para o provisionamento. Durante uma lentidão compartilhada, muitos fluxos de trabalho demoram mais ao mesmo tempo. A mesma taxa de solicitações de entrada pode, portanto, deixar muito mais trabalho em andamento, mesmo com a queda da capacidade do sistema de concluí-lo.
À esquerda, as chegadas permanecem fixas em uma operação por unidade de tempo. O aumento da duração de duas para seis unidades de tempo triplica o trabalho em andamento. À direita, os processadores ficam lentos ou indisponíveis, reduzindo a capacidade disponível para lidar com esse trabalho.
Quando uma dependência se degrada, mais chamadas falham ou expiram. Fluxos de trabalho de longa duração repetem essas chamadas para se recuperar de falhas temporárias. Em muitos fluxos de trabalho ativos, essas novas tentativas aumentam a pressão sobre a dependência com problemas, causando mais falhas e ainda mais novas tentativas — uma tempestade de novas tentativas.
Essas novas tentativas internas vêm de trabalho já aceito, portanto, o limitador de taxa de solicitações da API não as vê. Elas podem sustentar a sobrecarga mesmo depois que o tráfego de entrada retorna ao normal. Limitar os fluxos de trabalho ativos ajuda a conter essa pressão e dá ao trabalho inacabado a chance de ser esvaziado.
Definir uma taxa mais baixa não resolve a incompatibilidade. Isso gera margem de manobra ao rejeitar mais trabalho durante períodos saudáveis, e uma desaceleração grande o suficiente ainda pode esgotar essa margem. Aumentar a taxa faz melhor uso da capacidade saudável, mas aceita mais trabalho durante a degradação. Um único número precisa cobrir ambos os dias.
“Limitação de taxa” às vezes é usada de forma ampla para incluir limites de trabalho simultâneo. Aqui, distinguimos os dois mecanismos pelo que eles contam.
| Termo | Significado neste artigo |
|---|---|
| Operação | O fluxo de trabalho completo, incluindo o trabalho em segundo plano após o retorno da API. |
| Limite de taxa de solicitações | Um limite para solicitações aceitas por unidade de tempo, como 10 solicitações por segundo, com uma possível tolerância para picos. |
| Concorrência | Quantas operações estão ativas ao mesmo tempo, incluindo aquelas aguardando dependências. |
| Limite de concorrência | Um limite para operações ativas, como 100 ao mesmo tempo. Cada operação retém um slot até ser concluída. |
| Pendência | Trabalho aceito aguardando para começar; ele ainda não adquiriu um slot ativo. |
Qualquer tipo de limite pode ser fixo ou adaptativo. Nossa comparação é entre limites fixos de taxa de solicitações e limites de concorrência adaptativos para proteger trabalhos de longa duração.
A cozinha precisa rastrear as refeições que ainda estão sendo preparadas e a capacidade disponível para terminá-las. Na computação clássica do Databricks, o equivalente é o conjunto de fluxos de trabalho de criação de clusters que ainda estão provisionando infraestrutura. Damos a cada fluxo de trabalho ativo um slot e ajustamos o número de slots conforme as condições mudam.
Considere uma solicitação CreateCluster para um cluster com um driver e várias VMs de trabalhador. Assim que a solicitação é aceita, seu fluxo de trabalho de provisionamento aguarda um slot antes de começar. Rastreamos se esse trabalho está na fila, processando ativamente ou concluído.
Se todos os slots estiverem ocupados, a solicitação permanecerá na fila. Um fluxo de trabalho ativo mantém seu slot enquanto provisiona VMs e aguarda por dependências. Assim que o fluxo de trabalho é concluído, seu slot fica disponível para a inicialização de outro cluster. Um cluster inicializado com sucesso pode continuar executando cargas de trabalho de clientes por horas sem ocupar esse slot de provisionamento.
O slot deve cobrir a operação de provisionamento inteira, incluindo o trabalho em segundo plano após o retorno da API. O rastreamento de um slot não exige a retenção de uma thread.
Esse controlador conta fluxos de trabalho de provisionamento ativos. Clusters em execução, VMs alocadas e vCPUs são medidas separadas. Um fluxo de trabalho pode provisionar muitas VMs, portanto, um slot não implica um custo fixo de recursos.
Agora, suponha que um provedor de nuvem demore mais para provisionar VMs. Os fluxos de trabalho ativos mantêm seus slots por mais tempo, de modo que novas inicializações de cluster começam com menos frequência, mesmo que o limite de slots permaneça fixo. Os clientes veem esperas de inicialização mais longas à medida que as solicitações aceitas entram na fila.
O controle adaptativo também altera o limite de slots. Para a criação de clusters, os sinais úteis incluem quanto tempo o provisionamento leva e se os pools de threads críticos estão saturados. Quando esses sinais indicam congestionamento, o controlador reduz o número de fluxos de trabalho de provisionamento concorrentes. À medida que as condições se recuperam, ele permite cautelosamente mais recursos. A pressão de capacidade muda quando o trabalho aceito começa; as rejeições do limitador de taxa de RPC são reservadas para taxas de solicitações de entrada excepcionalmente altas.
Reduzir o limite evita que novas operações sejam iniciadas até que o trabalho ativo caia abaixo dele; as operações existentes ainda precisam de tempo para terminar. Esse tempo de resposta é importante quando os fluxos de trabalho duram minutos. As novas tentativas também precisam de tempo de espera exponencial e de um limite de tentativas para que os fluxos de trabalho ativos não continuem sobrecarregando uma dependência em recuperação. A limitação de concorrência não pode consertar uma dependência indisponível, mas pode limitar a pressão extra enquanto essa dependência se recupera.
O loop de controle responde quanto trabalho iniciar. Criar um serviço útil também significa decidir quem espera, quanto tempo eles esperam e o que dizemos a eles.
“Muitas solicitações” podem ocultar duas situações muito diferentes.
Na primeira, um cliente envia seu tráfego habitual, mas uma dependência compartilhada fica mais lenta. A capacidade diminuiu. Pedir ao cliente para corrigir seu padrão de tráfego atribui erroneamente um problema de serviço.
Na segunda, um cliente envia um pico incomum enquanto o serviço permanece saudável. Outros clientes estão competindo pelos mesmos recursos. Limitar esse pico protege a parte justa deles.
Para diferenciar esses casos, monitore a integridade do sistema, a demanda de entrada de cada tenant e a decisão de agendamento separadamente. Um grande número de operações em andamento por si só não prova que um cliente enviou demais: essas operações podem estar presas atrás de uma dependência lenta. Da mesma forma, um pico não precisa ser limitado por justiça se houver capacidade ociosa disponível e a política permitir.
Essa distinção pertence às métricas e às explicações voltadas para o cliente. Ela diz aos operadores se devem investigar a perda de capacidade ou uma carga de trabalho incomum, e diz aos clientes se a alteração de seu comportamento ajudará. Conte as falhas causadas pela degradação do serviço nas métricas de confiabilidade do serviço, mesmo quando elas aparecem como limitação. Para solicitações aceitas que esperam na fila, meça o impacto na latência de inicialização do cluster.
Para uma operação que leva minutos, uma breve espera geralmente é preferível a um erro imediato seguido por uma nova tentativa. Uma fila pode absorver um pico e permitir que o sistema se recupere.
Isso só funciona se a espera estiver de acordo com o prazo da solicitação. Limite o tamanho da fila e o tempo de espera de cada solicitação, torne o progresso visível e rejeite ou expire o trabalho quando ele não puder mais ser concluído de forma útil. Uma fila não pode transformar uma sobrecarga sustentada em capacidade; uma fila ilimitada pode transformar uma breve interrupção em horas de atraso.
Uma solicitação enfileirada deve ser um registro pequeno, não um trabalhador em execução que retém recursos escassos. Um backlog maior não deve tornar cada operação ativa mais cara por meio de varreduras repetidas ou concorrência por threads e conexões.
A limpeza precisa da mesma atenção. Se um grande backlog expirar junto, o serviço deve ser capaz de descartá-lo dentro de um tempo previsível. Planeje para o pior backlog, mantenha a expiração e a rejeição baratas e evite fazer configurações caras para trabalhos cujo prazo já passou. Caso contrário, a fila pode manter o serviço ocupado muito depois que o congestionamento original tiver terminado.
Imagine que um serviço deva atrasar cem solicitações. É melhor para cem clientes verem cada um uma solicitação lenta, ou para um cliente ver cem solicitações lentas?
A métrica agregada pode parecer a mesma. A experiência do cliente não será.
Um agendador faz essa escolha, quer a especifiquemos ou não. Defina qual trabalho deve vir primeiro, qual parcela cada tenant deve receber sob contenção e como o trabalho de menor prioridade evita esperar para sempre. Permita que os tenants usem a capacidade ociosa onde a política permitir, preservando o acesso justo quando outros tenants precisarem de sua parcela.
Aplicamos essas ideias a um sistema de gerenciamento de carga integrado para a criação de clusters no Databricks classic compute. Uma solicitação curta de API inicia um fluxo de trabalho muito mais longo que coordena várias dependências, incluindo nuvens públicas, para provisionar recursos de computação.
O sistema combina solicitações enfileiradas, limites de concorrência adaptativos e agendamento justo. Ele usa o trabalho já em andamento e a integridade do sistema para decidir quando as operações enfileiradas podem começar.
Mantivemos o limite de taxa de solicitações da API como uma linha de defesa final contra tráfego de entrada excepcionalmente alto. Ele fornece um limite de taxa de solicitações que podemos comunicar aos clientes. Os limites de concorrência adaptativos permanecem dentro do serviço e governam quando o trabalho aceito começa. Uma resposta de API bem-sucedida não garante uma inicialização imediata do cluster ou conclusão dentro de um tempo fixo.
A análise inicial de lançamento relatou três resultados:
O controle de concorrência adaptativo tornou o aumento de 7,5× possível ao proteger os fluxos de trabalho de longa execução à medida que as condições mudavam. Desde esse aumento, poucos clientes atingiram os limites mais altos de taxa de solicitação de criação de cluster, e não adicionamos novas substituições manuais para esses limites. Os clientes têm mais margem para escalar, com menos necessidade de exceções ajustadas individualmente.
A aplicação dessa abordagem a outros tipos de trabalho de longa execução levanta mais perguntas de design. Quando as operações têm custos de recursos muito diferentes, contar cada uma como um slot pode ser muito grosseiro; slots ponderados ou limites separados s ão extensões possíveis. Para fluxos de trabalho com vários gargalos, outra questão de design é onde aplicar o controle para que uma dependência lenta não retenha trabalho não relacionado.
Durante uma lentidão do provedor de nuvem, os fluxos de trabalho que já estão provisionando VMs podem continuar tentando novamente mesmo após o início de novas inicializações lentas. Associe limites de concorrência com espera exponencial e um limite de tentativas para reduzir essa pressão durante a recuperação.
Um limite de taxa de solicitações limita quantas solicitações são aceitas por unidade de tempo; um limite de concorrência limita quantas operações estão ativas ao mesmo tempo. Cada operação ativa mantém um slot até ser concluída, incluindo o tempo gasto aguardando em dependências.
Um fluxo de trabalho CreateCluster mantém seu slot durante o provisionamento de VMs, incluindo o tempo gasto aguardando em dependências após o retorno da API. Quando o provisionamento é concluído, o slot é liberado, embora o cluster possa continuar executando cargas de trabalho do cliente. O controlador conta os fluxos de trabalho de provisionamento ativos; ele não conta todos os clusters em execução ou VMs e vCPUs alocadas. O rastreamento de um slot não requer a retenção de uma thread.
Quando um provedor de nuvem fica mais lento, os fluxos de trabalho de provisionamento retêm seus slots por mais tempo e as solicitações aceitas demoram mais para iniciar. O controlador também reduz o limite de slots quando sinais de congestionamento, como latência de provisionamento ou saturação do pool de threads, indicam pressão. Conforme as condições se recuperam, ele permite cautelosamente mais trabalho simultâneo.
O limite fixo de taxa de solicitações da API protege contra tráfego de entrada excepcionalmente alto e fornece um limite de taxa de solicitações que podemos comunicar aos clientes. Os limites de concorrência adaptativos funcionam dentro do serviço: a pressão de capacidade enfileira as solicitações aceitas e atrasa o provisionamento. Uma resposta de API bem-sucedida não garante uma inicialização imediata do cluster ou conclusão dentro de um tempo fixo.
A análise inicial de lançamento relatou limites de taxa de solicitação de criação de cluster padrão 7,5× mais altos, mais de 99,99% menos erros de limite de taxa de criação de cluster no escopo relatado e a remoção de mais de cem substituições de limite de taxa específicas do cliente no escopo. Desde o aumento, poucos clientes atingiram os limites mais altos e nenhuma nova substituição manual foi adicionada para esses limites.
Para o problema complementar de aplicar cotas de API em escala, leia High Performance Ratelimiting at Databricks.
(Esta publicação no blog foi traduzida utilizando ferramentas baseadas em inteligência artificial) Publicação original
Assine nosso blog e receba os posts mais recentes diretamente na sua caixa de entrada.