Introdução
Após estruturar o domínio e o modelo de dados na Parte 2, o próximo passo natural é transformar essa base em um sistema seguro por padrão. Nesta etapa, o foco deixa de ser apenas estrutural e passa a ser operacional: controlar quem pode acessar o sistema, sob quais condições e com quais permissões, e o Laravel oferece os Middlewares.
O que são Middlewares
Os middlewares são componentes responsáveis por interceptar uma requisição antes que ela chegue ao seu destino final (controller ou view) e, opcionalmente, também processar a resposta antes que ela seja enviada ao navegador. Eles funcionam como camadas de proteção e controle ao redor da aplicação, permitindo executar verificações, validações, autenticação, autorização e outras regras globais sem poluir a lógica principal do sistema.
Em uma arquitetura moderna, middlewares são fundamentais para garantir que regras transversais — como segurança, isolamento de dados, controle de acesso e auditoria — sejam aplicadas de forma consistente em todas as rotas. Em vez de repetir verificações em cada controller, o middleware centraliza essas responsabilidades, tornando o código mais limpo, seguro e fácil de manter.
Passo 1 — Middleware de Empresa Ativa
Em sistemas multiempresa, o maior risco de segurança é o vazamento de dados entre organizações. O middleware de empresa ativa atua como a primeira barreira de proteção, garantindo que todo usuário autenticado esteja sempre associado a uma empresa válida e ativa antes de qualquer operação ser executada.
Implementação
php artisan make:middleware EnsureCompanyIsActive
public function handle(Request $request, Closure $next)
{
$user = auth()->user();
if (!$user || !$user->company || !$user->company->active) {
auth()->logout();
return redirect()->route('login');
}
app()->instance('company', $user->company);
return $next($request);
}
Registro no Laravel 12 (bootstrap/app.php):
->withMiddleware(function (Middleware $middleware): void {
$middleware->web(append: [
EnsureCompanyIsActive::class,
]);
})
Passo 2 — Middleware de Controle de Roles
Sem um mecanismo centralizado de autorização, sistemas crescem de forma desorganizada, espalhando verificações de permissão pelo código e criando pontos frágeis de segurança. O middleware de roles resolve isso de forma limpa, permitindo que cada rota declare explicitamente quais perfis podem acessá-la.
Implementação
php artisan make:middleware CheckRole
public function handle($request, Closure $next, ...$roles)
{
$user = auth()->user();
if (!$user) {
return redirect()->route('login');
}
if (!in_array($user->role->name, $roles)) {
abort(403);
}
return $next($request);
}
Registro no bootstrap/app.php:
$middleware->alias([
'role' => CheckRole::class,
]);
Passo 3 — Proteção Global das Rotas
Um sistema seguro não depende da memória do desenvolvedor para proteger cada funcionalidade. A proteção global de rotas garante que toda nova funcionalidade criada já nasça dentro de um ambiente controlado, evitando falhas humanas e vazamentos de acesso.
O que são Routes (Rotas)
No Laravel, as routes definem como a aplicação responde às requisições feitas pelos usuários. Cada rota associa uma URL a uma ação específica do sistema, como a execução de um controller, o retorno de uma view ou o processamento de uma operação interna. Elas funcionam como o ponto de entrada da aplicação e determinam, de forma clara, quais funcionalidades existem e como são acessadas.
No Laravel, o arquivo routes/web.php é o principal responsável por organizar as rotas da interface web. É nele que são declaradas as páginas públicas, as áreas protegidas por autenticação, as rotas administrativas e os agrupamentos de funcionalidades. Ao centralizar esse mapeamento em um único local, o sistema ganha previsibilidade, legibilidade e controle estrutural sobre o fluxo da aplicação.
Além disso, o web.php permite aplicar middlewares diretamente nas rotas ou em grupos de rotas, garantindo que regras como autenticação, autorização por papel e isolamento multiempresa sejam executadas antes de qualquer funcionalidade sensível. Essa abordagem reduz drasticamente a possibilidade de falhas de segurança e evita que novas funcionalidades sejam criadas fora da arquitetura de proteção definida para o sistema.
Estrutura recomendada (routes/web.php)
Route::get('/', function () {
return view('welcome');
});
require __DIR__.'/auth.php';
Route::middleware(['auth'])->group(function () {
Route::get('/dashboard', function () {
return view('dashboard');
})->name('dashboard');
Route::get('/profile', [ProfileController::class, 'edit'])->name('profile.edit');
Route::patch('/profile', [ProfileController::class, 'update'])->name('profile.update');
Route::delete('/profile', [ProfileController::class, 'destroy'])->name('profile.destroy');
Route::middleware('role:super_admin,admin')->group(function () {
Route::get('/admin', function () {
return view('admin.dashboard');
});
});
});
Conclusão
Ao final desta etapa, o sistema passa a ser seguro por arquitetura: toda requisição é validada por empresa, toda ação é controlada por papéis e nenhuma rota crítica permanece exposta. Essa base permite que as próximas etapas foquem exclusivamente em experiência do usuário e crescimento funcional, sem comprometer a segurança.
Leia Desenvolvendo um Sistema em Laravel — Parte 2: Arquitetura Multiempresa.