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 upgradeAgora, 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-configDownload 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.gzCompilaçã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:
./configureEsse 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 installFeita 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 installSe 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/dataDestino 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/dataCriação do cluster
Para criarmos nosso cluster do banco de dados, o primeiro passo é mudar para o usuário que acabamos de criar:
su - postgresDepois, 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 startSeguindo 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 startedEntã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 testPara 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 launcherInicializaçã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.serviceDebian shell: inicialização no boot habilitada
# systemctl is-enabled postgresql.service
enabledConclusã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.
