Teste de carga com NBomber: análise do framework .NET

O NBomber é um framework de teste de carga para .NET: você escreve cada teste como um cenário em C# ou F#, adiciona a um projeto comum e roda como qualquer outro programa. O teste de carga com NBomber combina com times que já desenvolvem em .NET e querem os testes de carga na mesma linguagem, no mesmo repositório e no mesmo executor de testes. O NBomber só é gratuito para uso pessoal e acadêmico; uma empresa precisa de uma licença paga, e esse fato decide mais avaliações do que qualquer recurso.

Não rodamos o NBomber para esta análise. Os fatos vêm da documentação, da página de preços, do repositório no GitHub e do pacote no NuGet do NBomber, conferidos em 21 de outubro de 2026, e as avaliações são nossas.

Quem faz o NBomber, e ele é gratuito?

A NBomber LLC desenvolve o framework, com o código no GitHub. Ele é gratuito para uso pessoal, hobby e acadêmico, e a página de licença diz com todas as letras que o NBomber não é gratuito para organizações.

A página de licença conta benchmarks, tutoriais e conteúdo de análise como uso pessoal. Dentro de uma empresa você precisa de uma licença Business ou Enterprise, emitida por organização e não por desenvolvedor, sem limite de instâncias ou de execuções em paralelo. A página de preços traz US$ 1.500 por ano para Business e US$ 2.500 por ano para Enterprise, ambas com 30 dias de garantia de reembolso. A chave de licença vai para o executor com .WithLicense(...) ou um argumento --license, e o NBomber precisa de acesso à internet para validá-la, com validação offline disponível sob pedido por e-mail (conferido em 21 de outubro de 2026).

A versão mais recente é a v6.7.1, publicada em 16 de outubro de 2026, quatro dias depois da 6.7.0 (conferido em 21 de outubro de 2026).

Como funciona um cenário do NBomber?

Um cenário é um nome mais uma função assíncrona que o NBomber cronometra a cada chamada. Você anexa simulações de carga e thresholds, registra o cenário no NBomberRunner e roda o programa.

Este teste pula o warm-up, sobe a taxa de chegada para 50 novas cópias do cenário por segundo em dois minutos, mantém por dez minutos e termina com código de saída 1 se 1% ou mais das requisições tiverem falhado. Ele usa o plugin NBomber.Http para a requisição:

var http = Http.CreateDefaultClient();

var scenario = Scenario.Create("browse", async context =>
{
    var request = Http.CreateRequest("GET",
        "https://staging.example.com/products");
    return await Http.Send(http, request);
})
.WithoutWarmUp()
.WithLoadSimulations(
    Simulation.RampingInject(rate: 50,
        interval: TimeSpan.FromSeconds(1),
        during: TimeSpan.FromMinutes(2)),
    Simulation.Inject(rate: 50,
        interval: TimeSpan.FromSeconds(1),
        during: TimeSpan.FromMinutes(10)))
.WithThresholds(
    Threshold.Create(s => s.Fail.Request.Percent < 1));

var result = NBomberRunner
    .RegisterScenarios(scenario).Run();
return result.Thresholds.Any(t => t.IsFailed) ? 1 : 0;

A página do cliente HTTP recomenda Http.CreateDefaultClient() em vez de um simples new HttpClient() e diz que o plugin registra os códigos de status e os dados transferidos (conferido em 21 de outubro de 2026). Um threshold sozinho só registra a falha no relatório; é a última linha que transforma isso num código de saída que um pipeline consegue ler. Sem .WithoutWarmUp(), o NBomber roda antes um warm-up de 30 segundos com as simulações do próprio cenário, segundo a página de cenários (conferido em 21 de outubro de 2026). Como o cenário é C# comum, tudo o que uma biblioteca .NET consegue chamar pode ser colocado sob carga do mesmo jeito.

Que modelos de carga o NBomber oferece?

Os dois. As simulações inject iniciam novas cópias a uma taxa fixa, não importa o que as anteriores estejam fazendo, o que é um modelo de carga aberto; as simulações constant mantêm um número fixo de cópias rodando, o que é um modelo fechado.

A página de simulações de carga lista todas (conferido em 21 de outubro de 2026):

• Abertas: Inject, RampingInject, InjectRandom e IterationsForInject.
• Fechadas: KeepConstant, RampingConstant e IterationsForConstant.
• Controle de tempo: Pause, que atrasa o início de um cenário ou o pausa por um tempo definido.

Nosso artigo sobre o modelo de carga aberto vs fechado explica qual combina com o seu tráfego. Um site público costuma se comportar como o modelo aberto; um grupo fixo de clientes internos, como o fechado.

Como funcionam os thresholds e os critérios de aprovação?

Os thresholds em tempo de execução checam as estatísticas em andamento, a cada 5 segundos por padrão, e aparecem no relatório HTML. Os asserts, escritos em xUnit ou NUnit, checam as estatísticas finais depois da execução, e um assert que falha encerra a execução com status de falha.

A página de thresholds mostra checagens de porcentagem de erros, códigos de status, percentis de latência (p50, p75, p95, p99 e máximo), requisições por segundo e bytes transferidos. Por padrão um threshold não para o teste; abortWhenErrorCount faz ele parar depois de um número definido de checagens que falharam (conferido em 21 de outubro de 2026). A página não informa um código de saída, por isso o exemplo acima devolve um a partir do resultado. Nosso guia de critérios de aprovação de um teste de carga ajuda a escolher os limites.

Quais protocolos o NBomber consegue testar?

Qualquer protocolo que uma biblioteca .NET fale, porque o NBomber só cronometra o código que você entrega. Há plugins prontos para HTTP, WebSockets, MQTT e AMQP, além de uma opção WebBrowser.

A página de visão geral descreve o framework como independente de protocolo, e a página de preços inclui esses plugins em todos os planos, inclusive no gratuito. Isso vale também para bancos de dados e filas de mensagens que você chama pelos próprios clientes .NET (conferido em 21 de outubro de 2026). Em troca, fora dos plugins você escreve e mantém o código do cliente.

Como escalar um teste do NBomber?

Com o NBomber Cluster: um Coordinator orquestra a execução e os Agents rodam os cenários, todos conversando por um broker de mensagens NATS. O Cluster faz parte da licença Enterprise.

A visão geral do cluster explica os papéis, e a página de licença diz que os desenvolvedores podem testá-lo localmente com um Local Dev Cluster antes de comprar; a página do Local Dev Cluster limita o Local Dev Cluster a 1 Coordinator e 2 Agents e para cada execução depois de um minuto (conferido em 21 de outubro de 2026). A integração com Kubernetes do NBomber Studio, também exclusiva do Enterprise, provisiona o NATS e os pods dos Agents para você. Sem o Cluster, um processo do NBomber roda numa só máquina; a página de requisitos de sistema sugere de 4 a 8 núcleos de CPU para carga alta.

A LoadFocus, que publica este site, não roda testes do NBomber. Ela roda planos de teste JMeter e scripts k6 a partir de 25 regiões na nuvem.

O que o NBomber faz bem, e onde estão os limites?

Ele é forte para times .NET: os testes são código C# ou F#, qualquer cliente .NET vira um teste de carga e os dois modelos de carga já vêm prontos. Os limites são a licença para empresas, um ecossistema de uma linguagem só e execuções distribuídas pagas.

• Os testes ficam ao lado do código da aplicação, com a mesma IDE, os mesmos pacotes e as mesmas revisões.
• Os thresholds já vêm embutidos, e os asserts rodam dentro dos testes xUnit ou NUnit que você já tem.
• O uso comercial exige licença, mesmo para um único desenvolvedor.
• Execuções distribuídas exigem o Enterprise e um broker NATS.
• Quem não conhece .NET vai precisar aprender C# ou F# primeiro.

Quando escolher k6, Gatling ou JMeter em vez do NBomber?

Escolha outra ferramenta quando o seu time não programa em .NET ou quando o custo da licença não cabe.

Escolha o k6 quando quiser scripts em JavaScript e uma ferramenta open source sem custo de licença para uso na empresa: o repositório dele é AGPL-3.0 (conferido em 21 de outubro de 2026). A LoadFocus roda scripts k6 a partir de 25 regiões na nuvem, embora rode cenários arrival-rate com um número fixo de usuários. Escolha o Gatling para uma ferramenta baseada em código na JVM; nossa análise do Gatling cobre o tema. Escolha o JMeter quando os testadores preferem uma interface gráfica ou quando você precisa de samplers JDBC, JMS ou LDAP de fábrica. O panorama de ferramentas de teste de carga open source coloca todas lado a lado.

FAQ

O NBomber é gratuito para uso comercial? Não. O NBomber só é gratuito para uso pessoal e acadêmico. Uma empresa precisa de uma licença Business de US$ 1.500 por ano ou de uma licença Enterprise de US$ 2.500 por ano.

Quais versões do .NET o NBomber suporta? Ele mira o .NET Standard 2.1, então roda no .NET Core 3.0 e em todas as versões do .NET posteriores. A documentação recomenda o .NET 10.

A LoadFocus consegue rodar testes do NBomber? Não. A LoadFocus roda planos de teste JMeter e scripts k6. Para rodar o NBomber em mais de uma máquina, use o NBomber Cluster, que exige uma licença Enterprise.

Leituras relacionadas

• Teste de carga com Gatling: análise da ferramenta JVM
• Ferramentas de teste de carga open source: seis opções
• Modelo de carga aberto vs fechado: qual usar e quando
• Critérios de aprovação de um teste de carga: como definir
• Teste de carga com Tsung: análise da ferramenta Erlang

As afirmações técnicas deste artigo não foram revisadas de forma independente.