Executando verificação de segurança...
14
WilsonFelipe
4 min de leitura ·

Usando LocalStack junto com Serverless Framework: Um guia passo a passo

Um desafio comum para desenvolvedores ao trabalhar com aplicações AWS é a necessidade de testá-las localmente antes de implantá-las em um ambiente de integração. Isso pode economizar tempo, dinheiro e evitar frustrações.

O LocalStack é uma plataforma de desenvolvimento que permite simular os serviços da AWS localmente, facilitando o desenvolvimento e teste de aplicações antes da implantação em ambientes reais. Já o Serverless Framework é uma ferramenta para criar, gerenciar e implantar aplicações serverless em diferentes provedores de nuvem, como AWS, Google Cloud e Microsoft Azure.

Neste tutorial, vamos ver como utilizar o Serverless Framework e o LocalStack para criar um ambiente de desenvolvimento local para suas aplicações AWS.

Pré-requisitos

  1. Instale o Node.js (recomendamos a versão 14.x ou superior).
  2. Instale o Docker e o Docker Compose.
  3. Instale o Serverless Framework globalmente com o comando npm install -g serverless.

Configurar o projeto

Siga os passos abaixo para configurar seu projeto:

  1. Crie uma nova pasta para o projeto e navegue até ela no terminal.
  2. Execute npm init -y para criar um arquivo package.json.
  3. Instale as dependências necessárias com o comando npm install --save-dev serverless serverless-localstack aws-sdk.

Configurando o Serverless e LocalStack

  1. Crie um arquivo serverless.yml e adicione a seguinte configuração (substitua "meu-projeto" pelo nome do seu projeto):
service: meu-projeto

provider:
  name: aws
  runtime: nodejs14.x
  stage: ${opt:stage, 'local'}
  region: us-east-1
  environment:
    IS_LOCAL: ${opt:stage, 'dev'} 

plugins:
  - serverless-localstack

custom:
  localstack:
    stages:
      - local
    host: http://localhost
    edgePort: 4566

functions:
  publishMessage:
    handler: handler.publishMessage
    events:
      - http:
          path: /publish
          method: post
  processMessage:
    handler: handler.processMessage
    events:
      - sqs:
          arn: arn:aws:sqs:us-east-1:000000000000:meu-projeto-sqs

resources:
  Resources:
    MySNSTopic:
      Type: AWS::SNS::Topic
      Properties:
        TopicName: meu-projeto-sns

    MySQSQueue:
      Type: AWS::SQS::Queue
      Properties:
        QueueName: meu-projeto-sqs

    MySNSToSQS:
      Type: AWS::SNS::Subscription
      Properties:
        Protocol: sqs
        TopicArn: !Ref MySNSTopic
        Endpoint: !GetAtt MySQSQueue.Arn

Este arquivo é a configuração principal do projeto Serverless, onde você define o provedor, plugins, funções e eventos relacionados.

  1. Crie um arquivo docker-compose.yml com a seguinte configuração:
version: '3.8'

services:
  localstack:
    container_name: localstack
    image: localstack/localstack:latest
    ports:
      - '4566:4566'
      - '4571:4571'
    environment:
      - SERVICES=s3,sns,sqs,lambda,apigateway
      - DEBUG=1
      - DATA_DIR=/tmp/localstack/data
      - LAMBDA_EXECUTOR=docker
      - LAMBDA_REMOTE_DOCKER=false
      - DOCKER_HOST=unix:///var/run/docker.sock
      - AWS_ACCESS_KEY_ID=test
      - AWS_SECRET_ACCESS_KEY=test
    volumes:
      - './.localstack:/tmp/localstack'
      - '/var/run/docker.sock:/var/run/docker.sock'

Este arquivo define a configuração do Docker Compose, que permite executar o LocalStack como um contêiner Docker.

  1. Crie um arquivo handler.js com o seguinte código:
const AWS = require('aws-sdk');


const isLocal = process.env.IS_LOCAL;


if (isLocal) {
  AWS.config.update({
    region: 'us-east-1',
    accessKeyId: 'test',
    secretAccessKey: 'test',
    endpoint: new AWS.Endpoint('http://localstack:4566'),
  });
}


const sns = new AWS.SNS();


module.exports.publishMessage = async (event) => {
  const message = JSON.parse(event.body).message;


  const params = {
    Message: message,
    TopicArn: 'arn:aws:sns:us-east-1:000000000000:meu-projeto-sns',
  };
  console.log('Publicando mensagem:', message);
  await sns.publish(params).promise();


  return {
    statusCode: 200,
    body: JSON.stringify({ message: 'Mensagem publicada com sucesso!' }),
  };
};


module.exports.processMessage = async (event) => {
  const message = event.Records[0].body;
  console.log('Mensagem recebida:', message);


  return {
    statusCode: 200,
  };
};

Este arquivo contém o código-fonte das funções Lambda:

  • publishMessage: Esta função recebe uma mensagem do corpo do evento, cria um objeto com os parâmetros necessários (Message e TopicArn) e publica a mensagem no tópico SNS. Retorna um JSON com uma mensagem de sucesso.
  • processMessage: Esta função recebe um evento SNS, extrai a mensagem do corpo do evento e a exibe no console. Retorna um status 200, indicando sucesso.
  1. Atualize os seguintes scripts no se package.json:
"scripts": {
    "infra:up": "docker compose up -d",
    "infra:down": "docker compose down",
    "deploy": "npx sls deploy --stage local"
}

Agora que você configurou tudo, siga os passos abaixo para implantar e testar sua aplicação localmente:

Inicie o LocalStack

No terminal, execute o seguinte comando para subir o LocalStack usando o Docker Compose:

npm run infra:up

Aguarde até que todos os serviços estejam em execução.

Implante sua aplicação:

Com o LocalStack em execução, execute o seguinte comando no terminal para implantar sua aplicação usando o Serverless Framework:

npm run deploy

Este comando empacota e implanta sua aplicação no LocalStack. Observe o URL de endpoint gerado na saída do comando.

Teste sua aplicação:

Para testar sua aplicação, você precisará fazer uma solicitação HTTP POST para a função publishMessage. Você pode fazer isso usando uma ferramenta como Postman ou Curl. Substitua [ENDPOINT_URL] pelo URL gerado no passo anterior.
Exemplo usando Curl:

curl -X POST -H "Content-Type: application/json" -d '{"message": "Olá, LocalStack!"}' [ENDPOINT_URL]/publish

Se a função publishMessage for executada com sucesso, você verá a mensagem "Mensagem publicada com sucesso!" na resposta.

Verifique a mensagem processada:

Para verificar a mensagem processada pela função processMessage, use o comando sls logs.

sls logs -t -f processMessage --stage local

Agora você pode verificar a mensagem processada usando o comando sls logs sem a necessidade de verificar os logs do contêiner Docker ou do terminal onde o LocalStack foi iniciado.

Encerrar o ambiente:

Quando terminar de testar sua aplicação, execute o seguinte comando para encerrar o LocalStack e remover os contêineres Docker:

npm run infra:down

Com este ambiente de desenvolvimento local configurado, você pode continuar a desenvolver sua aplicação AWS, testando-a localmente antes de implantá-la em um ambiente de integração ou produção.

Referências e links úteis:

Carregando publicação patrocinada...