Desenvolvimento de Sistemas para Automação Comercial

Voltar

Laravel - 29/05/2026


Criar ambiente de desenvolvimento WSL:

  • Extensões VS Code:

    Ajustar o Laravel com o VS Code:

    Conteúdo do .eslintrc.json:

    Sempre que instalar um módulo novo:

    Ajustes no VS Code: pressione F1 e procure por:

    Cole o settings.json:

  • Criar Projeto:

    O Docker é um gerenciador de containers e tem um plugin chamado compose. O que será usado primeiro é a imagem oficial do composer, que criará a estrutura do Laravel (uma aplicação em PHP). Por isso, quando falamos em app, estamos nos referindo ao Laravel.

    O Docker baixa e executa a imagem do composer, que cria a estrutura do Laravel pelo comando composer create-project laravel/laravel .:

    Quando o projeto já existir (por exemplo, baixado por git clone), o composer precisa ser executado novamente para instalar as dependências que não vão para o GitHub (a pasta vendor).

  • PHP:

    Depois de criada a estrutura do Laravel pelo composer, além de instalar os requisitos do arquivo composer.json, o comando acima também espelha os arquivos de dentro da imagem do PHP para a pasta atual do projeto. Essa é uma das formas de interagir com as configurações internas, então já podemos criar o diretório de configuração do php.ini.

    Conteúdo:

  • docker-compose.yml

    Configurar o docker-compose.yml para gerenciar a criação e a configuração do container do PHP, onde são definidos o vínculo de pastas e arquivos externos com os internos, as redes virtuais para comunicação com servidor e banco de dados, etc.

    Atenção: a indentação é fundamental, sempre com 2 espaços — nunca use TAB.

  • Dockerfile

    O Dockerfile tem configurações adicionais e comandos executados na construção da imagem do container.

    Também instala os pacotes necessários e define privilégios de usuário para evitar que os arquivos criados posteriormente fiquem como root.

  • .env

    Aqui são definidas as configurações de conexão. Por padrão o .env não vai para o git, por isso deve ser recriado e reconfigurado quando passar do ambiente DEV para o PROD.

    Conteúdo para alterar (deve bater com o container do Postgres):

  • Fortify:

    Para login e autenticação de usuário será usado o Fortify.

    Depois, registre o Fortify em bootstrap/providers.php:

    Se o container do PHP já estiver rodando, execute o composer install novamente para que sejam instaladas as dependências necessárias:

    Ou, se não estiver rodando, use a imagem temporária do composer:

  • Auto Cadastro de Usuário

    Para permitir o auto cadastro e a redefinição de senha, edite os arquivos a seguir.

    app/Providers/FortifyServiceProvider.php — adicione dentro de boot():

    No header da tela de login adicione:

    app/Models/User.php:

  • Spatie:

    O Spatie é responsável pelas regras de permissões: ele define quem pode ver o quê.

    O composer install instala as dependências necessárias.

    O php artisan migrate:refresh --seed reverte (down) e recria (up) todas as tabelas, recadastrando os usuários iniciais e suas permissões.

    Atenção! Se houver dados importantes no banco, não execute o migrate:refresh — você perderá tudo. Nesse caso, use o psql do Postgres para alterações pontuais.

  • Alterar o Model User

    As alterações abaixo já estão refletidas no app/Models/User.php mostrado no Auto Cadastro de Usuário. Em resumo, em app/Models/User.php:

    Importe o trait, abaixo do namespace App\Models:

    E dentro da classe User extends Authenticatable, garanta o uso do trait HasRoles:

  • Registrar o Middleware:

    Os Middlewares são registrados em bootstrap/app.php:

  • Criar Seeders:

    Criar os seeders dos primeiros usuários do app e suas permissões:

    Em database/seeders/RoleSeeder.php:

    Em database/seeders/UserSeeder.php:

  • Registrar os Seeders:

    Registre os seeders em database/seeders/DatabaseSeeder.php: primeiro o RoleSeeder e depois o UserSeeder, para que as tabelas sejam preenchidas na ordem correta (uma regra precisa existir antes de ser atribuída a um usuário).

  • Restringindo os acessos com Spatie:

    Para controlar o acesso de rotas inteiras, use:

    Para restringir apenas partes de uma view, use:

Criar banco de dados:

  • No diretório do servidor, crie as redes virtuais (se ainda não existirem) e suba o container do Postgres:

    Como o container já usa POSTGRES_USER=usuario, POSTGRES_PASSWORD=senha e POSTGRES_DB=banco, o usuário e o banco são criados automaticamente no primeiro start. Normalmente não é preciso criá-los à mão.

    Se precisar criar um banco/usuário adicional, conecte como o superusuário (usuario) no banco banco:

    E execute:

    Ou, caso já tenha um dump, basta restaurar:

Iniciando aplicativo pela primeira vez:

  • Suba o container, entre nele e abra o bash para configurar a aplicação via php artisan:

    Veja mais comandos Docker AQUI.

  • Gere a chave de criptografia, prepare o suporte a APIs, crie as tabelas base e alimente o banco com os dados pré-definidos:

Comandos php artisan:

  • Caso algum arquivo criado e espelhado venha com dono root, execute (fora do container):

  • Criar um Controller:

  • Criar um Model:

  • Criar um Model já com Migration, Controller e Resource (atalho muito útil):

  • Criar uma Migration:

  • Criar um Seeder:

  • Criar um Componente:

  • Criar um Mailable (envio de email):

  • Criar um Middleware (regra de acesso):

  • Criar um Command (comando de console próprio):

  • Criar um Form Request (validação isolada):

  • Criar uma Policy (autorização por model):

  • Criar um API Resource (transformar model em JSON):

  • Criar um Job (processamento em fila):

  • Criar uma Notification:

  • Criar Event e Listener:

  • Criar um Observer (eventos do model):

  • Criar uma Rule de validação personalizada:

  • Criar uma Factory e um Test:

  • Mostra o que o comando migrate fará:

  • Criar as tabelas dos Migrations e adicionar os dados dos Seeders:

  • Reverter o último lote de migrations (função down):

  • Executa a função down de todos os migrations, depois a função up de todos e, por fim, os seeders:

  • Apaga TODAS as tabelas do banco e executa os migrations e os seeders em seguida (recria tudo do zero):

  • Aplicar migrations pendentes em produção (sem confirmação interativa):

  • Adicionar apenas os dados dos Seeders quando as tabelas já existirem:

  • Rodar apenas um Seeder específico:

  • Limpa o banco por completo (tabelas, dados, tudo):

  • Limpeza geral quando algo está bugado:

  • Limpezas granulares (cache, config, rotas e views):

  • Gerar cache para mais velocidade em produção:

  • Gerar a chave de criptografia:

  • Criar link simbólico — expõe storage/app/public em public/storage, permitindo acesso público aos arquivos pelo browser:

  • Listar todas as rotas válidas:

  • Procurar uma rota específica:

  • Abrir o console interativo (testar código/queries ao vivo):

  • Ver informações do ambiente e da instalação:

  • Processar a fila de jobs (quando usar filas):

  • Listar as tarefas agendadas (scheduler):

GitHub:

  • Adicione as restrições no .gitignore para evitar problemas:

  • Configurar o GitHub:

Passando de DEV para PROD:

  • GitHub

    No servidor Debian de produção, após instalar e configurar o git e o docker, crie o diretório do projeto, baixe-o do GitHub e instale o composer via docker para gerar a pasta vendor, entre outras coisas:

    Crie as redes virtuais, o arquivo .env e a chave de criptografia:

Atualizando o Sistema:

  • Sempre que houver alterações no projeto no GitHub, execute:

    Dica: após o git pull, se houver novas dependências ou migrations, rode também composer install, php artisan migrate --force e php artisan optimize.

Tradução pt_BR:

  • No .env:

    Obs.: sempre que mexer no .env, execute:

Personalizando Email:

  • Para acompanhar o desenvolvimento do visual do email de recuperação de senha, use a rota temporária abaixo:

    Para exibir o logo, apague o if/else do arquivo resources/views/vendor/mail/html/themes/header.blade.php, mas deixe a tag da imagem com uma URL completa de uma imagem online:

Criar Componente:

  • Primeiro crie os arquivos:

  • Em app/View/Components/StatusDoc.php:

  • Em resources/views/components/status-doc.blade.php:

  • E quando for usar: