06.12.2024

Criação de uma API segura do Laravel com autenticação JWT

Ao criar APIs com o Laravel, é fundamental garantir a autenticação segura, especialmente ao lidar com dados do usuário. Os JSON Web Tokens (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 segura do Laravel 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 outro banco de dados configurado para seu aplicativo.

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

Etapa 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

em 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, você precisa 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’,
],
],

Isso diz ao Laravel para usar o driver

jwt

para solicitações de API e autenticar no provedor de

usuários

Etapa 5: criar o modelo de usuário e a migração

Se ainda não tiver criado um modelo de

usuário

, você pode criá-lo junto com o arquivo 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

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

usuários

php artisan migrate

Etapa 6: Implementar métodos JWT no modelo de usuário

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();
}public function getJWTCustomClaims()
{
return [];
}
}

Etapa 7: Criar controladores de autenticação

Crie um controlador para lidar com a autenticação do usuário:

php artisan make:controller AuthController

AuthController.php

, adicione métodos para registrar um usuário, fazer login e fazer logout:

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

funçãopública login(Request $request)
{
$credentials = $request->only(’email’, ‘password’);

se (!$token = Auth::attempt($credentials)) {
return response()->json([‘error’ => ‘Invalid credentials’], 401);
}

return response()->json([‘token’ => $token]);
}

funçãopública logout()
{
Auth::logout();

return response()->json([‘message’ => ‘Successfully logged out’]);
}

funçãopública 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;

Route::post(‘register’,[AuthController::class, ‘register’]);
Route::post(‘login’,[AuthController::class, ‘login’]);Route::post(‘login ‘,[AuthController::class, ‘login’]);
Route::post(‘logout’,[AuthController::class, ‘logout’])->middleware(‘auth:api’);
Route::get(‘me’,[AuthController::class, ‘me’])->middleware(‘auth:api’);

Essas rotas lidam com o registro do usuário, o login, o logout e a busca do usuário autenticado.

Etapa 9: proteção de rotas de 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);
 });

Isso garante que somente os usuários autenticados possam acessar essas rotas.

Etapa 10: Testar a API

Você pode testar sua API usando ferramentas como Postman ou cURL.

Registre um usuário:
POST /api/register Content-Type: application/json{
“name”: “John Doe”,
“email”: “john@example.com”,
“password” (senha): “password”,
“password_confirmation”: “password”
}
Fazer login:
POST /api/login Content-Type: application/json{
“email”: “john@example.com”,
“password” (senha): “password”
}
Isso retornará um token que você pode usar para autenticar outras solicitações.
Acessar rota protegida: para acessar uma rota protegida como
GET /api/me
, inclua o token no cabeçalho
Authorization
:
Authorization: Portador

Etapa 11: Atualização dos tokens JWT (opcional)

Para atualizar um token, você pode adicionar um método no

AuthController

public function refresh()
 {
 $token = Auth::refresh();
 return response()->json(['token' => $token]);
 }

Adicione a rota para atualização:

Route::post('refresh', [AuthController::class, 'refresh'])->middleware('auth:api');

Conclusão

Ao seguir este guia, você criou uma API segura do Laravel com autenticação JWT, permitindo o registro de usuário, o login e o acesso a rotas protegidas. O JWT permite que você mantenha um mecanismo de autenticação sem estado, o que é especialmente útil para escalonar 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.