Configurando autenticação no Laravel 11x com Sanctum

A autenticação no Laravel pode ser feita com o auxílio dos pacotes Sanctum ou Passport. O Passport é utilizado para autenticações mais complexas e específicas enquanto o Sanctum é uma solução mais simples e rápida, fornecendo um mecanismo de autenticação via token.

Por padrão, esses pacotes não vem configurados na instalação do laravel então nesse post vou mostrar como fazer isso, partindo do zero.

Para criar um novo projeto usando o framework Laravel precisamos primeiro instalar o gerenciador de dependências do php Composer com o seguinte comando:

curl -sS https://getcomposer.org/installer | php

Criar um novo projeto no Laravel.

 composer create-project --prefer-dist laravel/laravel nomeDoProjeto 

Como estamos falando de autenticação, vamos precisar ter uma conexão ativa com o nosso banco de dados configurada no arquivo .env do projeto .

As configurações podem ser feitas na seção com as informações DB_* (‘DB_CONNECTION’, ‘DB_GOST’, ‘DB_PORT’, etc) do arquivo.

Por padrão, o Laravel não vai vir com o arquivo api.php configurado então precisamos do auxílio do artisan para criação do api.php assim como a instalação do pacote Sanctum.

Vamos rodar o seguinte comando para isso:

php artisan install:api

Seguindo esses passos você deve ter uma classe model de Usuário no namespace App\Models\User.php. Nela, vamos precisar realizar a inclusão da trait ‘HasApiTokens‘

use Laravel\Sanctum\HasApiTokens; -> Import da trait na classe User.php

use HasApiTokens -> declaração do uso da trait no escopo da classe.

Ela deve ficar assim:

<?php

namespace App\Models;

// use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Sanctum\HasApiTokens;

class User extends Authenticatable
{
    use HasFactory, Notifiable, HasApiTokens;

    /**
     * The attributes that are mass assignable.
     *
     * @var array<int, string>
     */
    protected $fillable = [
        'name',
        'email',
        'password',
    ];

    /**
     * The attributes that should be hidden for serialization.
     *
     * @var array<int, string>
     */
    protected $hidden = [
        'password',
        'remember_token',
    ];

    /**
     * Get the attributes that should be cast.
     *
     * @return array<string, string>
     */
    protected function casts(): array
    {
        return [
            'email_verified_at' => 'datetime',
            'password' => 'hashed',
        ];
    }
}

Depois disso, vamos criar uma classe no nível dos controllers que vai registrar um novo usuário e realizar o login dele também, usando o artisan para nos ajudar.

php artisan make:controller AuthController

Depois vamos configurar rotas de autenticar e login no arquivo api.php

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

O método register vai ser responsável por criar um novo usuário enquanto o login vai autenticar um usuário registrado e retornar um token de acesso.

O método register fica assim:

    public function register(Request $request)
    {
        $request->validate([
            'name' => ['required', 'string', 'max:255'],
            'email' => ['required', 'string', 'email', 'max:255', 'unique:users'],
            'password' => ['required', 'string', 'min:8', 'confirmed'],
        ]);

        $user = User::create([
            'name' => $request->name,
            'email' => $request->email,
            'password' => Hash::make($request->password),
        ]);

        $token = $user->createToken('auth_token')->plainTextToken;

        return response()->json([
            'message' => 'Successfully registered',
            'user' => $user,
            'token' => $token
        ]);

    }

E o método login deve ficar da seguinte forma:

    public function login(Request $request){

        $request->validate([
            'email' => ['required', 'string', 'email', 'max:255'],
            'password' => ['required', 'string', 'min:8'],
        ]);

        $user = User::where('email', $request->email)->first();
        
        if(!$user || !Hash::check($request->password, $user->password)){
            return response(['message'=> 'Dados inválidos'], 401);
        }

        $token = $user->createToken('auth_token')->plainTextToken;

        return response()->json([
            'user'=>$user,
            'token'=>$token
        ]);

    }

A partir daí, já conseguimos criar novo usuário na rota ‘/register‘ e efetuar login com esse usuário na rota ‘/login‘. Ao efetuar o login recebemos o nosso token de autenticação que pode ser usado para acessar as rotas que estão protegidas pelo middleware Sanctum.

No arquivo api.php declaramos as rotas que vão pedir a autenticação:

Para testar o acesso com o token então criamos o controller e model “Post” (uma postagem).

php artisan make:controller PostController

php artisan make:model Post -m

*Quando criamos uma nova model podemos passar o parâmetro “-m” para fazer a criação automática de uma migration que vai fazer a criação de uma tabela relacional para esse modelo que estamos criando. No meu caso, a migration ficou assim:

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('content');
            $table->foreignId('user_id')->constrained()->onDelete('cascade');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('posts');
    }
};

Rodamos essa nova migração com o artisan:

php artisan migrate

E iniciamos o ambiente local de desenvolvimento com o comando:

php artisan serve

Agora, se tentarmos acessar as novas rotas que criamos sem passar qualquer autenticação, devemos receber o erro:

Mas usando o token que geramos há pouco, temos o seguinte resultado:

Com apenas esses passos conseguimos configurar o pacote Sanctum para controlar o acesso à nossa aplicação.