Criação de uma API segura do Laravel com autenticação JWT
Ao construir APIs com Laravel, é crucial garantir uma autenticação segura, especialmente quando se lida com dados do utilizador. Os Tokens Web JSON (JWT) oferecem um método robusto para lidar com a autenticação em aplicativos sem estado, permitindo a transmissão segura de informações do usuário entre as partes. Este guia o guiará pelo processo de criação de uma API Laravel segura usando a autenticação JWT.
Pré-requisitos
- Conhecimento básico de PHP e Laravel.
- Laravel instalado em sua máquina (de preferência Laravel 9 ou mais recente).
- Composer instalado.
- MySQL ou outra base de dados configurada para a sua aplicação.
Etapa 1: Criar um novo projeto Laravel
Primeiro, crie um novo projeto Laravel usando o Composer:
composer create-project laravel/laravel laravel-jwt-api
Navegue até o diretório do seu projeto:
cd laravel-jwt-api
Passo 2: Instalar o pacote de autenticação JWT
O pacote mais comumente usado para autenticação JWT no Laravel é o tymon/jwt-auth. Instale-o usando o Composer:
composer require tymon/jwt-auth
Após a instalação do pacote, publique a configuração do JWT:
php artisan vendor:publish --provider="Tymon\JWTAuth\Providers\LaravelServiceProvider"
Isso criará um arquivo config/jwt.php no seu projeto.
Etapa 3: gerar a chave secreta JWT
Gere uma chave secreta que o JWT usará para assinar tokens:
php artisan jwt:secret
Isso adicionará uma entrada JWT_SECRET ao seu arquivo .env, que é usado para codificar e decodificar os tokens.
Etapa 4: configurar a autenticação
Para configurar a autenticação JWT, é necessário configurar a proteção padrão para sua API. Atualize o arquivo config/auth.php da seguinte forma:
'defaults' => [
'guard' => 'api',
'passwords' => 'users',
],
'guards' => [
'api' => [
'driver' => 'jwt',
'provider' => 'users',
],
],Etapa 5: Criar o modelo de usuário e a migração
Se ainda não tiver criado um modelo de utilizador, pode criá-lo juntamente com o respetivo ficheiro de migração:
php artisan make:model User -m
Abra o arquivo de migração gerado em database/migrations/ e adicione os campos necessários, como nome, e-mail e senha:
public function up()
{
Schema::create('users', function (Blueprint $table) {
$table->id();
$table->string('name');
$table->string('email')->unique();
$table->string('password');
$table->timestamps();
});
}
Execute a migração para criar a tabela de utilizadores:
php artisan migrate
Passo 6: Implementar métodos JWT no modelo do utilizador
No modelo User(app/Models/User.php), implemente a interface JWTSubject e os métodos necessários:
use Tymon\JWTAuth\Contracts\JWTSubject;
use Illuminate\Foundation\Auth\User as Authenticatable;
class User extends Authenticatable implements JWTSubject
{
public function getJWTIdentifier()
{
return $this->getKey(); // Usually the primary key (id)
}
public function getJWTCustomClaims()
{
return [];
}
}Etapa 7: criar controladores de autenticação
Crie um controlador para tratar a autenticação do utilizador:
php artisan make:controller AuthController
Em AuthController.php, adicione métodos para registar um utilizador, iniciar sessão e terminar sessão:
<?php
namespace App\Http\Controllers;
use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Hash;
use Tymon\JWTAuth\Facades\JWTAuth;
class AuthController extends Controller
{
// User Registration
public function register(Request $request)
{
$request->validate([
'name' => 'required|string|max:255',
'email' => 'required|string|email|max:255|unique:users',
'password' => 'required|string|min:6|confirmed',
]);
$user = User::create([
'name' => $request->name,
'email' => $request->email,
'password' => Hash::make($request->password),
]);
$token = JWTAuth::fromUser($user);
return response()->json(['token' => $token], 201);
}
// User Login
public function login(Request $request)
{
$credentials = $request->only('email', 'password');
if (!$token = Auth::attempt($credentials)) {
return response()->json(['error' => 'Invalid credentials'], 401);
}
return response()->json(['token' => $token]);
}
// Logout User (Invalidate Token)
public function logout()
{
Auth::logout();
return response()->json(['message' => 'Successfully logged out']);
}
// Get Authenticated User
public function me()
{
return response()->json(Auth::user());
}
}Etapa 8: definir rotas de API
Adicione rotas para autenticação em routes/api.php:
use App\Http\Controllers\AuthController;
use Illuminate\Support\Facades\Route;
Route::post('register', [AuthController::class, 'register']);
Route::post('login', [AuthController::class, 'login']);
// Rotas protegidas (requerem token JWT)
Route::middleware('auth:api')->group(function () {
Route::post('logout', [AuthController::class, 'logout']);
Route::get('me', [AuthController::class, 'me']);
});Estas rotas tratam do registo do utilizador, do início de sessão, do fim de sessão e da obtenção do utilizador autenticado.
Etapa 9: Protegendo as rotas da API
Para proteger outras rotas de API, você pode usar o middleware auth:api. Por exemplo, se você tiver uma rota de recurso para postagens:
Route::middleware('auth:api')->group(function () {
Route::resource('posts', PostController::class);
});
Isto garante que apenas os utilizadores autenticados podem aceder a estas rotas.
Etapa 10: Testando a API
Você pode testar sua API usando ferramentas como Postman ou cURL.
- Registar um utilizador:
POST /api/register
Host: your-domain.com
Content-Type: application/json
{
"name": "John Doe",
"email": "john@example.com",
"password": "password",
"password_confirmation": "password"
} - Iniciar sessão:
POST /api/login
Host: your-domain.com
Content-Type: application/json
{
"email": "john@example.com",
"password": "password"
}Isso retornará um token que pode ser usado para autenticar outras solicitações. - Aceder à rota protegida: Para aceder a uma rota protegida como GET /api/me, inclua o token no cabeçalho Authorization:
Authorization: Bearer <token>
Etapa 11: Atualizar tokens JWT (opcional)
Para atualizar um token, pode adicionar um método no AuthController:
public function refresh()
{
$token = Auth::refresh();
return response()->json(['token' => $token]);
}Adicionar a rota para atualização:
Route::post('refresh', [AuthController::class, 'refresh'])->middleware('auth:api');
Conclusão
Ao seguir este guia, você construiu uma API Laravel segura com autenticação JWT, permitindo o registro do usuário, login e acesso a rotas protegidas. O JWT permite que você mantenha um mecanismo de autenticação sem estado, o que é especialmente útil para escalar APIs. Com essa configuração, você pode personalizar ainda mais a lógica de autenticação do seu aplicativo e integrar recursos adicionais, como controle de acesso baseado em função e tokens de atualização para sessões de longa duração.
