Como Instalar PostgreSQL no Ubuntu

Introdução

PostgreSQL, frequentemente referido simplesmente como Postgres, é um poderoso sistema de banco de dados objeto-relacional de código aberto. Com mais de 30 anos de desenvolvimento ativo, o PostgreSQL conquistou uma forte reputação por sua confiabilidade, robustez de recursos e desempenho.

Instalar o PostgreSQL no Ubuntu é uma escolha popular para muitos desenvolvedores e administradores de banco de dados devido a várias razões convincentes:

Compatibilidade: O Ubuntu, sendo uma das distribuições Linux mais amplamente utilizadas, oferece excelente compatibilidade com o PostgreSQL.
Desempenho: A combinação da eficiência do Ubuntu e da arquitetura robusta do PostgreSQL resulta em operações de banco de dados de alto desempenho.
Segurança: Tanto o Ubuntu quanto o PostgreSQL são conhecidos por seus fortes recursos de segurança, tornando essa combinação ideal para lidar com dados sensíveis.
Suporte da Comunidade: Tanto o Ubuntu quanto o PostgreSQL têm grandes comunidades ativas, garantindo que a ajuda esteja prontamente disponível quando necessário.
Gratuito e de Código Aberto: Ambos os sistemas são gratuitos para uso e de código aberto, permitindo uma implantação econômica e a capacidade de personalizar, se necessário.

Este guia irá orientá-lo pelo processo de instalação do PostgreSQL em seu sistema Ubuntu, desde a preparação até o uso básico. Se você está configurando um ambiente de desenvolvimento ou preparando um servidor de produção, este tutorial fornecerá os passos necessários para colocar o PostgreSQL em funcionamento no Ubuntu.

Pré-requisitos

Antes de começarmos o processo de instalação, é importante garantir que seu sistema atenda aos requisitos necessários e que você tenha as permissões apropriadas. Vamos passar pelos pré-requisitos:

Requisitos do Sistema Ubuntu

Versão do Ubuntu: Este guia é aplicável para Ubuntu 20.04 LTS (Focal Fossa) e versões mais recentes. No entanto, é sempre recomendado usar a versão mais recente de Suporte de Longo Prazo (LTS) para estabilidade.
Recursos do Sistema: O PostgreSQL pode rodar em sistemas com recursos limitados, mas para desempenho ideal, considere as seguintes recomendações:
- CPU: processador de 1 GHz ou mais rápido
- RAM: pelo menos 1 GB (4 GB ou mais recomendado para uso em produção)
- Armazenamento: 512 MB para a instalação do PostgreSQL, além de espaço adicional para seus bancos de dados
Conexão com a Internet: Você precisará de uma conexão ativa com a internet para baixar o PostgreSQL e suas dependências.

Permissões do Usuário

Para instalar o PostgreSQL, você precisará de privilégios sudo em seu sistema Ubuntu. Isso significa que você deve estar logado como usuário root ou ter uma conta que possa usar sudo para executar comandos com privilégios de root.

Para verificar se seu usuário tem privilégios sudo, você pode executar o seguinte comando no terminal:

sudo -v

Se você for solicitado a inserir uma senha e o comando for executado sem erros, seu usuário tem privilégios sudo.

Acesso ao Terminal

Você deve estar confortável usando a interface de linha de comando (CLI), pois usaremos o terminal para a maior parte do processo de instalação e configuração.

Faça Backup dos Seus Dados

Se você estiver instalando o PostgreSQL em um sistema que já possui dados importantes, é sempre uma boa prática fazer backup dos seus dados antes de prosseguir com qualquer instalação de software importante.

Atualizando o Sistema

Antes de instalar o PostgreSQL, é crucial garantir que seu sistema Ubuntu esteja atualizado. Esta etapa é importante por várias razões:

Segurança: As atualizações frequentemente incluem patches de segurança importantes.
Estabilidade: As atualizações mais recentes podem corrigir bugs e melhorar a estabilidade do sistema.
Compatibilidade: Ter os pacotes mais recentes pode evitar potenciais problemas de compatibilidade durante a instalação do PostgreSQL.

Passos para Atualizar o Ubuntu

Para atualizar seu sistema Ubuntu, siga estes passos:

Abra seu terminal. Você pode fazer isso pressionando Ctrl + Alt + T ou procurando por "Terminal" no painel do Ubuntu.
Primeiro, atualize as listas de pacotes para atualizações e novas instalações de pacotes. Execute o seguinte comando:
```
sudo apt update
```
Este comando atualiza a lista de pacotes disponíveis e suas versões, mas não instala ou atualiza nenhum pacote.
Após a atualização ser concluída, atualize os pacotes instalados para suas versões mais recentes:
```
sudo apt upgrade
```
Este comando mostrará uma lista de pacotes que estão prestes a ser atualizados. Pressione 'Y' e depois 'Enter' para confirmar e prosseguir com a atualização.
Opcionalmente, você pode executar uma atualização completa do sistema, que também lidará de forma inteligente com a mudança de dependências com novas versões de pacotes:
```
sudo apt full-upgrade
```
Tenha cuidado com este comando, pois ele pode remover alguns pacotes, se necessário, para atualizar outros.
Após o processo de atualização ser concluído, é uma boa ideia reiniciar seu sistema para garantir que todas as atualizações sejam aplicadas corretamente:
```
sudo reboot
```

Verificando a Atualização

Após o seu sistema reiniciar, você pode verificar se a atualização foi bem-sucedida verificando a versão do Ubuntu:

lsb_release -a

Este comando exibirá informações sobre sua distribuição Ubuntu, incluindo o número da versão.

Adicionando o Repositório do PostgreSQL

Embora o PostgreSQL esteja disponível nos repositórios padrão do Ubuntu, muitas vezes não é a versão mais recente. Para garantir que instalamos a versão estável mais recente do PostgreSQL, adicionaremos o repositório oficial do PostgreSQL ao nosso sistema.

Por que Adicionar o Repositório Oficial do PostgreSQL?

Últimas Versões: O repositório oficial fornece as versões mais atualizadas do PostgreSQL.
Atualizações Oportunas: Patches de segurança e correções de bugs estão disponíveis mais cedo através do repositório oficial.
Consistência: Usar o repositório oficial garante compatibilidade entre o PostgreSQL e suas extensões.

Passos para Adicionar o Repositório do PostgreSQL

Siga estes passos para adicionar o repositório do PostgreSQL ao seu sistema Ubuntu:

Primeiro, precisamos adicionar a chave de assinatura do PostgreSQL. Esta chave é usada para verificar se os pacotes que estamos prestes a instalar são autênticos. Execute o seguinte comando:
```
sudo apt-get install wget ca-certificates
wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
```
Em seguida, precisamos adicionar o repositório do PostgreSQL à lista de fontes do nosso sistema. Crie um novo arquivo chamado pgdg.list no diretório /etc/apt/sources.list.d/:
```
sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
```
Este comando cria um novo arquivo com as informações do repositório. A parte $(lsb_release -cs) detecta automaticamente sua versão do Ubuntu e insere o codinome correto.
Após adicionar o repositório, atualize as listas de pacotes novamente para incluir o repositório do PostgreSQL recém-adicionado:
```
sudo apt update
```

Verificando a Adição do Repositório

Para verificar se o repositório do PostgreSQL foi adicionado com sucesso, você pode verificar o conteúdo do arquivo pgdg.list:

cat /etc/apt/sources.list.d/pgdg.list

Você deve ver uma linha semelhante a:

deb http://apt.postgresql.org/pub/repos/apt focal-pgdg main

(Nota: "focal" pode ser substituído pelo codinome da sua versão do Ubuntu)

Instalando o PostgreSQL

Agora que adicionamos o repositório do PostgreSQL e atualizamos nosso sistema, estamos prontos para instalar o PostgreSQL. Este processo é simples e pode ser concluído com alguns comandos.

Comando para Instalar o PostgreSQL

Para instalar o PostgreSQL, usaremos o gerenciador de pacotes apt. Aqui está o comando para instalar a versão mais recente do PostgreSQL junto com uma extensão comumente usada:

sudo apt install postgresql postgresql-contrib

Vamos detalhar este comando:

postgresql: Este é o pacote principal do PostgreSQL.
postgresql-contrib: Este pacote contém utilitários e funcionalidades adicionais que não fazem parte do sistema principal do PostgreSQL, mas que são frequentemente úteis.

Durante o processo de instalação, você pode ser solicitado a confirmar a instalação. Se sim, digite 'Y' e pressione Enter para prosseguir.

Verificando a Instalação

Após a instalação ser concluída, é importante verificar se o PostgreSQL foi instalado corretamente e está em execução. Aqui estão algumas maneiras de fazer isso:

Verifique a versão do PostgreSQL:
```
psql --version
```
Isso deve exibir a versão do PostgreSQL que foi instalada.
Verifique o status do serviço PostgreSQL:
```
sudo systemctl status postgresql
```
Você deve ver uma saída indicando que o serviço está ativo (em execução).
Verifique se o PostgreSQL está ouvindo por conexões:
```
sudo ss -tunelp | grep 5432
```
Este comando verifica se o PostgreSQL está ouvindo na sua porta padrão (5432). Você deve ver uma saída se o PostgreSQL estiver funcionando corretamente.

Configuração Inicial do PostgreSQL

Quando você instala o PostgreSQL no Ubuntu, ele cria automaticamente uma nova conta de usuário chamada postgres. Esta conta está associada ao papel padrão do Postgres. Para interagir com o PostgreSQL usando esta conta, você pode mudar para ela assim:

sudo -i -u postgres

Em seguida, você pode acessar o prompt do PostgreSQL digitando:

psql

Isso o levará ao prompt do PostgreSQL, e você verá algo como:

psql (13.x)
Type "help" for help.

postgres=#

Para sair do prompt do PostgreSQL, digite:

\q

E para retornar à sua conta de usuário regular, basta digitar:

exit

Parabéns! Você instalou com sucesso o PostgreSQL em seu sistema Ubuntu. Na próxima seção, abordaremos como configurar o PostgreSQL para suas necessidades.

Configurando o PostgreSQL

Após instalar o PostgreSQL, é importante configurá-lo adequadamente para suas necessidades. Esta seção abordará a criação de um novo banco de dados, a configuração de um novo usuário e a configuração dos métodos de autenticação.

Criando um Novo Banco de Dados

Por padrão, o PostgreSQL cria um banco de dados chamado postgres. No entanto, é uma boa prática criar bancos de dados separados para seus projetos. Veja como criar um novo banco de dados:

Mude para o usuário postgres:
```
sudo -i -u postgres
```
Acesse o prompt do PostgreSQL:
```
psql
```
Crie um novo banco de dados usando o comando CREATE DATABASE:
```
CREATE DATABASE myproject;
```
Substitua myproject pelo nome desejado para seu banco de dados.
Você pode verificar a criação do banco de dados com:
```
\l
```
Isso listará todos os bancos de dados.

Configurando um Novo Usuário

É recomendado criar um novo usuário para cada aplicativo em vez de usar o superusuário padrão postgres. Veja como:

Enquanto ainda estiver no prompt do psql, crie um novo usuário:
```
CREATE USER myuser WITH PASSWORD 'mypassword';
```
Substitua myuser e mypassword pelo nome de usuário e senha desejados.

Conceda privilégios ao novo usuário no novo banco de dados:

GRANT ALL PRIVILEGES ON DATABASE myproject TO myuser;

Você pode verificar a criação do usuário com:
```
\du
```
Isso listará todos os usuários e seus papéis.

Configurando Métodos de Autenticação

O PostgreSQL usa diferentes métodos de autenticação que são configurados no arquivo pg_hba.conf. Veja como modificá-lo:

Saia do prompt do PostgreSQL:
```
\q
```
Abra o arquivo pg_hba.conf com um editor de texto (você pode precisar de privilégios sudo):
```
sudo nano /etc/postgresql/13/main/pg_hba.conf
```
Nota: Substitua 13 pelo número da sua versão do PostgreSQL, se diferente.
O arquivo contém linhas que determinam como os usuários podem se autenticar. Uma configuração típica pode parecer assim:
```
# TYPE  DATABASE        USER            ADDRESS                 METHOD
local   all             postgres                                peer
local   all             all                                     md5
host    all             all             127.0.0.1/32            md5
host    all             all             ::1/128                 md5
```
- local significa conectar através de sockets de domínio Unix
- host significa conectar através de TCP/IP
- md5 significa autenticação por senha
- peer significa que o nome do usuário do sistema mapeia diretamente para um nome de usuário do PostgreSQL
Após fazer as alterações, salve o arquivo e saia do editor.
Reinicie o PostgreSQL para que as alterações tenham efeito:
```
sudo systemctl restart postgresql
```

Lembre-se, estas são configurações básicas. Dependendo de suas necessidades específicas, você pode precisar ajustar as configurações ainda mais, especialmente para ambientes de produção onde a segurança é crucial.

Comandos Básicos do PostgreSQL

Agora que temos o PostgreSQL instalado e configurado, vamos explorar alguns comandos básicos que o ajudarão a interagir com seus bancos de dados. Esses comandos são essenciais para gerenciar bancos de dados, tabelas e realizar operações básicas.

Conectando-se ao PostgreSQL

Conecte-se como o usuário postgres:
```
sudo -i -u postgres
```
Inicie o terminal interativo do PostgreSQL:
```
psql
```
Para se conectar a um banco de dados específico:
```
psql -d myproject
```
Substitua myproject pelo nome do seu banco de dados.

Operações de Banco de Dados

Liste todos os bancos de dados:
```
\l
```
Conecte-se a um banco de dados específico:
```
\c myproject
```
Crie um novo banco de dados:
```
CREATE DATABASE newdb;
```
Exclua um banco de dados:
```
DROP DATABASE newdb;
```

Operações de Tabela

Liste as tabelas no banco de dados atual:
```
\dt
```

Crie uma nova tabela:

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    email VARCHAR(100) UNIQUE NOT NULL
);

Descreva a estrutura de uma tabela:
```
\d users
```
Exclua uma tabela:
```
DROP TABLE users;
```

Exemplos de Consultas Básicas

Insira dados em uma tabela:

INSERT INTO users (name, email) VALUES ('John Doe', '[email protected]');

Selecione todos os dados de uma tabela:
```
SELECT * FROM users;
```

Atualize dados em uma tabela:

UPDATE users SET name = 'Jane Doe' WHERE id = 1;

Exclua dados de uma tabela:
```
DELETE FROM users WHERE id = 1;
```

Outros Comandos Úteis

Mostre a versão do PostgreSQL:
```
SELECT version();
```
Liste todos os usuários e seus papéis:
```
\du
```
Mostre o usuário e o banco de dados atuais:
```
\conninfo
```
Execute comandos de um arquivo:
```
\i filename.sql
```
Saia do psql:
```
\q
```

Lembre-se, estes são apenas comandos básicos para você começar. O PostgreSQL oferece uma ampla gama de recursos avançados e comandos para operações e otimizações mais complexas.

Mantendo o PostgreSQL

A manutenção adequada da sua instalação do PostgreSQL é crucial para garantir desempenho ideal, integridade dos dados e segurança. Esta seção cobre algumas tarefas essenciais de manutenção que você deve conhecer.

Iniciando e Parando o Serviço PostgreSQL

Para iniciar o serviço PostgreSQL:
```
sudo systemctl start postgresql
```
Para parar o serviço PostgreSQL:
```
sudo systemctl stop postgresql
```
Para reiniciar o serviço PostgreSQL:
```
sudo systemctl restart postgresql
```
Para verificar o status do serviço PostgreSQL:
```
sudo systemctl status postgresql
```

Fazendo Backup e Restaurando Bancos de Dados

Fazer backup regularmente dos seus bancos de dados é crucial para a proteção dos dados. O PostgreSQL fornece vários métodos para backup e restauração.

Criando um Backup

Para fazer backup de um único banco de dados:
```
pg_dump dbname > dbname.sql
```
Para fazer backup de todos os bancos de dados:
```
pg_dumpall > all_databases.sql
```

Restaurando de um Backup

Para restaurar um único banco de dados:
```
psql dbname < dbname.sql
```
Para restaurar todos os bancos de dados:
```
psql -f all_databases.sql postgres
```

Atualizando o PostgreSQL

Manter o PostgreSQL atualizado é importante para segurança e desempenho. Veja como atualizar:

Atualize a lista de pacotes:
```
sudo apt update
```

Atualize o PostgreSQL:

sudo apt upgrade postgresql postgresql-contrib

Monitorando o PostgreSQL

Verifique as conexões ativas:
```
SELECT * FROM pg_stat_activity;
```

Monitore o tamanho do banco de dados:

SELECT pg_size_pretty(pg_database_size('dbname'));

Verifique os tamanhos das tabelas:

SELECT relname, pg_size_pretty(pg_total_relation_size(relid))
FROM pg_catalog.pg_statio_user_tables
ORDER BY pg_total_relation_size(relid) DESC;

Vacuum e Analyze

O PostgreSQL usa MVCC (Controle de Concorrência Multi-versão), o que pode levar a inchaço em tabelas e índices. O comando VACUUM ajuda a gerenciar isso:

Para fazer vacuum em uma tabela específica:
```
VACUUM tablename;
```
Para fazer vacuum e analisar (atualiza estatísticas) um banco de dados:
```
VACUUM ANALYZE;
```
Para vacuum automático, certifique-se de que o autovacuum esteja habilitado no seu arquivo postgresql.conf:
```
autovacuum = on
```

Gerenciamento de Logs

Os logs do PostgreSQL podem fornecer informações valiosas para solução de problemas e ajuste de desempenho:

Encontre a localização do arquivo de log:
```
SHOW log_directory;
SHOW log_filename;
```
Você pode modificar as configurações de log no arquivo postgresql.conf para ajustar o que é registrado e como.

Lembre-se, estas são tarefas básicas de manutenção. Para ambientes de produção, você pode precisar de estratégias mais avançadas, incluindo configuração de replicação, balanceamento de carga e implementação de soluções de backup e monitoramento mais sofisticadas.

Solucionando Problemas Comuns

Mesmo com uma configuração e manutenção cuidadosas, você pode encontrar problemas com sua instalação do PostgreSQL. Aqui estão alguns problemas comuns e suas soluções:

Problemas de Permissão

Problema: Erros de "Permissão negada" ao tentar acessar o PostgreSQL.

Solução:
- Certifique-se de que o usuário tenha as permissões necessárias:
```
sudo -i -u postgres
createuser --interactive
```
- Conceda as permissões necessárias ao usuário:
```
GRANT ALL PRIVILEGES ON DATABASE mydb TO myuser;
```
Problema: Não consigo acessar o PostgreSQL com seu usuário do Ubuntu.

Solução:
- Crie um papel do PostgreSQL com o mesmo nome que seu usuário do Ubuntu:
```
sudo -u postgres createuser --interactive
```

Problemas de Conexão

Problema: Erro de "Conexão recusada".

Solução:
- Verifique se o PostgreSQL está em execução:
```
sudo systemctl status postgresql
```
- Se não estiver em execução, inicie-o:
```
sudo systemctl start postgresql
```
- Certifique-se de que o PostgreSQL esteja ouvindo no endereço correto em postgresql.conf:
```
listen_addresses = 'localhost'  # ou '*' para todas as interfaces
```
Problema: Não consigo conectar remotamente.

Solução:
- Modifique pg_hba.conf para permitir conexões remotas:
```
host    all    all    0.0.0.0/0    md5
```
- Atualize postgresql.conf:
```
listen_addresses = '*'
```
- Reinicie o PostgreSQL:
```
sudo systemctl restart postgresql
```

Conflitos de Versão

Problema: Incompatibilidade entre a versão do PostgreSQL e as extensões instaladas.

Solução:
- Verifique a versão do PostgreSQL:
```
psql --version
```
- Certifique-se de que as extensões sejam compatíveis. Você pode precisar atualizar as extensões:
```
ALTER EXTENSION extension_name UPDATE TO 'new_version';
```

Problemas de Desempenho

Problema: Consultas lentas ou desempenho geral ruim.

Solução:
- Use EXPLAIN ANALYZE para entender a execução da consulta:
```
EXPLAIN ANALYZE SELECT * FROM large_table WHERE condition;
```
- Certifique-se de que a indexação esteja adequada:
```
CREATE INDEX idx_name ON table_name (column_name);
```
- Ajuste os parâmetros de configuração do PostgreSQL no arquivo postgresql.conf:
```
shared_buffers = 256MB
effective_cache_size = 768MB
```
Problema: Inchaço do banco de dados causando degradação do desempenho.

Solução:
- Execute VACUUM e ANALYZE regularmente:
```
VACUUM ANALYZE;
```
- Considere configurar autovacuum para manutenção automática.

Problemas de Espaço em Disco

Problema: Faltando espaço em disco.

Solução:
- Identifique tabelas e índices grandes:
```
SELECT relname, pg_size_pretty(pg_total_relation_size(relid))
FROM pg_catalog.pg_statio_user_tables
ORDER BY pg_total_relation_size(relid) DESC;
```
- Remova dados desnecessários ou arquive dados antigos.
- Considere a partição de tabelas para tabelas muito grandes.

Lembre-se, estas são soluções gerais. Os passos exatos podem variar dependendo da sua versão específica do PostgreSQL e da configuração do sistema. Sempre faça backup dos seus dados antes de fazer alterações significativas no seu banco de dados ou em sua configuração.

Instalar PostgreSQL no Ubuntu

Perguntas Frequentes (FAQ)

Q: Como posso descobrir qual versão do PostgreSQL estou executando?

A: Você pode usar o seguinte comando no terminal:

psql --version

Ou, se você já estiver no prompt do psql:

SELECT version();

Q: Posso ter várias versões do PostgreSQL instaladas no mesmo sistema Ubuntu?

A: Sim, é possível ter várias versões instaladas. No entanto, você precisa gerenciar as portas e diretórios de dados com cuidado para evitar conflitos.

Q: Como posso alterar a senha do usuário PostgreSQL?

A: Você pode alterar a senha usando o seguinte comando SQL:

ALTER USER username WITH PASSWORD 'new_password';

Q: Como posso habilitar o acesso remoto ao meu servidor PostgreSQL?

A: Você precisa modificar os arquivos postgresql.conf e pg_hba.conf. No postgresql.conf, defina listen_addresses = '*', e no pg_hba.conf, adicione uma linha como host all all 0.0.0.0/0 md5. Lembre-se de reiniciar o PostgreSQL após fazer essas alterações.

Q: Qual é a diferença entre TRUNCATE e DELETE no PostgreSQL?

A: TRUNCATE é mais rápido, pois remove todas as linhas em uma tabela sem escaneá-las individualmente. DELETE remove linhas uma a uma e registra as exclusões no log de transações. TRUNCATE também redefine sequências e não aciona gatilhos de DELETE.

Q: Como posso melhorar o desempenho do PostgreSQL?

A: Algumas maneiras de melhorar o desempenho incluem:

Indexação adequada
VACUUM e ANALYZE regulares
Otimização de consultas
Ajuste de parâmetros de configuração do PostgreSQL
Atualização de hardware (especialmente adicionando mais RAM)