Gestire l'autenticazione con Laravel

Introduzione

Nei tutorial precedenti di questa serie abbiamo visto insieme come installare e configurare Laravel, come definire i modelli e in che modo creare controller e template per la tua applicazione web. Nell'ultima puntata di questa serie imparerai invece a gestire l'autenticazione degli utenti nella tua applicazione web sviluppata con Laravel.

Le possibilità offerte dal framework Laravel sono tantissime: all'interno di questa guida, ti verranno mostrate le basi per poter costruire dei meccanismi funzionali di autenticazione, trattando una panoramica sulle features principali tra quelle offerte dalla documentazione di Laravel.

Laravel fornisce, prima di tutto, dei kit pronti per implementare il sistema di autenticazione, collegandolo alle tabelle degli utenti presenti nel tuo database. Ciò avviene usando dei kit che seguono le best practices per progettare meccanismi di autenticazione e le relative interfacce, garantendo affidabilità e sicurezza.

Verranno descritte anche delle sintassi per implementare manualmente i meccanismi di autenticazione, nel caso volessi optare per una maggiore personalizzazione senza usufruire dello scaffolding.

Pre Requisiti

• Aver installato Laravel e creato un'applicazione, seguendo gli step precedenti di questa serie
• Aver eseguito la migrazione del tuo database su Laravel

Legame con il database

Di default, Laravel contiene un modello sugli User situato nel percorso app/Models. Ciò ti permette, grazie a Eloquent, di recuperare le informazioni sugli utenti dal tuo database.

Laravel Breeze

Laravel Breeze è una implementazione molto minimale dell'autenticazione con le caratteristiche offerte da Laravel. All'interno di Breeze sono incluse le procedure di:

• Login
• Registrazione
• Reset della password
• Verifica email e conferma della password

L'interfaccia sarà invece costituita da uno stile molto minimale importato dai template di Blade e utilizzando lo stile di Tailwind CSS.

Installazione e setup

Puoi utilizzare Composer per installare nella tua applicazione web Laravel Breeze:

$ composer require laravel/breeze --dev

Verrà creato uno stack in cui Breeze effettuerà lo scaffolding. A questo punto, occorrerà lanciare un comando per installare i pacchetti di Breeze :

$ php artisan breeze:install

Ciò inserirà le viste, i percorsi, i controller e altre risorse alla tua applicazione. Tutto ciò verrà pubblicato in forma di codice accessibile nella directory della tua applicazione web. A questo punto, per la parte del front-end dovrai lanciare altri comandi per compilare le risorse necessarie:

$ php artisan migrate
$ npm install
$ npm run dev

Collegandoti all'indirizzo tuodominio/register, ti ritroverai in una pagina per registrarti alla tua applicazione web:

Per il login, puoi usare l'indirizzo tuodominio/register:

Potrai trovare tutti i percorsi di Breeze che sono stati definiti, dopo aver impartito i comandi di installazione precedenti, all'interno del file routes/auth.php. In più, potrai interagire a tuo piacimento con il codice per la creazione di controller e altre risorse per poter scoprirne al meglio le possibilità di personalizzazione.

Metodi di interazione con l'utente autenticato

Recuperare informazioni sull'utente autenticato

Ti è possibile, tramite l'integrazione del metodo user della facciata Auth, recuperare alcune informazioni sull'utente correntemente autenticato nella tua applicazione web. Per far ciò, ti sarà necessario specificare nel codice istruzioni simili a quelle di questo esempio:

	use Illuminate\Support\Facades\Auth;
 
// Retrieve the currently authenticated user...
$user = Auth::user();
 
// Retrieve the currently authenticated user's ID...
$id = Auth::id();

Controllare se lo user collegato sia autenticato

Per controllare se lo user collegato alla sessione sia autenticato o meno, puoi usare il metodo check, tramite la sintassi:

use Illuminate\Support\Facades\Auth;
 
if (Auth::check()) {
    // The user is logged in...
}

Tuttavia, è bene precisare che puoi utilizzare i middlewares per implementare controlli che reindirizzino l'utente o gli impediscano di percorrere determinati percorsi nel caso in cui non siano autenticati. Per ulteriori informazioni sui controller fai riferimento al tutorial su Come creare i controller con Laravel.

Regole di protezione dei Middlewares

Le regole di protezione consentono di specificare delle condizioni tali per cui consentire l'accesso a un utente di una particolare Route.

Laravel fornisce un middleware di nome auth: puoi appendere questo middleware inserendo la referenza nel codice alla classe Illuminate\Auth\Middleware\Authenticate.

Per far ciò, aggiungi le seguenti istruzioni al tuo codice:

	Route::get('/students', function () {
    // Only authenticated users may access this route...
})->middleware('auth');

Redirecting degli utenti non autenticati

Quando il middleware auth individua un utente non autenticato, si può occupare di rendirizzarlo alla pagina di login. Accedendo al percorso app/Http/Middleware/Authenticate.php potrai modificare il comportamento del meccanismo di redirect, modificando il corpo della funzione redirectTo.

Nel codice di default:

/**
 * Get the path the user should be redirected to.
 *
 * @param  \Illuminate\Http\Request  $request
 * @return string
 */
protected function redirectTo($request)
{
    return route('login'); //Puoi cambiare qualcosa qui
}

Specificare ulteriori restrizioni

Quando associ il middleware auth a un percorso, potrai anche specificare se il percorso debba essere ristretto solo a particolari utenti.

Questo viene eseguito grazie alle chiavi presenti nell'array guards, all'interno del file di configurazione auth.php.

Nell'esempio:

Route::get('/users', function () {
    // Only authenticated users may access this route...
})->middleware('auth:admin');

Impostare manualmente le meccaniche di autenticazione

Nel caso in cui tu non voglia ricorrere allo scaffolding di Breeze o altri starter kits, dovresti costruire manualmente le classi e le funzioni necessarie a gestire gli accessi in Laravel.

La prima importazione da inserire, sarebbe per la facade di nome auth, necessaria ad accedere ai servizi di Laravel dedicati all'autenticazione

use Illuminate\Support\Facades\Auth;

In secondo piano, dovresti specificare un nuovo controller dedicato:

class LoginController extends Controller
  {
     /**
     * Handle an authentication attempt.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
      public function authenticate(Request $request)
    {
    //Function body ...
    }
  }

Il prototipo della funzione authenticate prenderà in input una richiesta di login e restituirà, in base a dei controlli, una risposta.

Sviluppando il corpo della funzione, nell'esempio:

 public function authenticate(Request $request)
    {
        $credentials = $request->validate([
            'email' => ['required', 'email'],
            'password' => ['required'],
        ]);
 
        if (Auth::attempt($credentials)) {
            $request->session()->regenerate();
 
            return redirect()->intended('dashboard');
        }
 
        return back()->withErrors([
            'email' => 'No credentials matching.',
        ])->onlyInput('email');
    }

Analizzando la semantica del codice:

• la funzione riceve in input una richiesta contenente delle credenziali, inserite in dei campi di input sulla vista di login.
• Tramite il metodo attempt, viene accettato l' array contenente le credenziali aventi come campo email e password e come valori quelli inseriti. Il metodo verifica la presenza della email e, se presente, confronta la password nel database con quella inserita.
• Se l'esito di attempt è positivo, la sessione dell'utente autenticato viene avviata.
• Il metodo intended reindirizza l'utente alla pagina in cui si trovava prima di passare alla autenticazione. L'URI di destinazione può ovviamente essere modificato per reindirizzare l'utente alla pagina che si preferisce.

Di seguito viene mostrato il codice completo:

  <?php
 
namespace App\Http\Controllers;
 
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
 
class LoginController extends Controller
{
    /**
     * Handle an authentication attempt.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function authenticate(Request $request)
    {
        $credentials = $request->validate([
            'email' => ['required', 'email'],
            'password' => ['required'],
        ]);
 
        if (Auth::attempt($credentials)) {
            $request->session()->regenerate();
 
            return redirect()->intended('dashboard');
        }
 
        return back()->withErrors([
            'email' => 'The provided credentials do not match our records.',
        ])->onlyInput('email');
    }
}
  

Impostare il comportamento delle guard

Nella configurazione manuale, si possono impostare delle guard tramite la facade auth. Con questo meccanismo potrai settorializzare la tua applicazione e rendere le sue diverse parti accessibili ad alcuni gruppi di utenti o ad altri.

Come nel caso, precedente, il nome della guard dovrà essere presente nel file di configurazione auth.php.

Esempio di una guard nel file:

    if (Auth::guard('admin')->attempt($credentials)) {
    // ...
}
  

Abilitare la checkbox "Remember me"

La spunta sul box "Remember me" fornisce un valore aggiunto alla tua applicazione in termini di usabilità. Per implementare questa funzionalità, sarà sufficiente passare al metodo attempt un ulteriore parametro (un valore booleano ad esempio) per indicare che l'utente abbia spuntato la checkbox per l'opzione in oggetto.

Nel codice di esempio:

use Illuminate\Support\Facades\Auth;
 
if (Auth::attempt(['email' => $email, 'password' => $password], $remember)) {
    // Istruzioni per ricordare l'autenticazione...
}

A livello di database, è necessario registrare, per ogni utente, un eventuale token che supporti la funzionalità di remember me. Tramite il token sarà possibile far riconoscere a Laravel che quell'utente desideri conservare l'autenticazione fino a una sua esplicita richiesta di logout. Il campo presente nelle tabelle è già definito da Laravel, alla voce remember_token.

Per controllare se l'utente abbia un token, potrai ricorrere al metodo viaRemember:

use Illuminate\Support\Facades\Auth;
 
if (Auth::viaRemember()) {
    // ...
}

Autenticazione standard con HTTP

Nel caso tu voglia optare per una autenticazione minimale, senza ricorrere a una pagina di login dedicata, puoi sfruttare una semplice autenticazione HTTP, grazie al middleware auth.basic, messo a disposizione da Laravel.

Nell'esempio, si imposta l'autenticazione basic http. tramite il middleware citato, su una determinata Route:

Route::get('/profile', function () {
    // Only authenticated users may access this route...
})->middleware('auth.basic');

Grazie a questo codice, quando un utente proverà ad accedere a quel percorso specificato, il browser chiederà all'utente di inserire le sue credenziali prima di proseguire.

Logout

Per abilitare il logout, dovrai sfruttare il metodo logout offerto dalla facade auth. Oltre a questo, dovrai reindirizzare l'utente nel percorso principale della applicazione e resettare il token per la sessione.

La sintassi corrispondente alle operazioni descritte, nel codice sarebbe la seguente:

    use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
 
/**
 * Log the user out of the application.
 *
 * @param  \Illuminate\Http\Request  $request
 * @return \Illuminate\Http\Response
 */
public function logout(Request $request)
{
    Auth::logout();
 
    $request->session()->invalidate();
 
    $request->session()->regenerateToken();
 
    return redirect('/');
}

Conclusioni

I modi possibili per personalizzare il processo di autenticazione di Laravel, in base ai requisiti della tua applicazione, sono svariati.

Terminato questo tutorial, sarai stato in grado di configurare i principali meccanismi di autenticazione sia con Breeze che manualmente. Inoltre avrai assimilato le basi per poter configurare a piacimento diverse logiche di autenticazione, lavorando sulle opzioni o sui parametri delle funzioni prese in oggetto.