Guia de Instalação e Configuração do PostgreSQL a Partir do Código-Fonte no Oracle Linux 9

1. Introdução

Este guia oferece um roteiro detalhado e profissional para a instalação do PostgreSQL diretamente de seu código-fonte em um ambiente Oracle Linux 9. A compilação manual é a escolha preferencial para administradores de sistemas e engenheiros de banco de dados que necessitam de um controle refinado sobre o processo de instalação, permitindo a customização de parâmetros de compilação, a aplicação de patches específicos e a escolha de versões que ainda não estão disponíveis nos repositórios de pacotes padrão. O processo descrito neste documento cobre todas as etapas essenciais, desde a preparação da infraestrutura e a resolução de dependências até a configuração inicial do cluster de banco de dados e otimizações de performance.

Seguir este guia garantirá uma instalação robusta, segura e otimizada do PostgreSQL, alinhada com as melhores práticas de mercado para ambientes de produção e desenvolvimento.

2. Pré-requisitos Essenciais para a Instalação

Antes de iniciar o processo de instalação do PostgreSQL a partir do código-fonte, é imperativo garantir que todos os pré-requisitos listados abaixo sejam rigorosamente atendidos. A falha em cumprir qualquer um desses itens pode resultar em erros durante a compilação, problemas de funcionalidade ou instabilidade do sistema de banco de dados. A preparação adequada do ambiente é a base para uma instalação bem-sucedida e um desempenho otimizado.

• Sistema Operacional: O guia é especificamente elaborado para o Oracle Linux 9. Embora muitas das etapas possam ser aplicáveis a distribuições Linux compatíveis com Red Hat Enterprise Linux 9 (RHEL 9), como CentOS Stream 9 ou Rocky Linux 9, é fortemente recomendado utilizar o Oracle Linux 9 para garantir a compatibilidade total com as instruções e pacotes mencionados. A versão do kernel e as bibliotecas do sistema operacional são cruciais para a compilação do PostgreSQL.

• Acesso e Privilégios: É necessário ter acesso root ou privilégios sudo configurados para o usuário que executará os comandos de instalação. Muitos dos comandos envolvem a modificação de arquivos de sistema, instalação de pacotes e criação de usuários e diretórios com permissões elevadas. Certifique-se de que o usuário tenha a capacidade de executar comandos com sudo sem a necessidade de senha repetida, ou esteja logado como root.

• Conectividade de Rede: Uma conexão ativa e estável com a internet é fundamental. Esta conexão será utilizada para o download de pacotes de dependências do sistema operacional, bem como para o download do código-fonte do PostgreSQL e, opcionalmente, do TimescaleDB. Problemas de conectividade podem interromper o processo de download e compilação.

• Recursos de Hardware (Mínimos Recomendados para Teste):
  • vCPUs: Mínimo de 2 vCPUs. Para ambientes de produção ou cargas de trabalho mais intensas, um número maior de vCPUs é altamente recomendado para garantir o processamento eficiente das operações do banco de dados.
  • Memória RAM: Mínimo de 4GB de RAM. A compilação do código-fonte e a execução do PostgreSQL, especialmente com cargas de trabalho, consomem memória. Para ambientes de produção, 8GB ou mais são aconselháveis, dependendo do tamanho do banco de dados e do número de conexões simultâneas.
• Armazenamento em Disco: É crucial dispor de espaço em disco suficiente para o sistema operacional, os arquivos de instalação do PostgreSQL, os dados do banco de dados (PGDATA) e os logs. Recomenda-se um mínimo de 32GB para os dados do PostgreSQL, além do espaço necessário para o sistema operacional base. Para ambientes de produção, o dimensionamento do armazenamento deve ser baseado na projeção de crescimento dos dados e na estratégia de backup. A utilização de um disco separado para os dados do PostgreSQL é uma prática recomendada para otimização de I/O e gerenciamento de snapshots, conforme detalhado na Seção 4.4.

3. Estrutura de Diretórios Recomendada para Organização e Padronização

Uma estrutura de diretórios bem definida é fundamental para a manutenção, o gerenciamento e a escalabilidade de uma instalação de PostgreSQL. A organização proposta abaixo segue as melhores práticas do mercado, separando os binários da instalação, os arquivos de configuração, os dados do banco de dados e os logs. Esta abordagem facilita a realização de backups, a aplicação de atualizações e a solução de problemas, além de garantir uma maior segurança ao isolar os diferentes componentes do sistema.

A tabela a seguir detalha a estrutura de diretórios sugerida, que será utilizada ao longo deste guia. A utilização da versão majoritária do PostgreSQL no caminho dos diretórios permite a coexistência de múltiplas versões do PostgreSQL no mesmo servidor, uma prática comum em ambientes de desenvolvimento e teste.

Tipo de Arquivo/Diretório	Localização Padrão	Descrição Detalhada
Instalação (PGHOME)	/usr/local/pgsql/<VERSÃO MAJORITÁRIA>	Diretório raiz onde o PostgreSQL será instalado. Contém todos os subdiretórios, como bin, lib, share, etc. A localização em /usr/local é o padrão para software compilado manualmente.
Configuração e Dados	/var/local/pgsql/<VERSÃO MAJORITÁRIA>/	Diretório base para os dados e configurações do cluster. A separação em /var/local é ideal para dados de serviços locais.
Dados (PGDATA)	/var/local/pgsql/<VERSÃO MAJORITÁRIA>/data	O diretório de dados do PostgreSQL, conhecido como PGDATA. Contém todos os arquivos de dados, tabelas, índices e a configuração do cluster (postgresql.conf, pg_hba.conf, etc.).
Binários (PGBIN)	/usr/local/pgsql/<VERSÃO MAJORITÁRIA>/bin	Contém os executáveis do PostgreSQL, como psql, pg_ctl, initdb, pg_dump, etc. Este diretório deve ser adicionado ao PATH do sistema para facilitar o acesso aos comandos.
Logs (PGLOG)	/var/log/pgsql/<VERSÃO MAJORITÁRIA>	Diretório dedicado para armazenar os arquivos de log do PostgreSQL. A centralização dos logs em /var/log segue o padrão do Linux e facilita o monitoramento e a auditoria do sistema.
Write-Ahead Logging (PGWAL)	/var/local/pgsql/<VERSÃO MAJORITÁRIA>/wal	Diretório para os logs de transação (WAL). Separar o WAL em um disco diferente do PGDATA pode melhorar significativamente a performance de escrita em ambientes de alta transação.
Estatísticas Temporárias	/var/local/pgsql/<VERSÃO MAJORITÁRIA>/pg_stat_tmp	Diretório para arquivos de estatísticas temporárias. Montar este diretório em um tmpfs (memória RAM) pode otimizar a coleta de estatísticas, reduzindo a sobrecarga de I/O no disco.

4. Preparação da Infraestrutura do Servidor

A preparação da infraestrutura é uma etapa crítica que estabelece as bases para uma instalação estável e performática do PostgreSQL. Esta seção aborda desde a configuração de máquinas virtuais (com exemplos em Terraform) até o gerenciamento de snapshots, configuração de hostname e a adição de discos dedicados para os dados do banco de dados. A atenção a esses detalhes pode prevenir problemas futuros e otimizar o desempenho do sistema.

4.1. Configuração de Infraestrutura com Terraform (Exemplo Ilustrativo)

Para ambientes que utilizam Infraestrutura como Código (IaC), como o Terraform, é possível provisionar a máquina virtual do PostgreSQL de forma automatizada e replicável. O exemplo abaixo demonstra uma configuração básica para uma VM destinada ao PostgreSQL, especificando recursos de CPU, memória e configurações de rede. Este bloco de código serve como um ponto de partida e deve ser adaptado às necessidades específicas do seu ambiente e provedor de nuvem ou virtualização.

  psql = {
    vcpus  = 2, # Número de vCPUs alocadas para a VM. Ajustar conforme a carga de trabalho esperada.
    memory = "4096", # Memória RAM em MB. 4GB é o mínimo recomendado para testes; para produção, considere 8GB ou mais.
    os     = "oracle9", # Imagem do sistema operacional a ser utilizada, neste caso, Oracle Linux 9.
    networks = [
      { name = "dmz", ipv4 = "10.32.16.18", ipv4_prefix = 24, ipv6 = "fd00:32:16::18", ipv6_prefix = 64, if_name = "ens3", is_default_gateway = true },
    ] # Configurações de rede, incluindo endereços IPv4 e IPv6, e o nome da interface.
  },

4.2. Gerenciamento de Snapshots da Máquina Virtual (Altamente Recomendado)

Antes de realizar qualquer alteração significativa no sistema, como a instalação de um banco de dados, é uma prática de segurança fundamental criar um snapshot da máquina virtual. Um snapshot atua como um ponto de restauração, permitindo que o sistema seja revertido rapidamente para um estado anterior em caso de falhas inesperadas, erros de configuração ou problemas durante a instalação. Isso minimiza o tempo de inatividade e a perda de dados.

Os comandos a seguir demonstram como criar, listar, reverter e excluir snapshots utilizando qemu-img e virsh em um ambiente de virtualização KVM/QEMU. Adapte os comandos conforme seu hypervisor (e.g., VMware, VirtualBox, Proxmox).

# Criando o snapshot: Primeiro, desligue a VM para garantir a consistência do snapshot.
sudo virsh shutdown --domain psql
# Em seguida, crie o snapshot do disco da VM. Substitua 'psql.qcow2' pelo caminho do seu disco.
sudo qemu-img snapshot -c snapshot-psql /datastore/images/psql.qcow2

# Listar snapshots existentes para verificar se o snapshot foi criado com sucesso.
sudo qemu-img snapshot -l /datastore/images/psql.qcow2

# Para reverter a VM para um snapshot específico: Desligue a VM e use o comando 'snapshot -a'.
sudo virsh shutdown psql
sudo qemu-img snapshot -a snapshot-psql /datastore/images/psql.qcow2
# Após a reversão, inicie a VM novamente.
sudo virsh start psql

# Excluir um snapshot: Remova snapshots antigos para liberar espaço em disco e melhorar a performance.
sudo qemu-img snapshot -d snapshot-psql /datastore/images/psql.qcow2

4.3. Configuração do Hostname do Servidor

Definir um hostname claro e descritivo para o servidor é essencial para a identificação na rede, gerenciamento de logs e configuração de serviços. O hostname deve seguir um padrão que facilite a compreensão da função do servidor e sua localização na infraestrutura. Além de definir o hostname, é importante configurar o arquivo /etc/hosts para garantir a resolução de nomes localmente, o que pode ser crucial para a comunicação interna de serviços e para evitar problemas de DNS.

# Define o hostname completo do servidor. Exemplo: psql.lab.test
sudo hostnamectl set-hostname psql.lab.test

Verifique a configuração do hostname para confirmar que as alterações foram aplicadas corretamente:

hostname -f # Exibe o FQDN (Fully Qualified Domain Name)
hostname -d # Exibe o nome de domínio DNS
hostname -s # Exibe o nome curto do host
hostname -I # Exibe todos os endereços IP do host

Adicione as entradas correspondentes no arquivo /etc/hosts. Isso garante que o servidor possa resolver seu próprio nome e o FQDN sem depender de um servidor DNS externo, o que é útil em ambientes de teste ou em caso de problemas de rede.

# Adiciona as entradas IPv4 e IPv6 do hostname no /etc/hosts de forma dinâmica.
echo -e "$(hostname -I | cut -f1 -d' ')\t$(hostname -f)\t$(hostname -s)" | sudo tee -a /etc/hosts
echo -e "$(hostname -I | cut -f2 -d' ')\t$(hostname -f)\t$(hostname -s)" | sudo tee -a /etc/hosts

Alternativamente, você pode adicionar as entradas manualmente, substituindo os IPs e nomes pelos valores do seu ambiente:

# Exemplo de adição manual para IPv4 e IPv6.
echo -e "10.32.16.18\tpsql.lab.test\tpsql" | sudo tee -a /etc/hosts
echo -e "fd00:32:16::18\tpsql.lab.test\tpsql" | sudo tee -a /etc/hosts

4.4. Adição de Disco Dedicado para Dados do PostgreSQL (Recomendado para Performance)

Para otimizar a performance de I/O e facilitar o gerenciamento do armazenamento, é altamente recomendado utilizar um disco separado para os dados do PostgreSQL (/var/local/pgsql/). Esta prática isola as operações de leitura/escrita do banco de dados do sistema operacional, reduzindo a contenção de recursos e permitindo a utilização de sistemas de arquivos otimizados para cargas de trabalho de banco de dados, como o XFS. Além disso, facilita a expansão do armazenamento e a realização de backups e snapshots específicos para os dados.

No Hypervisor (Exemplo com virsh para KVM/QEMU):

Primeiro, crie um novo volume de disco no seu hypervisor. O tamanho do disco deve ser dimensionado de acordo com a projeção de crescimento dos seus dados.

# Criar um volume de disco de 32GB com formato 'raw' no pool de armazenamento 'images'.
sudo virsh vol-create-as --pool images --name psql-vdb.img --capacity 32G --format raw

# Anexar o disco recém-criado à máquina virtual 'psql'. O disco será visível como '/dev/vdb' dentro da VM.
sudo virsh attach-disk psql /datastore/images/psql-vdb.img vdb --targetbus virtio --persistent

# Verificar os discos anexados à VM para confirmar que o novo disco foi adicionado corretamente.
sudo virsh domblklist psql

No Servidor PostgreSQL (Configuração do Disco):

Após anexar o disco no hypervisor, ele precisará ser configurado dentro do sistema operacional da VM. Isso envolve a criação de partições (opcional, mas recomendado para LVM), volumes lógicos, formatação do sistema de arquivos e montagem.

Verifique se o novo disco (/dev/vdb no exemplo) foi reconhecido pelo sistema:

sudo fdisk -l | grep vdb -A3

Defina variáveis de ambiente para facilitar a execução dos comandos. Adapte os valores conforme sua necessidade.

MOUNT_POINT=/var/local/pgsql # Ponto de montagem para os dados do PostgreSQL.
DISK_DEVICE=/dev/vdb # Dispositivo do novo disco.
VG_NAME=vg-pgsql # Nome do Volume Group (Grupo de Volumes) LVM.
LV_NAME=lv-pgsql # Nome do Logical Volume (Volume Lógico) LVM.

Crie o volume físico (PV), grupo de volume (VG) e volume lógico (LV) usando LVM (Logical Volume Manager). O LVM oferece flexibilidade para redimensionar volumes no futuro.

sudo pvcreate ${DISK_DEVICE} # Inicializa o disco como um volume físico LVM.
sudo vgcreate ${VG_NAME} ${DISK_DEVICE} # Cria um grupo de volumes com o PV.
sudo lvcreate -l 100%FREE -n ${LV_NAME} ${VG_NAME} # Cria um volume lógico usando todo o espaço livre do VG.

Formate o volume lógico com um sistema de arquivos adequado para banco de dados. O XFS é amplamente recomendado para PostgreSQL devido ao seu bom desempenho com grandes arquivos e cargas de trabalho intensivas em I/O.

sudo mkfs.xfs /dev/mapper/vg--pgsql-lv--pgsql # Formata o LV com XFS.

Crie o ponto de montagem e configure o /etc/fstab para que o disco seja montado automaticamente na inicialização do sistema. A opção noatime melhora a performance ao evitar atualizações de timestamp de acesso a arquivos.

sudo mkdir ${MOUNT_POINT} # Cria o diretório que servirá como ponto de montagem.

# Adiciona a entrada no /etc/fstab para montagem automática do volume lógico.
echo "/dev/mapper/vg--pgsql-lv--pgsql  ${MOUNT_POINT}    xfs    rw,noatime,attr2,inode64,noquota 0 0" | sudo tee -a /etc/fstab

Recarregue os daemons do systemd e monte o disco. O systemctl daemon-reload é necessário após modificações no fstab para que o systemd reconheça as novas entradas.

sudo systemctl daemon-reload
sudo mount -a # Monta todos os sistemas de arquivos listados em /etc/fstab que ainda não foram montados.

Verifique se o disco foi montado corretamente no ponto de montagem desejado:

df -hT | grep pgsql # Exibe informações sobre sistemas de arquivos montados, filtrando pelo ponto de montagem do PostgreSQL.

5. Instalação de Dependências Essenciais

A compilação do PostgreSQL a partir do código-fonte requer um conjunto específico de ferramentas de desenvolvimento e bibliotecas. Esta seção detalha a instalação dessas dependências no Oracle Linux 9, garantindo que o ambiente esteja preparado para a compilação bem-sucedida do PostgreSQL e de suas extensões, como o TimescaleDB. É crucial instalar todas as dependências antes de prosseguir com a compilação para evitar erros e garantir a funcionalidade completa do banco de dados.

5.1. Definição de Variáveis de Ambiente para Pacotes

Para facilitar a gestão dos pacotes e tornar o processo mais flexível, definiremos variáveis de ambiente que agrupam os pacotes por sua finalidade. Isso permite uma fácil modificação e adaptação do script de instalação.

# PKG_RM: Pacotes de ferramentas de compilação que podem ser removidos após a instalação do PostgreSQL
# (ex: bison, gcc, flex, make, cmake). Estes são necessários apenas durante a fase de compilação.
PKG_RM="bison gcc flex make cmake"

# PKG: Pacotes utilitários que devem ser mantidos no sistema após a instalação
# (ex: bzip2, wget, tar, git). São úteis para diversas tarefas de administração.
PKG="bzip2 wget tar git"

# PKG_RH: Dependências específicas para sistemas baseados em Red Hat/Oracle Linux.
# Inclui bibliotecas de desenvolvimento para readline, OpenSSL, libxml2, OpenLDAP, libuuid, Python 3, ICU e Perl.
# O pacote 'docbook-dtds' e 'docbook-style-xsl' são necessários para a geração da documentação do PostgreSQL.
PKG_RH="readline-devel openssl-devel libxml2-devel openldap-devel \
libuuid-devel python3 python3-devel libicu-devel perl docbook-dtds docbook-style-xsl"

Nota Importante: Os pacotes cmake e git são dependências específicas para a compilação do TimescaleDB. Se você não planeja instalar o TimescaleDB, pode remover cmake e git da variável PKG_RM e PKG, respectivamente, para otimizar o uso de recursos e reduzir a superfície de ataque do sistema. Certifique-se de ajustar as variáveis conforme suas necessidades.

5.2. Instalação dos Pacotes Necessários

Utilize o gerenciador de pacotes dnf para instalar todas as dependências definidas. O comando dnf install -y garante que a instalação ocorra de forma não interativa, aceitando automaticamente todas as dependências. Após a instalação, dnf clean all é utilizado para limpar o cache de pacotes, liberando espaço em disco.

sudo dnf install -y ${PKG} ${PKG_RM} ${PKG_RH} # Instala todos os pacotes definidos nas variáveis.
sudo dnf clean all # Limpa o cache de pacotes do dnf.

5.3. Instalação do Pacote de Idioma Português (Locale)

Para garantir que o PostgreSQL possa ser configurado com o locale pt_BR.UTF-8 (Português do Brasil), é necessário instalar o pacote de idioma correspondente. Isso é fundamental para a correta ordenação de caracteres, formatação de datas e moedas, e mensagens de erro em português.

sudo dnf install -y glibc-langpack-pt # Instala o pacote de idioma português.
sudo dnf clean all # Limpa o cache de pacotes novamente.

Com todas as dependências instaladas, o ambiente está pronto para a compilação e instalação do PostgreSQL a partir do código-fonte.

6. Instalação do PostgreSQL a Partir do Código-Fonte

Esta seção é o cerne do guia, detalhando o processo de compilação e instalação do PostgreSQL diretamente de seu código-fonte. A instalação manual oferece flexibilidade incomparável, permitindo que você adapte o banco de dados às suas necessidades específicas de desempenho e segurança. Cada etapa, desde a definição de variáveis de ambiente até a configuração do serviço Systemd, é crucial para uma instalação bem-sucedida e um sistema robusto.

Nota Importante sobre Versionamento: A escolha da versão do PostgreSQL é um passo crítico. Recomenda-se consultar a Política de Versionamento do PostgreSQL para entender o ciclo de vida de cada versão e escolher uma que atenda aos seus requisitos de suporte e funcionalidades. Para os propósitos deste guia, utilizaremos a versão 17.5 como exemplo, mas você pode adaptar os comandos para a versão desejada.

6.1. Definição de Variáveis de Ambiente Globais

Antes de iniciar a compilação, é fundamental definir um conjunto de variáveis de ambiente. Estas variáveis padronizam os caminhos de instalação, versões e opções de compilação, garantindo consistência e facilitando a manutenção do script. A precisão nesta etapa é vital para evitar erros durante o processo de configure e make.

# PGVERSION: Variável para a versão completa do PostgreSQL (ex: 17.5).
# O usuário será solicitado a inserir esta versão para garantir flexibilidade.
read -p 'Digite o número de versão completo (X.Y) do PostgreSQL a ser baixado (ex: 17.5): ' PGVERSION

# PGMAJOR: Extrai a versão majoritária do PostgreSQL (ex: 17 a partir de 17.5).
# Essencial para a criação de diretórios específicos da versão.
export PGMAJOR=`echo ${PGVERSION} | cut -f1 -d.`

# PGHOME: Diretório de instalação principal do PostgreSQL.
# Todos os binários, bibliotecas e arquivos de suporte serão instalados aqui.
PGHOME="/usr/local/pgsql/${PGMAJOR}"

# PGBIN: Diretório onde os executáveis do PostgreSQL serão armazenados.
# Este caminho será adicionado ao PATH do usuário 'postgres' para acesso fácil aos comandos.
PGBIN="${PGHOME}/bin"

# PGUSERHOME: Diretório home do usuário 'postgres'.
# Utilizado para armazenar arquivos de configuração específicos do usuário e dados do cluster.
PGUSERHOME="/var/local/pgsql"

# PGLOG: Diretório para os arquivos de log do PostgreSQL.
# A centralização dos logs facilita o monitoramento e a depuração.
PGLOG="/var/log/pgsql/${PGMAJOR}"

# PGDATA: Diretório onde os dados do cluster do PostgreSQL serão armazenados.
# Contém todas as tabelas, índices e arquivos de configuração do banco de dados.
PGDATA="${PGUSERHOME}/${PGMAJOR}/data"

# PGWAL: Diretório para os logs de transação (Write-Ahead Log).
# Separar o WAL em um disco diferente pode melhorar a performance de I/O.
PGWAL="${PGUSERHOME}/${PGMAJOR}/wal"

# PG_STAT_TEMP: Diretório para arquivos de estatísticas temporárias.
# Recomenda-se montá-lo em tmpfs para otimização de performance.
PG_STAT_TEMP="${PGUSERHOME}/${PGMAJOR}/pg_stat_tmp"

# PGINCLUDEDIR: Diretório para os arquivos de cabeçalho C do PostgreSQL.
# Necessário para compilação de extensões e aplicações que interagem com o PostgreSQL.
PGINCLUDEDIR="/usr/local/include/pgsql/${PGMAJOR}"

# PYTHON: Caminho completo para o executável Python 3.
# Utilizado na compilação para habilitar o suporte a Python no PostgreSQL.
export PYTHON=`which python3`

# CONFIGURE_OPTS: Opções passadas ao script 'configure' do PostgreSQL.
# Estas opções habilitam funcionalidades específicas e definem caminhos de instalação.
# --prefix: Define o diretório de instalação base.
# --with-python: Habilita o suporte à linguagem PL/Python.
# --with-libxml: Habilita o suporte a XML (libxml2).
# --with-openssl: Habilita o suporte a SSL para conexões seguras.
# --with-ldap: Habilita o suporte a autenticação LDAP.
# --with-uuid=e2fs: Habilita o suporte a UUIDs usando a biblioteca e2fsprogs.
# --includedir: Define o diretório para os arquivos de cabeçalho.
CONFIGURE_OPTS="\
--prefix=${PGHOME} \
--with-python \
--with-libxml \
--with-openssl \
--with-ldap \
--with-uuid=e2fs \
--includedir=${PGINCLUDEDIR}"

# CPPFLAGS: Flags para o pré-processador C/C++.
# -DLINUX_OOM_SCORE_ADJ=0: Protege o processo principal do PostgreSQL de ser encerrado pelo OOM Killer do Linux.
CPPFLAGS="-DLINUX_OOM_SCORE_ADJ=0"

# NJOBS: Número de jobs paralelos para a compilação.
# Definido como o número de núcleos da CPU + 1 para otimizar o tempo de compilação.
NJOBS=$(expr $(nproc) + 1)

# CFLAGS/CXXFLAGS: Flags de otimização para o compilador C/C++.
# -march=native: Otimiza o código para a arquitetura da CPU local.
# -O2: Nível de otimização 2 (bom equilíbrio entre velocidade e tamanho do código).
# -pipe: Usa pipes em vez de arquivos temporários para comunicação entre estágios do compilador, acelerando a compilação.
CFLAGS="-march=native -O2 -pipe"
CXXFLAGS="$CFLAGS"

6.2. Criação de Usuário e Grupo Dedicados ao Sistema PostgreSQL

Para garantir a segurança e a integridade do sistema PostgreSQL, é uma prática essencial criar um usuário e um grupo de sistema dedicados (postgres). Este usuário será o proprietário dos arquivos do banco de dados e o responsável pela execução do processo do servidor PostgreSQL. Ao operar com privilégios mínimos, reduz-se significativamente o risco de vulnerabilidades e acessos não autorizados, seguindo o princípio do menor privilégio.

sudo groupadd -r postgres # Cria um novo grupo de sistema chamado 'postgres'. A opção -r cria um grupo de sistema.
sudo useradd \ # Inicia a criação de um novo usuário de sistema.
-c 'PostgreSQL system user' \ # Define um comentário descritivo para o usuário.
-s /bin/bash \ # Define o shell de login padrão para o usuário como /bin/bash.
-k /etc/skel \ # Copia os arquivos de esqueleto do diretório /etc/skel para o diretório home do novo usuário.
-d ${PGUSERHOME} \ # Define o diretório home do usuário 'postgres' para o caminho especificado em PGUSERHOME (e.g., /var/local/pgsql).
-g postgres \ # Atribui o usuário ao grupo primário 'postgres'.
-m -r postgres # Cria o diretório home do usuário (-m) e o define como um usuário de sistema (-r).

Este comando cria o usuário postgres com um diretório home em /var/local/pgsql (conforme definido por PGUSERHOME), garantindo que ele tenha um ambiente isolado e seguro para operar o banco de dados. O shell /bin/bash é fornecido para permitir o login e a execução de comandos como o usuário postgres para fins de administração e depuração.

6.3. Configuração de Variáveis de Ambiente para o Usuário postgres

Para que o usuário postgres possa interagir corretamente com a instalação do PostgreSQL, é essencial configurar suas variáveis de ambiente. Isso inclui definir o PATH para os binários do PostgreSQL, o LD_LIBRARY_PATH para as bibliotecas e o PGDATA para o diretório de dados. Essas configurações garantem que os comandos do PostgreSQL sejam encontrados e executados corretamente quando o usuário postgres estiver ativo. Criaremos um arquivo .pgvars no diretório home do usuário postgres e o carregaremos em seu perfil de shell.

sudo cat <<EOF | sudo tee ~postgres/.pgvars
# Environment Variables ======================================================
# Este arquivo define as variáveis de ambiente essenciais para o usuário postgres.
# Ele é carregado automaticamente no perfil do usuário para garantir o funcionamento correto do PostgreSQL.

# PGMAJOR: Versão majoritária do PostgreSQL (ex: 17).
PGMAJOR="${PGMAJOR}"

# PGHOME: Diretório de instalação do PostgreSQL.
# Caminho completo onde os arquivos do PostgreSQL foram instalados.
PGHOME="/usr/local/pgsql/\${PGMAJOR}"

# PGBIN: Diretório dos binários do PostgreSQL.
# Contém executáveis como pg_ctl, psql, initdb, etc.
PGBIN="${PGHOME}/bin"

# LD_LIBRARY_PATH: Caminho para as bibliotecas compartilhadas do PostgreSQL.
# Garante que as bibliotecas necessárias sejam encontradas pelo sistema.
export LD_LIBRARY_PATH="\${PGHOME}/lib:\${LD_LIBRARY_PATH}"

# MANPATH: Caminho para as páginas de manual do PostgreSQL.
# Permite acessar a documentação dos comandos do PostgreSQL via comando man.
export MANPATH="\${PGHOME}/man:\${MANPATH}"

# PATH: Adiciona o diretório de binários do PostgreSQL ao PATH do sistema.
# Isso permite executar os comandos do PostgreSQL diretamente, sem especificar o caminho completo.
export PATH="\${PGBIN}:\${PATH}"

# PGDATA: Diretório de dados do PostgreSQL.
# Informa ao PostgreSQL onde encontrar os arquivos de dados do cluster.
export PGDATA="${PGUSERHOME}/\${PGMAJOR}/data"

# Unset variables
unset PGMAJOR PGHOME PGBIN
EOF

Após criar o arquivo .pgvars, é necessário garantir que ele seja carregado sempre que o usuário postgres fizer login. Isso é feito adicionando uma linha ao arquivo .bash_profile ou .profile do usuário postgres.

# Verifica se o arquivo .bash_profile existe; se sim, adiciona a linha lá. Caso contrário, usa .profile.
if [ -f ~postgres/.bash_profile ]; then
sudo echo -e "\nsource ~/.pgvars" | sudo tee -a ~postgres/.bash_profile
else
sudo echo -e "\nsource ~/.pgvars" | sudo tee -a ~postgres/.profile
fi

Esta configuração garante que o ambiente do usuário postgres esteja sempre corretamente preparado para gerenciar e operar o servidor PostgreSQL, facilitando a execução de comandos e scripts relacionados ao banco de dados.

6.4. Criação e Configuração de Diretórios Essenciais

Para o funcionamento adequado do PostgreSQL, é necessário criar diretórios específicos para logs, dados e estatísticas temporárias. Além da criação, é crucial definir as permissões corretas para esses diretórios, garantindo que apenas o usuário postgres tenha acesso de leitura e escrita, o que é uma medida de segurança fundamental para proteger os dados do banco de dados.

sudo mkdir -pm 0700 ${PGLOG} ${PGDATA} ${PGWAL} ${PG_STAT_TEMP}

Explicação dos Comandos:

• sudo mkdir -pm 0700: Este comando cria os diretórios especificados com as permissões corretas e de forma recursiva, se necessário.
  • -p: Cria diretórios pai conforme necessário. Se os diretórios já existirem, nenhuma mensagem de erro é exibida.
  • -m 0700: Define as permissões do diretório como 0700. Isso significa que o proprietário (neste caso, o usuário postgres, que será definido posteriormente) tem permissões totais (leitura, escrita e execução), enquanto nenhum outro usuário ou grupo tem qualquer permissão. Esta é a permissão mínima recomendada para diretórios de dados sensíveis.
• ${PGLOG}: O diretório para os arquivos de log do PostgreSQL (e.g., /var/log/pgsql/17).
• ${PGDATA}: O diretório principal onde o cluster de banco de dados do PostgreSQL armazenará todos os seus dados (e.g., /var/local/pgsql/17/data).
• ${PGWAL}: O diretório para os arquivos de Write-Ahead Log (WAL) do PostgreSQL (e.g., /var/local/pgsql/17/wal).
• ${PG_STAT_TEMP}: O diretório para arquivos de estatísticas temporárias do PostgreSQL (e.g., /var/local/pgsql/17/pg_stat_tmp).

Após a execução deste comando, os diretórios estarão criados e com as permissões iniciais definidas. Posteriormente, as permissões de propriedade serão ajustadas para o usuário postgres.

6.5. Download e Descompactação do Código-Fonte do PostgreSQL

Com o ambiente preparado e as variáveis de ambiente definidas, o próximo passo é baixar o código-fonte do PostgreSQL e descompactá-lo. É crucial obter o código-fonte de uma fonte oficial e confiável para garantir a integridade e a segurança da sua instalação. O site oficial do PostgreSQL (ftp.postgresql.org) é a fonte recomendada para downloads.

wget -c https://ftp.postgresql.org/pub/source/v${PGVERSION}/postgresql-${PGVERSION}.tar.bz2 -P /tmp/ # Baixa o arquivo tar.bz2 do código-fonte do PostgreSQL para o diretório /tmp/.
# -c: Continua o download de um arquivo parcialmente baixado, se aplicável.
# -P /tmp/: Salva o arquivo no diretório /tmp/.

cd /tmp/ && tar xf postgresql-${PGVERSION}.tar.bz2 # Navega para /tmp/ e descompacta o arquivo baixado.
# tar xf: Extrai os arquivos do arquivo tar.bz2.

cd postgresql-${PGVERSION} # Entra no diretório recém-criado que contém o código-fonte descompactado.

Verificação da Integridade (Opcional, mas Recomendado):

Após o download, é uma boa prática verificar a integridade do arquivo baixado utilizando somas de verificação (checksums), como MD5 ou SHA256. Essas somas são geralmente fornecidas no mesmo diretório do download no site oficial do PostgreSQL. Isso garante que o arquivo não foi corrompido durante o download e que é o arquivo original.

Exemplo de verificação (substitua md5sum ou sha256sum pelo método disponível e o valor do checksum pelo oficial):

# Exemplo para MD5
md5sum postgresql-${PGVERSION}.tar.bz2
# Compare a saída com o checksum oficial fornecido no site do PostgreSQL.

# Exemplo para SHA256
sha256sum postgresql-${PGVERSION}.tar.bz2
# Compare a saída com o checksum oficial.

Após a descompactação, você estará no diretório postgresql-${PGVERSION}, que é o local onde a configuração e a compilação serão realizadas.

6.6. Configuração e Compilação do Código-Fonte do PostgreSQL

Com o código-fonte descompactado e as variáveis de ambiente definidas, o próximo passo é configurar e compilar o PostgreSQL. O script configure prepara o ambiente de compilação, verificando as dependências do sistema e gerando os Makefiles necessários. Em seguida, o comando make world inicia o processo de compilação de todos os componentes do PostgreSQL, incluindo o servidor, utilitários e documentação. Este processo pode ser demorado, dependendo dos recursos de hardware do seu servidor.

./configure ${CONFIGURE_OPTS} # Executa o script de configuração com as opções predefinidas.
# Este comando verifica a presença de bibliotecas e ferramentas necessárias e gera os Makefiles.

make -j${NJOBS} world # Inicia a compilação do PostgreSQL.
# -j${NJOBS}: Utiliza múltiplos núcleos da CPU para acelerar a compilação, conforme definido pela variável NJOBS.
# world: Compila todos os componentes do PostgreSQL, incluindo o servidor, clientes, módulos e documentação.

Monitoramento da Compilação:

Durante a execução do comando make world, você verá uma grande quantidade de saída no terminal, indicando o progresso da compilação de cada módulo. É importante monitorar essa saída para identificar quaisquer erros ou avisos que possam surgir. Em caso de erros, o processo de compilação será interrompido, e você precisará investigar a causa (geralmente, uma dependência ausente ou uma configuração incorreta) antes de tentar novamente.

Tempo de Compilação:

O tempo necessário para a compilação varia significativamente com base na quantidade de núcleos de CPU, memória RAM e velocidade do disco do seu servidor. Em máquinas com recursos mínimos, este processo pode levar várias horas. Em servidores mais robustos, pode ser concluído em minutos. Tenha paciência e certifique-se de que o sistema não entre em modo de suspensão ou hibernação durante a compilação.

Ao final da compilação bem-sucedida, você não verá mensagens de erro, e o prompt de comando retornará. Isso indica que os binários e bibliotecas do PostgreSQL foram gerados com sucesso e estão prontos para a instalação.

6.7. Instalação dos Binários e Bibliotecas do PostgreSQL

Após a compilação bem-sucedida do código-fonte, o próximo passo é instalar os binários, bibliotecas, arquivos de cabeçalho e documentação do PostgreSQL nos diretórios de destino definidos. O comando make install-world é responsável por copiar todos os componentes compilados para os locais apropriados no sistema de arquivos, tornando o PostgreSQL disponível para uso.

make install-world # Instala todos os componentes do PostgreSQL compilados.

Detalhes da Instalação:

• Binários: Os executáveis do PostgreSQL (como psql, pg_ctl, initdb, pg_dump, etc.) serão copiados para o diretório ${PGBIN} (e.g., /usr/local/pgsql/17/bin).
• Bibliotecas: As bibliotecas compartilhadas e estáticas necessárias para o funcionamento do PostgreSQL e para a compilação de aplicações que interagem com ele serão instaladas em ${PGHOME}/lib (e.g., /usr/local/pgsql/17/lib).
• Arquivos de Cabeçalho: Os arquivos de cabeçalho C (.h) serão instalados em ${PGINCLUDEDIR} (e.g., /usr/local/include/pgsql/17), essenciais para o desenvolvimento de aplicações e extensões que se comunicam com o PostgreSQL.
• Documentação e Manuais: As páginas de manual e outros arquivos de documentação serão instalados em seus respectivos diretórios dentro de ${PGHOME}.

Verificação Pós-Instalação:

Após a conclusão do comando make install-world, é recomendável verificar se os binários foram instalados corretamente e se estão acessíveis. Você pode fazer isso tentando executar um comando simples do PostgreSQL, como psql --version, embora ele ainda não esteja no PATH do usuário root ou sudo por padrão. O acesso completo será configurado para o usuário postgres na Seção 6.3.

# Exemplo de verificação (pode exigir o caminho completo se o PATH ainda não estiver configurado)
/usr/local/pgsql/${PGMAJOR}/bin/psql --version

Se a instalação for bem-sucedida, o comando retornará a versão do PostgreSQL, confirmando que os arquivos foram copiados para os locais corretos. Com os componentes instalados, o próximo passo é configurar o serviço Systemd para gerenciar o PostgreSQL.

6.8. Configuração do Serviço Systemd para Gerenciamento do PostgreSQL

Para que o PostgreSQL possa ser gerenciado de forma eficiente como um serviço do sistema no Oracle Linux 9, é necessário criar um arquivo de unidade Systemd. Isso permite que o banco de dados seja iniciado, parado, reiniciado e habilitado para iniciar automaticamente durante o boot do sistema, utilizando comandos padrão do systemctl. A configuração do Systemd é crucial para a automação e a estabilidade do serviço.

sudo cat << EOF | sudo tee /lib/systemd/system/postgresql-${PGMAJOR}.service
[Unit]
Description=PostgreSQL database server # Descrição do serviço.
After=syslog.target # Garante que o serviço de log esteja ativo antes do PostgreSQL.
After=network.target # Garante que a rede esteja configurada antes do PostgreSQL.

[Service]
Type=forking # Indica que o processo principal do serviço irá criar um processo filho e sair.
User=postgres # Define o usuário sob o qual o serviço será executado.
Group=postgres # Define o grupo sob o qual o serviço será executado.
Environment=PGDATA="${PGDATA}" # Define a variável de ambiente PGDATA para o serviço.
Environment=LD_LIBRARY_PATH="${PGHOME}/lib:\${LD_LIBRARY_PATH}" # Define o caminho para as bibliotecas do PostgreSQL.
OOMScoreAdjust=-1000 # Ajusta a pontuação OOM (Out-Of-Memory) para proteger o PostgreSQL de ser encerrado em situações de pouca memória.
ExecStart=${PGBIN}/pg_ctl start -D \${PGDATA} -s -w -t 300 # Comando para iniciar o serviço PostgreSQL.
# -D: Especifica o diretório de dados.
# -s: Saída silenciosa.
# -w: Espera o servidor iniciar.
# -t 300: Timeout de 300 segundos para o início.
ExecStop=${PGBIN}/pg_ctl stop -D \${PGDATA} -s -m fast # Comando para parar o serviço PostgreSQL.
# -m fast: Desligamento rápido, terminando todas as conexões ativas.
ExecReload=${PGBIN}/pg_ctl reload -D \${PGDATA} -s # Comando para recarregar a configuração do PostgreSQL.
TimeoutSec=300 # Tempo máximo para o serviço iniciar ou parar.

[Install]
WantedBy=multi-user.target # Define que o serviço deve ser iniciado no runlevel multi-usuário.
EOF

Explicação do Arquivo de Unidade Systemd:

• [Unit] Seção: Contém metadados sobre a unidade, como sua descrição e as dependências. After=syslog.target e After=network.target garantem que o PostgreSQL só tente iniciar após o sistema de log e a rede estarem operacionais.
• [Service] Seção: Define como o serviço será executado. Type=forking é apropriado para o PostgreSQL, pois o processo pg_ctl inicia o servidor e depois sai, deixando o processo do servidor em segundo plano. User e Group especificam que o serviço será executado com os privilégios do usuário postgres, aumentando a segurança. As variáveis Environment garantem que o PostgreSQL encontre seus dados e bibliotecas. OOMScoreAdjust é uma otimização crítica para evitar que o sistema operacional encerre o PostgreSQL em cenários de baixa memória. ExecStart, ExecStop e ExecReload definem os comandos para gerenciar o ciclo de vida do serviço.
• [Install] Seção: Contém informações sobre como a unidade deve ser habilitada. WantedBy=multi-user.target significa que o serviço será iniciado quando o sistema atingir o estado de multi-usuário (o padrão para servidores).

Após a criação deste arquivo, o Systemd precisará ser notificado sobre a nova unidade para que ela possa ser gerenciada. Isso será feito nas próximas etapas, após a configuração das permissões e a inicialização do cluster de banco de dados.

6.9. Ajuste de Permissões de Diretórios

Após a criação dos diretórios e a definição do usuário postgres, é fundamental ajustar as permissões de propriedade para garantir que o usuário postgres seja o proprietário dos diretórios de log e dados do PostgreSQL. Isso é crucial para a segurança e o funcionamento correto do banco de dados, pois o processo do PostgreSQL precisa ter permissão total para ler, escrever e executar arquivos nesses locais. A propriedade incorreta pode levar a erros de inicialização ou problemas de acesso durante a operação do banco de dados.

sudo chown -R postgres: /var/{log,local}/pgsql

Explicação do Comando:

• sudo chown -R postgres:: Este comando altera o proprietário e o grupo de forma recursiva (-R) para postgres para os diretórios especificados.
  • postgres:: Define o usuário postgres como proprietário e o grupo primário postgres como grupo proprietário. O : após o nome do usuário indica que o grupo também deve ser alterado para o grupo primário do usuário.
• /var/{log,local}/pgsql: Esta é uma expansão de brace que se expande para /var/log/pgsql e /var/local/pgsql. Isso garante que tanto o diretório de logs quanto o diretório base para os dados do PostgreSQL tenham suas propriedades ajustadas corretamente.

Ao executar este comando, todos os arquivos e subdiretórios dentro de /var/log/pgsql e /var/local/pgsql passarão a pertencer ao usuário e grupo postgres. Isso é um passo vital para a segurança, pois impede que outros usuários do sistema acessem ou modifiquem os arquivos do banco de dados sem autorização, e garante que o processo do PostgreSQL tenha os privilégios necessários para operar.

6.10. Inicialização do Cluster de Banco de Dados

Após a instalação dos binários e a configuração das permissões, o próximo passo é inicializar o cluster de banco de dados do PostgreSQL. Este processo cria a estrutura de diretórios de dados (PGDATA), os arquivos de configuração iniciais e as tabelas de catálogo do sistema. É crucial definir as configurações de locale e codificação de caracteres nesta etapa, pois elas afetam a forma como o PostgreSQL manipula strings, ordenações e formatações de dados. Para ambientes brasileiros, é altamente recomendado utilizar o locale pt_BR.UTF-8.

su - postgres -c "\ # Alterna para o usuário postgres para executar o comando initdb com os privilégios corretos.
initdb \ # Comando para inicializar um novo cluster de banco de dados PostgreSQL.
-D ${PGDATA} \ # Especifica o diretório onde o cluster de banco de dados será criado.
-E utf8 \ # Define a codificação de caracteres padrão para o cluster como UTF-8.
-U postgres \ # Define o nome do superusuário do banco de dados como 'postgres'.
-k \ # Habilita checksums nas páginas de dados para detecção de corrupção de dados.
--locale=pt_BR.utf8 \ # Define o locale geral para o cluster, afetando a formatação de datas, moedas, etc.
--lc-collate=pt_BR.UTF-8 \ # Define a regra de ordenação de strings para o locale pt_BR.UTF-8.
--lc-monetary=pt_BR.UTF-8 \ # Define a formatação de valores monetários para o locale pt_BR.UTF-8.
--lc-messages=pt_BR.UTF-8 \ # Define o idioma das mensagens do sistema para o locale pt_BR.UTF-8.
-T portuguese \ # Define o dicionário de texto completo padrão para o idioma português.
-X ${PGWAL}" # Especifica o diretório para os arquivos de Write-Ahead Log (WAL), separando-os do PGDATA.

Saída Esperada da Inicialização:

Após a execução bem-sucedida do comando initdb, você verá uma saída no terminal similar à seguinte. Esta saída confirma as configurações de locale, a ativação de checksums e a criação dos diretórios e arquivos iniciais do cluster. A mensagem de aviso sobre trust authentication é normal e será tratada na próxima seção para aumentar a segurança.

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 this locale configuration:
  locale provider:   libc
  LC_COLLATE:  pt_BR.UTF-8
  LC_CTYPE:    pt_BR.utf8
  LC_MESSAGES: pt_BR.UTF-8
  LC_MONETARY: pt_BR.UTF-8
  LC_NUMERIC:  pt_BR.utf8
  LC_TIME:     pt_BR.utf8
The default text search configuration will be set to "portuguese".

Data page checksums are enabled.

fixing permissions on existing directory /var/local/pgsql/17/data ... ok
fixing permissions on existing directory /var/local/pgsql/17/wal ... ok
creating subdirectories ... ok
selecting dynamic shared memory implementation ... posix
selecting default "max_connections" ... 100
selecting default "shared_buffers" ... 128MB
selecting default time zone ... America/Sao_Paulo
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:

    pg_ctl -D /var/local/pgsql/17/data -l logfile start

Esta saída indica que o cluster foi inicializado com sucesso. O aviso sobre a autenticação trust é uma medida de segurança padrão do initdb e será corrigido na próxima etapa para uma configuração mais segura.

6.11. Configuração de Autenticação Segura no pg_hba.conf

Por padrão, o initdb configura o PostgreSQL para usar o método de autenticação trust para conexões locais. Isso significa que qualquer usuário local pode se conectar ao banco de dados sem a necessidade de uma senha, o que representa um risco de segurança significativo, mesmo em ambientes de desenvolvimento. Para mitigar esse risco, é crucial alterar o método de autenticação para um mais seguro, como scram-sha-256, que exige uma senha criptografada para a autenticação. Esta alteração é feita no arquivo pg_hba.conf (Host-Based Authentication).

sudo -u postgres sed -i 's/trust/scram-sha-256/' ${PGDATA}/pg_hba.conf

Explicação do Comando:

• sudo -u postgres: Executa o comando sed como o usuário postgres. Isso é necessário porque o arquivo pg_hba.conf é de propriedade do usuário postgres e não deve ser modificado por outros usuários.
• sed -i 's/trust/scram-sha-256/': Este comando utiliza o sed (Stream Editor) para editar o arquivo pg_hba.conf no local (-i).
  • 's/trust/scram-sha-256/': Esta é a expressão de substituição do sed. Ela procura pela string trust e a substitui por scram-sha-256. Como o initdb cria uma configuração padrão com trust, este comando irá alterar todas as ocorrências para o método mais seguro.
• ${PGDATA}/pg_hba.conf: O caminho completo para o arquivo de configuração de autenticação do PostgreSQL.

Por que scram-sha-256?

scram-sha-256 (Salted Challenge Response Authentication Mechanism) é um método de autenticação moderno e seguro que oferece proteção contra ataques de replay e não transmite a senha em texto claro pela rede. É o método de autenticação recomendado para a maioria das instalações do PostgreSQL, oferecendo um equilíbrio ideal entre segurança e compatibilidade.

Após esta alteração, todas as conexões locais e de rede exigirão uma senha válida para o usuário postgres e outros usuários do banco de dados, fortalecendo significativamente a segurança da sua instalação.

6.12. Ajustes Essenciais no postgresql.conf para Operação e Performance

O arquivo postgresql.conf é o principal arquivo de configuração do PostgreSQL, controlando o comportamento do servidor, parâmetros de desempenho, segurança e logging. Após a inicialização do cluster, é necessário realizar alguns ajustes cruciais para permitir conexões remotas, configurar o sistema de logs e otimizar o uso de diretórios temporários. Estas modificações são fundamentais para que o PostgreSQL opere de forma eficiente e acessível em um ambiente de rede.

sed "s:\(^#listen_addresses.*\):\1\nlisten_addresses = '*':g" \
-i ${PGDATA}/postgresql.conf

sed "s:\(^#log_destination.*\):\1\nlog_destination = 'stderr':g" \
-i ${PGDATA}/postgresql.conf

sed "s:\(^#logging_collector.*\):\1\nlogging_collector = on:g" \
-i ${PGDATA}/postgresql.conf

sed "s:\(^#\)\(log_filename.*\):\1\2\n\2:g" \
-i ${PGDATA}/postgresql.conf

sed "s:\(^#log_directory.*\):\1\nlog_directory = '${PGLOG}':g" \
-i ${PGDATA}/postgresql.conf

sed \
"s:\(^#stats_temp_directory.*\):\1\nstats_temp_directory = '${PG_STAT_TEMP}':g" \
-i ${PGDATA}/postgresql.conf

Explicação das Modificações:

• listen_addresses = '*': Esta configuração é vital para permitir que o PostgreSQL aceite conexões de clientes remotos. Por padrão, o PostgreSQL escuta apenas na interface de loopback (localhost), o que impede conexões de outras máquinas. Definir como '*' faz com que ele escute em todas as interfaces de rede disponíveis. Para ambientes de produção, é mais seguro especificar endereços IP específicos ou sub-redes permitidas.

• log_destination = 'stderr': Direciona a saída de log para o erro padrão. Quando o PostgreSQL é executado como um serviço Systemd, o stderr é capturado pelo journal do Systemd, permitindo que os logs sejam visualizados com journalctl e centralizados com outras mensagens do sistema.

• logging_collector = on: Ativa o processo de coletor de logs do PostgreSQL. Este processo é responsável por capturar as mensagens de log do servidor e escrevê-las em arquivos no diretório especificado por log_directory.

• log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log': Define o padrão de nome para os arquivos de log. O uso de variáveis de tempo (%Y, %m, %d, %H, %M, %S) garante que novos arquivos de log sejam criados periodicamente, facilitando a rotação e o gerenciamento dos logs.

• log_directory = '${PGLOG}': Especifica o diretório onde os arquivos de log serão armazenados. Conforme definido nas variáveis de ambiente, este será /var/log/pgsql/<VERSÃO MAJORITÁRIA>, seguindo as melhores práticas de organização de logs do sistema.

• stats_temp_directory = '${PG_STAT_TEMP}': Define o diretório para arquivos de estatísticas temporárias. A coleta de estatísticas é crucial para o otimizador de consultas do PostgreSQL, e armazenar esses arquivos em um sistema de arquivos em memória (tmpfs) pode reduzir a latência de I/O e melhorar o desempenho geral do banco de dados, especialmente em cargas de trabalho intensivas em consultas.

6.13. Otimização de Performance: Montagem de pg_stat_tmp em Memória RAM (tmpfs)

Para maximizar o desempenho do PostgreSQL, especialmente em ambientes com alta carga de trabalho, é altamente recomendável montar o diretório pg_stat_tmp em um sistema de arquivos temporário baseado em memória RAM (tmpfs). Este diretório armazena dados temporários de estatísticas de execução de consultas, que são frequentemente acessados e modificados pelo servidor PostgreSQL. Ao movê-lo para a RAM, reduz-se drasticamente a latência de I/O associada à escrita e leitura em disco, resultando em uma coleta de estatísticas mais rápida e um otimizador de consultas mais eficiente.

echo -e "\ntmpfs ${PG_STAT_TEMP} tmpfs size=32M,uid=postgres,gid=postgres 0 0" | sudo tee -a /etc/fstab

Explicação da Configuração:

• tmpfs: Especifica o tipo de sistema de arquivos como tmpfs, que é um sistema de arquivos virtual baseado em memória RAM.
• ${PG_STAT_TEMP}: O ponto de montagem para este sistema de arquivos, que é o diretório pg_stat_tmp do PostgreSQL (e.g., /var/local/pgsql/17/pg_stat_tmp).
• tmpfs: Repete o tipo de sistema de arquivos.
• size=32M: Define o tamanho máximo que este sistema de arquivos temporário pode ocupar na memória RAM. O valor de 32M (32 Megabytes) é um ponto de partida razoável para a maioria dos ambientes, mas pode ser ajustado conforme a necessidade e a carga de trabalho do seu banco de dados. Um tamanho muito pequeno pode levar a erros de esgotamento de espaço, enquanto um tamanho muito grande pode consumir memória desnecessariamente.
• uid=postgres,gid=postgres: Define o proprietário do sistema de arquivos montado como o usuário postgres e o grupo postgres. Isso garante que o processo do PostgreSQL tenha as permissões corretas para acessar e manipular os arquivos neste diretório.
• 0 0: As duas últimas opções são para dump e pass (verificação do sistema de arquivos), respectivamente. 0 0 significa que o sistema de arquivos não será incluído em backups automáticos (dump) e não será verificado pelo fsck durante a inicialização.

Esta linha será adicionada ao arquivo /etc/fstab, garantindo que o pg_stat_tmp seja montado em RAM automaticamente a cada inicialização do sistema. Essa otimização é uma das maneiras mais eficazes de melhorar a responsividade do PostgreSQL em cenários de alta demanda por estatísticas.

6.14. Recarregamento de Daemons do Sistema e Montagem de Sistemas de Arquivos

Após realizar alterações no arquivo /etc/fstab (para a montagem do tmpfs para pg_stat_tmp) e criar o novo arquivo de serviço Systemd para o PostgreSQL, é fundamental informar ao sistema sobre essas modificações. O Systemd precisa recarregar seus daemons para reconhecer as novas configurações, e os novos sistemas de arquivos precisam ser montados para que as alterações entrem em vigor sem a necessidade de reiniciar o servidor.

sudo systemctl daemon-reload # Recarrega a configuração do Systemd.
# Este comando faz com que o Systemd releia todos os arquivos de unidade (.service, .mount, etc.)
# e atualize sua configuração interna para refletir as mudanças.

sudo mount -a # Monta todos os sistemas de arquivos listados em /etc/fstab que ainda não foram montados.
# Isso garante que o diretório pg_stat_tmp seja montado em tmpfs conforme configurado na etapa anterior.

Importância desses Comandos:

• systemctl daemon-reload: Sem este comando, o Systemd não reconheceria o novo serviço postgresql-${PGMAJOR}.service que foi criado, nem as alterações no fstab relacionadas ao tmpfs. É um passo obrigatório após qualquer modificação nos arquivos de configuração de unidade do Systemd.
• mount -a: Este comando é crucial para ativar a montagem do tmpfs para pg_stat_tmp imediatamente. Se houver outras entradas no /etc/fstab que ainda não foram montadas, elas também serão processadas. Isso evita a necessidade de reiniciar o servidor para que a otimização de performance do pg_stat_tmp seja aplicada.

Com esses comandos executados, o ambiente do sistema estará atualizado e pronto para que o serviço do PostgreSQL seja habilitado e iniciado.

6.15. Habilitar e Iniciar o Serviço PostgreSQL

Com todas as configurações e otimizações aplicadas, o último passo é habilitar e iniciar o serviço do PostgreSQL. Habilitar o serviço garante que ele será iniciado automaticamente a cada boot do sistema, enquanto iniciar o serviço o coloca em funcionamento imediatamente. Isso é feito utilizando os comandos padrão do systemctl.

sudo systemctl enable --now postgresql-${PGMAJOR}

Explicação do Comando:

• sudo systemctl enable: Este comando cria os links simbólicos necessários para que o serviço postgresql-${PGMAJOR}.service seja iniciado automaticamente durante o processo de boot do sistema.
• --now: Esta opção, quando usada em conjunto com enable, faz com que o serviço seja iniciado imediatamente após ser habilitado. Isso evita a necessidade de executar um comando systemctl start separado.
• postgresql-${PGMAJOR}: O nome da unidade de serviço Systemd que foi criada na Seção 6.8.

Verificação do Status do Serviço:

Após habilitar e iniciar o serviço, é crucial verificar seu status para confirmar que o PostgreSQL está em execução e operando sem erros. O comando systemctl status fornecerá informações detalhadas sobre o estado do serviço, incluindo se ele está ativo, o PID do processo principal e as últimas linhas de log.

systemctl status postgresql-${PGMAJOR}

Saída Esperada:

Uma saída bem-sucedida indicará que o serviço está active (running), similar a:

● postgresql-17.service - PostgreSQL database server
     Loaded: loaded (/lib/systemd/system/postgresql-17.service; enabled; vendor preset: disabled)
     Active: active (running) since Fri 2025-08-08 10:00:00 UTC; 1min ago
    Process: 12345 ExecStart=/usr/local/pgsql/17/bin/pg_ctl start -D /var/local/pgsql/17/data -s -w -t 300 (code=exited, status=0/SUCCESS)
   Main PID: 12347 (postgres)
      Tasks: 8 (limit: 4915)
     Memory: 25.0M
        CPU: 1.234s
     CGroup: /system.slice/postgresql-17.service
             ├─12347 /usr/local/pgsql/17/bin/postgres -D /var/local/pgsql/17/data
             ├─12348 postgres: checkpointer
             ├─12349 postgres: background writer
             ├─12350 postgres: walwriter
             ├─12351 postgres: autovacuum launcher
             ├─12352 postgres: stats collector
             ├─12353 postgres: logical replication launcher
             └─12354 postgres: walreceiver

Aug 08 10:00:00 psql.lab.test systemd[1]: Starting PostgreSQL database server...
Aug 08 10:00:01 psql.lab.test systemd[1]: Started PostgreSQL database server.

Se o serviço não iniciar ou apresentar erros, verifique os logs do Systemd usando journalctl -u postgresql-${PGMAJOR} para obter mais detalhes sobre a causa do problema. Com o serviço ativo e em execução, o PostgreSQL está agora operacional e pronto para receber conexões.

7. Instalação da Extensão TimescaleDB (Opcional)

O TimescaleDB é uma extensão de código aberto para PostgreSQL que transforma o banco de dados em uma poderosa solução de série temporal. Ele permite que o PostgreSQL lide eficientemente com grandes volumes de dados de séries temporais, oferecendo funcionalidades avançadas para ingestão, consulta e análise desses dados. Se sua aplicação lida com dados de sensores, logs, métricas financeiras ou qualquer outro tipo de dado temporal, a instalação do TimescaleDB pode ser extremamente benéfica.

Considerações Importantes:

• Compatibilidade: Antes de iniciar a instalação, é crucial consultar a documentação oficial do TimescaleDB para verificar a compatibilidade com a versão específica do PostgreSQL que você instalou. A compatibilidade entre versões é vital para evitar problemas de funcionamento.
• Política de Versionamento: O TimescaleDB segue a Política de Versionamento do PostgreSQL. Isso significa que, quando uma versão do PostgreSQL atinge seu End-of-Life (EOL), o suporte para essa versão no TimescaleDB também é descontinuado. Mantenha-se atualizado com as políticas de suporte de ambas as tecnologias.

7.1. Download e Compilação do TimescaleDB

Para instalar o TimescaleDB, você precisará clonar o repositório oficial do GitHub e compilá-lo a partir do código-fonte. Certifique-se de fazer o checkout da versão do TimescaleDB que é compatível com a sua versão do PostgreSQL.

git clone https://github.com/timescale/timescaledb.git # Clona o repositório oficial do TimescaleDB.
cd timescaledb/ # Navega para o diretório do repositório clonado.
git checkout 2.21.2 # Altere para a versão desejada do TimescaleDB. Consulte a documentação para compatibilidade.
./bootstrap -DPG_CONFIG=${PGHOME}/bin/pg_config # Executa o script de bootstrap para configurar a compilação.
# -DPG_CONFIG: Especifica o caminho para o executável pg_config do seu PostgreSQL, garantindo que o TimescaleDB seja compilado contra a sua instalação.
cd build && make # Navega para o diretório de build e inicia a compilação do TimescaleDB.
make install # Instala os binários e bibliotecas compiladas do TimescaleDB no seu ambiente PostgreSQL.

Observações sobre a Compilação:

• O processo de compilação do TimescaleDB pode levar alguns minutos, dependendo dos recursos do seu servidor.
• Certifique-se de que todas as dependências de compilação (como cmake e git, mencionadas na Seção 5.1) estejam instaladas antes de iniciar este processo.
• Em caso de erros durante a compilação, verifique as mensagens de erro e consulte a documentação do TimescaleDB para solução de problemas.

7.2. Configuração do PostgreSQL para TimescaleDB

Após a compilação e instalação do TimescaleDB, é necessário configurar o PostgreSQL para carregar a extensão. Isso é feito adicionando timescaledb à lista de bibliotecas pré-carregadas (shared_preload_libraries) no arquivo postgresql.conf. O pré-carregamento garante que a extensão esteja disponível para todos os bancos de dados e sessões desde o início do servidor.

sed "s:\(^#shared_preload_libraries.*\):\1\nshared_preload_libraries = 'timescaledb':g" -i ${PGDATA}/postgresql.conf

Explicação da Modificação:

• shared_preload_libraries: Esta configuração instrui o PostgreSQL a carregar as bibliotecas especificadas no momento da inicialização do servidor. Isso é necessário para extensões que modificam o comportamento fundamental do PostgreSQL, como o TimescaleDB.

Após esta alteração, você precisará reiniciar o serviço do PostgreSQL para que a nova configuração seja aplicada. Um simples systemctl restart postgresql-${PGMAJOR} será suficiente.

7.3. Verificação da Instalação do TimescaleDB

Para confirmar que o TimescaleDB foi instalado e configurado corretamente, você pode se conectar ao PostgreSQL e verificar se a extensão está disponível e pode ser criada em um banco de dados. Primeiramente, alterne para o usuário postgres e acesse o console psql.

su - postgres # Alterna para o usuário postgres.
psql # Conecta-se ao console psql.

Dentro do console psql, execute os seguintes comandos:

-- Verifica se a extensão TimescaleDB está disponível.
SELECT * FROM pg_available_extensions WHERE name = 'timescaledb';

-- Cria a extensão TimescaleDB em um banco de dados (ex: no banco de dados 'postgres').
-- Você deve criar a extensão em cada banco de dados onde deseja usar as funcionalidades do TimescaleDB.
CREATE EXTENSION IF NOT EXISTS timescaledb CASCADE;

-- Verifica a versão da extensão TimescaleDB instalada.
SELECT extversion FROM pg_extension WHERE extname = 'timescaledb';

-- Verifica se o TimescaleDB está ativo e funcionando corretamente.
SELECT * FROM timescaledb_information.timescaledb_config;

\q # Sai do console psql.

Se os comandos acima forem executados sem erros e retornarem as informações esperadas, significa que o TimescaleDB foi instalado e configurado com sucesso em seu ambiente PostgreSQL. Você está agora pronto para começar a criar hypertables e aproveitar os recursos de série temporal do TimescaleDB.