Como instalar e usar o PostgreSQL no Ubuntu 20.04

Tutoriais

Introdução

Sistemas de gerenciamento de banco de dados relacionais são um componente chave de muitos sites e aplicativos da web. Eles fornecem uma maneira estruturada de armazenar, organizar e acessar informações.

O PostgreSQL, ou Postgres, é um sistema de gerenciamento de banco de dados relacional que fornece uma implementação da linguagem de consulta SQL. Ele é compatível com padrões e possui muitos recursos avançados, como transações confiáveis e concorrência sem bloqueios de leitura.

Este guia demonstra como instalar o Postgres em um servidor Ubuntu 20.04. Ele também fornece algumas instruções para administração geral do banco de dados.

Implante um banco de dados PostgreSQL com um clique usando Bancos de Dados Gerenciados da DigitalOcean. Deixe a DigitalOcean cuidar da escalabilidade, manutenção e atualizações do seu banco de dados.

Pré-requisitos

Para seguir este tutorial, você precisará de um servidor Ubuntu 20.04 que tenha sido configurado seguindo nosso guia Configuração Inicial do Servidor para Ubuntu 20.04. Após completar este tutorial pré-requisito, seu servidor deverá ter um usuário não root com permissões sudo e um firewall básico.

Passo 1 — Instalando o PostgreSQL

Os repositórios padrão do Ubuntu contêm pacotes do Postgres, então você pode instalá-los usando o sistema de empacotamento apt.

Se você ainda não o fez recentemente, atualize o índice de pacotes local do seu servidor:

  1. sudo apt update

Em seguida, instale o pacote do Postgres juntamente com um pacote -contrib que adiciona algumas utilidades e funcionalidades adicionais:

  1. sudo apt install postgresql postgresql-contrib

Certifique-se de que o servidor esteja em execução usando o comando systemctl start:

  1. sudo systemctl start postgresql.service

Agora que o software está instalado e em execução, podemos analisar como ele funciona e como pode ser diferente de outros sistemas de gerenciamento de banco de dados relacionais que você possa ter usado.

Passo 2 — Usando Funções e Bancos de Dados do PostgreSQL

Por padrão, o Postgres usa um conceito chamado “roles” para gerenciar autenticação e autorização. Esses são, de certa forma, semelhantes às contas regulares no estilo Unix, mas o Postgres não distingue entre usuários e grupos e, em vez disso, prefere o termo mais flexível “role”.

Ao instalar, o Postgres é configurado para usar a autenticação por pares, ou seja, associa as roles do Postgres a uma conta de sistema Unix/Linux correspondente. Se uma role existir dentro do Postgres, um nome de usuário Unix/Linux com o mesmo nome poderá fazer login como essa role.

O procedimento de instalação criou uma conta de usuário chamada postgres que está associada à role padrão do Postgres. Para usar o Postgres, você pode fazer o login nessa conta.

Há algumas maneiras de usar essa conta para acessar o Postgres.

Fazendo a troca para a conta postgres

Para mudar para a conta postgres no seu servidor, digite:

  1. sudo -i -u postgres

Você pode agora acessar o prompt PostgreSQL imediatamente digitando:

  1. psql

A partir daí, você tem liberdade para interagir com o sistema de gestão de banco de dados conforme necessário.

Saia do prompt PostgreSQL digitando:

  1. \q

Isso te levará de volta ao prompt de comando Linux postgres.

Acessando um Prompt do Postgres sem Trocar de Conta

Você também pode executar o comando desejado com a conta postgres diretamente com sudo.

Por exemplo, no último exemplo, você foi instruído a acessar o prompt do Postgres primeiro mudando para o usuário postgres e depois executando psql para abrir o prompt do Postgres. Você pode fazer isso em um único passo executando o comando único psql como o usuário postgres com sudo, assim:

  1. sudo -u postgres psql

Isto irá logá-lo diretamente no Postgres sem o shell intermediário bash entre eles.

Novamente, você pode sair da sessão interativa do Postgres digitando:

  1. \q

Muitos casos de uso requerem mais de um papel do Postgres. Continue lendo para aprender como configurar estes.

Passo 3 — Criando um Novo Papel

Atualmente, você só tem a função postgres configurada dentro do banco de dados. Você pode criar novas funções a partir da linha de comando com o comando createrole. A flag --interactive irá solicitar o nome da nova função e também perguntará se ela deve ter permissões de superusuário.

Se você estiver conectado como a conta postgres, você pode criar um novo usuário digitando:

  1. createuser --interactive

Se, em vez disso, você preferir usar o sudo para cada comando sem mudar da sua conta normal, digite:

  1. sudo -u postgres createuser --interactive

O script irá solicitar algumas escolhas e, com base em suas respostas, executará os comandos corretos do Postgres para criar um usuário de acordo com suas especificações.

Output
Enter name of role to add: sammy
Shall the new role be a superuser? (y/n) y

Você pode obter mais controle passando algumas flags adicionais. Confira as opções olhando a página man:

  1. man createuser

Sua instalação do Postgres agora tem um novo usuário, mas você ainda não adicionou nenhum banco de dados. A próxima seção descreve esse processo.

Passo 4 — Criando um Novo Banco de Dados

Outra suposição que o sistema de autenticação do Postgres faz por padrão é que para qualquer função usada para fazer login, essa função terá um banco de dados com o mesmo nome ao qual ela pode acessar.

Isso significa que se o usuário que você criou na última seção se chama sammy, essa função tentará se conectar a um banco de dados também chamado “sammy” por padrão. Você pode criar o banco de dados apropriado com o comando createdb.

Se você estiver logado como a conta postgres, você digitaria algo como:

  1. createdb sammy

Se, em vez disso, você preferir usar sudo para cada comando sem mudar de sua conta normal, você digitaria:

  1. sudo -u postgres createdb sammy

Essa flexibilidade oferece múltiplos caminhos para criar bancos de dados conforme necessário.

Passo 5 — Abrindo um Prompt do Postgres com a Nova Função

Para fazer login com autenticação peer, você precisará de um usuário Linux com o mesmo nome que sua função e banco de dados do Postgres.

Se você não tiver um usuário Linux correspondente disponível, você pode criar um com o comando adduser. Você terá que fazer isso a partir de sua conta não-root com privilégios de sudo (ou seja, não logado como o usuário postgres):

  1. sudo adduser sammy

Depois que essa nova conta estiver disponível, você pode alternar e se conectar ao banco de dados digitando:

  1. sudo -i -u sammy

  2. psql

Ou, você pode fazer isso em linha:

  1. sudo -u sammy psql

Este comando irá fazer login automaticamente, assumindo que todos os componentes tenham sido configurados corretamente.

Se deseja que seu usuário se conecte a um banco de dados diferente, pode fazer isso especificando o banco de dados assim:

  1. psql -d postgres

Depois de iniciar a sessão, pode verificar as informações de conexão atuais digitando:

  1. \conninfo



Output
You are connected to database "sammy" as user "sammy" via socket in "/var/run/postgresql" at port "5432".

Isso é útil se estiver se conectando a bancos de dados não padrão ou com usuários não padrão.

Passo 6 — Criando e Excluindo Tabelas

Agora que sabe como se conectar ao sistema de banco de dados PostgreSQL, pode aprender algumas tarefas básicas de gerenciamento do Postgres.

A sintaxe básica para criar tabelas é a seguinte:

CREATE TABLE table_name (
    column_name1 col_type (field_length) column_constraints,
    column_name2 col_type (field_length),
    column_name3 col_type (field_length)
);

Como pode ver, esses comandos dão um nome à tabela e então definem as colunas, bem como o tipo de coluna e o comprimento máximo dos dados do campo. Também pode adicionar opcionalmente restrições de tabela para cada coluna.

Pode aprender mais sobre como criar e gerenciar tabelas no Postgres aqui.

Para fins de demonstração, crie a seguinte tabela:

  1. CREATE TABLE playground (

  2.     equip_id serial PRIMARY KEY,

  3.     type varchar (50) NOT NULL,

  4.     color varchar (25) NOT NULL,

  5.     location varchar(25) check (location in ('north', 'south', 'west', 'east', 'northeast', 'southeast', 'southwest', 'northwest')),

  6.     install_date date

  7. );

Este comando criará uma tabela que inventaria equipamentos de playground. A primeira coluna na tabela conterá números de ID de equipamento do tipo serial, que é um inteiro com incremento automático. Esta coluna também tem a restrição de PRIMARY KEY, o que significa que os valores dentro dela devem ser únicos e não nulos.

As próximas duas linhas criam colunas para o tipo e cor do equipamento, respectivamente, nenhum dos quais pode estar vazio. A linha após essas cria uma coluna localização bem como uma restrição que requer que o valor seja um dos oito valores possíveis. A última linha cria uma coluna data que registra a data em que você instalou o equipamento.

Para duas das colunas (equip_id e install_date), o comando não especifica um comprimento de campo. A razão para isso é que alguns tipos de dados não requerem um comprimento definido porque o comprimento ou formato é implícito.

Você pode ver sua nova tabela digitando:

  1. \d



Output
                  List of relations
 Schema |          Name           |   Type   | Owner 
--------+-------------------------+----------+-------
 public | playground              | table    | sammy
 public | playground_equip_id_seq | sequence | sammy
(2 rows)

Sua tabela de playground está aqui, mas também há algo chamado playground_equip_id_seq que é do tipo sequência. Isso é uma representação do tipo serial que você deu para sua coluna equip_id. Isso mantém o controle do próximo número na sequência e é criado automaticamente para colunas desse tipo.

Se você quiser ver apenas a tabela sem a sequência, você pode digitar:

  1. \dt



Output
          List of relations
 Schema |    Name    | Type  | Owner 
--------+------------+-------+-------
 public | playground | table | sammy
(1 row)

Com uma tabela pronta, vamos usá-la para praticar o gerenciamento de dados.

Passo 7 — Adicionando, Consultando e Excluindo Dados em uma Tabela

Agora que você tem uma tabela, você pode inserir alguns dados nela. Como exemplo, adicione um escorregador e um balanço chamando a tabela à qual deseja adicionar, nomeando as colunas e fornecendo dados para cada coluna, assim:

  1. INSERT INTO playground (type, color, location, install_date) VALUES ('slide', 'blue', 'south', '2017-04-28');

  2. INSERT INTO playground (type, color, location, install_date) VALUES ('swing', 'yellow', 'northwest', '2018-08-16');

Você deve ter cuidado ao inserir os dados para evitar alguns problemas comuns. Por exemplo, não envolva os nomes das colunas em aspas, mas os valores das colunas que você insere precisam de aspas.

Outra coisa a ter em mente é que você não deve inserir um valor para a coluna equip_id. Isso porque esse valor é gerado automaticamente sempre que você adiciona uma nova linha à tabela.

Recupere as informações que você adicionou digitando:

  1. SELECT * FROM playground;



Output
 equip_id | type  | color  | location  | install_date 
----------+-------+--------+-----------+--------------
        1 | slide | blue   | south     | 2017-04-28
        2 | swing | yellow | northwest | 2018-08-16
(2 rows)

Aqui, você pode ver que seu equip_id foi preenchido com sucesso e que todos os seus outros dados foram organizados corretamente.

Se o escorregador no parque quebrar e você precisar removê-lo, também pode excluir a linha da tabela digitando:

  1. DELETE FROM playground WHERE type = 'slide';

Consulte novamente a tabela:

  1. SELECT * FROM playground;



Output
 equip_id | type  | color  | location  | install_date 
----------+-------+--------+-----------+--------------
        2 | swing | yellow | northwest | 2018-08-16
(1 row)

Observe que a linha do escorregador já não faz parte da tabela.

Passo 8 — Adicionando e Removendo Colunas de uma Tabela

Após criar uma tabela, você pode modificá-la adicionando ou removendo colunas. Adicione uma coluna para mostrar a última visita de manutenção para cada equipamento digitando:

  1. ALTER TABLE playground ADD last_maint date;

Se visualizar novamente as informações da sua tabela, verá que a nova coluna foi adicionada, mas nenhum dado foi inserido:

  1. SELECT * FROM playground;



Output
 equip_id | type  | color  | location  | install_date | last_maint 
----------+-------+--------+-----------+--------------+------------
        2 | swing | yellow | northwest | 2018-08-16   | 
(1 row)

Se descobrir que sua equipe de trabalho usa uma ferramenta separada para acompanhar o histórico de manutenção, você pode excluir a coluna digitando:

  1. ALTER TABLE playground DROP last_maint;

Isso exclui a coluna last_maint e quaisquer valores encontrados dentro dela, mas deixa todos os outros dados intactos.

Passo 9 — Atualizando Dados em uma Tabela

Até agora, você aprendeu como adicionar registros a uma tabela e como excluí-los, mas este tutorial ainda não abordou como modificar entradas existentes.

Você pode atualizar os valores de uma entrada existente consultando o registro desejado e definindo a coluna para o valor que deseja usar. Você pode consultar o registro swing (isso corresponderá a todos os swings na sua tabela) e alterar sua cor para vermelho. Isso pode ser útil se você tiver pintado o conjunto de balanço:

  1. UPDATE playground SET color = 'red' WHERE type = 'swing';

Você pode verificar se a operação foi bem-sucedida consultando os dados novamente:

  1. SELECT * FROM playground;



Output
 equip_id | type  | color | location  | install_date 
----------+-------+-------+-----------+--------------
        2 | swing | red   | northwest | 2018-08-16
(1 row)

Como pode ver, o escorregador agora está registrado como sendo vermelho.

Conclusão

Você agora está configurado com o PostgreSQL no seu servidor Ubuntu 20.04. Se deseja aprender mais sobre o Postgres e como usá-lo, recomendamos que consulte os seguintes guias:

Source:
https://www.digitalocean.com/community/tutorials/how-to-install-and-use-postgresql-on-ubuntu-20-04