6 de novembro de 2024 Gustavo Rodrigues 1267 Views

Run Locally, Deploy Globally: Uma Introdução ao LocalStack

Transforme sua maneira de desenvolver na AWS com o LocalStack! Aprenda a testar localmente e implantar globalmente, reduzindo custos e acelerando seu projeto. Descubra o segredo dos desenvolvedores eficientes!

“Run Locally, Deploy Globally”

Em um mundo onde a agilidade e eficiência no desenvolvimento de aplicações cloud são vitais, LocalStack surge como uma solução inovadora. “Run Locally, Deploy Globally” – esta filosofia encapsula a essência do LocalStack, permitindo que desenvolvedores criem e testem aplicações AWS localmente, acelerando o tempo de desenvolvimento e aumentando a velocidade do produto. Com LocalStack, é possível reduzir gastos desnecessários com a AWS e eliminar a complexidade e os riscos associados à manutenção de contas de desenvolvimento AWS.

O LocalStack é uma ferramenta essencial para desenvolvedores que buscam simular serviços AWS localmente, economizando custos e agilizando o desenvolvimento. Quando combinado com a facilidade de uso do Docker, o LocalStack se torna ainda mais poderoso, permitindo a configuração de ambientes isolados com facilidade. Neste guia, vamos explorar como utilizar o LocalStack dentro de um contêiner Docker e integrá-lo com o OpenTofu, um framework de desenvolvimento moderno.

Benefícios do LocalStack

Desenvolvimento Acelerado: Ao simular serviços AWS no ambiente local, desenvolvedores podem iterar rapidamente, sem a necessidade de deploy contínuo na nuvem.
Redução de Custos: Testar localmente significa menos uso de recursos na nuvem, resultando em economia significativa.
Simplicidade e Segurança: Elimina a necessidade de gerenciar múltiplas contas de desenvolvimento AWS, reduzindo a complexidade e aumentando a segurança.

Pré-requisitos

Antes de mergulharmos na configuração e uso do LocalStack com Docker, certifique-se de que você tem os seguintes pré-requisitos instalados em sua estação de trabalho:

Docker:
OpenTofu:
AWS CLI:

Assumindo que você já tenha esses componentes instalados e configurados, vamos prosseguir com a utilização do LocalStack via Docker.

Configuração do Ambiente

Configurando o LocalStack com Docker

Crie um arquivo docker-compose.yml: Para iniciar, crie um arquivo docker-compose.yml na raiz do seu projeto. Este arquivo definirá o serviço LocalStack AWS. Apos criar o arquivo faça um docker compose up -d para iniciar o LocalStack.

version: "3.8"
services:
  localstack:
    container_name: "${LOCALSTACK_DOCKER_NAME:-localstack-main}"
    image: localstack/localstack
    ports:
      - "127.0.0.1:4566:4566"            # LocalStack Gateway
      - "127.0.0.1:4510-4559:4510-4559"  # external services port range
    environment:
      # LocalStack configuration: https://docs.localstack.cloud/references/configuration/
      - DEBUG=${DEBUG:-0}
      - START_WEB=1
    volumes:
      - "${LOCALSTACK_VOLUME_DIR:-./volume}:/var/lib/localstack"
      - "/var/run/docker.sock:/var/run/docker.sock"

O arquivo docker-compose.yaml é utilizado para definir e rodar aplicações Docker multi-container. No contexto deste arquivo, ele está configurado para iniciar um serviço que emula o ambiente AWS localmente usando o LocalStack. Vou explicar cada parte da configuração:

Entendo configurações do LocalStack no docker-compose.yaml

    ports:
    - "127.0.0.1:4566:4566"            # LocalStack Gateway
    - "127.0.0.1:4510-4559:4510-4559"  # external services port range

Define as portas que serão expostas e mapeadas do host para o container. O 127.0.0.1:4566:4566 mapeia a porta 4566 do host para a porta 4566 do container, que é usada como o gateway do LocalStack para acessar os serviços emulados. A faixa 127.0.0.1:4510-4559:4510-4559 mapeia um intervalo de portas para serviços externos que podem ser especificados para uso com o LocalStack.

    environment:
    - DEBUG=${DEBUG:-0}
    - START_WEB=1

Configura variáveis de ambiente dentro do container. DEBUG=${DEBUG:-0} configura o nível de debug para o LocalStack, usando o valor da variável de ambiente DEBUG se definido, ou 0 como padrão. START_WEB=1 habilita o dashboard web do LocalStack.

    volumes:
    - "${LOCALSTACK_VOLUME_DIR:-./volume}:/var/lib/localstack"
    - "/var/run/docker.sock:/var/run/docker.sock"

Monta volumes no container. O primeiro volume ${LOCALSTACK_VOLUME_DIR:-./volume}:/var/lib/localstack monta o diretório especificado pela variável de ambiente LOCALSTACK_VOLUME_DIR, ou ./volume como padrão, para /var/lib/localstack dentro do container, que é usado para persistência de dados do LocalStack. O segundo volume /var/run/docker.sock:/var/run/docker.sock permite ao LocalStack interagir com a engine Docker do host, o que é necessário para algumas funcionalidades avançadas, como a emulação de funções Lambda que executam em containers Docker.

Em resumo, este docker-compose.yaml configura um ambiente LocalStack no Docker, expondo portas necessárias para acesso aos serviços emulados e configurando variáveis de ambiente e volumes para controle de comportamento e persistência de dados.

Configurando `AWS CLI`

Para configurar o AWS CLI iremos utilizar credencias falsas visto que, é um ambiente local e de testes. O uso de credenciais falsas (fake) para o LocalStack é uma prática comum e recomendada por várias razões, especialmente quando se trata de emular serviços da AWS em um ambiente de desenvolvimento local.

AWS_DEFAULT_REGION=us-east-1
AWS_ACCESS_KEY_ID=fakeAccessKeyId
AWS_SECRET_ACCESS_KEY=fakeSecretAccessKey

1 – Configurar Profile AWS

aws configure --profile localstack

Primeiros Passos com o LocalStack

Configurando um Endpoint S3

Criar um Bucket S3: Após configurar o AWS CLI para usar LocalStack, definindo as credenciais no profile localstack vamos criar um bucket S3 usando o AWS CLI:
```
 aws s3 mb s3://meu-primeiro-bucket --endpoint=http://localhost:4566 --profile localstack
```

Listar Buckets: Verifique se o bucket foi criado:

 aws s3 ls --endpoint=http://localhost:4566 --profile localstack

Upload de Arquivos: Crie um arquivo e faça upload para o bucket:
Criando arquivo:

 echo "Olá, Mundo!" > index.html

Realizar upload para o Bucket S3:

 aws s3 cp index.html s3://meu-primeiro-bucket --endpoint=http://localhost:4566 --profile localstack

Antes de prosseguir, certifique-se de que o LocalStack esteja devidamente instalado e em execução conforme mencionado anteriormente.

Documentação para o OpenToFu

Este documento descreve a configuração do OpenToFu para criar recursos na AWS, especificamente usando o LocalStack para emular os serviços da AWS localmente. Para integrar o LocalStack com o OpenTofu, assumindo que você deseja utilizar os serviços S3 do LocalStack, vamos passar por um exemplo prático que mostra como configurar e usar esses serviços com OpenTofu, um framework fictício para desenvolvimento de aplicações cloud.

Utilizando o S3 com OpenTofu

A documentação abaixo explica cada parte do seu Tofu configurado para o uso com o LocalStack, um ambiente de desenvolvimento local que emula os serviços da AWS. O OpenTofu permite definir, provisionar e configurar infraestrutura na AWS de maneira declarativa através de códigos.

Antes de prosseguir, certifique-se de que o LocalStack esteja devidamente instalado e em execução conforme mencionado anteriormente.

Provider: O bloco provider especifica o provedor de serviços de nuvem, neste caso, a AWS.

    provider "aws" {
        region                      = "us-east-1" # Define a região onde os recursos serão criados. Altere conforme necessário.
        profile                     = "localstack" # O perfil a ser usado. Aqui, é especificado o 'localstack' para uso com o LocalStack.
        s3_use_path_style           = true # Força o uso do estilo de caminho para os buckets S3.
        skip_credentials_validation = true # Pula a validação das credenciais. Útil para ambientes de teste como o LocalStack.
        skip_metadata_api_check     = true # Pula a verificação da API de metadados. Importante para o funcionamento com o LocalStack.
        skip_requesting_account_id  = true # Pula a solicitação do ID da conta AWS. Necessário para o LocalStack.
        endpoints {
            s3 = "http://localhost:4566" # Define o endpoint do S3 para o LocalStack.
        }  
    }

Recurso: aws_s3_bucket: Define um bucket S3 na AWS. No contexto do LocalStack, este bucket é criado localmente.

 resource "aws_s3_bucket" "app" {
     bucket = "app" # Nome do bucket. Deve ser único.

     # Blocos de tags permitem adicionar metadados ao bucket para facilitar a organização e gerenciamento.
     tags = {
         Name        = "APP LocalStack" # Nome amigável para o bucket.
         Environment = "localStack" # Ambiente de desenvolvimento, indicando que está sendo usado o LocalStack.
     }
 }

Recurso: aws_s3_bucket_acl: Configura as permissões de acesso ao bucket S3 criado anteriormente.

 resource "aws_s3_bucket_acl" "app_acl" {
     depends_on = [aws_s3_bucket.app] # Garante que este recurso seja criado após o bucket S3.

     bucket = aws_s3_bucket.app.id # Referencia o ID do bucket S3 criado anteriormente.
     acl    = "public-read" # Define as permissões de acesso ao bucket. 'public-read' permite leitura pública.
 }

![alt](/posts/image-4.png)

Conclusão

LocalStack oferece uma solução robusta e eficiente para o desenvolvimento local de aplicações cloud, permitindo aos desenvolvedores simular serviços AWS como S3 e EC2 no conforto do seu ambiente local. Isso não apenas acelera o ciclo de desenvolvimento ao permitir testes rápidos e iterativos sem a necessidade de deploy na nuvem, mas também reduz significativamente os custos associados ao uso de recursos AWS reais.

Integrar o LocalStack com frameworks como o OpenTofu amplifica esses benefícios. O exemplo prático demonstrado ilustra como essa integração permite aos desenvolvedores utilizar serviços AWS de maneira eficaz, com a conveniência de uma configuração local. Ao criar buckets S3 e listar instâncias EC2 localmente, desenvolvedores podem desenvolver e testar funcionalidades específicas de suas aplicações com agilidade e precisão, sem se preocupar com os custos ou complexidades associadas à AWS real.

Essa abordagem “Run Locally, Deploy Globally” não só acelera o desenvolvimento e reduz custos, mas também simplifica o processo de desenvolvimento ao minimizar a complexidade e os riscos. Com LocalStack e OpenTofu, desenvolvedores têm ao seu dispor ferramentas poderosas que promovem uma maior eficiência e produtividade, permitindo que se concentrem no que realmente importa: criar aplicações inovadoras e de alta qualidade.

Portanto, explorar o LocalStack e integrá-lo com frameworks como o OpenTofu é uma estratégia inteligente para desenvolvedores que buscam otimizar seu fluxo de trabalho de desenvolvimento AWS, garantindo ao mesmo tempo a redução de custos e a aceleração do tempo de mercado para suas aplicações.

Referências

Install Docker Engine on Ubuntu docs.docker.com
Use docker-compose to configure and start your LocalStack Docker container docs.localstack.cloud
Install or update to the latest version of the AWS CLI docs.aws.amazon.com
Installing OpenTofu opentofu.org