Provisionamento de serviços¶

O objetivo deste documento é apresentar os procedimentos essenciais para o provisionamento local dos serviços mais comuns na construção de aplicações, tais como banco de dados relacional, banco de dados não-relacional, sistema de cache, armazenamento de objetos, entre outros. Esses procedimentos visam viabilizar o desenvolvimento dos projetos de referência disponibilizados aos times alocados nos clientes, permitindo que os desenvolvedores tirem o máximo proveito da implementação de referência.

Nas seções seguintes, serão apresentadas as etapas de instalação e configuração de cada serviço utilizando a ferramenta Docker Compose ⧉.

Pré-requisitos¶

Antes de prosseguir com o provisionamento dos serviços, é necessário baixar o arquivo docker-compose.yml pré-configurado com os serviços que serão provisionados localmente. Para fazer isso, siga as etapas abaixo:

Linux Windows

Faça download do arquivo pré-configurado ⧉.
Crie um diretório para armazenar o arquivo baixado:
```
mkdir --parents /opt/dev/tools/docker
```

Extraia o conteúdo do arquivo baixado no diretório recém-criado usando o seguinte comando:

tar -xzf docker-compose-linux.tar.gz \
    --directory /opt/dev/tools/docker \
    --strip-components=1 # (1)!

Acesse o diretório criado utilizando o comando:
```
cd /opt/dev/tools/docker
```

Documentação em progresso

Pronto! Agora você pode seguir para as seções que tratam do provisionamento dos serviços.

Instalação e configuração¶

PostgreSQL¶

O PostgreSQL ⧉ é um banco de dados relacional de código aberto amplamente utilizado em aplicações críticas devido a sua escalabilidade, confiabilidade e robustez. Ao utilizá-lo, é possível testar localmente funcionalidades que requerem suporte a SQL ⧉ e transações. Essa abordagem é particularmente útil porque muitos clientes preferem bancos de dados comerciais, como IBM DB2 ⧉, Oracle Database ⧉ e Microsoft SQL Server ⧉, que exigem licenças de uso e tornam a instalação local inviável.

Para iniciar o serviço do PostgreSQL em seu ambiente, utilizando a imagem Docker oficial ⧉, siga os passos abaixo:

Inicie o serviço do PostgreSQL com as configurações definidas no arquivo docker-compose.yml através do comando:
```
docker-compose up --detach postgres # (1)!
```
Verifique se o container está em execução listando os processos ativos do docker-compose usando o comando:
```
docker-compose ps # (1)!
```

Conecte-se ao banco de dados criado com base nas configurações do arquivo docker-compose.yml utilizando o comando:

docker exec -it postgres psql \
    --host localhost \
    --port 5432 \
    --dbname test_db \
    --username postgresUser # (1)!

Execute um comando SELECT para confirmar que tudo está funcionando conforme o esperado, por exemplo:
```
SELECT datname FROM pg_database; -- (1)!
```

Comandos úteis

Para visualizar os logs gerados pelo serviço postgres, utilize o seguinte comando:

docker-compose logs postgres

Para interromper o serviço postgres e manter o container e seu respectivo volume, use o comando abaixo:

docker-compose stop postgres

Para iniciar o container do serviço postgres, execute o seguinte comando:

docker-compose start postgres

Para parar e remover completamente o container do serviço postgres, utilize o comando:

docker-compose rm --stop postgres

As credenciais para conexão com o PostgreSQL provisionado localmente podem ser encontradas no arquivo docker-compose.yml. O trecho de código abaixo mostra as informações necessárias:

docker-compose.yml

...
postgres: # (1)!
  image: postgres:15-alpine
  container_name: postgres
  restart: unless-stopped
  environment:
    - POSTGRES_USER=postgresUser
    - POSTGRES_PASSWORD=postgresPass
    - POSTGRES_DB=test_db
    - PGDATA=/var/lib/postgresql/data
  ports:
    - 5432:5432
  volumes:
    - postgres_data:/var/lib/postgresql/data
    - ./postgres/setup.sql:/docker-entrypoint-initdb.d/setup.sql
  healthcheck:
    test: ["CMD-SHELL", "pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}"]
    interval: 10s
    timeout: 10s
    retries: 3
...

Os dados de conexão são:
Host: localhost
Port: 5432
Database: test_db
Username: postgresUser
Password: postgresPass

MongoDB¶

O MongoDB ⧉ é um banco de dados NoSQL ⧉ (não-relacional) orientado a documentos. Diferentemente dos bancos de dados relacionais tradicionais, que armazenam dados em tabelas com linhas e colunas, o MongoDB armazena dados em documentos semelhantes a JSON ⧉, permitindo estruturas complexas e aninhadas.

Para provisionar o serviço MongoDB em seu ambiente, utilizando a imagem Docker oficial ⧉, siga os passos abaixo:

Inicie o serviço MongoDB com as configurações definidas no arquivo docker-compose.yml utilizando o comando:
```
docker-compose up --detach mongo # (1)!
```
Verifique se o container está em execução listando os processos ativos do docker-compose com o comando:
```
docker-compose ps # (1)!
```

Conecte-se ao banco de dados criado com base nas configurações do arquivo docker-compose.yml através do comando:

docker exec -it mongo mongosh \
    --host localhost \
    --port 27017 \
    --username mongoUser \
    --password mongoPass \
    --quiet # (1)!

Execute os comandos abaixo para confirmar que tudo está funcionando conforme esperado:
```
show databases
use test
show collections # (1)!
```

Comandos úteis

Para visualizar os logs gerados pelo serviço mongo, utilize o seguinte comando:

docker-compose logs mongo

Para interromper o serviço mongo e manter o container e seu respectivo volume, use o comando abaixo:

docker-compose stop mongo

Para iniciar o container do serviço mongo, execute o seguinte comando:

docker-compose start mongo

Para parar e remover completamente o container do serviço mongo, utilize o comando:

docker-compose rm --stop mongo

As credenciais para conexão com o MongoDB provisionado localmente podem ser encontradas no arquivo docker-compose.yml. O trecho de código abaixo mostra as informações necessárias:

docker-compose.yml

...
mongo: # (1)!
  image: mongodb/mongodb-community-server:6.0-ubi8
  container_name: mongo
  restart: unless-stopped
  environment:
    - MONGODB_INITDB_ROOT_USERNAME=mongoUser
    - MONGODB_INITDB_ROOT_PASSWORD=mongoPass
  ports:
    - 27017:27017
  volumes:
    - mongo_data:/data/db
    - ./src/test/resources/tools/mongo/:/docker-entrypoint-initdb.d/:ro
  healthcheck:
    test: echo 'db.runCommand("ping").ok' | mongosh --host localhost --port 27017 --username mongoUser --password mongoPass --quiet
    interval: 10s
    timeout: 10s
    retries: 3
...

Os dados de conexão são:
Host: localhost
Port: 27017
Database: test
Username: mongoUser
Password: mongoPass

Elasticsearch¶

O Elasticsearch ⧉ é uma ferramenta open source de busca e análise de dados distribuídos baseada no Apache Lucene ⧉, que permite lidar com grandes volumes de dados estruturados e não estruturados em tempo real, além de funcionar como um banco de dados NoSQL ⧉.

Para provisionar o serviço Elasticsearch em seu ambiente, utilizando a imagem docker oficial ⧉, siga os passos abaixo:

Inicie o serviço Elasticsearch com as configurações definidas no arquivo docker-compose.yml utilizando o comando:
```
docker-compose up --detach elastic # (1)!
```
Verifique se o container está em execução listando os processos ativos do docker-compose com o comando:
```
docker-compose ps # (1)!
```
Confirme se tudo está funcionando corretamente executando o seguinte comando:
```
curl http://localhost:9200/ # (1)!
```

Comandos úteis

Para visualizar os logs gerados pelo serviço elastic, utilize o seguinte comando:

docker-compose logs elastic

Para interromper o serviço elastic e manter o container e seu respectivo volume, use o comando abaixo:

docker-compose stop elastic

Para iniciar o container do serviço elastic, execute o seguinte comando:

docker-compose start elastic

Para parar e remover completamente o container do serviço elastic, utilize o comando:

docker-compose rm --stop elastic

As credenciais para conexão com o Elasticsearch provisionado localmente podem ser encontradas no arquivo docker-compose.yml. O trecho de código abaixo mostra as informações necessárias:

docker-compose.yml

...
elastic: # (1)!
  image: elasticsearch:8.6.2
  container_name: elastic
  restart: unless-stopped
  environment:
    - node.name=elasticsearch
    - cluster.name=elasticsearch
    - discovery.type=single-node
    - xpack.security.enabled=false
    - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
  ports:
    - 9200:9200
    - 9300:9300
  volumes:
    - elastic_data:/usr/share/elasticsearch/data
  healthcheck:
    test: ["CMD-SHELL", "curl -s http://localhost:9200/_cat/health?h=status | grep -q green"]
    interval: 10s
    timeout: 10s
    retries: 3 
...

Os dados de conexão são:
Host: localhost
Port: 9200

Redis¶

O Redis ⧉ é um sistema de armazenamento de dados em memória open-source, que pode ser utilizado como banco de dados, cache, message broker e fila de tarefas. Ele armazena os dados em memória RAM, proporcionando um acesso mais rápido em comparação a outros sistemas de armazenamento que utilizam discos. Geralmente, é utilizado para armazenar em cache os resultados de pesquisas do banco, evitando sobrecarga nas bases de dados para consultas frequentes. Além disso, o Redis pode ser utilizado para armazenar em cache a resposta de requisições HTTP, especialmente aquelas que envolvem mídias, como vídeos, áudios e imagens.

Para provisionar o serviço Redis em seu ambiente, utilizando a imagem docker oficial ⧉, siga as etapas abaixo:

Inicie o serviço Redis com as configurações definidas no arquivo docker-compose.yml utilizando o seguinte comando:
```
docker-compose up --detach redis # (1)!
```
Verifique se o container está em execução listando os processos ativos do docker-compose com o comando:
```
docker-compose ps # (1)!
```

Confirme se tudo está funcionando corretamente executando o seguinte comando:

docker exec -it redis redis-cli \
    -h localhost \
    -p 6379 \
    -n 0 \
    PING # (1)!

Comandos úteis

Para visualizar os logs gerados pelo serviço redis, utilize o seguinte comando:

docker-compose logs redis

Para interromper o serviço redis e manter o container e seu respectivo volume, use o comando abaixo:

docker-compose stop redis

Para iniciar o container do serviço redis, execute o seguinte comando:

docker-compose start redis

Para parar e remover completamente o container do serviço redis, utilize o comando:

docker-compose rm --stop redis

As credenciais para conexão com o Redis provisionado localmente podem ser encontradas no arquivo docker-compose.yml. O trecho de código abaixo mostra as informações necessárias:

docker-compose.yml

...
redis: # (1)!
  image: bitnami/redis:7.0.10
  container_name: redis
  restart: unless-stopped
  environment:
    - ALLOW_EMPTY_PASSWORD=true
    - REDIS_DISABLE_COMMANDS=FLUSHDB,FLUSHALL
  ports:
    - 6379:6379
  volumes:
    - redis_data:/bitnami/redis/data
  healthcheck:
    test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
    interval: 10s
    timeout: 10s
    retries: 3
...

Os dados de conexão são:
Host: localhost
Port: 6379
Database: 0

Minio¶

O Minio ⧉ é uma ferramenta open source que permite o armazenamento de diversos tipos de arquivos, incluindo fotos, vídeos, arquivos de áudio e documentos. Ele oferece uma alternativa ao Amazon S3 ⧉ (Simple Storage Service). Embora muitos projetos precisem de uma solução para armazenar arquivos, geralmente soluções comerciais como Google Cloud Storage ⧉, Amazon S3 ⧉, IBM Cloud Object Storage ⧉ e Microsoft Azure Storage ⧉ são utilizadas em aplicações corporativas. No entanto, todas essas soluções são compatíveis com o S3, o que significa que é possível implementá-las da mesma forma, desde que se utilize uma SDK que não esteja vinculada a um provedor de armazenamento específico.

Para provisionar o serviço Minio em seu ambiente, utilizando a imagem docker oficial ⧉, basta executar os comandos abaixo:

Inicie o serviço Minio com as configurações definidas no arquivo docker-compose.yml utilizando o seguinte comando:
```
docker-compose up --detach minio # (1)!
```
Verifique se o container está em execução listando os processos ativos do docker-compose com o comando:
```
docker-compose ps # (1)!
```
Confirme se tudo está funcionando corretamente executando o seguinte comando:
```
curl -I http://localhost:9000/minio/health/cluster # (1)!
```

Comandos úteis

Para visualizar os logs gerados pelo serviço minio, utilize o seguinte comando:

docker-compose logs minio

Para interromper o serviço minio e manter o container e seu respectivo volume, use o comando abaixo:

docker-compose stop minio

Para iniciar o container do serviço minio, execute o seguinte comando:

docker-compose start minio

Para parar e remover completamente o container do serviço minio, utilize o comando:

docker-compose rm --stop minio

As credenciais para conexão com o Minio provisionado localmente podem ser encontradas no arquivo docker-compose.yml. O trecho de código abaixo mostra as informações necessárias:

docker-compose.yml

...
minio: # (1)!
  image: minio/minio:RELEASE.2023-02-27T18-10-45Z.fips
  command: server /data --console-address ":9100"
  container_name: minio
  restart: unless-stopped
  environment:
    - MINIO_ROOT_USER=minioUser
    - MINIO_ROOT_PASSWORD=minioPass
  ports:
    - 9000:9000
    - 9100:9100
  volumes:
    - minio_data:/data
  healthcheck:
    test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
    interval: 10s
    timeout: 10s
    retries: 3
minio-client:
  image: minio/mc:latest
  volumes:
    - ./minio/setup.sh:/setup.sh:ro
  entrypoint: ["sh", "./setup.sh", "http://minio:9000", "minioUser", "minioPass"]
  depends_on:
    - minio
...

Os dados de conexão são:
Host: localhost
Port: 9000
Username: minioUser
Password: minioPass

Mailhog¶

O Mailhog ⧉ é uma ferramenta de desenvolvimento de software que permite simular um servidor de e-mail local. É uma ótima opção para testes durante a construção de aplicações que envolvem o envio de e-mails, pois armazena os e-mails enviados pela aplicação e apresenta-os, juntamente com informações de cabeçalho, em uma interface web amigável. Essa solução oferece aos desenvolvedores a possibilidade de testar o envio de e-mails sem a preocupação de enviá-los para usuários reais ou gerar custos adicionais.

Para provisionar o serviço Mailhog em seu ambiente usando a imagem docker oficial ⧉, siga os passos abaixo:

Inicie o serviço Mailhog com as configurações definidas no arquivo docker-compose.yml, executando o seguinte comando:
```
docker-compose up --detach mailhog # (1)!
```
Verifique se o container está em execução listando os processos ativos do docker-compose com o comando:
```
docker-compose ps # (1)!
```
Confirme se tudo está funcionando corretamente usando o seguinte comando:
```
echo quit | telnet localhost 1025 # (1)!
```
Verifique se o console web da ferramenta está acessível digitando o endereço http://localhost:8025/ ⧉ em seu navegador:

Comandos úteis

Para visualizar os logs gerados pelo serviço mailhog, utilize o seguinte comando:

docker-compose logs mailhog

Para interromper o serviço mailhog e manter o container e seu respectivo volume, use o comando abaixo:

docker-compose stop mailhog

Para iniciar o container do serviço mailhog, execute o seguinte comando:

docker-compose start mailhog

Para parar e remover completamente o container do serviço mailhog, utilize o comando:

docker-compose rm --stop mailhog

As credenciais para conexão com o Mailhog provisionado localmente podem ser encontradas no arquivo docker-compose.yml. O trecho de código abaixo mostra as informações necessárias:

docker-compose.yml

...
mailhog: # (1)!
  image: mailhog/mailhog:latest
  container_name: mailhog
  restart: always
  ports:
    - 1025:1025 # porta do serviço SMTP
    - 8025:8025 # porta do console web usado para visualizar os e-mails
...

Os dados de conexão são:
Host: localhost
Port: 1025

Keycloak¶

O Keycloak ⧉ é uma ferramenta de gerenciamento de identidade e acesso que oferece recursos de autenticação, autorização e gerenciamento de usuários para aplicações web e móveis. Com ele, os desenvolvedores podem facilmente configurar recursos de autenticação multifator e social (por exemplo, login com contas do Google ou Facebook), bem como gerenciar usuários e permissões de acesso. O Keycloak segue as especificações do OAuth 2 ⧉ e OpenID Connect ⧉, que são protocolos padrões para autenticação e autorização de usuários em aplicações. Por ser uma ferramenta agnóstica a fornecedor, ele possibilita fácil integração com diversas plataformas e fornecedores de tecnologia.

Para provisionar o serviço Keycloak em seu ambiente usando a imagem docker oficial ⧉, siga os passos abaixo:

Inicie o serviço Keycloak com as configurações definidas no arquivo docker-compose.yml, executando o seguinte comando:
```
docker-compose up --detach keycloak # (1)!
```
Verifique se o container está em execução listando os processos ativos do docker-compose com o comando:
```
docker-compose ps # (1)!
```
Para verificar se a ferramenta está acessível, digite o endereço http://localhost:8080/ ⧉ em seu navegador.

Comandos úteis

Para visualizar os logs gerados pelo serviço keycloak, utilize o seguinte comando:

docker-compose logs keycloak

Para interromper o serviço keycloak e manter o container e seu respectivo volume, use o comando abaixo:

docker-compose stop keycloak

Para iniciar o container do serviço keycloak, execute o seguinte comando:

docker-compose start keycloak

Para parar e remover completamente o container do serviço keycloak, utilize o comando:

docker-compose rm --stop keycloak

As credenciais para conexão com o Keycloak provisionado localmente podem ser encontradas no arquivo docker-compose.yml. O trecho de código abaixo mostra as informações necessárias:

docker-compose.yml

...
keycloak: # (1)!
  image: quay.io/keycloak/keycloak:20.0.1
  container_name: keycloak
  restart: unless-stopped
  command:
    - start-dev
    - --import-realm
  ports:
    - 8080:8080
    - 8443:8443
  volumes:
    - ./keycloak/realm.json:/opt/keycloak/data/import/realm.json:ro
  environment:
    - KC_DB=postgres
    - KC_DB_URL=jdbc:postgresql://postgres:5432/keycloak
    - KC_DB_USERNAME=postgresUser
    - KC_DB_PASSWORD=postgresPass
    - KC_HOSTNAME=localhost
    - KC_HEALTH_ENABLED=true
    - KC_METRICS_ENABLED=true
    - KEYCLOAK_ADMIN=keycloakUser
    - KEYCLOAK_ADMIN_PASSWORD=keycloakPass
  healthcheck:
    test: ["CMD", "curl", "-f", "http://keycloak:8080/health/ready"]
    interval: 10s
    timeout: 10s
    retries: 3
  depends_on:
    - postgres
keycloak-client:
  image: quay.io/keycloak/keycloak:20.0.1
  volumes:
    - ./keycloak/setup.sh:/setup.sh:ro
  entrypoint: ["sh", "./setup.sh", "http://keycloak:8080", "mith", "keycloakUser", "keycloakPass"]
  depends_on:
    keycloak:
      condition: service_healthy
...

Os dados de conexão são:
Host: localhost
Port: 8080
Username: keycloakUser
Password: keycloakPass