Introdução

Se você busca uma maneira eficiente e flexível de configurar o PostgreSQL, especialmente em ambientes de desenvolvimento, teste ou produção com alta portabilidade, a utilização do Docker oferece uma solução poderosa e escalável. Em vez de lidar com instalações tradicionais que demandam configurações específicas de sistema operacional e dependências, o Docker permite encapsular o PostgreSQL em um container virtualizado, garantindo consistência e facilitando o processo de distribuição e execução em diferentes plataformas.

Neste artigo, vamos explorar passo a passo como instalar e configurar o PostgreSQL utilizando Docker, abordando os comandos básicos para criação do container.

Roteiro:

• Instalação Docker
• Instalação PostgreSQL
  • Vantagens de usar o PostgreSQL dentro de um container
  • Desvantagens de usar o PostgreSQL dentro de um container
• Gerenciamento de recursos no Docker
  • CPU e memória
  • Armazenamento de disco
  • Monitoramento de uso de recursos
  • Exemplo de container com gerenciamento de recursos

Instalação Docker

Vamos começar nosso processo instalando o Docker, e caso você já o tenha na máquina, basta pular para o próximo tópico.

Neste caso, optamos por utilizar o usuário root para facilitar a instalação.

Primeiro, vamos atualizar a lista de pacotes:

# apt-get update
Get:1 file:/etc/apt/mirrors/debian.list Mirrorlist [39 B]
Get:5 file:/etc/apt/mirrors/debian-security.list Mirrorlist [27 B]
Hit:6 http://security.debian.org bookworm-security InRelease
Hit:2 http://mirrors.digitalocean.com/debian bookworm InRelease
...

Agora, vamos instalar os pacotes necessários:

# apt-get install apt-transport-https ca-certificates curl gnupg lsb-release
Reading package lists... Done
Building dependency tree... Done
...

Após isso, vamos baixar a chave GPG do repositório Docker, que verifica a autenticidade e integridade dos pacotes Docker que iremos instalar:

# curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Na sequência, vamos configurar o repositório Docker, criando uma nova entrada ao arquivo de repositórios do APT:

# echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null

E mais uma vez iremos atualizar a lista de pacotes, agora com o novo repositório no sistema:

# apt-get update
Get:1 file:/etc/apt/mirrors/debian.list Mirrorlist [39 B]
Get:5 file:/etc/apt/mirrors/debian-security.list Mirrorlist [27 B]
Hit:7 https://repos-droplet.digitalocean.com/apt/droplet-agent main InRelease
Hit:6 http://security.debian.org bookworm-security InRelease
...

Por fim, vamos instalar a última versão do Docker Engine e do Docker Compose, sendo o primeiro a tecnologia responsável por criar e gerenciar containers, e o segundo, uma ferramenta para definir e gerenciar aplicativos que rodam em vários containers:

# apt-get install -y docker-ce docker-ce-cli containerd.io
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
docker-ce is already the newest version (5:27.1.0-1~debian.12~bookworm).
...

Pronto! O Docker foi instalado na sua máquina. Para facilitar o uso, aqui estão alguns comandos básicos:

• dpkg - l | grep docker: busca pacotes Docker instalados;
• docker images: lista de imagens (adicione -a para forçar a listagem de todas, independente do estado, que pode ser em execução ou parado);
• docker container ls: lista de containers (adicione -a para forçar a listagem de todos, independente do estado, que pode ser em execução ou parado);
• docker container start <nome_container>: inicia um container;
• docker container stop <nome_container>: para um container;
• docker container restart <nome_container>: reinicia um container;
• docker rm <nome_container>: remove um container;
• docker rmi <nome_imagem>: remove uma imagem;
• docker exec -it <nome_container> sh: executa o container de modo interativo, para mexer no shell;
• exit: sai do shell interativo do container.

Instalação Postgres

Para começar, vamos baixar a imagem do Postgres. Aqui, temos a opção de baixar a mais recente, sem informar alguma versão específica, ou de acrescentar uma tag para referenciar a versão desejada, acrescentando :<versão> na frente de postgres, por exemplo:

docker pull postgres:15

Como vamos usar a mais recente, rodamos sem a tag:

# docker pull postgres
Using default tag: latest
latest: Pulling from library/postgres
2cc3ae149d28: Already exists
d1a63825d58e: Pull complete
ed6f372fe58d: Pull complete
35f975e69306: Pull complete
40c4fe86e99d: Pull complete
4795e1a32ff6: Pull complete
bcb5a54ae87d: Pull complete
d3983228bec6: Pull complete
5378bf7229e9: Pull complete
bba3241011a6: Pull complete
5e1d0413d05a: Pull complete
6a489170d05e: Pull complete
440b39aff272: Pull complete
582c79113570: Pull complete
Digest: sha256:46aa2ee5d664b275f05d1a963b30fff60fb422b4b594d509765c42db46d48881
Status: Downloaded newer image for postgres:latest
docker.io/library/postgres:latest

Agora, vamos executar o container:

docker run --name meu_postgres -p 5434:5432 -e POSTGRES_PASSWORD=postgres -d postgres

Nessa série de comandos, fizemos o seguinte:

• docker run: criamos e rodamos o container;
• –name: com esse parâmetro, nomeamos esse container com “meu_postgres”;
• -p 5433:5432: mapeamos as portas entre o host (nossa máquina, onde o Docker está rodando) e o container criado (isso foi necessário porque temos o PostgreSQL instalado direto na máquina, e como é utilizada a porta padrão 5432, foi necessário mapear a 5434 no host para evitar conflito);
• -e POSTGRES_PASSWORD=postgres: definimos a senha como “postgres”;
• -d postgres: optamos pela execução do container em segundo plano, para que não ocupe nossa tela com os logs, as saídas e as mensagens da execução do container.

A saída do comando foi a seguinte:

# docker run --name meu_postgres -p 5434:5432 -e POSTGRES_PASSWORD=postgres -d postgres
856f2b7e2b688baa8fa77da223cad27a898359bac81fadf59a5e6d147a7525ed

Agora, podemos conferir o container, que tem o começo do mesmo ID retornado na saída anterior, o nome da imagem postgres, as portas que configuramos e o nome do container meu_postgres:

# docker container ls
CONTAINER ID   IMAGE      COMMAND                  CREATED              STATUS              PORTS                                       NAMES                      
856f2b7e2b68   postgres   "docker-entrypoint.s…"   About a minute ago   Up About a minute   0.0.0.0:5434->5432/tcp, :::5434->5432/tcp   meu_postgres

Para acessar, podemos rodar o comando abaixo, que nos colocará no shell do container :

# docker exec -it meu_postgres sh
#

Assim, podemos acessar normalmente o psql:

# psql -U postgres
psql (16.3 (Debian 16.3-1.pgdg120+1))
Type "help" for help.

postgres=#

Para acesso remoto, é necessário inserir o IP do host e a porta que configuramos, 5434, além de mexer nas configurações de segurança do PostgreSQL (pg_hba.conf).
Para localizar o pg_hba.conf, basta acessar o shell interativo com o comando docker exec it <nome_container> sh, mostrado anteriormente, e navegar até seu diretório, em /var/lib/postgresql/data:

# docker exec -it meu_postgres sh
# cd /var/lib/postgresql/data
# ls -lha
total 136K
drwx------ 19 postgres postgres 4.0K Jul 23 15:31 .
drwxr-xr-x  1 postgres postgres 4.0K Jul 23 07:23 ..
drwx------  5 postgres postgres 4.0K Jul 23 15:31 base
drwx------  2 postgres postgres 4.0K Jul 23 15:33 global
drwx------  2 postgres postgres 4.0K Jul 23 15:31 pg_commit_ts
drwx------  2 postgres postgres 4.0K Jul 23 15:31 pg_dynshmem
-rw-------  1 postgres postgres 5.7K Jul 23 15:31 pg_hba.conf

Pode ser necessário, ainda, instalar um editor de texto para mexer no arquivo, como o vi ou nano.

Vantagens de usar o PostgreSQL dentro de um container

• Isolamento: o container isola completamente o ambiente do PostgreSQL, garantindo que todas as dependências necessárias (bibliotecas, configurações, versões específicas do PostgreSQL) estejam encapsuladas dentro do container, o que evita conflitos com outros softwares instalados no host;
• Portabilidade: a imagem Docker é portátil e pode ser facilmente compartilhada entre diferentes máquinas e ambientes, isso simplifica a distribuição do ambiente de desenvolvimento e a colaboração em equipe;
• Eficiência: os containers Docker são mais leves que as máquinas virtuais tradicionais, o que resulta em uma inicialização mais rápida, menos sobrecarga de recursos e maior eficiência geral;
• Economia de recursos: com containers, você pode otimizar melhor o uso de recursos de hardware, permitindo que múltiplos containers compartilhem recursos do host de forma eficiente. Isso pode reduzir os custos de infraestrutura em comparação com a virtualização tradicional.

Desvantagens de usar o PostgreSQL dentro de um container

• Complexidade de gerenciamento: gerenciar e orquestrar múltiplos containers pode ser trabalhoso, especialmente quando há interdependências entre eles. A configuração e o gerenciamento de volumes, redes e outras propriedades podem exigir um entendimento aprofundado da infraestrutura de containers;
• Desempenho de I/O: pode resultar em latências mais altas no acesso aos discos e menor desempenho em operações de banco de dados, afetando a velocidade das consultas e a eficiência geral, em comparação com a utilização direto com o host;
• Persistência e backup: embora volumes Docker proporcionem persistência, a configuração incorreta pode levar à perda de dados. Realizar backups e garantir a recuperação de dados pode ser mais complexo e exigir práticas cuidadosas.

Gerenciamento de recursos no Docker

Para garantir uma execução eficiente e estável dos containers, é importante entender como o Docker compartilha os recursos do servidor.  Por isso, aqui veremos alguns comandos que permitem esse gerenciamento. É importante saber que esses parâmetros são inseridos apenas na criação do container, portanto, não é possível alterar recursos de um container já existente.

CPU e memória

O Docker compartilha os recursos de CPU e memória entre todos os containers em execução. Podemos gerenciar esses recursos com alguns comandos que serão demonstrados abaixo.

Limitação de CPU: defina limites de CPU para garantir que os containers não consumam mais do que o necessário. É possível fazer isso com o parâmetro --cpus, que indica a quantidade de núcleos que o container poderá usar (1,5 núcleo de CPU no exemplo):

docker run --name <nome_container> -p <porta_host>:<porta_container> -e POSTGRES_PASSWORD=<senha> --cpus="1.5" -d postgres

Limitação de memória: defina limites de memória para evitar que um container consuma toda a memória disponível. É possível fazer isso com o parâmetro -m seguido do tanto de memória que se deseja fornecer para o container:

docker run --name meu_postgres -p 5434:5432 -e POSTGRES_PASSWORD=postgres -m 512m -d postgres

Armazenamento de disco

Containers Docker usam o sistema de arquivos do host, mas cada container tem seu próprio sistema de arquivos isolado, chamado de volumes. É possível definir um volume para persistir seus dados, com o parâmetro -v:

docker run --name <nome_container> -p <porta_host>:<porta_container> -e POSTGRES_PASSWORD=<senha> -v <nome_volume> -d postgres

Os volumes criados por padrão são armazenados em /var/lib/docker/volumes/, na máquina hospedeira, e em /var/lib/postgresql/data no container, que, neste caso, é o diretório padrão do Postgres.

Os dados do volume são persistidos e, mesmo que o container seja parado ou removido, eles permanecem lá e podem ser usados por um novo container, basta utilizar o mesmo nome e endereço do volume em questão. Monitore o espaço em disco para evitar problemas.

Confira alguns comandos úteis para gerenciar seus volumes:

• docker volume ls: lista os volumes;
• docker volume inspect <nome_volume>: inspeciona um volume específico e traz detalhes sobre ele;
• docker volume rm <nome_volume>: remove um volume específico (garante que os dados não são mais necessários).

Monitoramento de uso de recursos

É possível usar ferramentas como docker stats para monitorar o uso de CPU, memória e disco pelos containers em tempo real:

# docker stats
CONTAINER ID   NAME           CPU %     MEM USAGE / LIMIT   MEM %     NET I/O       BLOCK I/O       PIDS
be1838d3bf17   meu_postgres   0.00%     33.89MiB / 961MiB   3.53%     2.38kB / 0B   5.98MB / 48MB   6

Exemplo de container com gerenciamento de recursos

Agora que aprendemos mais sobre nossos recursos, vamos recriar o container com uma melhor distribuição deles. Primeiro, vamos começar parando e removendo o container meu_postgres:

# docker container stop meu_postgres
meu_postgres
# docker rm meu_postgres
meu_postgres

Agora, vamos recriá-lo com todos os parâmetros vistos:

# docker run --name meu_postgres -p 5434:5432 -e POSTGRES_PASSWORD=postgres --cpus="1.0" -m 2g -v meu_volume:/var/lib/postgresql/data -d postgres
51434c5572aafc4ecb9f30d13b8ecb7a6b214cd01018ab86a6b50129d78ecdda

Checando a pasta de volumes, podemos encontrar o container recém-criado:

# cd /var/lib/docker/volumes/
# ls -lha
total 44K
drwx-----x  5 root root   4.0K Jul 23 15:51 .
drwx--x--- 12 root root   4.0K Jul 23 12:30 ..
drwx-----x  3 root root   4.0K Jul 23 12:53 
brw-------  1 root root 254, 1 Jul 23 12:30 backingFsBlockDev
-rw-------  1 root root    32K Jul 23 15:51 metadata.db
drwx-----x  3 root root   4.0K Jul 23 15:51 meu_volume

Conclusão

Ao adotar o PostgreSQL em containers Docker, empresas e desenvolvedores beneficiam-se de uma infraestrutura mais ágil e adaptável, capaz de suportar desde ambientes de desenvolvimento até sistemas complexos de produção. Essa abordagem não só otimiza recursos de hardware, mas também acelera o ciclo de desenvolvimento e melhora a segurança dos dados, promovendo uma arquitetura de software mais robusta e moderna.