Tutorial Gatling: Introdução ao Teste de Carga Gatling

gatling tutorial getting started with gatling load testing

Este tutorial em vídeo Gatling fornece uma revisão abrangente do Gatling, incluindo recursos, etapas de instalação e exemplos de uso do gravador de simulação Gatling:

Gatling é uma estrutura de teste de código aberto baseada em Scala. Ele está ganhando muita popularidade atualmente, com mais de 3 milhões de downloads nos últimos 3 anos.

Ele está disponível como um código-fonte aberto, bem como uma variante corporativa chamada Gatling Frontline com mais integrações e suporte da equipe Gatling. Mas todos os casos de uso práticos podem ser trabalhados usando a edição da comunidade Gatling, que é gratuita e de código aberto.

O que você aprenderá:

• Gatling Video Tutorial
  • Instalação
  • Características do Gatling
  • Aplicação em teste e gravação de script de amostra
  • Configure o Gatling Recorder e grave o primeiro script
  • Compreendendo o script de simulação
  • Executando teste usando script de simulação
  • Vantagens de usar Gatling
• Conclusão
  • Leitura recomendada

Gatling Video Tutorial

Vamos ver as etapas necessárias para começar com Gatling. Também cobriremos alguns dos recursos importantes do Gatling como parte deste tutorial.

Aqui está um vídeo tutorial sobre Gatling Introdução:

Instalação

Gatling pode ser instalado de 2 maneiras diferentes. Isso pode ser explicado da seguinte forma:

# 1) Usando Gatling como uma ferramenta autônoma, você pode simplesmente instalar o instalador / aplicativo, usando o Gatling oficial local na rede Internet e siga as instruções de instalação.

Observe que a pasta zip instalada contém arquivos shell e batch, o que torna o Gatling adequado para ser usado em diferentes sistemas operacionais como - Windows, MacOS, Linux / Unix, etc.

O instalador nada mais é que um gravador de script Gatling baseado em Java, que registra as ações do usuário por meio do navegador na ferramenta e que pode ser convertido em um script ou cenário que precisa ser carregado e testado. Veremos isso em detalhes nas próximas seções.

#dois) Outra forma de instalar / usar o Gatling é usá-lo como um pacote por meio do Maven / Gradle ou das ferramentas de construção do Scala.

Um ponto importante a ser observado aqui é que os scripts Gatling são todos baseados em Scala, portanto, a criação de um projeto baseado em Scala poderia usar a biblioteca Gatling, que pode ser importada por qualquer ferramenta de construção como Maven / Gradle ou SBT.

Características do Gatling

São os seguintes:

# 1) Arquitetura assíncrona e threads leves

Gatling tem uma arquitetura avançada baseada no kit de ferramentas Akka e é totalmente assíncrono. Isso dá uma vantagem em comparação com outras ferramentas de teste de desempenho como JMeter, onde cada thread corresponde a um único usuário.

Aqui, um único thread pode simular vários usuários, pois tem uma arquitetura de mensagens por meio do modelo de ator.
Em suma, um teste Gatling pode lidar com um número de usuários simultâneos por máquina, em comparação com outras ferramentas como Jmeter e, portanto, resulta em uma economia considerável de CPU e RAM.

Leitura Recomendada => Modelo de ator e arquitetura assíncrona de Gatling

# 2) A linguagem específica do domínio torna os testes legíveis

Os scripts Gatling são escritos em Scala e possuem uma DSL amigável que os torna altamente legíveis e menos sujeitos a erros. Para obter mais detalhes sobre Gatling DSL, consulte aqui .

# 3) Suporte agnóstico de protocolo

Gatling oferece suporte a uma ampla variedade de protocolos, incluindo HTTP, HTTPS e Web sockets. Ele também tem extensões para testes de carga de consultas / scripts SQL.

# 4) Relatórios e afirmações

Gatling fornece suporte pronto para a criação de relatórios HTML detalhados para os cenários que são executados e também tem recursos para aplicar asserções nas solicitações individuais em cenários - Por exemplo, Tempos de resposta, validação de conteúdo JSON, etc.

# 5) Gravador de teste baseado em interface amigável

Gatling vem com um gravador de teste gráfico fácil de usar, que pode gerar um script de simulação gravando a atividade ou ações do usuário em um navegador da web. Os scripts gerados são scripts baseados em Scala que podem ser executados no futuro e podem ser modificados de acordo com os requisitos.

Aplicação em teste e gravação de script de amostra

Para criar uma simulação de amostra, usaremos Aplicativo hospedado oficialmente fornecido pela Gatling

Estaremos usando o gravador de simulação de Gatling para começar a criar carga e fazer testes de desempenho. Antes de prosseguir, vamos discutir o cenário onde queremos carregar o teste.

O cenário é um caso de uso que estamos tentando testar. O que isso significa essencialmente que queremos imitar uma ação do usuário em um cenário ou conjunto de etapas que precisam ser testadas.

Por exemplo, Suponha que um usuário acesse qualquer site de comércio eletrônico, como Amazon.com, procure um produto e o adicione ao carrinho e, finalmente, finalize a compra com as informações de pagamento.

Toda a ação do usuário é um único cenário que contém etapas individuais como

• Navegando para o site Amazon.com.
• Esperando a página carregar.
• Procurando um produto por meio da barra de pesquisa de produtos.
• Adicionando o produto ao carrinho.
• Ir ao carrinho e finalizar a compra com o produto.
• Fazendo o pagamento.

Para testar a carga deste cenário completo, da perspectiva do sistema ou servidor, precisamos entender que nada mais é do que uma coleção ou série de chamadas de API que estão sendo feitas para o servidor de back-end, e é isso que queremos no teste de desempenho.

Para este exemplo, usaremos o cenário a seguir no aplicativo hospedado Gatling:

# 1) Navegar para Aplicativo hospedado Gatling .

#dois) Clique em “Adicionar um novo computador”.

# 3) Selecione o nome do computador como Apple e o nome da empresa como “Apple Inc” no menu suspenso, conforme mostrado na imagem abaixo.

# 4) Clique em ‘Criar este computador’ após inserir os detalhes.

Configure o Gatling Recorder e grave o primeiro script

Nesta seção, discutiremos como configurar o gravador de teste Gatling para criar uma simulação para o cenário que discutimos na seção anterior.

Estaremos usando o gravador de simulação Gatling, que está em uma forma muito simples, um proxy HTTP - você deve estar familiarizado com outras ferramentas de gravação HTTP como Fiddler ou proxy Http de cromo, etc. Portanto, o gravador Gatling é semelhante a recursos adicionais de conversão de gravação em um script de simulação de teste.

Então, vamos primeiro ver como configurar o gravador Gatling:

# 1) Uma vez que a pasta Gatling zip esteja instalada, simplesmente descompacte a pasta no local onde deseja que o Gatling seja instalado.

perguntas e respostas da entrevista php para 1 ano de experiência

#dois) Após esta etapa, precisamos definir 2 variáveis ​​de ambiente chamadas - GATLING_HOME (para o diretório inicial Gatling) e GATLING_CONF (para o local da pasta de configuração de Gatling).

Dependendo do tipo de sistema operacional, (ou seja, Windows ou Mac ou Linux), defina essas variáveis ​​de ambiente com os valores abaixo:

GATLING_HOME = {gatling-install-directory}

Exemplo:

GATLINE_CONF = {gatling-install-directory} / conf

Exemplo:

Uma vez que as variáveis ​​são definidas para validar, você pode simplesmente clicar no terminal o comando - exportação | pega “GATLING” e a saída deve mostrar as 2 variáveis ​​de ambiente que acabamos de definir.

# 3) Assim que essas variáveis ​​de ambiente forem definidas, precisamos iniciar nosso gravador de script Gatling. Para sistemas operacionais baseados em Windows, há um arquivo em lote fornecido com a instalação do Gatling e para sistemas operacionais baseados em Linux / MacOS, há um arquivo shell fornecido.

Abaixo está a estrutura de arquivos da pasta bin:

# 4) Portanto, dependendo do tipo de sistema operacional, podemos escolher o tipo de arquivo a ser executado para o gravador em execução. Observe que existem 2 arquivos aqui que usaremos:

• Arquivo Gatling.sh / Gatling.bat - para executar o script de simulação.
• Arquivo Recorder.sh / recorder.bat - para executar / abrir o gravador de simulação Gatling.

# 5) Vamos executar o script do gravador para abrir o gravador Gatling. Use o terminal Mac / Linux para executar o script de shell (ou execute diretamente o arquivo em lote do Windows).

# 6) Se as variáveis ​​de ambiente estiverem definidas corretamente, o comando acima deve abrir o gravador de script Gatling.

# 7) Observe a porta Http / https no gravador (a seleção padrão é 8000 ou 8080) - esta é a porta onde o listener de proxy de tráfego Http de Gatling está configurado. Podemos alterar este número de porta conforme nossa conveniência (ou podemos continuar com os valores padrão).

exemplos de aplicativo cliente-servidor e aplicativo baseado na web

# 8) Agora, vamos configurar o proxy chrome para escutar esta porta - ou seja, essencialmente, queremos rotear nosso tráfego Http do navegador através deste ouvinte ou gravador de proxy.
Siga isso ligação para configurar um proxy no Chrome para sistemas operacionais diferentes.

# 9) Assim que a porta for configurada, executaremos nosso cenário no Aplicativo hospedado Gatling.

# 10) Antes de iniciar a execução do cenário, primeiro precisamos configurar o nome do pacote e o nome da classe para o script de teste resultante e, em seguida, iniciar o ouvinte de proxy simplesmente clicando no botão “Iniciar” no gravador de script.

#onze) Assim que o gravador de proxy é iniciado, uma nova janela é exibida e, essencialmente, captura todas as solicitações que são disparadas quando o cenário é executado no navegador.

# 12) Navegar para Aplicativo hospedado Gatling no navegador.

Se você puder ver que a solicitação está gravada na janela do gravador, isso significa que a configuração do proxy para o navegador está correta e o gravador Gatling agora pode gravar as solicitações de acordo com o cenário de teste que está sendo executado (se não, volte para a etapa # 7 para corrigir a configuração de proxy para navegador / sistema).

# 13) Agora, uma vez que temos certeza de que a configuração está funcionando bem, clique em “Limpar” para remover tudo do gravador e comece a executar o cenário conforme mencionado abaixo:

• Navegar para Aplicativo hospedado Gatling
• Clique em “Adicionar um novo botão de computador”. Certifique-se de acessar um novo formulário de computador com o URL do navegador como http://computer-database.gatling.io/computers/new
• Agora preencha os valores no formulário com - Nome do computador como Apple e empresa como “Apple inc” também no menu suspenso.
• Clique em “Criar este computador” e você será redirecionado para o pagina inicial
• Este é todo o cenário que desejamos executar e criar um script de automação usando o gravador de script Gatling. Uma vez que as etapas acima são executadas, o gravador deve capturar todas as chamadas HTTP sendo feitas e deve ter a seguinte aparência.

• Observe que também há alguns comandos “PAUSE” no script gravado. Isso nada mais é do que o 'tempo de reflexão' que o gravador captura para imitar a ação do usuário - ou seja, o tempo gasto entre as solicitações. Esses valores podem ser configurados / alterados uma vez que o script é executado, dependendo dos neds reais.

# 14) Para concluir a criação do script, clique em “Parar e Salvar” na janela do gravador.

#quinze) O script de simulação deve ser criado no diretório ou pasta de simulação que é exibido na tela de configuração do gravador Gatling.

Compreendendo o script de simulação

Depois de criar o script para o cenário executado, navegue até a pasta de simulação e abra o script.

Observe que o script será criado com a mesma estrutura de pacote que foi especificada antes de iniciar o gravador - no nosso caso, será com.learn.gatling e o nome da classe será “AddProduct”.

Vamos abrir o arquivo AddProduct.scala e tentar percorrer as diferentes seções do script.

Isso pode ser explicado da seguinte forma:

# 1) Configuração de instalação :ou seja httpProtocol e cabeçalhos - Nesta seção, é feita a configuração geral de dados para o script, como:

• Tipo de protocolo - Http ou https,
• Outras coisas como baseUrl para ser usado em solicitações subsequentes.
• Informações de cabeçalho - informações de cabeçalho comuns, bem como os cabeçalhos a serem enviados com solicitações individuais. Consulte header_0 e headers_2 no snippet de código abaixo:

# 2) Definição do cenário: Ele contém o cenário real e a ordem das solicitações que precisam ser executadas para recriar o cenário que estava sendo executado na janela do navegador.

Além disso, um ponto importante a observar aqui é - acabamos de mencionar os URLs relativos aqui para as solicitações, em vez do URL completo. Isso é porque vamos usar configuração httpProtocol discutimos no ponto 1, onde os dados de configuração do cenário são definidos.

# 3) Execução do cenário: Esta seção é a seção mais importante que contém as etapas de configuração do cenário.

A configuração de injeção aqui é o número de usuários / threads ou, em outras palavras, a carga com a qual queremos testar este cenário.

O valor padrão para vários usuários é sempre 1 e pode ser alterado antes que o cenário seja executado.

Além disso, observe que também estamos usando a definição de httpProtocol que discutimos no ponto nº 1, que contém todas as configurações básicas para o cenário a ser executado.

setUp (scn.inject (atOnceUsers (1))). protocolos (httpProtocol)

Veremos mais detalhes sobre a configuração de injeção e carregamento no próximo tutorial.

Executando teste usando script de simulação

Agora, veremos como executar o cenário usando este script de simulação que foi criado usando o gravador. O script resultante criado é, na verdade, uma classe baseada em Scala que contém detalhes sobre o cenário executado por meio do navegador.

Aqui está um tutorial em vídeo para a execução do Gatling Script:

A instalação do Gatling vem com um script de shell (para usuários do Windows, é um script em lote) que pode ser usado para executar esta simulação.

Siga as etapas abaixo para executar a simulação criada:

# 1) Navegue até a pasta bin da instalação do Gatling ou simplesmente vá para - $ GATLING_HOME / bin

#dois) Execute o arquivo Gatling.sh para Linux / Mac os (ou o arquivo Gatling.bat para usuários do Windows).

# 3) No caso de vários arquivos de script presentes na pasta de simulação, o script solicitará que o usuário selecione a simulação que deseja executar (para simular isso, crie o mesmo cenário em pacotes diferentes, e quando o script Gatling for executado, você pode veja que exibe 2 scripts diferentes).

# 4) Simulação é selecionada (ou é definida como padrão para a simulação presente na pasta se houver apenas um script de simulação disponível).

# 5) O script agora pede para adicionar uma descrição de execução opcional. Você pode simplesmente ignorar isso e pressionar Enter para iniciar a execução da simulação.

# 6) Enquanto a simulação está sendo executada, você pode ver os relatórios de execução sendo impressos no terminal e os parâmetros como tempo de resposta, solicitações totais, sucesso / falhas, etc. a visão resumida será exibida assim que a execução do cenário for concluída.

# 7) Gatling também gera um relatório detalhado baseado em HTML no final da conclusão da execução do cenário, que contém muitos pontos de dados diferentes com relação ao cenário executado.

Veremos os detalhes do relatório gerado no próximo tutorial.

Vantagens de usar Gatling

Gatling fornece muitos recursos ricos em recursos para construir um bom conjunto de testes de automação de desempenho, aproveitando a ampla Gatling DSL, bem como o crescente suporte da comunidade para obter assistência e obter respostas para dúvidas.

É importante notar aqui que, ao contrário de outras ferramentas como JMeter, Gatling envolve uma curva de aprendizado íngreme, mas em vez disso, ele oferece muitos recursos de programação para criar um conjunto robusto e totalmente funcional de scripts de simulação de teste de desempenho e carga.

Algumas dessas vantagens são as seguintes:

• É leve e permite que um único thread seja usado para mais de uma solicitação, ao contrário da maioria das outras ferramentas de desempenho onde um thread é igualado a um usuário.
• O uso de um único thread para várias solicitações permite que o Gatling dimensione mais e gere uma carga maior, mesmo em uma única máquina.
• Gatling oferece a capacidade de rodar em modo distribuído quando há uma grande carga que precisa ser simulada.
• Fornece suporte para muitos outros protocolos além de HTTP,por exemplo, Websockets, MQTT, JDBC, etc, todos podem ter seu desempenho testado usando Gatling.
• Gatling fornece um DSL rico em recursos - Linguagem Específica de Domínio, que possui uma sintaxe fácil e fornece recursos poderosos quando combinados para criar um script de simulação.
• Ele também fornece muitos recursos de controle de simulação complexos, como construções de loop, tempo de reflexão de simulação, solicitações de limitação além do RPS desejado, etc.
• Ele possui recursos avançados de relatório prontos para uso e eles também podem ser personalizados, dependendo dos requisitos.

Conclusão

Neste tutorial, abordamos os fundamentos do uso do Gatling como ferramenta de teste de carga de escolha. Com o expressivo DSL e excelente suporte para protocolo HTTP, Gatling está rapidamente ganhando popularidade para ser usado como uma ferramenta preferida por muitos.

Também aprendemos sobre o gravador Gatling e o executor de script Gatling com um script de simulação de amostra que ajudou a entender o conceito básico de gravação de um script de simulação que poderia ser executado no futuro usando o executor Gatling Script.

No próximo tutorial, iremos cobrir a escrita de scripts Gatling como projetos Scala - ou seja, sem usar o gravador e entender os modelos de relatório que são gerados quando o Gatling conclui a execução da simulação.

Leitura recomendada

• Teste de carga com tutoriais HP LoadRunner
• Correlação - Teste de carga com LoadRunner
• Tutorial de teste de absorção - O que é teste de absorção
• Teste de carga usando LoadUI - uma ferramenta de teste de carga gratuita e de código aberto
• Revisão do WebLOAD - Introdução à ferramenta de teste de carga do WebLOAD
• Tutorial de teste destrutivo e teste não destrutivo
• Tutorial de teste de usabilidade: um guia de primeiros passos completo
• Teste de desempenho vs teste de carga vs teste de estresse (diferença)