Introdução

Neste tutorial, vamos explorar o framework Laravel para criar uma API RESTful robusta e escalável com autenticação JSON Web Token (JWT). A construção de APIs é uma habilidade essencial para desenvolvedores modernos, pois as aplicações têm se tornado cada vez mais dependentes da comunicação entre diferentes sistemas. Usaremos o Laravel, um dos frameworks PHP mais populares, que oferece ferramentas e funcionalidades poderosas para simplificar o desenvolvimento de aplicações. Você aprenderá desde a configuração do ambiente até a implementação da autenticação, endpoints e testes, garantindo que sua API esteja pronta para produção e mantenha a segurança necessária.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Certifique-se de ter o PHP, Composer e Laravel instalados em sua máquina. Também recomendamos um servidor local como o Laravel Valet ou o Homestead. Para verificar as versões instaladas, use os comandos `php -v` e `composer -v`. Caso não tenha o Laravel instalado, execute o comando `composer global require laravel/installer`.

    commands
    # Verificar versões instaladas
    php -v
    composer -v
    # Instalar o Laravel se necessário
    composer global require laravel/installer

  2. Criação do Projeto Laravel

    Utilize o comando do Laravel Installer para criar um novo projeto. Substitua ‘my-api’ pelo nome desejado para seu projeto. Após a criação, navegue até o diretório do projeto.

    commands
    # Criar um novo projeto Laravel
    laravel new my-api
    # Navegar até o diretório do projeto
    cd my-api

  3. Instalação de Dependências para Autenticação JWT

    Instale o pacote `tymon/jwt-auth` que fornece suporte para JWT em Laravel. Após a instalação, publique a configuração do pacote.

    commands
    # Instalar o pacote JWT-Auth
    composer require tymon/jwt-auth
    # Publicar a configuração do pacote
    php artisan vendor:publish --provider="Tymon\JWTAuth\JWTAuthServiceProvider"

  4. Configuração do Ambiente

    Adicione a chave JWT no arquivo `.env` para configurar o JWT-Auth. Utilize o comando `jwt:secret` para gerar a chave secreta necessária.

    commands
    # Gerar a chave secreta JWT
    php artisan jwt:secret
    # Adicionar a chave no arquivo .env
    JWT_SECRET=your_generated_secret_key

  5. Criação do Modelo `User`

    Laravel já inclui um modelo `User` por padrão, mas você pode personalizá-lo conforme suas necessidades. Certifique-se de incluir a interface `JWTSubject` para implementar a autenticação JWT.

    User.php
    <?php

namespace App\Models;

use Illuminate\Notifications\Notifiable;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Tymon\JWTAuth\Contracts\JWTSubject;

class User extends Authenticatable implements JWTSubject {
    use Notifiable;

    protected $fillable = ['name', 'email', 'password'];

    public function getJWTIdentifier() {
        return $this->getKey();
    }

    public function getJWTCustomAttributes() {
        return ['name' => $this->name];
    }
}

  6. Criação do Controlador `AuthController`

    Implemente o controlador que lidará com a autenticação, fornecendo métodos para registro e login de usuários. O método de login deve retornar um token JWT ao usuário autenticado.

    AuthController.php
    <?php

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Validator;
use Tymon\JWTAuth\JWTAuth;
use Tymon\JWTAuth\Exceptions\JWTException;

class AuthController extends Controller {
    public function register(Request $request) {
        $validator = Validator::make($request->all(), ['name' => 'required', 'email' => 'required|email|unique:users', 'password' => 'required']);
        if ($validator->fails()) {
            return response()->json($validator->errors(), 400);
        }
        $user = User::create(['name' => $request->name, 'email' => $request->email, 'password' => Hash::make($request->password)]);
        return response()->json(['user' => $user], 201);
    }

    public function login(Request $request) {
        $credentials = $request->only('email', 'password');
        try {
            if (!$token = JWTAuth::attempt($credentials)) {
                return response()->json(['error' => 'Unauthorized'], 401);
            }
        } catch (JWTException $e) {
            return response()->json(['error' => 'Could not create token'], 500);
        }
        return response()->json(compact('token'));
    }
}

  7. Definição das Rotas da API

    Adicione as rotas para os métodos de login e registro no arquivo `routes/api.php`. Isso permitirá que o frontend acesse essas funcionalidades.

    api.php
    use Illuminate\Support\Facades\Route;
use App\Http\Controllers\AuthController;

Route::post('/register', [AuthController::class, 'register']);
Route::post('/login', [AuthController::class, 'login']);

  8. Testando a API com Postman

    Agora que sua API está configurada, você pode usar o Postman para testar suas rotas de registro e login. Certifique-se de enviar as requisições com o cabeçalho `Content-Type: application/json`.

    curl_examples
    # Testar o registro de um usuário
    curl -X POST http://localhost/api/register -H 'Content-Type: application/json' -d '{"name": "Teste", "email": "teste@mail.com", "password": "senha123"}'
    # Testar o login
    curl -X POST http://localhost/api/login -H 'Content-Type: application/json' -d '{"email": "teste@mail.com", "password": "senha123"}'

  9. Implementação de Testes Unitários

    Use PHPUnit para criar testes de unidade, garantindo que as funcionalidades de autenticação sejam executadas corretamente. Crie um teste para o registro e login usando o comando `php artisan make:test AuthControllerTest`.

    AuthControllerTest.php
    <?php

namespace Tests\Unit;

use Tests\TestCase;
use Illuminate\Foundation\Testing\WithFaker;
use Illuminate\Support\Facades\Hash;
use App\Models\User;

class AuthControllerTest extends TestCase {
    use WithFaker;

    public function testUserCanRegister() {
        $response = $this->postJson('/api/register', ['name' => 'Teste', 'email' => 'teste@mail.com', 'password' => 'senha123']);
        $response->assertStatus(201);
    }

    public function testUserCanLogin() {
        $user = User::create(['name' => 'Teste', 'email' => 'teste@mail.com', 'password' => Hash::make('senha123')]);
        $response = $this->postJson('/api/login', ['email' => 'teste@mail.com', 'password' => 'senha123']);
        $response->assertSuccessful();
    }
}

  10. Executando a Aplicação e Testes

    Use o Artisan para iniciar o servidor local e realizar os testes automatizados. O comando `php artisan serve` irá iniciar a aplicação. Para rodar os testes, utilize `php artisan test`.

    commands
    # Iniciar o servidor local
    php artisan serve
    # Executar os testes unitários
    php artisan test

Conclusão

Neste tutorial, você aprendeu a desenvolver uma API RESTful utilizando o Laravel, incluindo a configuração do ambiente, instalação das dependências, implementação de autenticação JWT, rotas e testes unitários. A construção de APIs seguras e escaláveis é crucial no desenvolvimento moderno e, com o Laravel, você simplificou muitas das complexidades envolvidas. Agora, você está pronto para expandir suas habilidades em PHP e Laravel, construindo aplicações ainda mais robustas e adaptadas às necessidades do mercado.

Hashtags

#Laravel #API #JWT #PHP #DesenvolvimentoDeSoftware