Laravel Docker · 18 min read · Sep 23, 2025

Como Instalar o Laravel com Docker no Ubuntu 22.04

Laravel é um framework PHP gratuito e de código aberto que fornece um conjunto de ferramentas e recursos para construir aplicações PHP modernas. Com uma ampla variedade de pacotes e extensões compatíveis, o Laravel se tornou popular, com muitos desenvolvedores adotando-o como seu framework de escolha. O Laravel fornece ferramentas poderosas de banco de dados, incluindo um ORM (Object Relational Mapper) chamado Eloquent e mecanismos integrados para criar migrações de banco de dados. Ele vem com uma ferramenta de linha de comando chamada Artisan, que permite aos desenvolvedores inicializar novos modelos, controladores e outros componentes da aplicação, acelerando o desenvolvimento geral da aplicação.

Containerizar uma aplicação refere-se ao processo de adaptar uma aplicação e seus componentes para que possam ser executados em ambientes leves conhecidos como contêineres. Este guia usará o Docker Compose para containerizar uma aplicação Laravel para desenvolvimento.

Criamos três contêineres Docker para nossa aplicação Laravel.

  • Um serviço app executando PHP 8.2-FPM
  • Um serviço db executando MySQL 8.0
  • Um serviço nginx que usa o serviço app para processar código PHP antes de servir a aplicação Laravel ao usuário

Também criaremos um certificado SSL para nosso site Laravel usando o Let’s Encrypt.

Pré-requisitos

  • Um servidor executando Ubuntu 22.04.
  • Um usuário não-root com privilégios sudo.
  • Um nome de domínio totalmente qualificado (FQDN) apontando para seu servidor. Para nossos propósitos, usaremos example.com como o nome de domínio.
  • Certifique-se de que tudo está atualizado. $ sudo apt update
  • Instale pacotes utilitários básicos. Alguns deles podem já estar instalados. $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y

Passo 1 - Configurar o Firewall

O primeiro passo é configurar o firewall. O Ubuntu vem com o ufw (Uncomplicated Firewall) por padrão.

Verifique se o firewall está em execução.

$ sudo ufw status

Você deve obter a seguinte saída.

Status: inactive

Permita a porta SSH para que o firewall não interrompa a conexão atual ao ativá-lo.

$ sudo ufw allow OpenSSH

Permita também as portas HTTP e HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Ative o Firewall

$ sudo ufw enable
Comando pode interromper conexões ssh existentes. Prosseguir com a operação (y|n)? y
Firewall está ativo e habilitado na inicialização do sistema

Verifique o status do firewall novamente.

$ sudo ufw status

Você deve ver uma saída semelhante.

Status: active

Para                         Ação      De
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Passo 2 - Instalar SSL

Antes de prosseguir, vamos primeiro criar um certificado SSL para nosso domínio. Faremos isso fora do Docker, pois é mais fácil de manter. Mais tarde, sincronizaremos os certificados com o contêiner, que serão renovados e atualizados regularmente.

Precisamos instalar o Certbot para gerar o certificado SSL. Você pode instalar o Certbot usando o repositório do Ubuntu ou pegar a versão mais recente usando a ferramenta Snapd. Usaremos a versão Snapd.

O Ubuntu 22.04 vem com o Snapd instalado por padrão. Execute os seguintes comandos para garantir que sua versão do Snapd esteja atualizada. Certifique-se de que sua versão do Snapd esteja atualizada.

$ sudo snap install core
$ sudo snap refresh core

Instale o Certbot.

$ sudo snap install --classic certbot

Use o seguinte comando para garantir que o comando Certbot seja executado criando um link simbólico para o diretório /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Execute o seguinte comando para gerar um Certificado SSL.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d example.com

O comando acima fará o download de um certificado para o diretório /etc/letsencrypt/live/example.com em seu servidor.

Gere um certificado Diffie-Hellman group.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Faça um teste do processo para verificar se a renovação do SSL está funcionando corretamente.

$ sudo certbot renew --dry-run

Se você não vir erros, está tudo pronto. Seu certificado será renovado automaticamente.

Após configurar o Docker e instalar o Laravel, o processo de renovação precisará ser modificado. Abordaremos isso em uma seção posterior.

Passo 3 - Instalar Docker e Docker Compose

O Ubuntu 22.04 vem com uma versão mais antiga do Docker. Para instalar a versão mais recente, primeiro, importe a chave GPG do Docker.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Crie um arquivo de repositório do Docker.

$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Atualize a lista de repositórios do sistema.

$ sudo apt update

Instale a versão mais recente do Docker.

$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Verifique se está em execução.

$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: active (running) since Sat 2023-01-14 10:41:35 UTC; 2min 1s ago
TriggeredBy: ? docker.socket
       Docs: https://docs.docker.com
   Main PID: 2054 (dockerd)
      Tasks: 52
     Memory: 22.5M
        CPU: 248ms
     CGroup: /system.slice/docker.service
             ??  2054 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Por padrão, o Docker requer privilégios de root. Se você quiser evitar usar sudo toda vez que executar o comando docker, adicione seu nome de usuário ao grupo docker.

$ sudo usermod -aG docker $(whoami)

Você precisará sair do servidor e entrar novamente como o mesmo usuário para habilitar essa alteração ou usar o seguinte comando.

$ su - ${USER}

Confirme que seu usuário foi adicionado ao grupo Docker.

$ groups
navjot wheel docker

Passo 4 - Baixar o Laravel e Instalar Dependências

O primeiro passo é baixar a versão mais recente do Laravel e instalar as dependências, incluindo o Composer, o gerenciador de pacotes PHP.

Crie o diretório da aplicação Laravel.

$ mkdir ~/laravel

Mude para o diretório.

$ cd ~/laravel

Clone a versão mais recente do Laravel para o diretório. Não se esqueça do . no final do comando, que significa que o Git clonará os arquivos no diretório atual.

$ git clone https://github.com/laravel/laravel.git .

Use a imagem do Compose do Docker para montar os diretórios que você precisa para seu projeto Laravel. Isso evita a necessidade de instalar o Composer globalmente.

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

O comando acima cria um contêiner efêmero que é montado no diretório atual antes de ser removido. Ele copia o conteúdo do seu diretório Laravel para o contêiner e garante que a pasta vendor que o Composer cria dentro do contêiner seja copiada de volta para o diretório atual.

Defina permissões no diretório Laravel para que ele seja de propriedade do usuário atualmente logado.

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

Passo 5 - Criar o Arquivo Docker Compose

Crie e abra o arquivo Docker compose para edição.

$ nano docker-compose.yml

Cole o seguinte código nele. Aqui, definimos três serviços: app, webserver e db. Substitua MYSQL_ROOT_PASSWORD sob o serviço db por uma senha forte de sua escolha.

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: howtoforge/app
    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

  webserver:
    container_name: webserver
    image: nginx:alpine
    restart: unless-stopped
    tty: true
    ports:
        - 80:80
        - 443:443
    volumes:
        - ./:/var/www
        - ./nginx/conf.d:/etc/nginx/conf.d
        - ./nginx/logs:/var/log/nginx
        - /etc/ssl/certs/dhparam.pem:/etc/ssl/certs/dhparam.pem
        - /etc/letsencrypt:/etc/letsencrypt
    logging:
        options:
            max-size: "10m"
            max-file: "3"
    networks:
      - app-network

  db:
    image: mysql:latest
    container_name: db
    restart: unless-stopped
    tty: true
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_ROOT_PASSWORD: MYSQL_ROOT_PASSWORD
      MYSQL_USER: laraveluser
      MYSQL_PASSWORD: password
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - dbdata:/var/lib/mysql
      - ./mysql/my.cnf:/etc/mysql/my.cnf
    networks:
      - app-network

volumes:
  dbdata:
    driver: local

networks:
  app-network:
    driver: bridge

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Vamos passar pelos serviços em detalhes.

  • app - Este serviço define a aplicação Laravel e executa uma imagem Docker personalizada chamada howtoforge/app. Criaremos essa imagem na próxima etapa. O diretório de trabalho para o Laravel dentro do contêiner é definido como /var/www, que é mapeado para o diretório atual no host. Também montamos um arquivo de configuração PHP que é copiado para o contêiner PHP. Vamos configurar isso em uma etapa posterior.
  • webserver - Este serviço cria um contêiner usando a imagem Docker do Nginx e expõe as portas 80 e 443 para o host. Também montamos volumes para logs do Nginx, configuração personalizada, diretório da aplicação Laravel e certificados SSL.
  • db - Este serviço cria um contêiner usando a imagem Docker do MySQL e define variáveis de ambiente configurando o nome do banco de dados e a senha root do MySQL. Você pode nomear o banco de dados como quiser e substituir MYSQL_ROOT_PASSWORD por uma senha forte de sua escolha. Além disso, defina o nome de usuário do MySQL (MYSQL_USER_NAME) e a senha (MYSQL_USER_PASSWORD) que terão acesso ao banco de dados que você escolheu. Este serviço também mapeia a porta 3306 do contêiner para a porta 3306 no host. Também montamos um volume para configuração personalizada do MySQL e um volume local para dados do MySQL. Isso permite que você reinicie o serviço db sem perder os dados.

Para fazer os serviços se comunicarem entre si, criamos uma rede Docker chamada app-network. Ela é configurada como uma rede bridge. Isso permite que os contêineres conectados a ela se comuniquem entre si. O driver de rede bridge instala regras na máquina host para que contêineres em diferentes redes bridge não possam se comunicar diretamente entre si.

Passo 6 - Criar o Dockerfile

Um Dockerfile é usado para criar imagens personalizadas. Não existe uma imagem padrão para o Laravel, por isso precisamos definir um Dockerfile para criar uma imagem personalizada para o Laravel. Ele contém comandos para instalar pacotes e configurar o ambiente Linux dependendo das necessidades da sua aplicação. Você também pode publicar sua imagem personalizada no Docker Hub ou em qualquer registro Docker privado. Você pode aprender mais em nosso tutorial sobre Dockerfile.

Crie e abra o Dockerfile para edição.

$ nano Dockerfile

Cole o seguinte código nele.

FROM php:8.2-fpm

# Copiar composer.lock e composer.json
COPY composer.lock composer.json /var/www/

# Definir diretório de trabalho
WORKDIR /var/www

# Instalar dependências
RUN apt-get update && apt-get install -y \
    build-essential \
    libpng-dev \
    libjpeg62-turbo-dev \
    libfreetype6-dev \
    locales \
    zip \
    jpegoptim optipng pngquant gifsicle \
    vim \
    libzip-dev \
    unzip \
    git \
    curl \
    libonig-dev

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

# Instalar extensões
RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl
RUN docker-php-ext-configure gd --enable-gd --with-freetype --with-jpeg
RUN docker-php-ext-install gd

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

# Copiar o conteúdo do diretório da aplicação existente para o diretório de trabalho
COPY . /var/www

# Atribuir permissões do diretório de trabalho ao usuário www-data
RUN chown -R www-data:www-data \
        /var/www/storage \
        /var/www/bootstrap/cache

# Atribuir permissões de escrita aos diretórios de logs e framework
RUN chmod 775 storage/logs \
        /var/www/storage/framework/sessions \
        /var/www/storage/framework/views

# Expor a porta 9000 e iniciar o servidor php-fpm
EXPOSE 9000
CMD ["php-fpm"]

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Vamos ver o que está acontecendo aqui. Primeiro, criamos nossa imagem personalizada em cima da imagem docker:php:8.2-fpm. Esta é uma imagem baseada em Debian que tem o PHP 8.2-FPM instalado. O Dockerfile usa várias diretivas para realizar operações, a diretiva RUN especifica os comandos para atualizar, instalar e configurar as configurações dentro do contêiner, a diretiva COPY para copiar arquivos para dentro do contêiner, a diretiva EXPOSE para expor uma porta no contêiner e a diretiva CMD para executar um comando.

Primeiro, copiamos os arquivos do Composer do diretório Laravel no host para dentro do contêiner no diretório /var/www. Também definimos o diretório de trabalho para o contêiner como /var/www. Em seguida, instalamos vários pré-requisitos e pacotes necessários para o Laravel funcionar, incluindo extensões PHP como mbstring, gd, exif, zip, pdo_mysql e pcntl. Depois, instalamos o gerenciador de pacotes Composer.

Em seguida, copiamos todos os arquivos do diretório Laravel para o contêiner e definimos permissões no diretório de trabalho para o usuário www-data. Este é o usuário que o PHP usa por padrão na plataforma Debian. Em seguida, definimos as permissões corretas de escrita para os diretórios de logs, sessões e views do Laravel.

E finalmente, expomos a porta 9000 para o serviço PHP-FPM, que será usado pelo servidor Nginx, e executamos o comando PHP para iniciar o contêiner.

Passo 7 - Configurar PHP

Crie o diretório PHP.

$ mkdir ~/laravel/php

Crie e abra o arquivo local.ini para edição.

$ nano local.ini

Cole o seguinte código nele.

upload_max_filesize=40M
post_max_size=40M

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado. Essas diretivas definem o tamanho máximo de upload para arquivos enviados. Altere o valor conforme suas necessidades. Você pode colocar qualquer configuração específica do PHP para substituir as diretivas padrão.

Passo 8 - Configurar Nginx

Crie o diretório Nginx para a configuração do site.

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

Precisamos criar um arquivo de configuração do Nginx para usar o PHP-FPM como o servidor FastCGI para servir o Laravel.

Crie e abra o arquivo app.conf para edição.

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

Cole o seguinte código nele.

server {
    # Redirecionar qualquer solicitação http para https
    listen 80;
    listen [::]:80;
    server_name example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    index index.php index.html;

    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;

    root /var/www/public;
    client_max_body_size 40m;

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;
    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:10m;
    ssl_session_tickets off;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers off;
    ssl_ecdh_curve secp384r1;
    ssl_dhparam /etc/ssl/certs/dhparam.pem;

    # OCSP stapling
    ssl_stapling on;
    ssl_stapling_verify on;
    resolver 8.8.8.8 8.8.4.4 valid=300s;
    resolver_timeout 5s;

    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;
    }
}

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

O arquivo acima configura o Nginx para servir tanto as versões HTTP quanto HTTPS do site Laravel e redirecionar automaticamente qualquer solicitação HTTP para HTTPS. Certifique-se de que o valor da variável client_max_body_size corresponda ao tamanho de upload definido na etapa anterior.

No bloco de localização do PHP, a diretiva fastcgi_pass especifica que o serviço app está ouvindo em um socket TCP na porta 9000. O servidor PHP-FPM também pode ouvir em um socket Unix, que tem uma vantagem sobre um socket TCP. Mas isso não funciona se os serviços estiverem sendo executados em hosts diferentes, que é o caso aqui, pois o contêiner app está sendo executado em um host diferente do seu contêiner webserver.

Passo 9 - Configurar MySQL

Vamos configurar o MySQL para habilitar o log de consultas gerais e especificar o arquivo de log correspondente.

Crie o diretório MySQL.

$ mkdir ~/laravel/mysql

Crie e abra o arquivo my.cnf para edição.

$ nano ~/laravel/my.cnf

Cole o seguinte código nele.

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

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Passo 10 - Configurando o Arquivo de Ambiente

Agora que criamos e configuramos todos os serviços, é hora de iniciar os contêineres. Mas antes de fazermos isso, precisamos configurar as variáveis de ambiente para o Laravel. O Laravel vem com um arquivo de ambiente padrão, .env.example.

Crie uma cópia do arquivo de ambiente de exemplo.

$ cp .env.example .env

Abra o arquivo .env para edição.

$ nano .env

Encontre o bloco começando com DB_CONNECTION e atualize os valores das variáveis de acordo com suas necessidades.

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

O valor de DB_HOST será o serviço db. O DB_NAME, DB_USERNAME e DB_PASSWORD serão o nome do banco de dados, nome de usuário e senha que você escolheu na etapa 4 no arquivo Docker compose.

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Passo 11 - Iniciar os Contêineres e Completar a Instalação do Laravel

Finalmente, é hora de iniciar os contêineres.

$ docker compose up -d

Este comando, quando executado pela primeira vez, puxará as imagens Nginx, MySQL e criará a imagem app usando o Dockerfile que criamos. Uma vez que o processo esteja completo, você pode verificar o status dos seus contêineres usando o seguinte comando.

$ docker ps

Você verá uma saída semelhante.

CONTAINER ID   IMAGE            COMMAND                  CREATED       STATUS       PORTS                                                                      NAMES
a57be976c0fa   mysql:latest     "docker-entrypoint.s…"   6 hours ago   Up 6 hours   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp                       db
85e515c4a404   howtoforge/app   "docker-php-entrypoi…"   6 hours ago   Up 6 hours   9000/tcp                                                                   app
8418bbc83bd3   nginx:alpine     "/docker-entrypoint.…"   6 hours ago   Up 6 hours   0.0.0.0:80->80/tcp, :::80->80/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp   webserver

Uma vez que os contêineres estejam em execução, é hora de finalizar a instalação do Laravel usando o comando docker compose exec para executar comandos dentro do contêiner.

Gere uma chave de aplicação e copie-a para seu arquivo .env para proteger sessões de usuários e criptografar dados de usuários.

$ docker compose exec app php artisan key:generate

Crie o cache da aplicação Laravel.

$ docker compose exec app php artisan config:cache

Este comando carregará as configurações no arquivo /var/www/bootstrap/cache/config.php.

Visite https://example.com em seu navegador e você verá a seguinte página implicando a instalação bem-sucedida do Laravel.

Página Inicial do Laravel

Passo 12 - Configurar Renovação do SSL

Agora que o site Laravel está ativo, é hora de revisitar as configurações do SSL para configurar a renovação. Para isso, precisaremos criar scripts para parar o serviço webserver antes de iniciar a renovação e iniciar o serviço novamente uma vez que o certificado seja renovado. O Certbot fornece dois hooks, pre_hook e post_hook para esse propósito.

Crie o diretório SSL para armazenar os scripts.

$ mkdir ~/laravel/ssl

Crie o script server-stop.sh.

$ sh -c 'printf "#!/bin/sh\ndocker stop webserver\n" > ~/laravel/ssl/server-stop.sh'

Crie o script server-start.sh.

$ sh -c 'printf "#!/bin/sh\ndocker start webserver\n" > ~/laravel/ssl/server-start.sh'

Torne os scripts executáveis.

$ chmod +x ~/laravel/ssl/server-*.sh

Agora precisamos dizer ao Certbot para usar esses scripts. Abra o arquivo /etc/letsencrypt/renewal/example.com.conf para edição.

$ sudo nano /etc/letsencrypt/renewal/example.com.conf

Cole as seguintes linhas no final do arquivo.

pre_hook = /home//laravel/ssl/server-stop.sh
post_hook = /home//laravel/ssl/server-start.sh

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Teste o processo de renovação do Certificado fazendo um teste.

$ sudo certbot renew --dry-run

Você receberá uma saída semelhante confirmando o sucesso.

Saving debug log to /var/log/letsencrypt/letsencrypt.log

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Processing /etc/letsencrypt/renewal/example.com.conf
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Account registered.
Hook 'pre-hook' ran with output:
 webserver
Simulating renewal of an existing certificate for example.com

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Congratulations, all simulated renewals succeeded:
  /etc/letsencrypt/live/example.com/fullchain.pem (success)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Hook 'post-hook' ran with output:
 webserver

Seus certificados SSL agora serão renovados automaticamente e usados pelo contêiner Docker para servir sua aplicação Laravel.

Passo 13 - Migração de Dados e Console Tinker

Agora que a aplicação está em execução, você pode migrar seus dados e experimentar o comando tinker. Tinker é um REPL (Read-Eval-Print Loop) para Laravel. O comando tinker inicia um console PsySH com Laravel pré-carregado. PsySH é um console de desenvolvedor em tempo de execução e um depurador interativo para PHP. O comando tinker permite que você interaja com a aplicação Laravel a partir da linha de comando em um shell interativo.

Teste a conexão MySQL usando o comando artisan migrate no contêiner. Ele criará uma tabela migrations no banco de dados.

$ docker compose exec app php artisan migrate

Você receberá a seguinte saída.

 INFO  Preparing database.

  Creating migration table .............................................................................................. 32ms DONE

 INFO  Running migrations.

  2014_10_12_000000_create_users_table .................................................................................. 184ms DONE
  2014_10_12_100000_create_password_resets_table ......................................................................... 259ms DONE
  2019_08_19_000000_create_failed_jobs_table ............................................................................ 102ms DONE
  2019_12_14_000001_create_personal_access_tokens_table .................................................................. 46ms DONE

Em seguida, inicie o console PsySH usando o comando tinker.

$ docker compose exec app php artisan tinker

Você receberá o seguinte prompt.

Psy Shell v0.11.10 (PHP 8.2.1 — cli) by Justin Hileman
>

Teste a conexão MySQL obtendo os dados que você acabou de migrar executando o seguinte comando no prompt do console.

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

Você receberá a seguinte saída.

= Illuminate\Support\Collection {#3670
    all: [
      {#3679
        +"id": 1,
        +"migration": "2014_10_12_000000_create_users_table",
        +"batch": 1,
      },
      {#3681
        +"id": 2,
        +"migration": "2014_10_12_100000_create_password_resets_table",
        +"batch": 1,
      },
      {#3682
        +"id": 3,
        +"migration": "2019_08_19_000000_create_failed_jobs_table",
        +"batch": 1,
      },
      {#3683
        +"id": 4,
        +"migration": "2019_12_14_000001_create_personal_access_tokens_table",
        +"batch": 1,
      },
    ],
  }

Digite exit para sair do console.

> exit
   INFO  Goodbye.

Você pode usar tinker para interagir com seus bancos de dados e experimentar serviços e modelos. Agora você pode começar a usar o Laravel para desenvolvimento adicional.

Conclusão

Isso conclui nosso tutorial, onde você containerizou e instalou a aplicação Laravel usando Docker, MySQL e PHP. Você também serviu a aplicação em um nome de domínio seguro. Se você tiver alguma dúvida, poste nos comentários abaixo.

Share: X/Twitter LinkedIn
#Laravel Docker

Receba novas postagens na sua caixa de entrada

Sem spam. Cancele a assinatura a qualquer momento.