Como instalar o PostgreSQL no Linux (Debian) compilado

Introdução

Agora que já vimos como instalar o PostgreSQL no Windows, chegou a hora de elevar o nível da brincadeira com a instalação no Linux. Elevar porque, apesar de esse sistema operacional ser menos utilizado em comparação ao outro e também intimidar mais as pessoas sem o uso da interface gráfica, existem estudos que demonstram melhor performance do PostgreSQL em sistemas de base Linux (estamos trabalhando em testes e em breve teremos artigos sobre isso!), muito por ele ter nascido para rodar em ambientes Unix e derivados, conforme citado no artigo anterior. 

Quando o assunto é instalar o PostgreSQL, considerar a opção de compilar o código-fonte abre portas para uma experiência de banco de dados única. Essa abordagem permite uma personalização total, ajustando o PostgreSQL para necessidades mais específicas. Antes, essa era a única opção de instalação do PostgreSQL disponível, depois vieram os pacotes nativos das distribuições (que não permitem a você escolher qual versão vai instalar) e, finalmente, o repositório oficial da comunidade PostgreSQL, conhecida como PGDG (PostgreSQL Global Development Group). Assim, instalar o PostgreSQL via compilação tornou-se um processo um tanto obsoleto, e vamos entender se você quiser pular para o próximo capítulo. Sério! Sem dramas aqui. No entanto, se você quiser aprender um pouco mais sobre o processo e se tornar mais íntimo com o que acontece por baixo do capô, recomendamos que você siga esse tutorial pelo menos uma vez na vida. 

Pode acontecer também de um dia você se deparar com um Unix, como um Solaris, HP-UX, AIX, FreeBSD ou outra distribuição Linux não suportada pelo PGDG, e realmente precisar compilar o PostgreSQL na mão. Honestamente, esperamos que você não precise. Existe ainda a lenda de que o PostgreSQL compilado é mais rápido que o PostgreSQL instalado por pacotes. Será? Vamos realizar alguns testes mais a frente e veremos o que vamos descobrir.

Agora, vamos mergulhar juntos nesta jornada e ver como essa escolha pode transformar sua experiência com o PostgreSQL no Linux Debian. Usaremos como referência o guia de instalação a partir do código-fonte do site oficial PostgreSQL.

Neste artigo, veremos:

• Prerrequisitos
• Download do código-fonte
• Compilação
• Destino de arquivos
• Criação de usuário
• Criação do cluster
• Serviço
• Processos em execução
• Inicialização automática

Prerrequisitos

Como boa prática, o primeiro passo de qualquer instalação é atualizar a lista de pacotes disponíveis nos repositórios configurados no sistema, como também atualizar esses pacotes para suas versões mais recentes. 

Aqui estamos utilizando acesso de superusuário/root, caso esteja com outro acesso basta acrescentar “sudo” na frente de todos os comandos. Faremos as atualizações citadas com os dois comandos abaixo:

apt-get update

apt-get upgrade

Agora, para começar, será necessário instalar algumas dependências essenciais para que o processo de compilação ocorra com sucesso. É possível ter mais informações sobre cada uma delas na página oficial do site do PostgreSQL. Pode ser necessário confirmar a instalação de algumas dependências com “y”.

Abaixo está o comando necessário referente às respectivas dependências: Make, GCC, ICU, GNU Readline, Zlib e Pkg-config:

apt-get install make build-essential libicu-dev libreadline-dev zlib1g-dev pkg-config

Download do código-fonte

Vamos pegar o código-fonte do PostgreSQL direto da página oficial de download, onde são disponibilizadas duas opções de arquivo:

• postgresql-version.tar.gz: usa algoritmo de compressão gzip, sendo mais eficiente em termos de velocidade e menos em relação ao espaço em disco;
• postgresql-version.tar.bz2: usa algoritmo de compressão bzip2, sendo mais eficiente em compressão e economia de espaço em disco e menos em velocidade.

Optamos por baixar a última versão disponível na data de criação deste artigo, sendo ela a versão 16.2, no arquivo tipo tar.gz:

wget https://ftp.postgresql.org/pub/source/v16.2/postgresql-16.2.tar.gz

# wget https://ftp.postgresql.org/pub/source/v16.2/postgresql-16.2.tar.gz
--2024-03-06 18:21:51--  https://ftp.postgresql.org/pub/source/v16.2/postgresql-16.2.tar.gz
Resolving ftp.postgresql.org (ftp.postgresql.org)... 72.32.157.246, 87.238.57.227, 147.75.85.69, ...
Connecting to ftp.postgresql.org (ftp.postgresql.org)|72.32.157.246|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 32558575 (31M) [application/octet-stream]
Saving to: ‘postgresql-16.2.tar.gz’
postgresql-16.2.ta 100%[===============>]  31.05M  38.1MB/s    in 0.8s
2024-03-06 18:21:52 (38.1 MB/s) - ‘postgresql-16.2.tar.gz’ saved [32558575/32558575]

Após feito o download, é hora de descompactar o arquivo baixado: 

tar xvf postgresql-16.2.tar.gz

Compilação

Agora que temos nosso código em mãos, precisamos fazer a compilação dele. Para isso, você deve entrar na pasta gerada após a descompactação (postgresql-<versão>) e rodar um comando para configuração do ambiente antes da compilação:

./configure

Esse comando nos permite ainda utilizar algumas opções para personalização da instalação, como definição de diretório, porta e inclusão de extensões e ferramentas. Mais informações podem ser encontradas nesta página do site PostgreSQL.

Agora, é preciso rodar dois comandos para realizar a compilação, sendo o primeiro para compilar e reconstruir partes fundamentais do sistema operacional, e o segundo, para instalar os binários resultantes e outros arquivos no sistema (essa etapa pode demorar um pouquinho):

make world
make install

Feita a compilação, você deve entrar no diretório contrib, dentro da pasta na qual já está (~/postgresql-16.2/contrib) e rodar novamente comandos do utilitário make. Isso serve para garantir a disponibilização das extensões do PostgreSQL, que podem vir a ser úteis no futuro (elas não ficarão disponíveis automaticamente nos seus bancos de dados, mas você terá a possibilidade de utilizá-las depois através do comando CREATE EXTENSION):

make all
make install

Se houver algum erro ao executar algum dos comandos com make, antes de tentar novamente é importante rodar make clean para remover os arquivos gerados na tentativa de compilação e iniciar uma nova do zero.Feita a compilação, diferente da instalação via pacotes, é necessário criar manualmente o diretório onde serão armazenados os dados das bases criadas (comando sem saída):

mkdir -p /var/lib/pgsql/data

Destino de arquivos

Após a instalação do PostgreSQL, temos uma estrutura de pastas para armazenamento dos arquivos e dados:

• Principal diretório, local onde são armazenados os executáveis, arquivos de cabeçalho, bibliotecas e outros:

/usr/local/pgsql/

• Diretório dos executáveis do PostgreSQL:

/usr/local/pgsql/bin/

• Diretório que contém os arquivos de cabeçalho necessários para compilar programas que interagem com PostgreSQL:

/usr/local/pgsql/include/

• Diretório de bibliotecas compartilhadas:

/usr/local/pgsql/lib/

• Diretório criado manualmente, sendo responsável por armazenar dados de tabelas, logs etc.:

/var/lib/pgsql/data/

Criação de usuário

Além da criação manual da pasta data, também é necessário criar o usuário postgres (que mais uma vez, na instalação via pacotes, é criado automaticamente), sendo importante para segurança e isolamento de serviços:

adduser postgres

# adduser postgres
Adding user `postgres' ...
Adding new group `postgres' (1001) ...
Adding new user `postgres' (1001) with group `postgres (1001)' ...
Creating home directory `/home/postgres' ...
Copying files from `/etc/skel' ...
New password:
Retype new password:
passwd: password updated successfully
Changing the user information for postgres
Enter the new value, or press ENTER for the default
        Full Name []:
        Room Number []:
        Work Phone []:
        Home Phone []:
        Other []:
Is the information correct? [Y/n] Y
Adding new user `postgres' to supplemental / extra groups `users' ...
Adding user `postgres' to group `users' ...

E então, para garantir as permissões necessárias do diretório principal do banco ao usuário postgres, rodaremos este comando (sem saída):

chmod 700 /var/lib/pgsql/data
chown postgres: /var/lib/pgsql/data

Criação do cluster

Para criarmos nosso cluster do banco de dados, o primeiro passo é mudar para o usuário que acabamos de criar:

su - postgres

Depois, rodar este comando para inicializar e criar o cluster:

/usr/local/pgsql/bin/initdb -D /var/lib/pgsql/data

$ /usr/local/pgsql/bin/initdb -D /var/lib/pgsql/data
The files belonging to this database system will be owned by user "postgres".
This user must also own the server process.

The database cluster will be initialized with locale "C.UTF-8".
The default database encoding has accordingly been set to "UTF8".
The default text search configuration will be set to "english".

Data page checksums are disabled.

fixing permissions on existing directory /var/lib/pgsql/data ... ok
creating subdirectories ... ok
selecting dynamic shared memory implementation ... posix
selecting default max_connections ... 100
selecting default shared_buffers ... 128MB
selecting default time zone ... Etc/UTC
creating configuration files ... ok
running bootstrap script ... ok
performing post-bootstrap initialization ... ok
syncing data to disk ... ok

initdb: warning: enabling "trust" authentication for local connections
initdb: hint: You can change this by editing pg_hba.conf or using the option -A, or --auth-local and --auth-host, the next time you run initdb.

Success. You can now start the database server using:

    /usr/local/pgsql/bin/pg_ctl -D /var/lib/pgsql/data -l logfile start

Seguindo a própria saída anterior, vamos iniciar o servidor de banco de dados:

/usr/local/pgsql/bin/pg_ctl -D /var/lib/pgsql/data -l logfile start

$ /usr/local/pgsql/bin/pg_ctl -D /var/lib/pgsql/data -l logfile start
waiting for server to start.... done
server started

Então, podemos criar nosso primeiro banco de dados, neste caso, conforme tutorial oficial, nomeado de ‘test’ (comando sem saída):

/usr/local/pgsql/bin/createdb test

Para acessar o psql e administrar o banco, podemos usar:

/usr/local/pgsql/bin/psql test

$ /usr/local/pgsql/bin/psql test
psql (16.2)
Type "help" for help.
test=#

Serviços e processos

Serviços

Para gerenciar o serviço do PostgreSQL, podemos contar com os comandos pg_ctl, que devem ser rodados pelo usuário postgres:

• Iniciar o serviço:

/usr/local/pgsql/bin/pg_ctl -D /var/lib/pgsql/data start

• Parar o serviço:

/usr/local/pgsql/bin/pg_ctl -D /var/lib/pgsql/data stop

• Reiniciar o serviço:

/usr/local/pgsql/bin/pg_ctl -D /var/lib/pgsql/data restart

• Recarregar o serviço (não impacta a disponibilidade do serviço):

/usr/local/pgsql/bin/pg_ctl -D /var/lib/pgsql/data reload

• Conferir o status do serviço:

/usr/local/pgsql/bin/pg_ctl -D /var/lib/pgsql/data status

• Promover um servidor standby a master:

/usr/local/pgsql/bin/pg_ctl -D /var/lib/pgsql/data promote

Além disso, também podemos contar com o executável postgres para iniciar o servidor no modo interativo, ou seja, permanecendo a execução e exibindo logs enquanto estiver ativo (é possível interromper com “Ctrl + C”, parando o serviço):

/usr/local/pgsql/bin/postgres -D /var/lib/pgsql/data/

Outra opção de recarregar as configurações do serviço é pelo envio do sinal HUP ao processo do PostgreSQL, necessitando da informação do ID do processo (é possível ter acesso pelo comando de checar status exibido anteriormente):

kill -HUP <ID_processo>

Processos

Para checar os processos do PostgreSQL, podemos usar:

ps aux | grep postgres

# ps aux | grep postgres
root       26930  0.0  0.3   6104  3352 pts/0    S    14:23   0:00 su - postgres
postgres   26931  0.0  0.4   5536  4784 pts/0    S+   14:23   0:00 -bash
postgres   27044  0.0  2.0 197300 20572 ?        Ss   14:47   0:00 /usr/local/pgsql/bin/postgres -D /var/lib/pgsql/novo_cluster -p 5434
postgres   27045  0.0  1.8 197572 18180 ?        Ss   14:47   0:00 postgres: checkpointer
postgres   27046  0.0  0.4 197432  4432 ?        Ss   14:47   0:00 postgres: background writer
postgres   27048  0.0  0.8 197432  8256 ?        Ss   14:47   0:00 postgres: walwriter
postgres   27049  0.0  0.5 198908  5540 ?        Ss   14:47   0:00 postgres: autovacuum launcher
postgres   27050  0.0  0.5 198888  5556 ?        Ss   14:47   0:00 postgres: logical replication launcher
postgres   27430  0.0  2.0 197300 20576 ?        Ss   15:29   0:00 /usr/local/pgsql/bin/postgres -D /var/lib/pgsql/data
postgres   27431  0.0  0.4 197440  4400 ?        Ss   15:29   0:00 postgres: checkpointer
postgres   27432  0.0  0.6 197432  5948 ?        Ss   15:29   0:00 postgres: background writer
postgres   27434  0.0  0.9 197432  9636 ?        Ss   15:29   0:00 postgres: walwriter
postgres   27435  0.0  0.7 198908  7372 ?        Ss   15:29   0:00 postgres: autovacuum launcher
postgres   27436  0.0  0.7 198888  6956 ?        Ss   15:29   0:00 postgres: logical replication launcher

Inicialização automática

Habilitar a inicialização automática do nosso servidor PostgreSQL com uma instalação via código compilado pede alguns passos a mais em comparação com a instalação por pacotes (que necessita de apenas um comando), como a criação de um arquivo de unidade, seguido do carregamento de configurações do systemctl para finalizarmos com a habilitação no boot. Então, para começar:

• Vamos criar um arquivo de texto (que vai ser nosso arquivo de unidade do systemd):

nano /etc/systemd/system/postgresql.service

• Deve-se adicionar nesse arquivo o seguinte conteúdo (para sair basta apertar “Ctrl + X” e “y” para salvar a inserção de texto, seguido de Enter para confirmar tudo):

Conteúdo do arquivo de unidade

[Unit]
Description=PostgreSQL Database Server
Documentation=https://www.postgresql.org/docs/current/static/
[Service]
ExecStart=/usr/local/pgsql/bin/pg_ctl -D /var/lib/pgsql/data start
ExecStop=/usr/local/pgsql/bin/pg_ctl -D /var/lib/pgsql/data stop
ExecReload=/usr/local/pgsql/bin/pg_ctl -D /var/lib/pgsql/data reload
TimeoutSec=300
User=postgres
Group=postgres
[Install]
WantedBy=default.target

• Agora que temos o arquivo criado, precisamos recarregar as configurações do systemd para que ele seja reconhecido:

systemctl daemon-reload

• E, por fim, basta habilitar o serviço postgresql para iniciar no boot:
  systemctl enable postgresql.service

Pronto! Seu servidor PostgreSQL será iniciado automaticamente ao ligar a máquina. Caso queira conferir, basta utilizar o comando abaixo, que verifica se um serviço está habilitado para iniciar no boot:

systemctl is-enabled postgresql.service

Debian shell: inicialização no boot habilitada

# systemctl is-enabled postgresql.service
enabled

Conclusão

Por mais que essa maneira de instalar o PostgreSQL demore um pouco mais e tenha alguns passos manuais que são automatizados na instalação via pacotes, ao escolher instalar através da compilação do código-fonte, você começa a entender melhor como as coisas funcionam internamente. Este conhecimento é fundamental para aqueles que desejam se aprofundar no conhecimento sobre os mecanismos internos do PostgreSQL. É só a ponta do iceberg, mas é um bom começo. Veremos nos próximos artigos, formas mais simples e eficientes de instalar e manter o PostgreSQL em servidores Linux.