Passo 7: Configurando um Banco de Dados

5.0 version
Maintained

Configurando um Banco de Dados

O objetivo do site Livro de Visitas da Conferência é coletar feedback durante as conferências. Precisamos armazenar os comentários dos participantes da conferência em um armazenamento permanente.

Um comentário é melhor descrito por uma estrutura de dados fixa: um autor, seu e-mail, o texto do feedback e uma foto opcional. É o tipo de dado que pode ser melhor armazenado em um banco de dados relacional tradicional.

PostgreSQL é o banco de dados que usaremos.

Adicionando o PostgreSQL ao Docker Compose

Em nossa máquina local decidimos usar o Docker para gerenciar serviços. Crie um arquivo docker-compose.yaml e adicione o PostgreSQL como um serviço:

docker-compose.yaml
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
version: '3'

services:
    database:
        image: postgres:11-alpine
        environment:
            POSTGRES_USER: main
            POSTGRES_PASSWORD: main
            POSTGRES_DB: main
        ports: [5432]

Isso irá instalar um servidor PostgreSQL na versão 11 e configurar algumas variáveis de ambiente que controlam o nome e as credenciais do banco de dados. Os valores não importam.

Nós também expomos a porta do PostgreSQL (5432) no container para o host local. Isso nos ajudará a acessar o banco de dados a partir da nossa máquina.

Nota

A extensão pdo_pgsql deve ter sido instalada quando o PHP foi configurado em uma etapa anterior.

Iniciando o Docker Compose

Inicie o Docker Compose em segundo plano (-d):

1
$ docker-compose up -d

Espere um pouco para deixar o banco de dados iniciar e verifique se tudo está funcionando bem:

1
2
3
4
5
$ docker-compose ps

        Name                      Command              State            Ports
---------------------------------------------------------------------------------------
guestbook_database_1   docker-entrypoint.sh postgres   Up      0.0.0.0:32780->5432/tcp

Se não houver containers em execução ou se a coluna State não exibir Up, verifique os logs do Docker Compose:

1
$ docker-compose logs

Acessando o Banco de Dados Local

Usar o utilitário de linha de comando psql pode ser útil de tempos em tempos. Mas você precisa lembrar das credenciais e do nome do banco de dados. Menos óbvio, você também precisa saber a porta local usada pelo banco de dados na máquina. O Docker escolhe uma porta aleatória para que você possa trabalhar em mais de um projeto usando o PostgreSQL ao mesmo tempo (a porta local é parte da saída do docker-compose ps).

Se você executar o psql através da CLI do Symfony, não precisará lembrar de nada.

A CLI do Symfony detecta automaticamente os serviços Docker em execução para o projeto e expõe as variáveis de ambiente que o psql precisa para conectar ao banco de dados.

Graças a estas convenções, acessar o banco de dados usando symfony run é muito mais fácil:

1
$ symfony run psql

Nota

Se você não tem o binário psql no seu host local, você também pode executá-lo via docker:

1
$ docker exec -it guestbook_database_1 psql -U main -W main

Adicionando o PostgreSQL à SymfonyCloud

Para a infraestrutura de produção na SymfonyCloud, adicionar um serviço como o PostgreSQL deve ser feito no arquivo .symfony/services.yaml, atualmente vazio:

.symfony/services.yaml
1
2
3
4
db:
    type: postgresql:11
    disk: 1024
    size: S

O serviço db é um banco de dados PostgreSQL na versão 11 (como o Docker) que nós queremos provisionar em um pequeno container com 1GB de disco.

Também precisamos “vincular” o BD ao container da aplicação, que é descrito em .symfony.cloud.yaml`:

.symfony.cloud.yaml
1
2
relationships:
    database: "db:postgresql"

O serviço db do tipo postgresql é referenciado como database no container da aplicação.

O último passo é adicionar a extensão pdo_pgsql ao runtime do PHP:

.symfony.cloud.yaml
1
2
3
4
runtime:
    extensions:
        - pdo_pgsql
        # other extensions here

Aqui está o diff completo das alterações em .symfony.cloud.yaml:

patch_file
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
--- a/.symfony.cloud.yaml
+++ b/.symfony.cloud.yaml
@@ -4,6 +4,7 @@ type: php:7.3

 runtime:
     extensions:
+        - pdo_pgsql
         - apcu
         - mbstring
         - sodium
@@ -12,6 +13,9 @@ runtime:
 build:
     flavor: none

+relationships:
+    database: "db:postgresql"
+
 web:
     locations:
         "/":

Faça o commit destas alterações e então implante novamente na SymfonyCloud:

1
2
3
$ git add .
$ git commit -m'Configuring the database'
$ symfony deploy

Acessando o Banco de Dados na SymfonyCloud

O PostgreSQL agora está executando localmente via Docker e em produção na SymfonyCloud.

Como acabamos de ver, executar symfony run psql automaticamente conecta ao banco de dados hospedado pelo Docker graças às variáveis de ambiente expostas pelo symfony run.

Se você quiser conectar ao PostgreSQL hospedado nos containers de produção, você pode abrir um túnel SSH entre a máquina local e a infraestrutura da SymfonyCloud:

1
$ symfony tunnel:open --expose-env-vars

Por padrão, os serviços da SymfonyCloud não são expostos como variáveis de ambiente na máquina local. Isso deve ser feito explicitamente através da flag --expose-env-vars. Por quê? Conectar ao banco de dados de produção é uma operação perigosa. Você pode mexer com dados reais. Exigir a flag é como confirmar que é isso o que você deseja fazer.

Agora, conecte-se ao banco de dados PostgreSQL remoto usando symfony run psql como antes:

1
$ symfony run psql

Quando acabar, não se esqueça de fechar o túnel:

1
$ symfony tunnel:close

Dica

Para executar algumas consultas SQL no banco de dados de produção, em vez de obter um shell, você também pode usar o comando symfony sql.

Expondo Variáveis de Ambiente

O Docker Compose e a SymfonyCloud funcionam perfeitamente com o Symfony graças às variáveis de ambiente.

Verifique todas as variáveis de ambiente expostas pelo symfony executando symfony var:export:

1
2
3
4
5
6
7
8
$ symfony var:export

PGHOST=127.0.0.1
PGPORT=32781
PGDATABASE=main
PGUSER=main
PGPASSWORD=main
# ...

As variáveis de ambiente PG* são lidas pelo utilitário psql. E as outras?

Quando um túnel é aberto para a SymfonyCloud com a flag --expose-env-vars, o comando var:export retorna as variáveis de ambiente remotas:

1
2
3
$ symfony tunnel:open --expose-env-vars
$ symfony var:export
$ symfony tunnel:close

  • « Previous Passo 6: Criando um Controlador
  • Next » Passo 8: Descrevendo a Estrutura de Dados

This work, including the code samples, is licensed under a Creative Commons BY-NC-SA 4.0 license.