DEV Community: Paulo Guilherme

Grafana k6 - usando JS para testes de carga

Paulo Guilherme — Mon, 22 Aug 2022 01:51:00 +0000

Atualmente uma das melhores maneiras de testar e simular o comportamento da sua API em mar aberto é com testes de carga.

Várias ferramentas estão disponíveis na nossa comunidade JMeter, Katalon, Postman são algumas das principais.

Vamos falar de uma ferramenta especial nesse artigo, ela é fácil, open source e muito simples de configurar.

Se até pro espaço nosso querido JavaScript já foi... Claro que vamos ter ele por aqui quando o assunto é teste de carga.

// Detect dark theme var iframe = document.getElementById('tweet-1561509981941284864-515'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1561509981941284864&theme=dark" }

- Ladies and gentlemen i present you k6!

k6

k6 é uma ferramenta open source desenvolvido pelo time do Grafana Labs, focada em realização de testes de carga orientado a objetivos.

Usando o k6, você pode testar a confiabilidade e o desempenho de seus sistemas e detectar regressões e problemas de desempenho mais cedo.

How it works

k6 trabalha com o conceito de usuários virtuais (VUs) que executam scripts. Eles são essencialmente loops while(true) paralelos.

Os scripts devem conter, no mínimo, uma função padrão exportada - isso define o ponto de entrada para suas VUs, semelhante à função main() em várias linguagens.

Para cada bateria de teste é necessário especificar quantos VUs serão utilizados além dos scripts que executaram as chamadas e suas regras.

scripts - escritos em JavaScript devem exportar uma função default que servirá como main para a bateria de testes.
VUs - ou virtual users são usuários gerados pelo k6 em tempo de execução que farão requisicões HTTP em looping durante todo o tempo da bateria de testes.

Key features

CLI com APIs amigáveis ao desenvolvedor.
JavaScript ES2015/ES6 - com suporte para módulos locais e remotos
Checks e Thresholds - para testes de carga orientados para objetivos e fáceis de automatizar

Hands on

Uma das características principais do k6 é que ele possui uma alta integração com diversos serviços de cloud e observability do mercado.

Para esse artigo vamos utilizar alguma delas, são elas:

Grafana Dashboards
Influx DB
Docker

recomendo fortemente a leitura da documentação oficial do k6 que além de muito abrangente é recheada de exemplos de demonstrações de utilização.

Let's code

A imagem acima demonstra como vamos estruturar nosso projeto, com a ajuda do Docker vamos preparar um ambiente que nos fornecerá toda a infraestrutura necessária e também recursos para a visualização dos resultados em tempo real.

Todo o código desenvolvido para esse artigo foi publicado em meu GitHub e poderá ser acessado nesse repositório.

O que vamos testar?

Durante esse artigo vamos fazer uma bateria de testes usando a API pública The Star Wars API como backend e simularemos alguns cenários usando o k6 e acompanharemos via dashboard todas as requisições realizadas e suas métricas publicadas.

app.js

import http from 'k6/http'
import { check, sleep } from 'k6'

/** 
 * etapas do nosso teste:
 * os primeiros 30 segundos teremos um aumento de 0 a 20 usuarios acessando a api
 * em seguida um periodo de 1m e 30s com o pico de 20 usuarios fazendo requisicoes em loop infinito
 * depois gradativamente os usuarios vao deixar de acessar a api de 20 até chegarem a 0 em 20 segundos
 * **/
export const options = {
    stages: [
        { duration: '30s', target: 20 },
        { duration: '1m30s', target: 20 },
        { duration: '20s', target: 0 },
    ],
}

export default function () {
    const id = Math.floor(Math.random() * 10) + 1
    const url = `http://swapi.dev/api/people/${id}`

    console.log(`calling [${url}]`)
    const response = http.get(url) //requisicao

    check(response, { "status is 200": (r) => r.status === 200 }) //validacao se ocorreu tudo certo
    sleep(1) //intervalo entre as chamadas
}

nesse cenário estamos fazendo pouquíssimas requisições (em média é realizada aproximadamente 200 requisições em 2m 20s) mas em um cenário com mais de 200 VUs conseguimos chegar a 150 req/segundo e um total de aproximadamente 2000 em 5 minutos.

Fica o convite para fazer um teste mais parrudo e ver como o k6 se sai. 😎

para os demais arquivos de configuração do dashboard sugiro utilizar as métricas mais convenientes para o cenário especifico, nesse artigo acabei expondo todas.

Run

docker compose up -d influxdb grafana

Vamos primeiro subir os contêineres que utilizaremos para a visualização dos resultados.

docker compose run k6

Executando o run vamos começar a visualizar as primeiras chamadas sendo realizadas para a API.

Podemos visualizar em runtime a execução na url http://localhost:3000/d/k6/k6-load-testing-results

Conclusão

Com certeza k6 é uma excelente ferramenta para testes de performance uma ótima opção para substituir o JMeter por exemplo.

Com uma série de integrações disponíveis e a facilidade de escrever cenários, regras e validações a etapa de testes de carga que normalmente é custosa e demorada consegue ser muito mais rápida e iterativa com o time.

Não pense que a utilização de JavaScript faz o k6 ter uma performance inferior aos demais, sua performance é excelente e ficará limitada apenas a hardware e conexão disponíveis com a opção até mesmo de ser executado em clusteres.

Com a possibilidade de escrevermos scripts com limites e regras de aceitação, além da possibilidade de gerarmos lógicas e manipulação de variáveis durante os testes fica bem difícil não querer experimentar um pouco dessa ferramenta.

Recomendo fortemente a utilização do k6 para testes de carga, stress e performance e recomendo também a leitura da documentação oficial.

Serverless e Alexa - personalizando sua assistente pessoal

Paulo Guilherme — Sun, 26 Jun 2022 08:01:18 +0000

"Alexa o que iremos fazer hoje?"
"-Vamos desenvolver nossa própria skill usando Nodejs e AWS Lambda!"

As assistentes pessoais já fazem parte dos nossos dias, com suas inúmeras utilidades e possibilidades a Alexa tem se tornado a queridinha das assistentes.

Quer aprender como desenvolver sua própria Skill e ter a Alexa um pouquinho mais com a sua cara?
Então vem comigo, que vou mostrar um pouco como foi minha experiência desenvolvendo com a Alexa.😉

Antes de começarmos ...

Todo comando que fazemos para Alexa é dividido em pequenas partes.

intent: Comando de voz.

utterances: Enunciado que identifica a sua intenção.

slots: Valor do comando que será enviado para API.

A Alexa funciona dentro de uma arquitetura serverless, então para termos nossa própria skill vamos precisar de uma function AWS Lambda e podemos aproveitar do Free Tier da AWS para desenvolver e hospedar a nossa funçãozinha. 😎

O diagrama acima exemplifica bem como vai funcionar todo o fluxo saindo do usuário até a execução da lambda.

Show me the code

Chega de conversa e vamos para o código, para esse tutorial vamos desenvolver uma skill que nos responda com um ensinamento aleatório do nosso querido Mestre Yoda.

O código dessa solução está disponível no Github, clique no link do repositório

Vamos usar o framework Serverles para nos ajudar nessa missão.
Com ele vamos conseguir atualizar e fazer o deploy da lambda que será executada sempre que falarmos com a Alexa.

Ingredientes

Nodejs 12.x
NPM
AWS account
Alexa Echo Dot
Alexa developer Amazon account

Com todos os ingredientes no balcão e as contas devidamente criadas vamos ao modo de preparo.

Criando o projeto

Vamos começar fazendo o download das ferramentas que vamos utilizar.

$ npm install -g serverless

Depois de instalado vamos criar uma pasta e rodar o seguinte comando.

$ serverless create --name ensinamentos-yoda --template aws-nodejs

Vale lembrar que o serverless utiliza as configurações e o usuário configurado no AWS CLI, caso não tenha baixado é super fácil existem vários exemplos na documentação oficial ou na nossa comunidade.

O framework Serverless tem uma variedade de plugins para nos ajudar durante o desenvolvimento, nessa missão vamos precisar do serverless-alexa-skills.

$ serverless plugin install --name serverless-alexa-skills

Pronto! temos nosso projeto, repare na estrutura criada, temos um arquivo chamado serverless.yml e outro handler.js esses carinhas merecem uma atenção especial por que são os responsáveis por toda a execução da nossa lambda.

handler.js - contém a função main que será chamada sempre que a lambda for disparada.

serverless.yml - arquivo de configuração responsável por toda estrutura, plugins, deploy e publicação da lambda.

Para ver a lambda funcionando em ambiente local é só executar o comando a seguir na pasta do projeto.

$ serverless invoke local -f {$FUNCTION_NAME}

Normalmente a função criada por padrão tem o nome de hello, mas durante o projeto vamos precisar renomear.

Com a função criada vamos adicionar mais alguns detalhes para conseguirmos acessar a SDK. 🚀

Usando o NPM conseguimos instalar a lib da SDK que vamos utilizar para programar a Alexa. Na mesma pasta execute npm install ask-sdk-core.

serverless.yml

Vamos especificar algumas configurações logo de início.

service: ensinamentos-yoda #nome do projeo
frameworkVersion: "3"

provider:
  name: aws
  runtime: nodejs12.x 
  stage: dev 
  region: us-east-2

functions:
  yoda:
    handler: handler.yoda #nome da função que será disparada

plugins:
  - serverless-alexa-skills

custom:
  alexa: []

handler.js

'use strict';

const ensinamentos = [
  'Muito a aprender você ainda tem, jovem Padawan.',
  'Faça. Ou não faça. Não existe a tentativa',
  'O medo leva a raiva, a raiva leva ao ódio, o ódio leva ao sofrimento',
  'Paciência você deve ter meu jovem Padawan',
  'Um Jedi usa a Força para o conhecimento e defesa, nunca para o ataque.',
  'Raiva, medo, agressão. Ao lado sombrio elas pertencem'
]

module.exports.yoda = async (event) => {
  console.log(`[INFO] ${Date(Date.now())} Lambda disparada `)

  return 'Lembre-se do que o mestre Yoda disse: ' +
    ensinamentos[Math.floor(Math.random() * ensinamentos.length)]
};

Durante o desenvolvimento podemos usar o comando serverless invoke local -f yoda para testar localmente sem provisionamento de cloud

Round 1

Primeira etapa concluída! temos nossa regra de negócio pronta, sempre que executada a lambda responde com algum ensinamento aleatório da lista.

$ serverless invoke local -f yoda
[INFO] Sun Jun 26 2022 01:48:21 GMT-0300 (Horário Padrão de Brasília) Lambda disparada 
"Lembre-se do que o mestre Yoda disse: Muito a aprender você ainda tem, jovem Padawan."

Round 2 - Criando nossa skill

Vamos nos autenticar com a API da Alexa, nosso amigo serverless nos ajudará muito nessa missão.

$ serverless alexa auth

Após ser redirecionado para a página do console vamos fazer o login com nossa conta Amazon, de preferência com a mesma conta que configuramos nosso Amazon Echo.

Depois de efetuar o login com sucesso receberemos a mensagem "Thank you for using Serverless Alexa Skills Plugin!!".

Agora autenticados podemos criar nossa skill na plataforma da Amazon.

$ serverless alexa create --name ensinamentos-yoda --locale pt-BR --type custom

Se tudo der certo teremos o ID da nossa skill exibido no console ao fim da execução.

Acessando a página Amazon Alexa Console conseguimos visualizar nossa skill criada e prontinha para o show. 😎

Fique à vontade para explorar o painel, repare que também podemos editar e configurar nossa skill pela plataforma, mas vamos seguir usando o plugin do serverless para o tutorial.

Com a skill criada vamos adicionar mais algumas configurações no serverless.yml.

#---resto do código---
functions:
  yoda:
    handler: handler.yoda #nome da função que será disparada

plugins:
  - serverless-alexa-skills #plugin alexa skill

custom:
  alexa:
    skills:
      - id: ${env:ALEXA_SKILL_ID} #ID informado no comando create
        manifest:
          apis:
            custom: {}
          publishingInformation:
            locales:
              pt-BR:
                name: ensinamentos-yoda
          manifestVersion: '1.0'
        models:
          pt-BR:
            interactionModel:
              languageModel:
                invocationName: ensinamentos yoda #Nome usado para invocar a skill 'Alexa, abrir ensinamentos Yoda'
                intents: 
                  - name: AMAZON.CancelIntent
                    samples: []
                  - name: AMAZON.HelpIntent
                    samples: []
                  - name: AMAZON.StopIntent
                    samples: []
                  - name: PedirEnsinamentoIntent #Intenção que criaremos para executar nossa regra
                    samples: #Frases que usaremos para pedir um ensinamento, Seja Criativo!
                      - 'O que o yoda diria'
                      - 'me fale um ensinamento'
                      - 'qual o pensamento do dia'

Lembra das intent que comentamos lá em cima? A API por padrão define algumas padrões para qualquer skill: AMAZON.CancelIntent, AMAZON.HelpIntent, AMAZON.StopIntent

Depois de editado o arquivo vamos executar mais dois comandinhos, eles serão nossos companheiros durante todo o desenvolvimento.

$ serverless alexa update
$ serverless alexa build

Sempre que um comando é enviado para a API da Alexa precisaremos de um handler próprio para resolve-lo.

Para esse projeto teremos os seguintes handlers:

LaunchRequestHandler Quando o usuário invoca sua skill sem uma intenção específica, a Alexa envia para sua skill um payload de LaunchRequest.
PedirEnsinamentoIntent Executada sempre que o usuário pedir um ensinamento do mestre Yoda.
HelpIntentHandler Executada sempre que o usuário enviar um AMAZON.HelpIntent.
CancelAndStopIntentHandler Executada sempre que o usuário enviar um AMAZON.CancelIntent ou AMAZON.StopIntent.
SessionEndedRequestHandler Executada sempre que o usuário desejar encerrar a skill

'use strict';
const Alexa = require('ask-sdk-core')

const ensinamento = () => {
  const ensinamentos = [
    'Muito a aprender você ainda tem, jovem Padawan.',
    'Faça. Ou não faça. Não existe a tentativa',
    'O medo leva a raiva, a raiva leva ao ódio, o ódio leva ao sofrimento',
    'Paciência você deve ter meu jovem Padawan',
    'Um Jedi usa a Força para o conhecimento e defesa, nunca para o ataque.',
    'Raiva, medo, agressão. Ao lado sombrio elas pertencem'
  ]

  return 'Lembre-se do que o mestre Yoda disse: ' +
    ensinamentos[Math.floor(Math.random() * ensinamentos.length)]
}

const LaunchRequestHandler = {
  canHandle(handlerInput) {
    return Alexa.getRequestType(handlerInput.requestEnvelope) === 'LaunchRequest'
  },
  handle(handlerInput) {
    const speechText = 'Olá, que a força esteja com você, me peça um ensinamento do mestre Yoda'

    return handlerInput.responseBuilder
      .speak(speechText)
      .reprompt(speechText)
      .withSimpleCard('Olá, que a força esteja com você, me peça um ensinamento do mestre Yoda', speechText)
      .getResponse()
  }
}


const PedirEnsinamentoIntent = {
  canHandle(handlerInput) {
    return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
      && Alexa.getIntentName(handlerInput.requestEnvelope) === 'PedirEnsinamentoIntent'
  },
  async handle(handlerInput) {

    const speechText = ensinamento() //chamada a nossa função

    return handlerInput.responseBuilder
      .speak(speechText)
      .withSimpleCard('Mestre Yoda.', speechText)
      .getResponse()
  }
}

const CancelAndStopIntentHandler = {
  canHandle(handlerInput) {
    return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
      && (Alexa.getIntentName(handlerInput.requestEnvelope) === 'AMAZON.CancelIntent'
        || Alexa.getIntentName(handlerInput.requestEnvelope) === 'AMAZON.StopIntent')
  },
  handle(handlerInput) {
    const speechText = 'Que a força esteja com você!'

    return handlerInput.responseBuilder
      .speak(speechText)
      .withSimpleCard('Que a força esteja com você!', speechText)
      .withShouldEndSession(true)
      .getResponse()
  }
}

const SessionEndedRequestHandler = {
  canHandle(handlerInput) {
    return Alexa.getRequestType(handlerInput.requestEnvelope) === 'SessionEndedRequest'
  },
  handle(handlerInput) {
    // Any clean-up logic goes here.
    return handlerInput.responseBuilder.getResponse()
  }
}


const ErrorHandler = {
  canHandle() {
    return true;
  },
  handle(handlerInput, error) {
    console.log(`Error handled: ${error.message}`);

    return handlerInput.responseBuilder
      .speak('Encontrei um probleminha, vamos tentar de novo ?')
      .reprompt('Encontrei um probleminha, vamos tentar de novo ?')
      .getResponse();
  }
}


let skill

module.exports.yoda = async (event) => {
  console.log(`[INFO] ${Date(Date.now())} Lambda disparada `)

  if (!skill) {
    skill = Alexa.SkillBuilders.custom()
      .addRequestHandlers(
        LaunchRequestHandler, //responsável por abrir nossa skill
        PedirEnsinamentoIntent,
        CancelAndStopIntentHandler,
        SessionEndedRequestHandler //responsável para encerrar nossa skill
      )
      .addErrorHandlers(ErrorHandler)//mensagem para caso de erros
      .create()
  }

  return await skill.invoke(event)
}

Rolou muitas mudanças dessa vez, recomendo fortemente dar uma olhada na documentação oficial onde tem vários exemplos e explicações sobre as etapas e funções desse código.

Nesse ponto da nossa aventura temos uma lambda capaz de receber um comando de voz da Alexa e responder com um ensinamento do mestre Yoda.

Não esqueça dos nossos amigos.

$ serverless alexa update
$ serverless alexa build

Estamos quase lá

Já temos nosso código e nossa skill agora vamos fazer todas as peças se encaixarem?

Partiu!

Deploy

O nosso amigo serverless também nos ajudará na etapa do deploy, vamos precisar publicar nossa lambda para cloud e adicionar o gatilho de execução pela Alexa.

$ serverless deploy

Hora da mágica!🧙‍♂️ esse comando vai executar todas as etapas necessária de publicação e os recursos necessários para termos o serviço na nossa conta AWS.

Prontinho! temos nosso backend agora só precisamos adicionar um gatilho para a função.

Clique em Visão geral da função.
Clique em Adicionar gatilho.
Selecione Alexa.
Para Skill ID verification, selecione Disable.

Depois de criada vamos editar mais uma vez o arquivo serverless.yml e adicionar o ARN da função para ser chamada pela Alexa.

#---resto do código---
 apis:
  custom: 
   endpoint:
    uri: ${env:AWS_LAMBDA_ARN}
#---resto do código---

Lembre-se de atualizar e fazer o build da skill mais uma vez.

Testando

Essa jornada foi longa mas chegamos ao final.

Para testarmos nossa skill podemos usar o aplicativo, Amazon Echo ou a página de teste do Alexa Developer Console.

Usando o Amazon Echo Dot

Abra o aplicativo Amazon Alexa.
No menu Mais acesse Skills & Games.
Selecione a aba Suas Skills.
Clique no card Desenv..
Clique em ensinamentos-yoda.
Clique em Ativar Skill.
Diga "Alexa abrir ensinamentos yoda"
Diga alguma das frases que configuramos, por exemplo "O que o Yoda diria"

Conclusão

Desenvolver com a Alexa é uma aventura muito divertida, existem inúmeras opções e funcionalidades que podemos explorar.

O objetivo desse tutorial foi tentar mostrar os primeiros passos para conseguir usar a API da Amazon e sua integração com o serviço AWS Lambda.

Espero que este post tenha inspirado você a explorar o Alexa Skill Kit e criar algo para ela.😊

Recomendo a leitura das documentações oficiais e os links que deixarei abaixo para definições mais técnicas e detalhadas.

Links

Happy Coding!