Como implantar o PostgreSQL em um contêiner do Docker

Introdução

O Docker modernizou a maneira como criamos e implantamos o aplicativo. Ele nos permite criar contêineres leves, portáteis e autossuficientes que podem executar qualquer aplicativo facilmente.

Este blog pretende explicar como usar o Docker para executar o banco de dados PostgreSQL. Não cobre a instalação ou configuração do docker. Consulte as instruções de instalação do docker aqui. Algumas informações adicionais podem ser encontradas em nosso blog anterior sobre MySQL e Docker.

Antes de entrar em detalhes, vamos rever algumas terminologias.

Dockerfile
Contém o conjunto de instruções/comandos para instalar ou configurar o aplicativo/software.
Imagem do Docker
A imagem do Docker é construída a partir de uma série de camadas que representam instruções do Dockerfile. A imagem do Docker é usada como modelo para criar um contêiner.
Vinculação de contêineres e rede definida pelo usuário
O Docker usou a ponte como mecanismo de rede padrão e usou --links para vincular os contêineres entre si. Para acessar o container PostgreSQL a partir de um container de aplicação, deve-se vincular ambos os containers no momento da criação. Aqui neste artigo, estamos usando redes definidas pelo usuário, pois o recurso de link será descontinuado em breve.
Persistência de dados no Docker
Por padrão, os dados dentro de um contêiner são efêmeros. Sempre que o contêiner for reiniciado, os dados serão perdidos. Os volumes são o mecanismo preferencial para manter os dados gerados e usados por um contêiner do Docker. Aqui, estamos montando um diretório de host dentro do contêiner onde todos os dados são armazenados.

Vamos começar a construir nossa imagem PostgreSQL e usá-la para rodar um container.

Dockerfile PostgreSQL

# example Dockerfile for https://docs.docker.com/engine/examples/postgresql_service/


FROM ubuntu:14.04

# Add the PostgreSQL PGP key to verify their Debian packages.
# It should be the same key as https://www.postgresql.org/media/keys/ACCC4CF8.asc
RUN apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys B97B0AFCAA1A47F044F244A07FCC7D46ACCC4CF8

# Add PostgreSQL's repository. It contains the most recent stable release
#     of PostgreSQL, ``9.3``.
RUN echo "deb http://apt.postgresql.org/pub/repos/apt/ precise-pgdg main" > /etc/apt/sources.list.d/pgdg.list

# Install ``python-software-properties``, ``software-properties-common`` and PostgreSQL 9.3
#  There are some warnings (in red) that show up during the build. You can hide
#  them by prefixing each apt-get statement with DEBIAN_FRONTEND=noninteractive
RUN apt-get update && apt-get install -y python-software-properties software-properties-common postgresql-9.3 postgresql-client-9.3 postgresql-contrib-9.3

# Note: The official Debian and Ubuntu images automatically ``apt-get clean``
# after each ``apt-get``

# Run the rest of the commands as the ``postgres`` user created by the ``postgres-9.3`` package when it was ``apt-get installed``
USER postgres

# Create a PostgreSQL role named ``postgresondocker`` with ``postgresondocker`` as the password and
# then create a database `postgresondocker` owned by the ``postgresondocker`` role.
# Note: here we use ``&&\`` to run commands one after the other - the ``\``
#       allows the RUN command to span multiple lines.
RUN    /etc/init.d/postgresql start &&\
    psql --command "CREATE USER postgresondocker WITH SUPERUSER PASSWORD 'postgresondocker';" &&\
    createdb -O postgresondocker postgresondocker

# Adjust PostgreSQL configuration so that remote connections to the
# database are possible.
RUN echo "host all  all    0.0.0.0/0  md5" >> /etc/postgresql/9.3/main/pg_hba.conf

# And add ``listen_addresses`` to ``/etc/postgresql/9.3/main/postgresql.conf``
RUN echo "listen_addresses='*'" >> /etc/postgresql/9.3/main/postgresql.conf

# Expose the PostgreSQL port
EXPOSE 5432

# Add VOLUMEs to allow backup of config, logs and databases
VOLUME  ["/etc/postgresql", "/var/log/postgresql", "/var/lib/postgresql"]

# Set the default command to run when starting the container
CMD ["/usr/lib/postgresql/9.3/bin/postgres", "-D", "/var/lib/postgresql/9.3/main", "-c", "config_file=/etc/postgresql/9.3/main/postgresql.conf"]

Se você observar o Dockerfile de perto, ele consiste em comandos que são usados para instalar o PostgreSQL e realizar algumas alterações de configuração no sistema operacional Ubuntu.

Criando imagem PostgreSQL

Podemos construir uma imagem PostgreSQL a partir do Dockerfile usando o comando docker build.

# sudo docker build -t postgresondocker:9.3 .

Aqui, podemos especificar a tag (-t) para a imagem como nome e versão. O ponto (.) no final especifica o diretório atual e usa o Dockerfile presente no diretório atual. O nome do arquivo Docker deve ser “Dockerfile”. Se você quiser especificar um nome personalizado para seu arquivo docker, deverá usar -f no comando docker build.

# sudo docker build -t postgresondocker:9.3 -f <your_docker_file_name>

Saída:(opcional, use a janela de texto da barra de rolagem, se possível)

Sending build context to Docker daemon  4.096kB
Step 1/11 : FROM ubuntu:14.04
14.04: Pulling from library/ubuntu
324d088ce065: Pull complete 
2ab951b6c615: Pull complete 
9b01635313e2: Pull complete 
04510b914a6c: Pull complete 
83ab617df7b4: Pull complete 
Digest: sha256:b8855dc848e2622653ab557d1ce2f4c34218a9380cceaa51ced85c5f3c8eb201
Status: Downloaded newer image for ubuntu:14.04
 ---> 8cef1fa16c77
Step 2/11 : RUN apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys B97B0AFCAA1A47F044F244A07FCC7D46ACCC4CF8
 ---> Running in ba933d07e226
.
.
.
fixing permissions on existing directory /var/lib/postgresql/9.3/main ... ok
creating subdirectories ... ok
selecting default max_connections ... 100
selecting default shared_buffers ... 128MB
creating configuration files ... ok
creating template1 database in /var/lib/postgresql/9.3/main/base/1 ... ok
initializing pg_authid ... ok
initializing dependencies ... ok
creating system views ... ok
loading system objects' descriptions ... ok
creating collations ... ok
creating conversions ... ok
creating dictionaries ... ok
setting privileges on built-in objects ... ok
creating information schema ... ok
loading PL/pgSQL server-side language ... ok
vacuuming database template1 ... ok
copying template1 to template0 ... ok
copying template1 to postgres ... ok
syncing data to disk ... ok

Success. You can now start the database server using:

    /usr/lib/postgresql/9.3/bin/postgres -D /var/lib/postgresql/9.3/main
or
    /usr/lib/postgresql/9.3/bin/pg_ctl -D /var/lib/postgresql/9.3/main -l logfile start

Ver Cluster Port Status Owner    Data directory               Log file
9.3 main    5432 down   postgres /var/lib/postgresql/9.3/main /var/log/postgresql/postgresql-9.3-main.log
update-alternatives: using /usr/share/postgresql/9.3/man/man1/postmaster.1.gz to provide /usr/share/man/man1/postmaster.1.gz (postmaster.1.gz) in auto mode
invoke-rc.d: policy-rc.d denied execution of start.
Setting up postgresql-contrib-9.3 (9.3.22-0ubuntu0.14.04) ...
Setting up python-software-properties (0.92.37.8) ...
Setting up python3-software-properties (0.92.37.8) ...
Setting up software-properties-common (0.92.37.8) ...
Processing triggers for libc-bin (2.19-0ubuntu6.14) ...
Processing triggers for ca-certificates (20170717~14.04.1) ...
Updating certificates in /etc/ssl/certs... 148 added, 0 removed; done.
Running hooks in /etc/ca-certificates/update.d....done.
Processing triggers for sgml-base (1.26+nmu4ubuntu1) ...
Removing intermediate container fce692f180bf
 ---> 9690b681044b
Step 5/11 : USER postgres
 ---> Running in ff8864c1147d
Removing intermediate container ff8864c1147d
 ---> 1f669efeadfa
Step 6/11 : RUN    /etc/init.d/postgresql start &&    psql --command "CREATE USER postgresondocker WITH SUPERUSER PASSWORD 'postgresondocker';" &&    createdb -O postgresondocker postgresondocker
 ---> Running in 79042024b5e8
 * Starting PostgreSQL 9.3 database server
   ...done.
CREATE ROLE
Removing intermediate container 79042024b5e8
 ---> 70c43a9dd5ab
Step 7/11 : RUN echo "host all  all    0.0.0.0/0  md5" >> /etc/postgresql/9.3/main/pg_hba.conf
 ---> Running in c4d03857cdb9
Removing intermediate container c4d03857cdb9
 ---> 0cc2ed249aab
Step 8/11 : RUN echo "listen_addresses='*'" >> /etc/postgresql/9.3/main/postgresql.conf
 ---> Running in fde0f721c846
Removing intermediate container fde0f721c846
 ---> 78263aef9a56
Step 9/11 : EXPOSE 5432
 ---> Running in a765f854a274
Removing intermediate container a765f854a274
 ---> d205f9208162
Step 10/11 : VOLUME  ["/etc/postgresql", "/var/log/postgresql", "/var/lib/postgresql"]
 ---> Running in ae0b9f30f3d0
Removing intermediate container ae0b9f30f3d0
 ---> 0de941f8687c
Step 11/11 : CMD ["/usr/lib/postgresql/9.3/bin/postgres", "-D", "/var/lib/postgresql/9.3/main", "-c", "config_file=/etc/postgresql/9.3/main/postgresql.conf"]
 ---> Running in 976d283ea64c
Removing intermediate container 976d283ea64c
 ---> 253ee676278f
Successfully built 253ee676278f
Successfully tagged postgresondocker:9.3

Criação de rede de contêiner

Use o comando abaixo para criar uma rede definida pelo usuário com driver de ponte.

# sudo docker network create --driver bridge postgres-network

Confirmar a criação da rede

# sudo docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
a553e5727617        bridge              bridge              local
0c6e40305851        host                host                local
4cca2679d3c0        none                null                local
83b23e0af641        postgres-network    bridge              local

Criação de contêiner

Precisamos usar o comando “docker run” para criar um contêiner a partir da imagem do docker. Estamos executando o container postgres no modo daemonize com a ajuda da opção -d.

# sudo docker run --name postgresondocker --network postgres-network -d postgresondocker:9.3

Use o comando abaixo para confirmar a criação do contêiner.

# sudo docker container ls 
CONTAINER ID        IMAGE                  COMMAND                  CREATED              STATUS              PORTS               NAMES
06a5125f5e11        postgresondocker:9.3   "/usr/lib/postgresql…"   About a minute ago   Up About a minute   5432/tcp            postgresondocker

Nós não especificamos nenhuma porta para expor, então ela irá expor a porta 5432 padrão do postgres para uso interno. O PostgreSQL está disponível apenas de dentro da rede Docker, não poderemos acessar este contêiner Postgres em uma porta de host.

Veremos como acessar o contêiner Postgres na porta do host em uma seção posterior deste artigo.

Conectando-se ao contêiner PostgreSQL dentro da rede Docker

Vamos tentar conectar ao container Postgres a partir de outro container dentro da mesma rede Docker que criamos anteriormente.Aqui, usamos o cliente psql para conectar ao Postgres. Usamos o nome do container Postgres como hostname, usuário e senha presentes no arquivo Docker.

# docker run -it --rm --network postgres-network postgresondocker:9.3 psql -h postgresondocker -U postgresondocker --password
Password for user postgresondocker: 
psql (9.3.22)
SSL connection (cipher: DHE-RSA-AES256-GCM-SHA384, bits: 256)
Type "help" for help.

postgresondocker=#

A opção --rm no comando run removerá o container assim que encerrarmos o processo psql.

# sudo docker container ls 
CONTAINER ID        IMAGE                  COMMAND                  CREATED              STATUS              PORTS               NAMES
2fd91685d1ea        postgresondocker:9.3   "psql -h postgresond…"   29 seconds ago       Up 30 seconds       5432/tcp            brave_spence
06a5125f5e11        postgresondocker:9.3   "/usr/lib/postgresql…"   About a minute ago   Up About a minute   5432/tcp            postgresondocker

Persistência de dados

Os contêineres do Docker são efêmeros por natureza, ou seja, os dados que são usados ou gerados pelo contêiner não são armazenados em nenhum lugar implicitamente. Perdemos os dados sempre que o contêiner é reiniciado ou excluído. O Docker fornece volumes nos quais podemos armazenar os dados persistentes. É um recurso útil pelo qual podemos provisionar outro contêiner usando o mesmo volume ou dados em caso de desastre.

Vamos criar um volume de dados e confirmar sua criação.

# sudo docker volume create pgdata
pgdata

# sudo docker volume ls
DRIVER              VOLUME NAME
local                   pgdata

Agora temos que usar esse volume de dados enquanto executamos o container Postgres. Certifique-se de excluir o contêiner postgres mais antigo que está sendo executado sem volumes.

# sudo docker container rm postgresondocker -f 
postgresondocker

# sudo docker run --name postgresondocker --network postgres-network -v pgdata:/var/lib/postgresql/9.3/main -d postgresondocker:9.3

Executamos o contêiner Postgres com um volume de dados anexado a ele.

Crie uma nova tabela no Postgres para verificar a persistência dos dados.

# docker run -it --rm --network postgres-network postgresondocker:9.3 psql -h postgresondocker -U postgresondocker --password
Password for user postgresondocker: 
psql (9.3.22)
SSL connection (cipher: DHE-RSA-AES256-GCM-SHA384, bits: 256)
Type "help" for help.

postgresondocker=# \dt
No relations found.
postgresondocker=# create table test(id int);
CREATE TABLE
postgresondocker=# \dt 
            List of relations
 Schema | Name | Type  |      Owner       
--------+------+-------+------------------
 public | test | table | postgresondocker
(1 row)

Exclua o contêiner Postgres.

# sudo docker container rm postgresondocker -f 
postgresondocker

Crie um novo container Postgres e confirme se a tabela de teste está presente ou não.

# sudo docker run --name postgresondocker --network postgres-network -v pgdata:/var/lib/postgresql/9.3/main -d postgresondocker:9.3


# docker run -it --rm --network postgres-network postgresondocker:9.3 psql -h postgresondocker -U postgresondocker --password
Password for user postgresondocker: 
psql (9.3.22)
SSL connection (cipher: DHE-RSA-AES256-GCM-SHA384, bits: 256)
Type "help" for help.

postgresondocker=# \dt
            List of relations
 Schema | Name | Type  |      Owner       
--------+------+-------+------------------
 public | test | table | postgresondocker
(1 row)

Baixe o whitepaper hoje PostgreSQL Management &Automation with ClusterControlSaiba o que você precisa saber para implantar, monitorar, gerenciar e dimensionar o PostgreSQLBaixe o whitepaper

Expor o serviço PostgreSQL ao host

Você deve ter notado que não expusemos nenhuma porta do contêiner PostgreSQL anteriormente. Isso significa que o PostgreSQL só é acessível aos contêineres que estão na rede postgres que criamos anteriormente.

Para usar o serviço PostgreSQL, precisamos expor a porta do contêiner usando a opção --port. Aqui, expusemos a porta do contêiner Postgres 5432 na porta 5432 do host.

# sudo docker run --name postgresondocker --network postgres-network -v pgdata:/var/lib/postgresql/9.3/main -p 5432:5432 -d postgresondocker:9.3
# sudo docker container ls
CONTAINER ID        IMAGE                  COMMAND                  CREATED             STATUS              PORTS                    NAMES
997580c86188        postgresondocker:9.3   "/usr/lib/postgresql…"   8 seconds ago       Up 10 seconds       0.0.0.0:5432->5432/tcp   postgresondocker

Agora você pode conectar o PostgreSQL diretamente no localhost.

# psql -h localhost -U postgresondocker --password
Password for user postgresondocker: 
psql (9.3.22)
SSL connection (cipher: DHE-RSA-AES256-GCM-SHA384, bits: 256)
Type "help" for help.

postgresondocker=#

Exclusão de contêiner

Para excluir o contêiner, precisamos parar o contêiner em execução primeiro e, em seguida, excluir o contêiner usando o comando rm.

# sudo docker container stop postgresondocker 

# sudo docker container rm postgresondocker
postgresondocker

Use a opção -f (--force) para excluir diretamente o contêiner em execução.

# sudo docker container rm postgresondocker -f
postgresondocker

Espero que agora você tenha seu próprio ambiente local dockerizado para o PostgreSQL.

Observação: Este artigo fornece uma visão geral sobre como podemos usar o PostgreSQL no docker para ambiente de desenvolvimento/POC. A execução do PostgreSQL no ambiente de produção pode exigir alterações adicionais nas configurações do PostgreSQL ou do docker.

Conclusão

Existe uma maneira simples de executar o banco de dados PostgreSQL dentro de um contêiner do Docker. O Docker encapsula efetivamente a implantação, a configuração e determinados procedimentos de administração. O Docker é uma boa opção para implantar o PostgreSQL com o mínimo de esforço. Tudo o que você precisa fazer é iniciar um contêiner Docker pré-construído e você terá o banco de dados PostgreSQL pronto para o seu serviço.

Referências

Instalação do Docker:https://docs.docker.com/install
Volumes:https://docs.docker.com/storage/volumes
Redes definidas pelo usuário:https://docs.docker.com/network/
Arquivo do Docker Postgres:https://docs.docker.com/engine/examples/postgresql_service
MySQL no Docker:Noções básicas:https://severalnines.com/blog/mysql-docker-containers-understanding-basics