Teste de carga com Artillery: análise da ferramenta Node.js

O Artillery é uma ferramenta de teste de carga open source que roda em Node.js e descreve cada teste num arquivo YAML, TypeScript ou JavaScript. O teste de carga com Artillery combina com times que vivem no ecossistema JavaScript, que querem novos usuários chegando num ritmo definido ou que querem testes de navegador com Playwright na mesma ferramenta. Times que querem um binário único sem runtime ficam mais bem servidos com o k6, e times que precisam de muitos protocolos de fábrica, com o JMeter.

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

Quem desenvolve o Artillery, e qual é a licença?

A Artillery Software Inc. mantém o projeto no GitHub. A maior parte do código está sob MPL-2.0, que permite uso comercial; alguns módulos específicos do Azure estão sob a Business Source License.

O README do repositório permite usar o Artillery no Azure para avaliação e prova de conceito, e exige licença comercial para uso comercial ou em produção ali. A versão mais recente é a 2.0.34, publicada no npm em 14 de agosto de 2026, e os metadados do pacote pedem Node.js 22.18.0 ou mais novo; o guia de instalação recomenda a LTS mais recente (conferido em 19 de outubro de 2026).

Como funciona um script de teste do Artillery?

Um script tem duas partes: config, que define o alvo, as fases de carga e os plugins, e scenarios, que lista o que cada usuário virtual faz. Você pode escrever em YAML ou exportar config e scenarios de um arquivo TypeScript ou JavaScript.

Este teste sobe de 5 para 50 novos usuários por segundo em dois minutos, mantém 50 por segundo por dez minutos e falha se o percentil 99 do tempo de resposta chegar a 800 ms:

config:
  target: https://staging.example.com
  phases:
    - duration: 120
      arrivalRate: 5
      rampTo: 50
      name: ramp
    - duration: 600
      arrivalRate: 50
      name: sustain
  plugins:
    ensure:
      thresholds:
        - http.response_time.p99: 800
scenarios:
  - name: browse and add to cart
    flow:
      - get:
          url: /products
      - think: 2
      - post:
          url: /cart
          json:
            sku: A-100

Segundo a referência de scripts de teste, os quatro tipos de fase são uma taxa de chegada constante, uma rampa linear com rampTo, um arrivalCount fixo distribuído num período e uma pause. O código próprio carregado por config.processor pode ser um módulo TypeScript localmente e no Fargate, mas não no Lambda (conferido em 19 de outubro de 2026).

Que modelo de carga o Artillery usa?

O Artillery inicia novos usuários virtuais no ritmo que você define, tenham os anteriores terminado ou não. É um modelo de carga aberto, que mantém as chegadas mesmo quando o sistema fica lento.

Cada novo usuário escolhe um cenário, roda e vai embora, então um sistema lento acumula usuários como o tráfego real faria. maxVusers limita o número de usuários simultâneos numa fase se você precisar proteger o gerador de carga. Nosso artigo sobre o modelo de carga aberto vs fechado explica a diferença, e a lei de Little mostra como a taxa de chegada e o tempo de resposta definem o número de usuários simultâneos.

Quais protocolos e navegadores ele testa?

HTTP é o padrão, e WebSocket, Socket.IO e Playwright vêm embutidos. gRPC e AWS Kinesis precisam de motores instalados à parte.

A página de motores descreve o modelo: cada cenário roda num motor, e você pode escrever o seu. No npm, o artillery-engine-grpc está na 0.0.9 e o artillery-engine-kinesis na 1.1.1, ambos sob MPL-2.0. O motor Playwright roda seu código Playwright em navegadores headless reais e publica Web Vitals como TTFB, FCP e LCP por página. A documentação avisa que um navegador separado por usuário, em vez de um contexto de navegador, exige muito mais CPU e memória (conferido em 19 de outubro de 2026). Nosso panorama de ferramentas de teste de carga WebSocket coloca o Artillery ao lado de outras opções para apps em tempo real.

Como ele se encaixa na CI?

O plugin ensure transforma métricas em checagens de aprovação, e uma checagem que falha faz o Artillery sair com código diferente de zero. Isso basta para qualquer sistema de CI reprovar o build.

A referência do ensure oferece dois tipos de checagem: thresholds, em que uma métrica precisa ficar abaixo de um valor, e conditions, que combinam métricas numa expressão como http.response_time.p95 < 250 and http.request_rate > 1000. Uma condição marcada com strict: false só avisa, sem reprovar. O plugin apdex acrescenta uma pontuação Apdex aos testes HTTP, com limite padrão de 500 ms (conferido em 19 de outubro de 2026); nosso artigo sobre a pontuação Apdex explica como ler esse número. Para um arquivo de workflow, veja nosso guia de teste de carga no GitHub Actions.

Como escalar um teste do Artillery?

Pela linha de comando, na sua própria conta de nuvem: run-lambda e run-fargate na AWS, run-aci no Azure Container Instances. O Artillery cria os recursos de que a execução precisa e remove os temporários depois.

O guia do Fargate lista os recursos e as permissões de IAM envolvidos. O guia do Lambda informa os limites: um teste não pode passar de 15 minutos, um teste em andamento não pode ser parado, e os hooks before e after rodam uma vez por worker. O guia do Azure exige o Artillery 2.0.19 ou mais novo e, fora de avaliação, uma assinatura (conferido em 19 de outubro de 2026).

A LoadFocus, que publica este site, não roda scripts do Artillery. Ela roda planos de teste JMeter e scripts k6 a partir de 25 regiões na nuvem, então para o Artillery os comandos acima são o caminho para escalar.

Quanto custa o Artillery Cloud?

O dashboard é opcional: os resultados só vão para ele quando você roda com --record e uma chave de API. Os planos vão de um nível gratuito a US$ 499 por mês.

A página de preços lista (conferido em 19 de outubro de 2026):

• Free: 30 relatórios por mês, 1 mês de retenção, 2 membros, testes distribuídos com até 5 workers e 30 minutos.
• Team, US$ 199 por mês: 1.000 relatórios, 6 meses, 8 membros, até 25 workers e 2 horas.
• Business, US$ 499 por mês: 2.500 relatórios, 18 meses, sem limite de membros, workers ou duração.

SSO corporativo, logs de auditoria e SLAs de suporte começam em US$ 1.199 por mês, e o faturamento anual economiza 20%.

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

Ele é forte em carga por taxa de chegada, scripts curtos e legíveis e testes de navegador com Playwright. É mais fraco quando você precisa de um binário único, de muitos protocolos sem complementos ou de usar o Azure sem licença.

Como ferramenta Node.js, ele pode usar qualquer módulo do npm em funções próprias, ao custo de mais um runtime em cada máquina de teste. Limites que a própria documentação aponta:

• Execuções no Lambda param aos 15 minutos e não podem ser canceladas.
• Código próprio em TypeScript (config.processor) não roda no Lambda.
• gRPC e Kinesis são motores separados.
• Uso em produção no Azure exige licença comercial.

Quando escolher k6, JMeter ou Locust em vez do Artillery?

Escolha outra ferramenta quando o runtime, os protocolos ou a linguagem dela combinarem mais com o seu time.

Escolha o k6 quando quiser um binário Go sem Node.js para manter e thresholds no script. Nossa comparação k6 vs Artillery coloca os dois lado a lado. A LoadFocus roda scripts k6 a partir de 25 regiões na nuvem, mas executa cenários arrival-rate com um número fixo de usuários; para manter uma taxa de chegada, rode-os com o próprio k6.

Escolha o JMeter quando precisar de JDBC, JMS, LDAP ou FTP de fábrica, ou quando seus testadores montarem testes numa interface gráfica.

Escolha o Locust quando o seu time escrever Python; nossa análise do Locust trata dele. O panorama de ferramentas de teste de carga open source coloca todas lado a lado.

FAQ

O Artillery é gratuito para uso comercial? A CLI é quase toda MPL-2.0, que permite uso comercial. A exceção é o Azure: uso comercial ou em produção dos módulos do Azure exige licença comercial.

O Artillery roda testes de navegador? Sim. O motor Playwright embutido roda seu código Playwright em navegadores headless e publica Web Vitals de cada página.

A LoadFocus roda scripts do Artillery? Não. A LoadFocus roda planos de teste JMeter e scripts k6. Para escalar um teste do Artillery, use run-lambda, run-fargate ou run-aci.

Leituras relacionadas

• k6 vs Artillery: qual ferramenta de teste de carga escolher
• Ferramentas de teste de carga open source: seis opções
• Modelo de carga aberto vs fechado: qual usar e quando
• Ferramentas de teste de carga WebSocket: seis opções
• Pontuação Apdex: o que é e como calcular

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