Instalação do LocalStack

O que é o LocalStack?

LocalStack é um emulador de cloud que simula serviços AWS na sua máquina local. Ele permite que você desenvolva e teste aplicações AWS sem:

• Criar uma conta AWS
• Pagar qualquer valor
• Correr risco de cobranças acidentais

┌─────────────────────────────────────────────────────────────┐
│                      LocalStack                              │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   Sua Máquina                     "Falso" AWS                │
│   ┌─────────────┐                ┌─────────────────┐        │
│   │   AWS CLI   │ ──────────►    │   LocalStack    │        │
│   │   Scripts   │   Port 4566    │   (Docker)      │        │
│   │   Apps      │                │                 │        │
│   └─────────────┘                │   Serviços:     │        │
│                                  │   • S3          │        │
│                                  │   • Lambda      │        │
│                                  │   • DynamoDB    │        │
│                                  │   • SQS/SNS     │        │
│                                  │   • CloudWatch  │        │
│                                  │   • etc.        │        │
│                                  └─────────────────┘        │
│                                                              │
│   ✅ Gratuito     ✅ Local     ✅ Sem conta AWS              │
└─────────────────────────────────────────────────────────────┘

Pré-requisitos

Docker Desktop (Obrigatório)

O LocalStack roda em um container Docker. Você precisa instalar o Docker Desktop primeiro.

Download:

• Windows: https://www.docker.com/products/docker-desktop/
• macOS: https://www.docker.com/products/docker-desktop/
• Linux: Instruções específicas para sua distribuição

Verificar Docker

# Verificar se o Docker está instalado
docker --version

# Verificar se o Docker está funcionando
docker run hello-world

Resultado esperado:

Docker version 24.x.x, build xxxxx

Important Windows

No Windows, o Docker Desktop deve estar iniciado antes de usar o LocalStack. Verifique o ícone do Docker na barra de tarefas.

Instalação do LocalStack

Método 1: Via Docker (Recomendado)

Este é o método mais simples e confiável.

Iniciar o LocalStack:

docker run -d \
  --name localstack \
  -p 4566:4566 \
  -p 4510-4559:4510-4559 \
  -e SERVICES=s3,lambda,sqs,dynamodb,cloudwatch,cloudformation \
  -e DEBUG=1 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  localstack/localstack

No Windows PowerShell:

docker run -d `
  --name localstack `
  -p 4566:4566 `
  -p 4510-4559:4510-4559 `
  -e SERVICES=s3,lambda,sqs,dynamodb,cloudwatch,cloudformation `
  -e DEBUG=1 `
  localstack/localstack

Método 2: Via Docker Compose (Recomendado para este curso)

Crie um arquivo docker-compose.yml:

version: '3.8'

services:
  localstack:
    container_name: localstack
    image: localstack/localstack:latest
    ports:
      - "4566:4566"            # Porta principal
      - "4510-4559:4510-4559"  # Portas adicionais
    environment:
      - SERVICES=s3,lambda,sqs,sns,dynamodb,cloudwatch,cloudformation,iam
      - DEBUG=1
      - DATA_DIR=/tmp/localstack/data
      - DOCKER_HOST=unix:///var/run/docker.sock
    volumes:
      - "${LOCALSTACK_VOLUME_DIR:-./volume}:/var/lib/localstack"
      - "/var/run/docker.sock:/var/run/docker.sock"

Iniciar com Docker Compose:

docker-compose up -d

Método 3: Via pip (Alternativa)

# Instalar o LocalStack CLI
pip install localstack

# Iniciar o LocalStack
localstack start

Verificação da Instalação

Etapa 1: Verificar se o container está rodando

docker ps

Resultado esperado:

CONTAINER ID   IMAGE                   COMMAND                  STATUS          PORTS
abc123def456   localstack/localstack   "docker-entrypoint.sh"   Up 2 minutes    0.0.0.0:4566->4566/tcp

Etapa 2: Verificar o estado do LocalStack

curl http://localhost:4566/_localstack/health

Resultado esperado:

{
  "services": {
    "s3": "running",
    "lambda": "running",
    "sqs": "running",
    "dynamodb": "running",
    ...
  }
}

No Windows PowerShell:

Invoke-RestMethod http://localhost:4566/_localstack/health

Etapa 3: Testar com AWS CLI

# Criar um bucket S3
aws --endpoint-url=http://localhost:4566 s3 mb s3://meu-primeiro-bucket --profile localstack

# Listar os buckets
aws --endpoint-url=http://localhost:4566 s3 ls --profile localstack

Resultado esperado:

make_bucket: meu-primeiro-bucket
2024-12-18 10:30:00 meu-primeiro-bucket

Serviços Disponíveis no LocalStack

Versão Gratuita (Community)

Serviço	Suporte	Observações
S3	✅ Completo	Armazenamento de objetos
Lambda	✅ Completo	Funções serverless
SQS	✅ Completo	Fila de mensagens
SNS	✅ Completo	Notificações
DynamoDB	✅ Completo	Banco NoSQL
CloudWatch Logs	✅ Parcial	Apenas logs
CloudFormation	✅ Básico	Templates simples
IAM	✅ Básico	Papéis e políticas
EC2	⚠️ Limitado	Apenas metadados
VPC	⚠️ Limitado	Simulação básica

O que usaremos

┌─────────────────────────────────────────────────────────────┐
│              Serviços LocalStack para este curso             │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   PRÁTICA COMPLETA              SOMENTE TEORIA              │
│   (LocalStack)                  (Sem simulação)             │
│                                                              │
│   ✅ S3                        📚 EC2 (instâncias)           │
│   ✅ Lambda                    📚 VPC completo               │
│   ✅ SQS/SNS                   📚 EBS                        │
│   ✅ DynamoDB                  📚 ELB/ALB                    │
│   ✅ CloudWatch Logs           📚 Route 53                   │
│   ✅ CloudFormation            📚 Auto Scaling               │
│   ✅ IAM (básico)                                            │
│                                                              │
└─────────────────────────────────────────────────────────────┘

Comandos de Gerenciamento do LocalStack

Iniciar o LocalStack

# Com Docker
docker start localstack

# Com Docker Compose
docker-compose up -d

# Com CLI
localstack start

Parar o LocalStack

# Com Docker
docker stop localstack

# Com Docker Compose
docker-compose down

# Com CLI
localstack stop

Ver os logs

docker logs localstack

# Acompanhar os logs em tempo real
docker logs -f localstack

Reiniciar de forma limpa

docker stop localstack
docker rm localstack
# Depois execute novamente o comando docker run

Script de Automação

Crie um script para facilitar o início:

Windows (start-localstack.ps1)

# start-localstack.ps1
Write-Host "Iniciando o LocalStack..." -ForegroundColor Green

# Verificar se o container existe
$container = docker ps -a -q -f name=localstack

if ($container) {
    Write-Host "Removendo o container antigo..."
    docker rm -f localstack
}

# Iniciar o LocalStack
docker run -d `
    --name localstack `
    -p 4566:4566 `
    -p 4510-4559:4510-4559 `
    -e SERVICES=s3,lambda,sqs,dynamodb,cloudwatch,cloudformation `
    localstack/localstack

Write-Host "Aguardando inicialização (30 segundos)..." -ForegroundColor Yellow
Start-Sleep -Seconds 30

# Verificar
Write-Host "Verificando..." -ForegroundColor Green
aws --endpoint-url=http://localhost:4566 s3 ls --profile localstack

Write-Host "LocalStack está pronto!" -ForegroundColor Green

macOS/Linux (start-localstack.sh)

#!/bin/bash
echo "Iniciando o LocalStack..."

# Remover o container antigo se existir
docker rm -f localstack 2>/dev/null

# Iniciar o LocalStack
docker run -d \
    --name localstack \
    -p 4566:4566 \
    -p 4510-4559:4510-4559 \
    -e SERVICES=s3,lambda,sqs,dynamodb,cloudwatch,cloudformation \
    localstack/localstack

echo "Aguardando inicialização (30 segundos)..."
sleep 30

# Verificar
echo "Verificando..."
aws --endpoint-url=http://localhost:4566 s3 ls --profile localstack

echo "LocalStack está pronto!"

Aliases Práticos

Para simplificar os comandos, configure um alias:

Windows PowerShell

Adicione ao arquivo $PROFILE:

function awslocal {
    aws --endpoint-url=http://localhost:4566 --profile localstack $args
}

macOS/Linux

Adicione ao ~/.bashrc ou ~/.zshrc:

alias awslocal='aws --endpoint-url=http://localhost:4566 --profile localstack'

Usando o alias

# Em vez de:
aws --endpoint-url=http://localhost:4566 s3 ls --profile localstack

# Você escreverá:
awslocal s3 ls

Teste Completo do Ambiente

Execute estes comandos para validar sua instalação:

# 1. Verificar Docker
docker --version

# 2. Verificar LocalStack
docker ps | grep localstack

# 3. Verificar saúde
curl http://localhost:4566/_localstack/health

# 4. Criar um bucket S3
awslocal s3 mb s3://test-bucket

# 5. Listar os buckets
awslocal s3 ls

# 6. Remover o bucket de teste
awslocal s3 rb s3://test-bucket

# 7. Verificar Lambda (deve estar vazio)
awslocal lambda list-functions

Captura de Tela Esperada

PS C:\Users\SeuNome> docker ps
CONTAINER ID   IMAGE                   STATUS          PORTS
abc123         localstack/localstack   Up 5 minutes    0.0.0.0:4566->4566/tcp

PS C:\Users\SeuNome> awslocal s3 ls
2024-12-18 10:30:00 test-bucket

PS C:\Users\SeuNome> awslocal lambda list-functions
{
    "Functions": []
}

Solução de Problemas

Problema: "Cannot connect to the Docker daemon"

Solução:

1. Verifique se o Docker Desktop está iniciado
2. No Windows, clique no ícone do Docker na barra de tarefas
3. Aguarde até que o Docker esteja "Running"

Problema: "Port 4566 already in use"

Solução:

# Encontrar o processo
# Windows
netstat -ano | findstr 4566

# Linux/macOS
lsof -i :4566

# Finalize o processo ou altere a porta
docker run -p 4567:4566 ...

Problema: "Connection refused to localhost:4566"

Solução:

1. Aguarde 30-60 segundos após iniciar
2. Verifique os logs: docker logs localstack
3. Reinicie o container

Problema: Comandos AWS muito lentos

Solução: O LocalStack pode ser lento na primeira chamada. Isso é normal. As chamadas seguintes serão mais rápidas.

Checklist de Validação

• Docker Desktop instalado e iniciado
• Container do LocalStack em execução
• Porta 4566 acessível
• Comando awslocal s3 ls funcionando
• Alias awslocal configurado

Quiz de Validação

1. O que é o LocalStack?
2. Em qual porta o LocalStack escuta por padrão?
3. Por que usamos --endpoint-url com AWS CLI?
4. Quais serviços AWS o LocalStack emula bem?
5. Como verificar se o LocalStack está funcionando?

---

Próxima seção: Lab: Configuração do ambiente