> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Introduzione all'autenticazione

> Le basi delle funzionalità di autenticazione di Laravel. Dall'introduzione del sistema di autenticazione tramite starter kit al recupero dell'utente autenticato.

## Cos'è l'autenticazione

L'autenticazione è il meccanismo che verifica "chi è" l'utente che accede.
Nelle applicazioni web, riceviamo email e password da un form di login e, se corretti, salviamo le informazioni dell'utente nella sessione.
Nelle richieste successive si identifica l'utente consultando quella sessione.

Le funzionalità di autenticazione di Laravel sono composte da due concetti: le "guard" e i "provider".

* **Guard**: definiscono come autenticare l'utente in ciascuna richiesta. Quella predefinita è la guard `session`, che gestisce lo stato con sessione e cookie.
* **Provider**: definiscono come recuperare l'utente dal database. Quello predefinito usa Eloquent.

<Info>
  Il file di configurazione dell'autenticazione è `config/auth.php`. Le impostazioni predefinite sono adatte alla maggior parte delle applicazioni web.
</Info>

```mermaid theme={null}
flowchart TD
    A["Richiesta di login"] --> B["Guard<br>(definisce il metodo di autenticazione)"]
    B --> C["Provider<br>(recupera l'utente dal DB)"]
    C --> D{"Controllo di autenticazione"}
    D -- "Successo" --> E["Salva le informazioni utente<br>nella sessione"]
    E --> F["Redirect a pagina<br>autenticata"]
    D -- "Fallimento" --> G["Redirect alla schermata<br>di login"]
```

## Autenticazione tramite starter kit

In Laravel, scegliendo semplicemente uno starter kit quando crei l'applicazione con `laravel new`, vengono costruite automaticamente le funzionalità di login, registrazione, reset password e altre. È l'approccio più consigliato.

<Steps>
  <Step title="Crea l'applicazione">
    Crea l'applicazione con l'installer di Laravel. Durante il processo viene mostrato un prompt per selezionare lo starter kit.

    ```shell theme={null}
    laravel new my-app
    ```

    Puoi scegliere tra **React**, **Vue**, **Livewire** e **Svelte** come starter kit.
    Scegli in base allo stack tecnologico del team.
  </Step>

  <Step title="Installa le dipendenze frontend">
    ```shell theme={null}
    cd my-app
    npm install && npm run build
    ```
  </Step>

  <Step title="Prepara il database">
    Verifica le impostazioni del database nel file `.env` ed esegui le migration.

    ```shell theme={null}
    php artisan migrate
    ```

    Vengono applicate le migration iniziali, inclusa la tabella `users`.
  </Step>

  <Step title="Avvia il server di sviluppo">
    ```shell theme={null}
    composer run dev
    ```

    Aprendo `http://localhost:8000` nel browser, nella navigazione appariranno i link "Register" e "Log in".
    Visita `/register` e registra un utente di prova.
  </Step>
</Steps>

Con uno starter kit sono immediatamente disponibili queste funzionalità.

| Funzionalità         | URL                 |
| -------------------- | ------------------- |
| Registrazione utente | `/register`         |
| Login                | `/login`            |
| Reset password       | `/forgot-password`  |
| Verifica email       | `/email/verify`     |
| Modifica profilo     | `/settings/profile` |

<Tip>
  Il codice generato dallo starter kit (controller, route, viste) risiede tutto nella tua applicazione. Puoi modificarlo e personalizzarlo liberamente.
</Tip>

### Starter kit disponibili

#### React

Puoi costruire SPA moderne con React 19, TypeScript, Tailwind e [shadcn/ui](https://ui.shadcn.com).
Grazie a [Inertia](https://inertiajs.com), sfrutti il frontend React mantenendo il routing lato server.

#### Vue

Utilizza Vue Composition API, TypeScript, Tailwind e [shadcn-vue](https://www.shadcn-vue.com/).
Come React, si integra con il server tramite Inertia.

#### Livewire

Usa [Livewire](https://livewire.laravel.com) per costruire UI dinamiche solo in PHP.
Ideale per team che lavorano principalmente con i template Blade o che vogliono evitare framework JavaScript.
Include la libreria di componenti [Flux UI](https://fluxui.dev).

#### Svelte

Usa Svelte 5, TypeScript, Tailwind e [shadcn-svelte](https://www.shadcn-svelte.com/).
Costruisci SPA moderne combinandolo con Inertia.

## Facade Auth

Con la facade `Auth` puoi ottenere le informazioni dell'utente attualmente autenticato o verificarne lo stato.

### Ottenere l'utente autenticato

```php theme={null}
use Illuminate\Support\Facades\Auth;

// Ottieni l'utente corrente
$user = Auth::user();

// Ottieni solo l'ID dell'utente
$id = Auth::id();
```

Nei controller puoi ottenere l'utente anche dall'oggetto `Request`.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class DashboardController extends Controller
{
    public function index(Request $request)
    {
        $user = $request->user();

        return view('dashboard', ['user' => $user]);
    }
}
```

### Verifica dello stato di autenticazione

`Auth::check()` restituisce `true` / `false` a seconda che l'utente sia autenticato.

```php theme={null}
use Illuminate\Support\Facades\Auth;

if (Auth::check()) {
    // Autenticato
} else {
    // Non autenticato
}
```

Nei template Blade le direttive `@auth` e `@guest` sono comode.

```blade theme={null}
@auth
    <p>Ciao, {{ Auth::user()->name }}</p>
    <a href="/logout">Logout</a>
@endauth

@guest
    <a href="/login">Login</a>
    <a href="/register">Registrati</a>
@endguest
```

## Protezione delle route

Per creare route accessibili solo agli utenti autenticati usa il middleware `auth`.

```php theme={null}
// routes/web.php

// Accessibile solo agli utenti autenticati
Route::get('/dashboard', function () {
    return view('dashboard');
})->middleware('auth');
```

Gli utenti non autenticati vengono reindirizzati automaticamente a `/login`.

Per proteggere più route in blocco usa un gruppo.

```php theme={null}
Route::middleware('auth')->group(function () {
    Route::get('/dashboard', [DashboardController::class, 'index']);
    Route::get('/profile', [ProfileController::class, 'show']);
    Route::get('/settings', [SettingsController::class, 'index']);
});
```

<Warning>
  Se dimentichi il middleware `auth`, gli utenti non autenticati potranno accedere. Applicalo sempre alle route da proteggere.
</Warning>

### Route solo per ospiti

Per reindirizzare gli utenti autenticati usa il middleware `guest`.
Applicandolo alle pagine di login e registrazione, gli utenti già autenticati vengono inviati alla dashboard.

```php theme={null}
Route::middleware('guest')->group(function () {
    Route::get('/login', [AuthController::class, 'showLogin']);
    Route::get('/register', [AuthController::class, 'showRegister']);
});
```

## Autenticazione manuale

Per implementare il login manualmente, senza starter kit, usa `Auth::attempt()`.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Http\RedirectResponse;
use Illuminate\Support\Facades\Auth;

class LoginController extends Controller
{
    public function login(Request $request): RedirectResponse
    {
        $credentials = $request->validate([
            'email' => ['required', 'email'],
            'password' => ['required'],
        ]);

        if (Auth::attempt($credentials)) {
            // Autenticazione riuscita — rigenera la sessione per prevenire attacchi CSRF
            $request->session()->regenerate();

            return redirect()->intended('/dashboard');
        }

        // Autenticazione fallita
        return back()->withErrors([
            'email' => 'Email o password non corretti.',
        ])->onlyInput('email');
    }
}
```

Passi le credenziali come primo argomento di `Auth::attempt()`.
La password viene confrontata automaticamente con l'hash, quindi passala in chiaro.

Per implementare la funzione "ricordami", passa `true` come secondo argomento.

```php theme={null}
// Usa il valore della checkbox "ricordami"
Auth::attempt($credentials, $request->boolean('remember'));
```

<Info>
  Anche implementando l'autenticazione manualmente, ti consiglio di ispirarti al codice degli starter kit. Sono ottimi esempi di implementazione sicura.
</Info>

## Logout

Per disconnettere l'utente chiama `Auth::logout()`.
La best practice è invalidare anche la sessione e rigenerare il token CSRF.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Http\RedirectResponse;
use Illuminate\Support\Facades\Auth;

class LogoutController extends Controller
{
    public function logout(Request $request): RedirectResponse
    {
        Auth::logout();

        // Invalida la sessione
        $request->session()->invalidate();

        // Rigenera il token CSRF
        $request->session()->regenerateToken();

        return redirect('/');
    }
}
```

Usa il metodo POST per la route.

```php theme={null}
Route::post('/logout', [LogoutController::class, 'logout'])->middleware('auth');
```

Nel template Blade invia la richiesta POST tramite un form.

```blade theme={null}
<form method="POST" action="/logout">
    @csrf
    <button type="submit">Logout</button>
</form>
```

## Riepilogo

| Obiettivo                               | Metodo                              |
| --------------------------------------- | ----------------------------------- |
| Aggiungere velocemente l'autenticazione | Starter kit (`laravel new`)         |
| Ottenere l'utente corrente              | `Auth::user()` / `$request->user()` |
| Verificare lo stato di login            | `Auth::check()`                     |
| Proteggere una route                    | `->middleware('auth')`              |
| Effettuare il login manualmente         | `Auth::attempt($credentials)`       |
| Effettuare il logout                    | `Auth::logout()`                    |

## Prossimi passi

<Card title="Middleware" icon="shield-halved" href="/it/middleware">
  Impara nel dettaglio come funziona il middleware `auth` e come creare middleware personalizzati.
</Card>


## Related topics

- [Starter kit](/it/starter-kits.md)
- [Hashing](/it/hashing.md)
- [Reset della password](/it/passwords.md)
- [Introduzione a React — le basi per usarlo con Inertia × Laravel](/it/blog/react-introduction.md)
- [Introduzione a Vue.js — le basi per usarlo con Inertia × Laravel](/it/blog/vue-introduction.md)