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 aplicativos PHP modernos. Com uma grande variedade de pacotes e extensões compatíveis, o Laravel se tornou popular, com muitos desenvolvedores adotando-o como sua estrutura preferida. 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 Artisan, com a qual os desenvolvedores podem inicializar novos modelos, controladores e outros componentes de aplicativo, o que acelera o desenvolvimento geral do aplicativo.
Conteinerizar um aplicativo refere-se ao processo de adaptação de um aplicativo e seus componentes para poder executá-lo em ambientes leves conhecidos como contêineres. Este guia usará o Docker Compose para conteinerizar um aplicativo Laravel para desenvolvimento.
Criaremos três contêineres Docker para nossa aplicação Laravel.
- Um serviço
appexecutando PHP 8.2-FPM - Um serviço
dbexecutando MySQL 8.0 - Um serviço
nginxque usa o serviçoapppara analisar o código PHP antes de servir o aplicativo Laravel ao usuário
Também criaremos um certificado SSL para nosso site Laravel usando 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 o seu servidor. Para nossos propósitos, usaremos example.com como nome de domínio.
Certifique-se de que tudo esteja atualizado.
$ sudo apt update
Instale pacotes de utilitários básicos. Alguns deles já podem 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 Firewall
O primeiro passo é configurar o firewall. O Ubuntu vem com ufw (Firewall Descomplicado) 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 portas HTTP e HTTPS também.
$ sudo ufw allow http
$ sudo ufw allow https
Habilite o Firewall
$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup
Verifique o status do firewall novamente.
$ sudo ufw status
Você deverá ver uma saída semelhante.
Status: active
To Action From
-- ------ ----
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. Criaremos isso fora do Docker, pois é fácil de manter. Posteriormente, sincronizaremos os certificados com o contêiner, que será renovado e atualizado regularmente.
Precisamos instalar o Certbot para gerar o certificado SSL. Você pode instalar o Certbot usando o repositório do Ubuntu ou obter a versão mais recente usando a ferramenta Snapd. Estaremos usando a versão Snapd.
Ubuntu 22.04 vem com 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 comando a seguir 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 -d example.com
O comando acima fará download de um certificado para o diretório /etc/letsencrypt/live/example.com em seu servidor.
Gere um certificado do grupo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Faça uma simulação do processo para verificar se a renovação do SSL está funcionando bem.
$ sudo certbot renew --dry-run
Se você não encontrar 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.
Etapa 3 - Instale o Docker e o 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 Docker GPG.
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
Crie um arquivo de repositório 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 ele 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 o uso de 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 fazer login novamente como o mesmo usuário para ativar essa alteração ou usar o seguinte comando.
$ su - ${USER}
Confirme se seu usuário foi adicionado ao grupo Docker.
$ groups
navjot wheel docker
Passo 4 - Baixe o Laravel e instale as 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 do aplicativo Laravel.
$ mkdir ~/laravel
Mude para o diretório.
$ cd ~/laravel
Clone a versão mais recente do Laravel no diretório. Não esqueça o . no final do comando, o que significa que o Git irá clonar os arquivos no diretório atual.
$ git clone https://github.com/laravel/laravel.git .
Use a imagem Compose do Docker para montar os diretórios necessários para o 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 em ligação ao seu 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 pertença ao usuário logado no momento.
$ sudo chown -R $USER:$USER ~/laravel
Etapa 5 - Crie o arquivo Docker Compose
Crie e abra o arquivo de composição do Docker 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 no 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 examinar os serviços em detalhes.
app- Este serviço define a aplicação Laravel e executa uma imagem Docker do cliente intituladahowtoforge/app. Criaremos esta imagem na próxima etapa. O diretório de trabalho do Laravel dentro do contêiner é definido em/var/wwwque é mapeado para o diretório atual no host. Também montamos um arquivo de configuração PHP que é copiado para o contêiner PHP. Iremos configurar isso em uma etapa posterior.webserver- Este serviço cria um contêiner usando a imagem Nginx Docker e expõe as portas 80 e 443 ao host. Também montamos volumes para logs Nginx, configuração personalizada, diretório de aplicativos Laravel e certificados SSL.db- Este serviço cria um contêiner usando a imagem MySQL Docker 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 substituirMYSQL_ROOT_PASSWORDpor 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 ligamos o volume de montagem para configuração personalizada do MySQL e um volume local para dados do MySQL. Isso permite reiniciar o serviçodbsem perder os dados.
Para fazer com que os serviços se comuniquem entre si, criamos uma rede Docker chamada app-network . Está definido como uma rede bridge. Ele permite que os contêineres conectados a ele 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 – Crie 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 do seu aplicativo. Você também pode publicar sua imagem personalizada no Docker Hub ou em qualquer registro privado do Docker.
Crie e abra o Dockerfile para edição.
$ nano Dockerfile
Cole o seguinte código nele.
FROM php:8.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 \
libzip-dev \
unzip \
git \
curl \
libonig-dev
# 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 --enable-gd --with-freetype --with-jpeg
RUN docker-php-ext-install gd
# Install composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
# Copy existing application directory contents to the working directory
COPY . /var/www
# Assign permissions of the working directory to the www-data user
RUN chown -R www-data:www-data \
/var/www/storage \
/var/www/bootstrap/cache
# Assign writing permissions to logs and framework directories
RUN chmod 775 storage/logs \
/var/www/storage/framework/sessions \
/var/www/storage/framework/views
# Expose port 9000 and start php-fpm server
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 sobre a imagem Docker php:8.2-fpm. Esta é uma imagem baseada em Debian que possui 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 definir configurações dentro do contêiner, a diretiva COPY para copiar arquivos para o contêiner, COPY para copiar arquivos para o contêiner, COPY diretivaEXPOSE para expor uma porta no contêiner e diretiva CMD para executar um comando.
Primeiro, copiamos os arquivos do Composer do diretório Laravel no host dentro do contêiner para o diretório /var/www. Também definimos o diretório de trabalho do contêiner como /var/www. Em seguida, instalamos vários pré-requisitos e pacotes necessários para o funcionamento do Laravel, incluindo extensões PHP, incluindo mbstring, gd, exif, zip, pdo_mysql e pcntl. Em seguida, instalamos o gerenciador de pacotes Composer.
A seguir, 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. A seguir, definimos permissões de gravação corretas para os logs, sessões e diretórios de visualizações do Laravel.
E por fim, expomos a porta 9000 para o serviço PHP-FPM que será utilizado pelo servidor Nginx, e executamos o comando PHP para iniciar o container.
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. Estas diretivas definem o tamanho máximo dos arquivos carregados. Altere o valor conforme suas necessidades. Você pode colocar qualquer configuração específica do PHP para substituir as diretivas padrão.
Etapa 8 – Configurar o 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 Nginx para usar PHP-FPM como 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 {
# Redirect any http requests to 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 versões HTTP e HTTPS do site Laravel e redirecionar qualquer solicitação HTTP para HTTPS automaticamente. 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á escutando em um soquete TCP na porta 9000. O servidor PHP-FPM também pode escutar em um soquete Unix que tem uma vantagem sobre um soquete TCP. Mas não funciona se os serviços estiverem sendo executados em hosts diferentes, o 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
Configuraremos o MySQL para habilitar o log de consulta geral 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 containers. Mas antes de fazermos isso, precisamos configurar as variáveis de ambiente do 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 do 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 de composição do Docker.
Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.
Passo 11 - Inicie os Containers e conclua a instalação do Laravel
Finalmente é hora de iniciar os contêineres.
$ docker compose up -d
Este comando, quando executado pela primeira vez, extrairá as imagens Nginx, MySQL e criará a imagem app usando o Dockerfile nós criamos. Assim que o processo for concluído, você pode verificar o status de 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
Assim que os contêineres estiverem em execução, é hora de terminar a instalação do Laravel usando o comando docker compose exec para executar comandos dentro do contêiner.
Gere uma chave de aplicativo e copie-a para o arquivo .env para proteger as sessões do usuário e criptografar os dados do usuário.
$ docker compose exec app php artisan key:generate
Crie o cache do aplicativo Laravel.
$ docker compose exec app php artisan config:cache
Este comando carregará as definições de configuração no arquivo /var/www/bootstrap/cache/config.php.
Visite https://example.com em seu navegador e você verá a seguinte página indicando a instalação bem-sucedida do Laravel.
Passo 12 – Configurar renovação SSL
Agora que o site Laravel está ativo, é hora de revisitar as configurações de SSL para configurar a renovação. Para isso, precisaremos criar scripts para parar o serviço webserver antes de iniciar a renovação e reiniciar o serviço assim que o certificado for renovado. Certbot fornece dois ganchos, pre_hook e post_hook para essa finalidade.
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/<username>/laravel/ssl/server-stop.sh
post_hook = /home/<username>/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 uma simulação.
$ sudo certbot renew --dry-run
Você obterá 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 atender sua aplicação Laravel.
Passo 13 - Migração de Dados e Console Tinker
Agora que o aplicativo 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 o Laravel pré-carregado. PsySH é um console de desenvolvedor em tempo de execução e um depurador interativo para PHP. O comando tinker permite interagir 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 migrações no banco de dados.
$ docker compose exec app php artisan migrate
Você obterá 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ê obterá 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ê conteinerizou e instalou o aplicativo Laravel usando Docker, MySQL e PHP. Você também serviu o aplicativo em um nome de domínio seguro. Se você tiver alguma dúvida, poste-a nos comentários abaixo.