Prologo

Primi Passi

Architettura

Le Basi

Approfondimenti

Sicurezza

Database

Eloquent ORM

Testing

Package

Richieste

Introduzione

La classe Illuminate\Http\Request di Laravel offre un approccio orientato agli oggetti per interagire con la richiesta HTTP corrente gestita dalla tua applicazione, oltre a recuperare input, cookie e file inviati con la richiesta.

Interagire con la richiesta

Accesso alla Richiesta

Per ottenere un’istanza della richiesta HTTP corrente tramite dependency injection, devi specificare il tipo della classe Illuminate\Http\Request nella tua closure di route o nel metodo del controller. L’istanza della richiesta in arrivo sarà automaticamente iniettata dal service container di Laravel:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;

class UserController extends Controller
{
    /**
     * Salva un nuovo utente.
     */
    public function store(Request $request): RedirectResponse
    {
        $name = $request->input('name');

        // Salva l'utente...

        return redirect('/users');
    }
}

Come accennato, puoi anche specificare il tipo della classe Illuminate\Http\Request in una closure di route. Il service container inietterà automaticamente la richiesta in arrivo nella closure quando verrà eseguita:

use Illuminate\Http\Request;

Route::get('/', function (Request $request) {
    // ...
});

Iniezione delle Dipendenze e Parametri

Se il tuo metodo del controller si aspetta anche input da un parametro di route, dovresti elencare i parametri di route dopo le altre dipendenze. Ad esempio, se la tua route è definita così:

use App\Http\Controllers\UserController;

Route::put('/user/{id}', [UserController::class, 'update']);

Puoi comunque usare il type-hint Illuminate\Http\Request e accedere al parametro di route id definendo il metodo del tuo controller nel seguente modo:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;

class UserController extends Controller
{
    /**
     * Aggiorna l'utente specificato.
     */
    public function update(Request $request, string $id): RedirectResponse
    {
        // Aggiorna l'utente...

        return redirect('/users');
    }
}

Percorso, Host e Metodo della Richiesta

L’istanza Illuminate\Http\Request fornisce vari metodi per esaminare la richiesta HTTP in arrivo ed estende la classe Symfony\Component\HttpFoundation\Request. Di seguito discuteremo alcuni dei metodi più importanti.

Recuperare il Percorso della Richiesta

Il metodo path restituisce le informazioni del percorso della richiesta. Quindi, se la richiesta arriva a http://example.com/foo/bar, il metodo path restituirà foo/bar:

$uri = $request->path();

Ispezionare il Percorso della Richiesta / Route

Il metodo is ti permette di verificare che il percorso della richiesta in arrivo corrisponda a un determinato pattern. Puoi usare il carattere * come jolly quando utilizzi questo metodo:

if ($request->is('admin/*')) {
    // ...
}

Usando il metodo routeIs, puoi determinare se la richiesta in arrivo corrisponde ad una route nominata:

if ($request->routeIs('admin.*')) {
    // ...
}

Recuperare l’URL della Richiesta

Per ottenere l’URL completo della richiesta in arrivo, puoi usare i metodi url o fullUrl. Il metodo url restituisce l’URL senza la stringa di query, mentre fullUrl include la stringa di query:

$url = $request->url();

$urlWithQueryString = $request->fullUrl();

Se desideri aggiungere dati alla stringa di query all’URL corrente, puoi chiamare il metodo fullUrlWithQuery. Questo metodo unisce l’array fornito di variabili della stringa di query con quella corrente:

$request->fullUrlWithQuery(['type' => 'phone']);

Se vuoi ottenere l’URL corrente senza un determinato parametro della stringa di query, puoi utilizzare il metodo fullUrlWithoutQuery:

$request->fullUrlWithoutQuery(['type']);

Ottenere l’Host della Richiesta

Puoi ottenere l’"host" della richiesta in arrivo tramite i metodi host, httpHost e schemeAndHttpHost:

$request->host();
$request->httpHost();
$request->schemeAndHttpHost();

Recuperare il Metodo della Richiesta

Il metodo method restituisce il verbo HTTP della richiesta. Puoi usare il metodo isMethod per verificare che il verbo HTTP corrisponda a una stringa specifica:

$method = $request->method();

if ($request->isMethod('post')) {
    // ...
}

Header della Richiesta

Puoi ottenere un header dalla richiesta usando il metodo header sull’istanza di Illuminate\Http\Request. Se l’header non è presente, verrà restituito null. Tuttavia, il metodo header accetta un secondo argomento opzionale che verrà restituito se l’header non è presente:

$value = $request->header('X-Header-Name');

$value = $request->header('X-Header-Name', 'default');

Il metodo hasHeader può essere utilizzato per verificare se la richiesta contiene un determinato header:

if ($request->hasHeader('X-Header-Name')) {
    // ...
}

Per comodità, il metodo bearerToken può essere usato per ottenere un token bearer dall’header Authorization. Se nessun header di questo tipo è presente, verrà restituita una stringa vuota:

$token = $request->bearerToken();

Richiedere l’indirizzo IP

Il metodo ip può essere utilizzato per ottenere l’indirizzo IP del client che ha effettuato la richiesta alla tua applicazione:

    $ipAddress = $request->ip();

Se desideri ottenere un array di indirizzi IP, inclusi tutti gli indirizzi IP del client inoltrati dai proxy, puoi utilizzare il metodo ips. L’indirizzo IP "originale" del client sarà alla fine dell’array:

    $ipAddresses = $request->ips();

In generale, gli indirizzi IP dovrebbero essere considerati input non affidabili e controllati dall’utente, e usati solo a scopo informativo.

Tipo dei Contenuti

Laravel fornisce diversi metodi per ispezionare i tipi di contenuto richiesti dalla richiesta in ingresso tramite l’intestazione Accept. Innanzitutto, il metodo getAcceptableContentTypes restituirà un array contenente tutti i tipi di contenuto accettati dalla richiesta:

    $contentTypes = $request->getAcceptableContentTypes();

Il metodo accepts accetta un array di tipi di contenuto e restituisce true se uno qualsiasi dei tipi di contenuto è accettato dalla richiesta. Altrimenti, verrà restituito false:

    if ($request->accepts(['text/html', 'application/json'])) {
        // ...
    }

Puoi usare il metodo prefers per determinare quale tipo di contenuto, tra quelli forniti, è più preferito dalla richiesta. Se nessuno dei tipi di contenuto forniti è accettato dalla richiesta, verrà restituito null:

    $preferred = $request->prefers(['text/html', 'application/json']);

Poiché molte applicazioni servono solo HTML o JSON, puoi usare il metodo expectsJson per verificare rapidamente se la richiesta in ingresso si aspetta una risposta JSON:

    if ($request->expectsJson()) {
        // ...
    }

Richieste PSR-7

Lo standard PSR-7 specifica le interfacce per i messaggi HTTP, comprese richieste e risposte. Se desideri ottenere un’istanza di una richiesta PSR-7 invece di una richiesta Laravel, devi prima installare alcune librerie. Laravel utilizza il componente Symfony HTTP Message Bridge per convertire le solite richieste e risposte Laravel in implementazioni compatibili con PSR-7:

composer require symfony/psr-http-message-bridge
composer require nyholm/psr7

Una volta installate queste librerie, puoi ottenere una richiesta PSR-7 specificando l’interfaccia della richiesta nel tuo closure di rotta o nel metodo del controller:

use Psr\Http\Message\ServerRequestInterface;

Route::get('/', function (ServerRequestInterface $request) {
    // ...
});

Se ritorni un’istanza di risposta PSR-7 da una rotta o da un controller, verrà automaticamente convertita nuovamente in un’istanza di risposta Laravel e mostrata dal framework.

Input

Recuperare Input

Recuperare Tutti i Dati di Input

Puoi ottenere tutti i dati di input della richiesta in arrivo come un array usando il metodo all. Questo metodo può essere utilizzato sia che la richiesta provenga da un modulo HTML o sia una richiesta XHR:

$input = $request->all();

Usando il metodo collect, puoi ottenere tutti i dati di input della richiesta in arrivo come una collection:

$input = $request->collect();

Il metodo collect permette anche di ottenere un sottoinsieme dei dati di input della richiesta in arrivo come una collection:

$request->collect('users')->each(function (string $user) {
    // ...
});

Recuperare un Valore di Input

Con alcuni semplici metodi, puoi accedere a tutti i dati inseriti dall’utente tramite la tua istanza Illuminate\Http\Request senza preoccuparti del verbo HTTP utilizzato per la richiesta. Indipendentemente dal verbo HTTP, puoi usare il metodo input per recuperare i dati dell’utente:

    $name = $request->input('name');

Puoi passare un valore di default come secondo argomento al metodo input. Questo valore sarà restituito se il valore di input richiesto non è presente nella richiesta:

    $name = $request->input('name', 'Sally');

Quando lavori con form che contengono input array, usa la notazione "dot" per accedere agli array:

    $name = $request->input('products.0.name');

    $names = $request->input('products.*.name');

Puoi chiamare il metodo input senza argomenti per recuperare tutti i valori di input come un array associativo:

    $input = $request->input();

Recuperare Input dalla Query String

Mentre il metodo input recupera i valori da tutto il payload della richiesta (inclusa la query string), il metodo query recupera solo i valori dalla query string:

$name = $request->query('name');

Se il valore della query string richiesto non è presente, verrà restituito il secondo argomento di questo metodo:

$name = $request->query('name', 'Helen');

Puoi chiamare il metodo query senza argomenti per recuperare tutti i valori della query string come un array associativo:

$query = $request->query();

Recuperare i Valori di Input JSON

Quando invii richieste JSON alla tua applicazione, puoi accedere ai dati JSON tramite il metodo input, a condizione che l’intestazione Content-Type della richiesta sia impostata correttamente su application/json. Puoi anche usare la sintassi a punti per recuperare valori annidati all’interno di array/oggetti JSON:

    $name = $request->input('user.name');

Recuperare Valori di Stringhe

Invece di recuperare i dati di input della richiesta come una string primitiva, puoi usare il metodo string per ottenere i dati della richiesta come un’istanza di Illuminate\Support\Stringable:

$name = $request->string('name')->trim();

Recuperare valori di input interi

Per ottenere valori di input come interi, puoi usare il metodo integer. Questo metodo tenterà di convertire il valore di input in un intero. Se il input non è presente o la conversione fallisce, restituirà il valore predefinito che specifichi. Questo è particolarmente utile per la paginazione o altri input numerici:

$perPage = $request->integer('per_page');

Recupero di Valori Booleani dagli Input

Quando si lavora con elementi HTML come checkbox, la tua applicazione può ricevere valori "truthy" che in realtà sono stringhe. Per esempio, "true" o "on". Per comodità, puoi utilizzare il metodo boolean per ottenere questi valori come booleani. Il metodo boolean restituisce true per 1, "1", true, "true", "on" e "yes". Tutti gli altri valori restituiranno false:

    $archived = $request->boolean('archived');

Recuperare i Valori di Input Data

Per comodità, i valori di input contenenti date/ore possono essere recuperati come istanze di Carbon usando il metodo date. Se la richiesta non contiene un valore di input con il nome fornito, verrà restituito null:

$birthday = $request->date('birthday');

Il secondo e il terzo argomento accettati dal metodo date possono essere utilizzati per specificare rispettivamente il formato della data e il fuso orario:

$elapsed = $request->date('elapsed', '!H:i', 'Europe/Madrid');

Se il valore di input è presente ma ha un formato non valido, verrà lanciata una InvalidArgumentException; pertanto, si raccomanda di validare l’input prima di invocare il metodo date.

Recupero dei Valori Enum dall’Input

I valori di input che corrispondono a PHP enums possono essere ottenuti dalla richiesta. Se la richiesta non include un valore di input con il nome indicato oppure se l’enum non ha un valore corrispondente, verrà restituito null. Il metodo enum prende il nome del valore di input e la classe enum come primo e secondo parametro:

use App\Enums\Status;

$status = $request->enum('status', Status::class);

Se il valore di input è un array di valori che corrispondono a un PHP enum, puoi utilizzare il metodo enums per ottenere l’array di valori come istanze enum:

use App\Enums\Product;

$products = $request->enums('products', Product::class);

Recuperare Input tramite Proprietà Dinamiche

Puoi anche accedere ai dati inviati dall’utente utilizzando le proprietà dinamiche sull’istanza di Illuminate\Http\Request. Ad esempio, se uno dei form della tua applicazione contiene un campo name, puoi accedere al valore del campo in questo modo:

$name = $request->name;

Quando usi le proprietà dinamiche, Laravel cercherà prima il valore del parametro nel payload della richiesta. Se non è presente, Laravel cercherà il campo nei parametri della route corrispondente.

Recuperare una Parte dei Dati di Input

Se hai bisogno di recuperare un sottoinsieme dei dati di input, puoi usare i metodi only ed except. Entrambi questi metodi accettano un singolo array o una lista di argomenti dinamica:

$input = $request->only(['username', 'password']);

$input = $request->only('username', 'password');

$input = $request->except(['credit_card']);

$input = $request->except('credit_card');

Il metodo only restituisce tutte le coppie chiave/valore che richiedi; tuttavia, non restituirà coppie chiave/valore che non sono presenti nella richiesta.

Presenza dell’Input

Puoi utilizzare il metodo has per determinare se un valore è presente nella richiesta. Il metodo has restituisce true se il valore è presente nella richiesta:

if ($request->has('name')) {
    // ...
}

Quando viene fornito un array, il metodo has verificherà se tutti i valori specificati sono presenti:

if ($request->has(['name', 'email'])) {
    // ...
}

Il metodo hasAny restituisce true se almeno uno dei valori specificati è presente:

if ($request->hasAny(['name', 'email'])) {
    // ...
}

Il metodo whenHas eseguirà la closure fornita se un valore è presente nella richiesta:

$request->whenHas('name', function (string $input) {
    // ...
});

Può essere passata una seconda closure al metodo whenHas che verrà eseguita se il valore specificato non è presente nella richiesta:

$request->whenHas('name', function (string $input) {
    // Il valore "name" è presente...
}, function () {
    // Il valore "name" non è presente...
});

Se desideri determinare se un valore è presente nella richiesta e non è una stringa vuota, puoi utilizzare il metodo filled:

if ($request->filled('name')) {
    // ...
}

Se desideri determinare se un valore manca nella richiesta o è una stringa vuota, puoi utilizzare il metodo isNotFilled:

if ($request->isNotFilled('name')) {
    // ...
}

Quando viene fornito un array, il metodo isNotFilled verificherà se tutti i valori specificati mancano o sono vuoti:

if ($request->isNotFilled(['name', 'email'])) {
    // ...
}

Il metodo anyFilled restituisce true se almeno uno dei valori specificati non è una stringa vuota:

if ($request->anyFilled(['name', 'email'])) {
    // ...
}

Il metodo whenFilled eseguirà la closure fornita se un valore è presente nella richiesta e non è una stringa vuota:

$request->whenFilled('name', function (string $input) {
    // ...
});

Può essere passata una seconda closure al metodo whenFilled che verrà eseguita se il valore specificato non è "filled":

$request->whenFilled('name', function (string $input) {
    // Il valore "name" è pieno...
}, function () {
    // Il valore "name" non è pieno...
});

Per determinare se una chiave data è assente dalla richiesta, puoi utilizzare i metodi missing e whenMissing:

if ($request->missing('name')) {
    // ...
}

$request->whenMissing('name', function () {
    // Il valore "name" manca...
}, function () {
    // Il valore "name" è presente...
});

Unione di Input Aggiuntivo

A volte potresti aver bisogno di unire manualmente input aggiuntivo ai dati di input esistenti della richiesta. Per farlo, puoi usare il metodo merge. Se una chiave di input esiste già nella richiesta, verrà sovrascritta dai dati forniti al metodo merge:

$request->merge(['votes' => 0]);

Il metodo mergeIfMissing può essere utilizzato per unire input nella richiesta se le chiavi corrispondenti non esistono già nei dati di input della richiesta:

$request->mergeIfMissing(['votes' => 0]);

Input Precedente

Laravel ti permette di mantenere l’input da una richiesta durante la successiva. Questa funzionalità è particolarmente utile per ripopolare i moduli dopo aver rilevato errori di validazione. Tuttavia, se stai usando le funzionalità di validazione di Laravel, potrebbe non essere necessario utilizzare manualmente questi metodi di flashing degli input della sessione, poiché alcune delle funzionalità di validazione integrate di Laravel li usano automaticamente.

Memorizzazione Temporanea dell’Input nella Sessione

Il metodo flash della classe Illuminate\Http\Request salva temporaneamente l’input corrente nella sessione in modo che sia disponibile durante la prossima richiesta dell’utente all’applicazione:

    $request->flash();

Puoi anche utilizzare i metodi flashOnly e flashExcept per salvare temporaneamente solo una parte dei dati della richiesta nella sessione. Questi metodi sono utili per mantenere informazioni sensibili come le password fuori dalla sessione:

    $request->flashOnly(['username', 'email']);

    $request->flashExcept('password');

Memorizzare l’Input e Reindirizzare

Poiché spesso vorrai memorizzare temporaneamente i dati di input nella sessione e poi reindirizzare alla pagina precedente, puoi facilmente concatenare la memorizzazione dell’input a un redirect usando il metodo withInput:

return redirect('/form')->withInput();

return redirect()->route('user.create')->withInput();

return redirect('/form')->withInput(
    $request->except('password')
);

Recupero dell’Input Precedente

Per recuperare gli input inviati nella richiesta precedente, chiama il metodo old su un’istanza di Illuminate\Http\Request. Il metodo old preleverà i dati di input inviati precedentemente dalla session:

$username = $request->old('username');

Laravel fornisce anche un helper globale old. Se stai visualizzando input passati all’interno di un template Blade, è più comodo usare l’helper old per ripopolare il form. Se non esiste un vecchio input per il campo dato, verrà restituito null:

<input type="text" name="username" value="{{ old('username') }}">

Cookie

Recuperare i Cookie dalle Richieste

Tutti i cookie creati dal framework Laravel sono criptati e firmati con un codice di autenticazione, il che significa che saranno considerati invalidi se modificati dal client. Per recuperare il valore di un cookie dalla richiesta, usa il metodo cookie su un’istanza di Illuminate\Http\Request:

    $value = $request->cookie('name');

Trimming e Normalizzazione dell’Input

Per impostazione predefinita, Laravel include i middleware Illuminate\Foundation\Http\Middleware\TrimStrings e Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull nello stack dei middleware globali dell’applicazione. Questi middleware automaticamente rimuovono gli spazi da tutti i campi di tipo stringa in arrivo nella richiesta e convertono eventuali campi stringa vuoti in null. In questo modo, non devi preoccuparti di queste operazioni di normalizzazione nelle tue rotte e controller.

Disabilitare la Normalizzazione dell’Input

Se desideri disabilitare questo comportamento per tutte le richieste, puoi rimuovere i due middleware dallo stack dei middleware della tua applicazione invocando il metodo $middleware->remove nel file bootstrap/app.php della tua applicazione:

use Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull;
use Illuminate\Foundation\Http\Middleware\TrimStrings;

->withMiddleware(function (Middleware $middleware) {
    $middleware->remove([
        ConvertEmptyStringsToNull::class,
        TrimStrings::class,
    ]);
})

Se desideri disabilitare il trimming delle stringhe e la conversione delle stringhe vuote per un sottoinsieme di richieste alla tua applicazione, puoi utilizzare i metodi middleware trimStrings e convertEmptyStringsToNull nel file bootstrap/app.php della tua applicazione. Entrambi i metodi accettano un array di closures, che devono restituire true o false per indicare se la normalizzazione dell’input deve essere saltata:

->withMiddleware(function (Middleware $middleware) {
    $middleware->convertEmptyStringsToNull(except: [
        fn (Request $request) => $request->is('admin/*'),
    ]);

    $middleware->trimStrings(except: [
        fn (Request $request) => $request->is('admin/*'),
    ]);
})

File

Recuperare File Caricati

Puoi recuperare i file caricati da un’istanza di Illuminate\Http\Request utilizzando il metodo file oppure le proprietà dinamiche. Il metodo file restituisce un’istanza della classe Illuminate\Http\UploadedFile, che estende la classe PHP SplFileInfo e fornisce vari metodi per interagire con il file:

$file = $request->file('photo');

$file = $request->photo;

Puoi verificare se un file è presente nella richiesta usando il metodo hasFile:

if ($request->hasFile('photo')) {
    // ...
}

Validare i Caricamenti Riusciti

Oltre a verificare che il file sia presente, puoi controllare che non ci siano stati problemi nel caricamento del file tramite il metodo isValid:

if ($request->file('photo')->isValid()) {
    // ...
}

Percorsi e Estensioni dei File

La classe UploadedFile contiene anche metodi per accedere al percorso completo del file e alla sua estensione. Il metodo extension cercherà di determinare l’estensione del file in base al suo contenuto. Questa estensione potrebbe essere diversa da quella fornita dal client:

    $path = $request->photo->path();

    $extension = $request->photo->extension();

Altri Metodi per i File

Ci sono diversi altri metodi disponibili sulle istanze UploadedFile. Consulta la documentazione API della classe per maggiori informazioni su questi metodi.

Salvataggio dei File Caricati

Per salvare un file caricato, solitamente utilizzerai uno dei tuoi filesystems configurati. La classe UploadedFile dispone di un metodo store che sposterà un file caricato su uno dei tuoi dischi, che può essere una posizione sul filesystem locale o un servizio di cloud storage come Amazon S3.

Il metodo store accetta il percorso in cui il file deve essere salvato relativo alla directory root configurata del filesystem. Questo percorso non deve includere un nome file, poiché verrà generato automaticamente un ID univoco come nome del file.

Il metodo store accetta anche un secondo argomento opzionale per il nome del disco che deve essere utilizzato per salvare il file. Il metodo restituirà il percorso del file relativo alla radice del disco:

    $path = $request->photo->store('images');
    $path = $request->photo->store('images', 's3');

Se non desideri che venga generato automaticamente un nome file, puoi utilizzare il metodo storeAs, che accetta come argomenti il percorso, il nome del file e il nome del disco:

    $path = $request->photo->storeAs('images', 'filename.jpg');
    $path = $request->photo->storeAs('images', 'filename.jpg', 's3');

Per ulteriori informazioni sul salvataggio dei file in Laravel, consulta la completa documentazione sul salvataggio dei file.

Configurare i Proxy Affidabili

Quando esegui le tue applicazioni dietro un load balancer che si occupa dei certificati TLS / SSL, potresti notare che la tua applicazione a volte non genera link HTTPS quando usi l’helper url. Di solito questo accade perché il traffico viene inoltrato dal load balancer sulla porta 80 e l’applicazione non sa che deve generare link sicuri.

Per risolvere questo problema, puoi abilitare il middleware Illuminate\Http\Middleware\TrustProxies incluso nella tua applicazione Laravel, che ti permette di personalizzare rapidamente i bilanciatori di carico o i proxy a cui la tua applicazione deve affidarsi. I tuoi proxy devono essere specificati usando il metodo trustProxies nel file bootstrap/app.php della tua applicazione:

->withMiddleware(function (Middleware $middleware) {
    $middleware->trustProxies(at: [
        '192.168.1.1',
        '10.0.0.0/8',
    ]);
})

Oltre a configurare i proxy fidati, puoi anche configurare le intestazioni del proxy a cui affidarti:

->withMiddleware(function (Middleware $middleware) {
    $middleware->trustProxies(headers: Request::HEADER_X_FORWARDED_FOR |
        Request::HEADER_X_FORWARDED_HOST |
        Request::HEADER_X_FORWARDED_PORT |
        Request::HEADER_X_FORWARDED_PROTO |
        Request::HEADER_X_FORWARDED_AWS_ELB
    );
})

Se stai usando AWS Elastic Load Balancing, il valore di headers dovrebbe essere Request::HEADER_X_FORWARDED_AWS_ELB. Se il tuo bilanciatore di carico utilizza l’intestazione standard Forwarded secondo RFC 7239, il valore di headers dovrebbe essere Request::HEADER_FORWARDED. Per maggiori informazioni sulle costanti che possono essere usate nel valore headers, consulta la documentazione di Symfony su affidarsi ai proxy.

Fidarsi di tutti i proxy

Se stai usando Amazon AWS o un altro fornitore di load balancer "cloud", potresti non conoscere gli indirizzi IP effettivi. In questo caso, puoi usare * per aprire a tutti i proxy:

    ->withMiddleware(function (Middleware $middleware) {
        $middleware->trustProxies(at: '*');
    })

Configurazione degli Host di Fiducia

Per impostazione predefinita, Laravel risponde a tutte le richieste che riceve indipendentemente dal contenuto dell’intestazione Host della richiesta HTTP. Inoltre, il valore dell’intestazione Host verrà utilizzato durante la generazione di URL assoluti per la tua applicazione durante una richiesta web.

Tipicamente, dovresti configurare il tuo server web, come Nginx o Apache, per inviare solo le richieste alla tua applicazione che corrispondono a un determinato hostname. Tuttavia, se non hai la possibilità di personalizzare direttamente il tuo server web e hai bisogno di istruire Laravel a rispondere solo a determinati nomi host, puoi farlo abilitando il middleware Illuminate\Http\Middleware\TrustHosts per la tua applicazione.

Per abilitare il middleware TrustHosts, devi invocare il metodo trustHosts nel file bootstrap/app.php della tua applicazione. Utilizzando l’argomento at di questo metodo, puoi specificare gli hostnames a cui la tua applicazione deve rispondere. Le richieste in arrivo con altri valori dell’intestazione Host saranno rifiutate:

    ->withMiddleware(function (Middleware $middleware) {
        $middleware->trustHosts(at: ['laravel.test']);
    })

Per impostazione predefinita, le richieste provenienti da sottodomini dell’URL dell’applicazione sono automaticamente considerate affidabili. Se desideri disabilitare questo comportamento, puoi utilizzare l’argomento subdomains:

    ->withMiddleware(function (Middleware $middleware) {
        $middleware->trustHosts(at: ['laravel.test'], subdomains: false);
    })

Se hai bisogno di accedere ai file di configurazione o al database della tua applicazione per determinare gli host di fiducia, puoi fornire una closure all’argomento at:

    ->withMiddleware(function (Middleware $middleware) {
        $middleware->trustHosts(at: fn () => config('app.trusted_hosts'));
    })
Lascia un commento

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Laravel-Italia.it è il sito della Community Italiana di Laravel.
2024 — Laravel-Italia