Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.
;
};
export const sections = [{
id: "installer-laravel",
title: "Installer Laravel"
}, {
id: "installation-de-la-trousse-sdk",
title: "Installation de la trousse SDK"
}, {
id: "configuration-sdk",
title: "Configuration SDK"
}, {
id: "routes-de-connexion",
title: "Routes de connexion"
}, {
id: "contrôle-d-accès",
title: "Contrôle d’accès"
}, {
id: "renseignements-de-l-utilisateur",
title: "Renseignements de l’utilisateur"
}, {
id: "gestion-des-utilisateurs",
title: "Gestion des utilisateurs"
}, {
id: "exécuter-l-application",
title: "Exécuter l’application"
}];
La [Auth0’s Laravel SDK (trousse SDK Laravel Auth0)](https://github.com/auth0/laravel-auth0) vous permet d’ajouter rapidement l’authentification, la gestion du profil utilisateur et le contrôle d’accès au routage à votre application Laravel. Ce guide explique comment intégrer Auth0 avec une nouvelle (ou existante) application [Laravel 9 or 10 (Laravel 9 ou 10)](https://github.com/auth0/laravel-auth0#support-policy).
**Si vous n’avez pas déjà configuré une application Laravel**, ouvrez un shell dans un répertoire approprié pour un nouveau projet et exécutez la commande suivante :
`composer create-project --prefer-dist laravel/laravel auth0-laravel-app ^9.0`
Toutes les commandes de ce guide supposent que vous les exécutez à partir de la racine de votre projet Laravel, donc vous devez placer `cd` dans le nouveau répertoire du projet :
`cd auth0-laravel-app`
Exécutez la commande suivante dans le répertoire de votre projet pour installer la trousse [Auth0 Laravel SDK](https://github.com/auth0/laravel-auth0) :
`composer require auth0/login:^7.8 --update-with-all-dependencies`
Générez ensuite un fichier de configuration pour la trousse SDK pour votre application :
`php artisan vendor:publish --tag auth0`
Exécutez la commande suivante à partir du répertoire de votre projet pour télécharger l’interface de ligne de commande (CLI) Auth0 :
`curl -sSfL HTTPs://raw.githubusercontent.com/auth0/auth0-cli/main/install.sh | sh -s -- -b .`
Ensuite, authentifiez la CLI avec votre compte Auth0 en choisissant « as a user (en tant qu’utilisateur) » lorsque vous y êtes invité :
`./auth0 login`
Ensuite, créez une nouvelle application avec Auth0 :
```
./auth0 apps create \
--name "My Laravel Application" \
--type "regular" \
--auth-method "post" \
--callbacks "http://localhost:8000/callback" \
--logout-urls "http://localhost:8000" \
--reveal-secrets \
--no-input \
--json > .auth0.app.json
```
Vous devez également créer une nouvelle API :
```
./auth0 apis create \
--name "My Laravel Application's API" \
--identifier "https://github.com/auth0/laravel-auth0" \
--offline-access \
--no-input \
--json > .auth0.api.json
```
Cela produit deux fichiers qui configurent la trousse SDK dans votre répertoire de projet.
Comme ces fichiers contiennent des renseignements personnels, il est important de les traiter comme étant sensibles. Vous devez vous assurer de ne pas les soumettre au contrôle de version. Si vous utilisez Git, vous devez les ajouter à votre fichier `.gitignore` :
`echo ".auth0.*.json" >> .gitignore`
La trousse SDK enregistre automatiquement toutes les routes nécessaires pour que les utilisateurs de votre application s’authentifient.
| **Routes** | **Objet** |
| ----------- | ---------------------------------- |
| `/login` | Initie le flux d’authentification. |
| `/logout` | Déconnecte l’utilisateur. |
| `/callback` | Gère le rappel de Auth0. |
Si vous avez besoin d’un plus grand contrôle sur les utilisateurs, ou s’ils entrent en conflit avec les routes existantes dans votre application, vous pouvez enregistrer manuellement les contrôleurs de la trousse SDK. Veuillez consulter le fichier de mise à jour de la trousse [SDK README](https://github.com/auth0/laravel-auth0) pour les intégrations avancées.
Les installations d’authentification de Laravel utilisent des « gardes » pour définir comment les utilisateurs sont authentifiés pour chaque demande. Vous pouvez utiliser la protection d’authentification de la trousse SDK Auth0 pour restreindre l’accès aux routes de votre application.
Pour exiger que les utilisateurs s’authentifient avant d’accéder à une route, vous pouvez utiliser l’intergiciel `auth` de Laravel.
```
Route::get('/private', function () {
return response('Welcome! You are logged in.');
})->middleware('auth');
```
Vous pouvez également exiger que les utilisateurs authentifiés aient des [autorisations](https://auth0.com/docs/manage-users/access-control/rbac) spécifiques en combinant cela avec l'intergiciel `can` de Laravel.
```
Route::get('/scope', function () {
return response('You have `read:messages` permission, and can therefore access this resource.');
})->middleware('auth')->can('read:messages');
```
Les renseignements de l’utilisateur authentifié sont accessibles à partir de la Facade `Auth` de Laravel, ou de la fonction d’assistance `auth()`.
Par exemple, pour récupérer l’identificateur et l’adresse courriel de l’utilisateur :
```
Route::get('/', function () {
if (! auth()->check()) {
return response('You are not logged in.');
}
$user = auth()->user();
$name = $user->name ?? 'User';
$email = $user->email ?? '';
return response("Hello {$name}! Your email address is {$email}.");
});;
```
Vous pouvez mettre à jour les informations utilisateur en utilisant la [Auth0 Management API](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md). Tous les terminaux de gestion sont accessibles via la méthode `management()` de la trousse SDK.
**Avant de faire des appels à la Management API, vous devez permettre à votre application de communiquer avec la Management API.** Cela peut être fait à partir de la [page API du Auth0 Dashboard](https://manage.auth0.com/#/apis), en choisissant la `Auth0 Management API` et en sélectionnant l’onglet Machine to Machine Applications (Communication entre machines). Autoriser votre application Laravel, puis cliquez sur la flèche vers le bas pour choisir les permissions que vous souhaitez accorder.
Pour l’exemple suivant, dans lequel nous allons mettre à jour les métadonnées d’un utilisateur et attribuer une couleur préférée aléatoire, vous devez accorder les permissions `read:users` et `update:users`. Une liste des points de terminaison API et les permissions requises peuvent être trouvées dans [la documentation de la Management API](https://auth0.com/docs/api/management/v2).
```
use Auth0\Laravel\Facade\Auth0;
Route::get('/colors', function () {
$endpoint = Auth0::management()->users();
$colors = ['red', 'blue', 'green', 'black', 'white', 'yellow', 'purple', 'orange', 'pink', 'brown'];
$endpoint->update(
id: auth()->id(),
body: [
'user_metadata' => [
'color' => $colors[random_int(0, count($colors) - 1)]
]
]
);
$metadata = $endpoint->get(auth()->id());
$metadata = Auth0::json($metadata);
$color = $metadata['user_metadata']['color'] ?? 'unknown';
$name = auth()->user()->name;
return response("Hello {$name}! Your favorite color is {$color}.");
})->middleware('auth');
```
Un guide de référence rapide de toutes les méthodes de la Management API de la trousse SDK est [disponible ici](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md).
Vous êtes maintenant prêt à lancer votre application Laravel, de sorte qu’elle puisse accepter les demandes :
`php artisan serve`
##### Point de contrôle
Ouvrez votre navigateur Web et essayez d’accéder aux routes suivantes :
* [http://localhost:8000](http://localhost:8000) pour voir la route publique.
* [http://localhost:8000/private](http://localhost:8000/private) pour être invité à s’authentifier.
* [http://localhost:8000](http://localhost:8000) pour voir la route publique, maintenant authentifiée.
* [http://localhost:8000/scope](http://localhost:8000/scope) pour vérifier si vous avez [l’autorisation](https://auth0.com/docs/manage-users/access-control/rbac)`read:messages`.
* [http://localhost:8000/update](http://localhost:8000/update) pour mettre à jour le profil utilisateur.
* [http://localhost:8000/logout](http://localhost:8000/logout) pour vous déconnecter.
### Lecture supplémentaire
* [Référentiels et modèles d’utilisateurs](https://github.com/auth0/laravel-auth0/blob/main/docs/Users.md) étend la trousse SDK Laravel Auth0 pour utiliser des modèles d’utilisateurs personnalisés, et comment stocker et récupérer les utilisateurs à partir d’une base de données.
* [Événements d’appels](https://github.com/auth0/laravel-auth0/blob/main/docs/Events.md) explique comment écouter les événements soulevés par la trousse SDK Laravel Auth0, pour personnaliser pleinement le comportement de votre intégration.
* Le soutien de la [Management API](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md) est intégré à la trousse SDK Laravel Auth0, vous permettant d’interagir avec Management API à partir de votre application Laravel.
## Étapes suivantes
Beau travail! Si vous en êtes arrivé là, vous devriez avoir la connexion, la déconnexion et les informations de profil utilisateur actives dans votre application.
Cela conclut notre tutoriel de démarrage rapide, mais il y a tellement plus à explorer. Pour en savoir plus sur ce que vous pouvez faire avec Auth0, consultez :
* [Auth0 Dashboard](https://manage.auth0.com/#) : apprenez à configurer et gérer votre locataire et vos applications Auth0
* [Trousse SDK laravel-auth0](https://github.com/auth0/laravel-auth0) : explorez en détail la trousse SDK utilisée dans ce tutoriel
* [Auth0 Marketplace](https://marketplace.auth0.com/) : découvrez des intégrations que vous pouvez activer pour étendre les fonctionnalités d’Auth0
```php routes/web.php lines theme={null}
Route::get('/private', function () {
return response('Welcome! You are logged in.');
})->middleware('auth');
Route::get('/scope', function () {
return response('You have `read:messages` permission, and can therefore access this resource.');
})->middleware('auth')->can('read:messages');
```
```php routes/web.php lines theme={null}
Route::get('/', function () {
if (! auth()->check()) {
return response('You are not logged in.');
}
$user = auth()->user();
$name = $user->name ?? 'User';
$email = $user->email ?? '';
return response("Hello {$name}! Your email address is {$email}.");
});
```
```php routes/web.php lines theme={null}
use Auth0\Laravel\Facade\Auth0;
Route::get('/colors', function () {
$endpoint = Auth0::management()->users();
$colors = ['red', 'blue', 'green', 'black', 'white', 'yellow', 'purple', 'orange', 'pink', 'brown'];
$endpoint->update(
id: auth()->id(),
body: [
'user_metadata' => [
'color' => $colors[random_int(0, count($colors) - 1)]
]
]
);
$metadata = $endpoint->get(auth()->id());
$metadata = Auth0::json($metadata);
$color = $metadata['user_metadata']['color'] ?? 'unknown';
$name = auth()->user()->name;
return response("Hello {$name}! Your favorite color is {$color}.");
})->middleware('auth');
```
Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.