How To Set Up Laravel, Nginx, and MySQL with Docker Compose

O autor selecionou A FreeBSD Foundation para receber uma doação como parte do programa Write for DOnations.

Introdução

Ao longo dos últimos anos, o Docker tornou-se uma solução frequentemente usada para implantar aplicativos graças a como ele simplifica a execução e implantação de aplicativos em contêineres efêmeros. Ao usar uma pilha do aplicativo LEMP, por exemplo, com o PHP, Nginx, MySQL e o framework Laravel, o Docker pode simplificar significativamente o processo de configuração.

O Docker Compose simplificou ainda mais o processo de desenvolvimento, permitindo que os desenvolvedores definam sua infraestrutura, incluindo serviços de aplicativo, redes e volumes em um único arquivo. O Docker Compose oferece uma alternativa eficiente para executar vários comandos docker container create e docker container run.

Neste tutorial, você irá construir um aplicativo Web usando o framework Laravel, com o Nginx como servidor Web e o MySQL como banco de dados, todos dentro de contêineres Docker. Você definirá a configuração de toda a pilha em um arquivo docker-compose, junto com arquivos de configuração para o PHP, MySQL e Nginx.

Pré-requisitos

Antes de começar, será necessário:

• Um servidor Ubuntu 18.04 e um usuário não root com privilégios sudo. Siga o tutorial Configuração inicial de servidor com o Ubuntu 18.04 para configurar isso.
• O Docker instalado, seguindo os Passos 1 e 2 de Como instalar e usar o Docker no Ubuntu 18.04.
• O Docker Compose instalado, seguindo o Passo 1 de Como instalar o Docker Compose no Ubuntu 18.04.

Passo 1 — Fazendo download do Laravel e instalando dependências

Como primeiro passo, vamos obter a versão mais recente do Laravel e instalar as dependências para o projeto, incluindo o Composer, o gerenciador de pacotes a nível de aplicativo para o PHP. Vamos instalar essas dependências com o Docker para evitar ter que instalar o Composer globalmente.

Primeiramente, verifique se você está no seu diretório home e faça uma cópia da versão mais recente do Laravel para um diretório chamado laravel-app:

cd ~
git clone https://github.com/laravel/laravel.git laravel-app

Vá até o diretório laravel-app:

cd ~/laravel-app

Em seguida, utilize a imagem do composer para montar os diretórios que você precisará para seu projeto Laravel e evite os custos de instalar o Composer globalmente:

docker run --rm -v $(pwd):/app composer install

Ao usar os flag -v e --rm com o docker run, cria-se um contêiner efêmero que será montado e ligado ao seu diretório atual antes de ser removido. Isso irá copiar o conteúdo do seu diretório ~/laravel-app para o contêiner e também irá garantir que a pasta vendor que o Composer cria dentro do contêiner seja copiada para o seu diretório atual.

Como passo final, defina as permissões no diretório do projeto para que ele seja propriedade do seu usuário não root:

sudo chown -R $USER:$USER ~/laravel-app

Isso será importante quando escrever o Dockerfile para sua imagem do aplicativo no Passo 4, uma vez que permitirá que você trabalhe com seu código do aplicativo e executar processos no seu contêiner como um usuário não root.

Com seu código do aplicativo funcionando, você pode seguir em frente para definir seus serviços com o Docker Compose.

Passo 2 — Criando o arquivo do Docker Compose

Construir seus aplicativos com o Docker Compose simplifica o processo de configurar e criar uma nova versão da sua infraestrutura. Para configurar nosso aplicativo Laravel, vamos escrever um arquivo docker-compose que defina nosso servidor Web, banco de dados e serviços de aplicativo.

Abra o arquivo:

nano ~/laravel-app/docker-compose.yml

No arquivo docker-compose, você definirá três serviços: app, webserver e db. Adicione o código a seguir ao arquivo, certificando-se de substituir a senha root para o MYSQL_ROOT_PASSWORD, definida como uma variável de ambiente sob o serviço db, por uma senha forte da sua escolha:

version: '3'
services:

  #PHP Service
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: digitalocean.com/php
    container_name: app
    restart: unless-stopped
    tty: true
    environment:
      SERVICE_NAME: app
      SERVICE_TAGS: dev
    working_dir: /var/www
    networks:
      - app-network

  #Nginx Service
  webserver:
    image: nginx:alpine
    container_name: webserver
    restart: unless-stopped
    tty: true
    ports:
      - "80:80"
      - "443:443"
    networks:
      - app-network

  #MySQL Service
  db:
    image: mysql:5.7.22
    container_name: db
    restart: unless-stopped
    tty: true
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_ROOT_PASSWORD: your_mysql_root_password
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    networks:
      - app-network

#Docker Networks
networks:
  app-network:
    driver: bridge

Os serviços aqui definidos incluem:

• app: esta definição de serviço contém o aplicativo Laravel e executa uma imagem personalizada do Docker, digitalocean.com/php, que você definirá no Passo 4. Ela também define o working_dir no contêiner para /var/www.
• webserver: esta definição de serviço extrai a imagem nginx:alpine do Docker e expõe as portas 80 e 443.
• db: esta definição de serviço extrai a imagem mysql:5.7.22 do Docker e define algumas variáveis de ambiente, incluindo um banco de dados chamado laravel para o seu aplicativo e a senha da** root** do banco de dados. Você pode dar o nome que quiser ao banco de dados e deve substituir o your_mysql_root_password pela senha forte escolhida. Esta definição de serviço também mapeia a porta 3306 no host para a porta 3306 no contêiner.

Cada propriedade container_name define um nome para o contêiner, que corresponde ao nome do serviço. Se não definir esta propriedade, o Docker irá atribuir um nome a cada contêiner combinando um nome de uma pessoa historicamente famosa e uma palavra aleatória separada por um underline.

Para facilitar a comunicação entre contêineres, os serviços estão conectados a uma rede bridge chamada app-network. Uma rede bridge utiliza um software bridge que permite que os contêineres conectados à mesma rede bridge se comuniquem uns com os outros. O driver da bridge instala automaticamente regras na máquina do host para que contêineres em redes bridge diferentes não possam se comunicar diretamente entre eles. Isso cria um nível de segurança mais elevado para os aplicativos, garantindo que apenas serviços relacionados possam se comunicar uns com os outros. Isso também significa que você pode definir várias redes e serviços que se conectam a funções relacionadas: os serviços de aplicativo front-end podem usar uma rede frontend, por exemplo, e os serviços back-end podem usar uma rede backend.

Vamos ver como adicionar volumes e bind mounts às definições do seu serviço para persistir os dados do seu aplicativo.

Passo 3 — Persistindo os dados

O Docker tem recursos poderosos e convenientes para persistir os dados. No nosso aplicativo, vamos usar volumes e bind mounts para persistir o banco de dados, o aplicativo e os arquivos de configuração. Os volumes oferecem flexibilidade para backups e persistência além do ciclo de vida de um contêiner, enquanto os bind mounts facilitam alterações no código durante o desenvolvimento, fazendo alterações nos arquivos do host ou diretórios imediatamente disponíveis nos seus contêineres. Nossa configuração usará ambos.

No arquivo docker-compose, defina um volume chamado dbdata sob a definição do serviço db para persistir o banco de dados MySQL:

...
#MySQL Service
db:
  ...
    volumes:
      - dbdata:/var/lib/mysql
    networks:
      - app-network
  ...

O volume com nome dbdata persiste o conteúdo da pasta /var/lib/mysql presente dentro do container. Isso permite que você pare e reinicie o serviço db sem perder dados.

No final do arquivo, adicione a definição para o volume dbdata:

...
#Volumes
volumes:
  dbdata:
    driver: local

Com esta definição no lugar, você poderá usar este volume em diferentes serviços.

Em seguida, adicione um bind mount ao serviço db para os arquivos de configuração do MySQL que você criará no Passo 7:

...
#MySQL Service
db:
  ...
    volumes:
      - dbdata:/var/lib/mysql
      - ./mysql/my.cnf:/etc/mysql/my.cnf
  ...

Este bind mount vincula o ~/laravel-app/mysql/my.cnf ao /etc/mysql/my.cnf no contêiner.

Em seguida, adicione bind mounts ao serviço webserver. Haverá dois: um para seu código do aplicativo e outro para a definição de configuração do Nginx que você criará no Passo 6:

#Nginx Service
webserver:
  ...
  volumes:
      - ./:/var/www
      - ./nginx/conf.d/:/etc/nginx/conf.d/
  networks:
      - app-network

O primeiro bind mount vincula o código do aplicativo no diretório ~/laravel-app ao diretório /var/www dentro do contêiner. O arquivo de configuração que você adicionará ao ~/laravel-app/nginx/conf.d/ também será montado em etc/nginx/conf.d/ no container, permitindo que o conteúdo do diretório de configuração seja adicionado ou modificado conforme necessário.

Por fim, adicione os seguintes bind mounts ao serviço app para o código do aplicativo e os arquivos de configuração:

#PHP Service
app:
  ...
  volumes:
       - ./:/var/www
       - ./php/local.ini:/usr/local/etc/php/conf.d/local.ini
  networks:
      - app-network

O serviço app está vinculando a pasta ~/laravel-app, que contém o código do aplicativo, à pasta /var/www no contêiner com o uso do bind mount. Isso irá acelerar o processo de desenvolvimento, uma vez que quaisquer alterações feitas no seu diretório local do aplicativo serão refletidas instantaneamente dentro do contêiner. Você também está vinculando seu arquivo de configuração PHP, ~/laravel-app/php/local.ini, ao /usr/local/etc/php/conf.d/local.ini dentro do contêiner. Você criará o arquivo de configuração local do PHP no Passo 5.

Seu arquivo docker-compose agora se parecerá com este:

version: '3'
services:

  #PHP Service
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: digitalocean.com/php
    container_name: app
    restart: unless-stopped
    tty: true
    environment:
      SERVICE_NAME: app
      SERVICE_TAGS: dev
    working_dir: /var/www
    volumes:
      - ./:/var/www
      - ./php/local.ini:/usr/local/etc/php/conf.d/local.ini
    networks:
      - app-network

  #Nginx Service
  webserver:
    image: nginx:alpine
    container_name: webserver
    restart: unless-stopped
    tty: true
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./:/var/www
      - ./nginx/conf.d/:/etc/nginx/conf.d/
    networks:
      - app-network

  #MySQL Service
  db:
    image: mysql:5.7.22
    container_name: db
    restart: unless-stopped
    tty: true
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_ROOT_PASSWORD: your_mysql_root_password
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - dbdata:/var/lib/mysql/
      - ./mysql/my.cnf:/etc/mysql/my.cnf
    networks:
      - app-network

#Docker Networks
networks:
  app-network:
    driver: bridge
#Volumes
volumes:
  dbdata:
    driver: local

Salve o arquivo e saia do seu editor quando terminar de fazer alterações.

Com seu arquivo docker-compose escrito, você pode agora construir a imagem personalizada para seu aplicativo.

Passo 4 — Criando o Dockerfile

O Docker permite que você especifique o ambiente dentro de contêineres individuais com um Dockerfile. Um Dockerfile permite que você crie imagens personalizadas que você possa usar para instalar o software necessário para seu aplicativo e configurar as definições baseando-se nos seus requisitos. Você pode enviar as imagens personalizadas que você criar para o Docker Hub ou qualquer registro privado.

Nosso Dockerfile estará localizado no nosso diretório ~/laravel-app. Crie o arquivo:

nano ~/laravel-app/Dockerfile

Este Dockerfile irá definir a imagem base e especificar os comandos e instruções necessários para construir a imagem do aplicativo Laravel. Adicione o código a seguir ao arquivo:

FROM php:7.2-fpm

# Copy composer.lock and composer.json
COPY composer.lock composer.json /var/www/

# Set working directory
WORKDIR /var/www

# Install dependencies
RUN apt-get update && apt-get install -y \
    build-essential \
    libpng-dev \
    libjpeg62-turbo-dev \
    libfreetype6-dev \
    locales \
    zip \
    jpegoptim optipng pngquant gifsicle \
    vim \
    unzip \
    git \
    curl

# Clear cache
RUN apt-get clean && rm -rf /var/lib/apt/lists/*

# Install extensions
RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl
RUN docker-php-ext-configure gd --with-gd --with-freetype-dir=/usr/include/ --with-jpeg-dir=/usr/include/ --with-png-dir=/usr/include/
RUN docker-php-ext-install gd

# Install composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

# Add user for laravel application
RUN groupadd -g 1000 www
RUN useradd -u 1000 -ms /bin/bash -g www www

# Copy existing application directory contents
COPY . /var/www

# Copy existing application directory permissions
COPY --chown=www:www . /var/www

# Change current user to www
USER www

# Expose port 9000 and start php-fpm server
EXPOSE 9000
CMD ["php-fpm"]

Primeiramente, o Dockerfile cria uma imagem sobre a imagem Docker php:7.2-fpm. Esta é uma imagem baseada no Debian que tem a implementação FastCGI PHP-FPM do PHP instalada. O arquivo também instala os pacotes pré-requisitos para o Laravel: o mcrypt, pdo_mysql, mbstring e imagick com o composer.

A diretriz RUN especifica os comandos para atualizar, instalar e configurar as configurações dentro do contêiner, incluindo a criação de um usuário e grupo dedicados chamados www. A instrução WORKDIR especifica o diretório /var/www como diretório de trabalho para o aplicativo.

Criar um usuário e grupo dedicados com permissões limitadas mitiga a vulnerabilidade inerente na execução de contêineres Docker, que são executados por padrão como root. Ao invés de executar este contêiner como root, criamos o usuário www, que tem acesso de leitura/escrita à pasta /var/www graças à instrução COPY que estamos usando com a flag --chown para copiar as permissões da pasta do aplicativo.

Por fim, o comando EXPOSE expõe uma porta no contêiner, 9000, para o servidor php-fpm. O CMD especifica o comando que deve ser executado assim que o contêiner for criado. Aqui, o CMD especifica o "php-fpm", que fará com que o servidor inicie.

Salve o arquivo e saia do seu editor quando terminar de fazer alterações.

Agora, você pode seguir em frente para definir sua configuração PHP.

Passo 5 — Configurando o PHP

Agora que você definiu sua infraestrutura no arquivo docker-compose, é possível configurar o serviço PHP para agir como um processador PHP para pedidos de entrada do Nginx.

Para configurar o PHP, será criado o arquivo local.ini dentro da pasta php. Este é o arquivo que você vinculou ao /usr/local/etc/php/conf.d/local.ini dentro do contêiner no Passo 2. A criação deste arquivo permitirá que você substitua o arquivo padrão php.ini que o PHP lê quando inicia.

Crie o diretório php:

mkdir ~/laravel-app/php

Em seguida, abra o arquivo local.ini:

nano ~/laravel-app/php/local.ini

Para demonstrar como configurar o PHP, adicionaremos o código a seguir para definir limitações de tamanho para arquivos enviados:

upload_max_filesize=40M
post_max_size=40M

As diretrizes upload_max_filesize e post_max_size definem o tamanho máximo permitido para arquivos enviados e demonstram como você pode definir configurações php.ini a partir do seu arquivo local.ini. Você pode colocar qualquer configuração específica do PHP que queira substituir no arquivo local.ini.

Salve o arquivo e saia do seu editor.

Com o seu arquivo PHP local.ini no lugar, você pode seguir em frente para configurar o Nginx.

Passo 6 — Configurando o Nginx

Com o serviço PHP configurado, você pode modificar o serviço Nginx para usar o PHP-FPM como o servidor FastCGI a atender um conteúdo dinâmico. O servidor FastCGI baseia-se em um protocolo binário para relacionar programas interativos com um servidor Web. Para maiores informações, consulte este artigo Entendendo e implementando o proxy FastCGI no Nginx.

Para configurar o Nginx, será criado um arquivo app.conf com a configuração do serviço na pasta ~/laravel-app/nginx/conf.d/.

Primeiramente, crie o diretório nginx/conf.d/:

mkdir -p ~/laravel-app/nginx/conf.d

Em seguida, crie o arquivo de configuração app.conf:

nano ~/laravel-app/nginx/conf.d/app.conf

Adicione o código a seguir ao arquivo para especificar sua configuração do Nginx:

server {
    listen 80;
    index index.php index.html;
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
    root /var/www/public;
    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass app:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
    }
    location / {
        try_files $uri $uri/ /index.php?$query_string;
        gzip_static on;
    }
}

O bloco de servidor define a configuração do servidor Web Nginx com as diretrizes a seguir:

• listen: esta diretriz define a porta na qual o servidor irá escutar os pedidos de entrada.
• error_log e access_log: estas diretrizes definem os arquivos para a criação de registros.
• root: esta diretriz define o caminho da pasta root, formando o caminho completo para qualquer arquivo solicitado no sistema de arquivo local.

No bloco de localização php, a diretriz fastcgi_pass especifica que o serviço app está escutando em um socket TCP na porta 9000. Isso faz com que o servidor PHP-FPM escute pela rede em vez de escutar por um socket Unix. Embora um socket Unix tenha uma ligeira vantagem de velocidade em relação a um socket TCP, ele não tem um protocolo de rede e, desta maneira, ignora a pilha de rede. Para casos onde os hosts estão localizados em uma máquina, um socket Unix pode fazer sentido, mas nos casos em que se tenha serviços sendo executados em hosts diferentes, um socket TCP oferece a vantagem de permitir que você se conecte a serviços distribuídos. Pelo fato do nosso contêiner app estar sendo executado em um host diferente do nosso contêiner webserver, um socket TCP faz mais sentido para nossa configuração.

Salve o arquivo e saia do seu editor quando terminar de fazer alterações.

Graças ao bind mount criado no Passo 2, quaisquer alterações que você faça dentro da pasta nginx/conf.d/ serão refletidas diretamente dentro do contêiner webserver.

Em seguida, vamos olhar nossas configurações do MySQL.

Passo 7 — Configurando o MySQL

Com o PHP e o Nginx configurados, você pode habilitar o MySQL para agir como o banco de dados para seu aplicativo.

Para configurar o MySQL, será criado o arquivo my.cnf na pasta mysql. Este é o arquivo que você vinculou ao /etc/mysql/my.cnf dentro do contêiner no Passo 2. Este bind mount permite que você substitua as configurações my.cnf sempre que necessário.

Para demonstrar como isso funciona, adicionaremos as configurações ao arquivo my.cnf que habilitam o registro de consulta geral e especificam o arquivo de registro.

Primeiramente, crie o diretório mysql:

mkdir ~/laravel-app/mysql

Em seguida, crie o arquivo my.cnf:

nano ~/laravel-app/mysql/my.cnf

No arquivo, adicione o código a seguir para habilitar o registro de consulta e definir a localização do arquivo de registro:

[mysqld]
general_log = 1
general_log_file = /var/lib/mysql/general.log

Este arquivo my.cnf habilita os registros, definindo a configuração general_log em 1 para permitir registros gerais. A configuração general_log_file especifica onde os registros serão armazenados.

Salve o arquivo e saia do seu editor.

Nosso próximo passo será iniciar os contêineres.

Passo 8 — Modificando as configurações do ambiente e executando os contêineres

Agora que definiu todos os seus serviços no seu arquivo docker-compose e criou os arquivos de configuração para esses serviços, você pode iniciar os contêineres. Como passo final, porém, vamos fazer uma cópia do arquivo .env.example que o Laravel inclui por padrão e nomear a copia .env, que é o arquivo que o Laravel espera para definir seu ambiente:

cp .env.example .env

Você pode agora modificar o arquivo .env no contêiner app para incluir detalhes específicos sobre sua configuração.

Abra este arquivo usando o nano ou o editor de texto de sua escolha:

nano .env

Encontre o bloco que especifica o DB_CONNECTION e atualize-o para refletir as especificidades da sua configuração. Você modificará os seguintes campos:

• O DB_HOST será seu contêiner de banco de dados db.
• O DB_DATABASE será o banco de dados laravel.
• O DB_USERNAME será o nome de usuário que você usará para o seu banco de dados. Neste caso, vamos usar laraveluser.
• O DB_PASSWORD será a senha segura que você gostaria de usar para esta conta de usuário.

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laraveluser
DB_PASSWORD=your_laravel_db_password

Salve suas alterações e saia do seu editor.

Com todos os seus serviços definidos no seu arquivo docker-compose, você precisa emitir um único comando para iniciar todos os contêineres, criar os volumes e configurar e conectar as redes:

docker-compose up -d

Quando você executar o docker-compose up pela primeira vez, ele irá baixar todas as imagens Docker necessárias, o que pode levar um tempo. Assim que as imagens forem baixadas e armazenadas na sua máquina local, o Compose criará seus contêineres. A flag -d faz o daemon do processo, executando seus contêineres em segundo plano.

Assim que o processo for concluído, utilize o comando a seguir para listar todos os contêineres em execução:

docker ps

Você verá o seguinte resultado com detalhes sobre seus contêineres do app, webserver e db:

Output
CONTAINER ID        NAMES               IMAGE                             STATUS              PORTS
c31b7b3251e0        db                  mysql:5.7.22                      Up 2 seconds        0.0.0.0:3306->3306/tcp
ed5a69704580        app                 digitalocean.com/php              Up 2 seconds        9000/tcp
5ce4ee31d7c0        webserver           nginx:alpine                      Up 2 seconds        0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp

O CONTAINER ID neste resultado é um identificador único para cada contêiner, enquanto o NAMES lista o nome do serviço associado a cada um. Você pode usar ambos esses identificadores para acessar os contêineres. IMAGE define o nome da imagem para cada contêiner, enquanto o STATUS fornece informações sobre o estado do contêiner: se ele está em execução, reiniciando ou parado.

Usaremos agora o docker-compose exec para definir a chave do aplicativo para o aplicativo Laravel. O comando docker-compose exec permite que você execute comandos específicos em contêineres.

Este comando gerará uma chave e a copiará para seu arquivo .env, garantindo que as sessões do seu usuário e os dados criptografados permaneçam seguros:

docker-compose exec app php artisan key:generate

Você tem agora as configurações de ambiente necessárias para executar seu aplicativo. Para colocar essas configurações em um arquivo de cache, que irá aumentar a velocidade de carregamento do seu aplicativo, execute:

docker-compose exec app php artisan config:cache

Suas definições da configuração serão carregadas em /var/www/bootstrap/cache/config.php no contêiner.

Como passo final, visite http://your_server_ip​​​ no navegador. Você verá a seguinte página inicial para seu aplicativo Laravel:

Com os seus contêineres em execução e as suas informações de configuração definidas, você pode seguir em frente para configurar as informações do seu usuário para o banco de dados laravel no contêiner db.

Passo 9 — Criando um usuário para o MySQL

A instalação padrão do MySQL cria apenas a conta administrativa root, que tem privilégios ilimitados no servidor do banco de dados. Geralmente, é melhor evitar usar contas administrativas root ao interagir com o banco de dados. Ao invés disso, vamos criar um usuário de banco de dados dedicado para o banco de dados do nosso aplicativo Laravel.

Para criar um novo usuário, execute uma bash shell interativa no contêiner db com o docker-compose exec:

docker-compose exec db bash

Dentro do contêiner, logue na conta administrativa root do MySQL:

mysql -u root -p

Você será solicitado a inserir a senha que você definiu para a conta root do MySQL durante a instalação no seu arquivo docker-compose.

Inicie procurando pelo banco de dados chamado laravel que você definiu no seu arquivo docker-compose. Execute o comando show databases para procurar por bancos de dados existentes:

show databases;

Você verá o banco de dados laravel listado no resultado:

Output
+--------------------+
| Database           |
+--------------------+
| information_schema |
| laravel            |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
5 rows in set (0.00 sec)

Em seguida, crie a conta de usuário que terá permissão para acessar esse banco de dados. Nosso nome de usuário será laraveluser, embora você possa substituí-lo por outro nome se preferir. Certifique-se apenas de que seu nome de usuário e senha aqui utilizados correspondam aos detalhes que você definiu no seu arquivo .env no passo anterior:

GRANT ALL ON laravel.* TO 'laraveluser'@'%' IDENTIFIED BY 'your_laravel_db_password';

Reinicie os privilégios para notificar o servidor MySQL das alterações:

FLUSH PRIVILEGES;

Saia do MySQL:

EXIT;

Por fim, saia do contêiner:

exit

Você configurou a conta de usuário para seu banco de dados do aplicativo Laravel e está pronto para migrar seus dados e trabalhar com o console Tinker.

Passo 10 — Migrando dados e trabalhando com o console Tinker

Com seu aplicativo em execução, você pode migrar seus dados e testar o comando tinker, que iniciará um console PsySH com o Laravel pré-carregado. O PsySH é um console de desenvolvimento runtime e um corretor de bugs interativo para o PHP e o Tinker é um REPL específico para o Laravel. Usar o comando tinker permitirá que você interaja com seu aplicativo Laravel a partir da linha de comando em uma shell interativa.

Primeiramente, teste a conexão com o MySQL executando o comando Laravel artisan migrate, que cria uma tabela migrations no banco de dados de dentro do contêiner:

docker-compose exec app php artisan migrate

Este comando irá migrar as tabelas padrão do Laravel. O resultado que confirma a migração será como este:

Output
Migration table created successfully.
Migrating: 2014_10_12_000000_create_users_table
Migrated:  2014_10_12_000000_create_users_table
Migrating: 2014_10_12_100000_create_password_resets_table
Migrated:  2014_10_12_100000_create_password_resets_table

Assim que a migração for concluída, você pode fazer uma consulta para verificar se está devidamente conectado ao banco de dados usando o comando tinker:

docker-compose exec app php artisan tinker

Teste a conexão do MySQL obtendo os dados que acabou de migrar:

\DB::table('migrations')->get();

Você verá um resultado que se parece com este:

Output
=> Illuminate\Support\Collection {#2856
     all: [
       {#2862
         +"id": 1,
         +"migration": "2014_10_12_000000_create_users_table",
         +"batch": 1,
       },
       {#2865
         +"id": 2,
         +"migration": "2014_10_12_100000_create_password_resets_table",
         +"batch": 1,
       },
     ],
   }

Você pode usar o tinker para interagir com seus bancos de dados e testar serviços e modelos.

Com seu aplicativo Laravel funcionando, você está pronto para mais desenvolvimento e experimentação.

Conclusão

Você tem agora um aplicativo de pilha LEMP em execução no seu servidor, que você testou ao acessar a página inicial do Laravel e ao criar migrações de banco de dados MySQL.

A chave para a simplicidade desta instalação é o Docker Compose, que permite que você crie um grupo de contêineres Docker, definidos em um único arquivo, com um único comando. Se você quiser aprender mais sobre como fazer integração contínua com o Docker Compose, veja Como configurar um ambiente de teste de integração contínua com o Docker e o Docker Compose no Ubuntu 16.04. Se você quiser simplificar seu processo de implantação do aplicativo Laravel, então o Como implantar aplicativos Laravel automaticamente com o Deployer no Ubuntu 16.04 será uma leitura relevante.