leocarmo.dev

leocarmo.dev

Ambiente de desenvolvimento das galáxias usando Docker

Ambiente de desenvolvimento das galáxias usando Docker

Subscribe to my newsletter and never miss my upcoming articles

Criar um ambiente de desenvolvimento local pode parecer um desafio. Quem nunca sofreu ~ pelo menos um pouco ~ para conseguir ter as dependências rodando na sua maquina para criar um projeto?

Pois é, normalmente passamos por isso quase sempre. Antes de conhecer o Docker, isso era muito mais difícil... Ter que subir um banco de dados localmente sempre dava algum tipo de dor de cabeça, ainda mais quando era preciso ter uma versão específica por conta de algum projeto já existente que precisava de manutenção.

A ideia é te ajudar a montar um ambiente de desenvolvimento local de forma fácil e rápida usando tudo com Docker. Além disso, vou te mostrar algumas ferramentas de apoio que podem ajudar muito na hora de debugar algumas coisas.

É importante que você tenha pelo menos uma base sobre Docker e Docker Compose e claro, tenha ele instalado na sua máquina.

Para facilitar, sugiro que você clone o projeto que deixei preparado para este artigo com todos os arquivos prontos.

git clone git@github.com:leocarmo/docker-local-stack.git

Antes de iniciar as ferramentas, criaremos uma rede para nossos containers, pois teremos vários arquivos diferentes para nossas stacks, assim você pode escolher de forma mais fácil qual utilizar e quando.

docker network create global-default

Tópicos:


1. Visibilidade de containers

A primeira ferramenta que gosto de usa é o DockStation, infelizmente ele precisa ser instalado na sua máquina, prometo que será o único.

Ele tem uma infinidade de ferramentas para te ajudar a gerenciar melhor seus containers, o que precisaremos em breve, e uma interface bem amigável.

Aqui tem um preview dele:

DockStation

De qualquer forma, caso você não queira instalar nada na sua máquina, existe uma alternativa que é o Portainer, ele pode ser iniciado via container, e também tem diversas ferramentas disponíveis para te ajudar.

Portainer

O exemplo para rodar via compose está aqui.

Para iniciar o Portainer:

docker compose -f container-visibility/docker-compose-portainer.yaml up -d

2. Redis

Falando sobre Redis, normalmente usamos ele de duas formas: single node ou cluster. Ainda temos outra ferramenta que traz uma visibilidade incrível, evitando que seja preciso criar código para debugar chaves, consumo de recursos e ainda consegue sugerir melhorias nas buscas, por exemplo. Falaremos dela em breve.

Começando pelo Redis single node, esse aqui é um exemplo do compose. Para iniciar:

docker compose -f redis/docker-compose-single.yaml up -d

Sim, bem simples. Agora montaremos um cluster. Para isso, utilizaremos as imagens da Bitnami, eles possuem diversas outras ferramentas já prontas para utilizar também, vale a pena dar uma olhada.

Vale pontuar que não é uma imagem oficial do Redis como a do single node. É possível criar um cluster utilizando a imagem oficial, mas nosso foco aqui é para desenvolvimento local, então utilizaremos o que é mais fácil e rápido para ter rodando.

O repositório com o docker-compose original da Bitnami está no github deles, porém, realizei algumas pequenas modificações para que ele possa ter contato com todos os outros containers que utilizaremos aqui.

O compose do Redis cluster com algumas pequenas mudanças que fiz está aqui. Para iniciar:

docker compose -f redis/docker-compose-cluster.yaml up -d

Ótimo, agora temos um single node e um cluster de Redis funcionando!

Vou te mostrar uma ferramenta que gosto muito, o RedisInsight, que é uma GUI para interagir com o Redis (por isso modifiquei tudo para ficar na network global-default).

RedisInsight

Então nosso compose do RedisInsight fica assim. Para iniciar:

docker compose -f redis/docker-compose-insight.yaml up -d

Para conectar o RedisInsight ao nosso cluster ou ao single node é bem simples, ele fica neste endereço: http://0.0.0.0:8001/. Depois, basta selecionar que você já possui um database e colocar as informações para conectar. Um exemplo para conectar no cluster:

image.png

Não esqueça da senha: redis


3. Kafka

Para ter um cluster de Apache Kafka rodando, precisamos do ZooKeeper. É bem simples também, aqui tem o compose com tudo isso, sendo um cluster de Kafka com 3 brokers. Para rodar:

docker compose -f kafka/docker-compose-cluster.yaml up -d

O destaque aqui vai para a ferramenta Kowl, que é uma UI para o Kafka, gostei bastante dela comparada a outras.

Kowl Kafka

O Kowl ficará disponível em http://0.0.0.0:8080/.

Ele tem a versão open-source, mas também tem uma versão Business, enquanto ela está na versão beta, você pode conseguir uma licença limitada, porém gratuita e eterna aqui.

Até o dia de hoje, ainda está liberado, então aproveita!


4. MongoDB

Para o Mongo, foi bem simples montar algo que já resolva localmente nossa necessidade. Coloquei também o mongo-express no compose para ajudar no debug.

mongo-express

O compose final está aqui. Caso queira ver mais parâmetros disponíveis na imagem oficial, você pode acessar aqui. Para rodar:

docker compose -f mongodb/docker-compose-single.yaml up -d

O mongo-express ficará disponível em http://0.0.0.0:8081/.

Caso você precise de algo mais robusto, a Bitnami também tem um compose pronto com múltiplos shards, vale a pena conferir aqui.


5. ElasticSearch

Este também foi fácil, a própria documentação oficial disponibiliza um compose praticamente pronto, eu apenas reduzi um node, acredito que dois já são suficientes para desenvolvimento local, o link está aqui. Para rodar:

docker compose -f elasticsearch/docker-compose-cluster.yaml up -d

O ElasticSearch ficará disponível em http://0.0.0.0:9200/ e o Kibana em http://0.0.0.0:5601/.

O destaque aqui vai para o Cerebro, uma UI que ajuda bastante na hora de entender como está a distribuição dos shards, consumo de recurso, entre outras informações importantes do cluster.

Cerebro

O compose do Cerebro está aqui e ficará disponível em http://0.0.0.0:9000/. Para rodar:

docker compose -f elasticsearch/docker-compose-cerebro.yaml up -d

Para começar usar é simples, basta colocar o endereço do ElasticSearch, no nosso caso o nome do container e a porta: http://es01:9200.


6. Databases

Nesta seção, deixei os principais bancos preparados: MariaDB, MySQL e o Postgres com pgAdmin4.

Também são bem simples, o compose do MariaDB está aqui, do MySQL aqui e do Postgres aqui. Para rodar cada um:

docker compose -f databases/docker-compose-mariadb.yaml up -d
docker compose -f databases/docker-compose-mysql.yaml up -d
docker compose -f databases/docker-compose-postgres.yaml up -d

Ao subir os containers, os volumes serão criados em databases/var, no mesmo diretório dos arquivos do compose.

Para gerenciar o Postgres, o pgAdmin estará disponível em http://0.0.0.0:5050/:

pgAdmin

Para gerenciar o MariaDB e MySQL, sugiro utilizar o MySQL Workbench, que infelizmente não tem sua versão em container... Mas vale a pena, ele é muito completo e vai te ajudar bastante.

MySQL Workbench


7. Mock

Sempre que estamos desenvolvendo microsserviços, em algum momento vamos nos deparar com alguma dependência externa, e isso pode ser uma grande dor de cabeça.

Para ajudar nessa questão, gosto muito de utilizar um serviço de mock para desenvolvimento. Além de ajudar muito da hora de codar, pode ser muito útil também para realização de testes, por exemplo. Aqui tem mais alguns benefícios de se utilizar.

Venho utilizando o MockServer, ele é bem customizável, possui inúmeras funcionalidades, é bem fácil de configurar, possui uma UI para debug bem bacana e a documentação é bem completa.

MockServer

O compose dele está aqui, e dentro da mesma pasta existe um arquivo de configurações, caso você queira mudar essas configurações, basta seguir esta documentação. Para rodar:

docker compose -f mock/docker-compose.yaml up -d

Após subir os containers, a UI estará disponível em: http://0.0.0.0:1080/mockserver/dashboard, e caso você não tenha alterado o arquivo de configurações, a rota de testes será: http://0.0.0.0:1080/hello


8. AWS

Com certeza não poderia faltar o AWS LocalStack. Então se você não conhece esse projeto e usa AWS, recomendo dar uma olhada.

Apesar de muito útil, pode dar algum trabalho configurar alguns recursos nele, mas após configurado corretamente, pode salvar muito tempo tentando resolver algo direto pela AWS, além de economizar na conta rsrs.

A ideia aqui é deixar um SQS configurado e rodando. Para configurar outros recursos basta dar uma olhada na documentação oficial.

O compose do SQS está aqui. Para iniciar:

docker compose -f aws/docker-compose-sqs.yaml up

Se tudo der certo, você verá a seguinte mensagem no console de que o mock do SQS subiu com sucesso na porta 4566:

SQS LocalStack

Repare na segunda linha a mensagem: Starting mock SQS service on http port 4566 ...

O LocalStack também sobre uma rota de heath check, que fica disponível em https://0.0.0.0:4566/health, lá você deveria ver o seguinte json:

{
    "services": {
        "sqs": "running"
    },
    "features": {
        "persistence": "disabled",
        "initScripts": "initialized"
    }
}

Ótimo, com tudo isso funcionando, utilizaremos esse serviço. Primeiro, precisamos criar uma fila, pois só subimos o serviço. Para isso, utilizamos o aws-cli.

Criando uma fila no SQS:

aws --endpoint-url=http://0.0.0.0:4566 sqs create-queue --queue-name my-queue

Para verificar se a fila foi criada com sucesso utilize o comando:

aws --endpoint-url=http://0.0.0.0:4566 sqs list-queues

Agora enviaremos uma mensagem para a fila que criamos:

aws --endpoint-url=http://0.0.0.0:4566 sqs send-message --queue-url http://0.0.0.0:4566/000000000000/my-queue --message-body 'Hello SQS World'

Para ler a mensagem que acabamos de criar:

aws --endpoint-url=http://0.0.0.0:4566 sqs receive-message --queue-url http://0.0.0.0:4566/000000000000/my-queue

Para acessar a lista completa de comandos do SQS via aws-cli acesse a documentação oficial.


Dica: caso voce já tenha uma network criada para suas aplicações, basta conectar os containers criados aqui com a sua network usando este comando:

docker network connect my-network redis-single

Importante: para as stacks em cluster, é preciso conectar cada container na sua network.


Basicamente com essa stack muitos dos problemas do dia a dia podem ser resolvidos. Espero que te ajude de alguma forma no seu fluxo de desenvolvimento local.

Alguma sugestão de alguma ferramenta que faltou aqui? Deixa nos comentários!

 
Share this