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: "installation-de-laravel",
title: "Installation de Laravel"
}, {
id: "installation-de-la-trousse-sdk",
title: "Installation de la trousse SDK"
}, {
id: "configuration-sdk",
title: "Configuration SDK"
}, {
id: "contrôle-d-accès",
title: "Contrôle d’accès"
}, {
id: "informations-de-jeton",
title: "Informations de jeton"
}, {
id: "récupérer-des-informations-sur-l-utilisateur",
title: "Récupérer des informations sur l’utilisateur"
}, {
id: "exécuter-l-application",
title: "Exécuter l’application"
}, {
id: "récupérer-un-jeton-de-test",
title: "Récupérer un jeton de test"
}];
[La trousse SDK Laravel d’Auth0](https://github.com/auth0/laravel-auth0) vous permet d’ajouter rapidement une autorisation basée sur un jeton et un 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 ou 10](https://github.com/auth0/laravel-auth0#support-policy).
***
**Les applications dorsales diffèrent des applications Web traditionnelles en ce sens qu’elles ne gèrent pas l’authentification des utilisateurs et n’ont pas d’interface utilisateur. Elles fournissent une API avec laquelle d’autres applications peuvent interagir. Elles acceptent les** [**jetons d’accès**](https://auth0.com/docs/secure/tokens/access-tokens) **des en-têtes** **`Authorization`** **dans les requêtes pour contrôler l’accès aux routes.**
Des applications frontales distinctes sont généralement créées pour interagir avec ces types d’applications dorsales. Il peut s’agir [d’applications à page unique](https://auth0.com/docs/quickstart/spa) ou [d’applications natives ou mobiles](https://auth0.com/docs/quickstart/native) (pour lesquelles Auth0 fournit également des trousses SDK).
Pour interagir avec votre application dorsale, les utilisateurs doivent d’abord s’authentifier auprès d’Auth0 à l’aide de l’application frontale. L’application frontale récupère ensuite un jeton d’accès auprès d’Auth0, qu’elle peut utiliser pour adresser des demandes à votre application dorsale au nom de l’utilisateur.
Comme leur nom l’indique, les [jetons d’accès](https://auth0.com/docs/secure/tokens/access-tokens) sont conçus pour traiter les questions de contrôle d’accès (autorisation) et ne contiennent pas d’informations sur l’utilisateur. **Les applications dorsales fonctionnent exclusivement avec des jetons d’accès.** Vous pouvez récupérer des informations sur l’utilisateur créateur du jeton à l’aide de la [Management API](https://auth0.com/docs/api/management/v2), que nous présenterons plus loin.
**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-api ^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 bous placer `cd` dans le nouveau répertoire du projet :
```
cd auth0-laravel-api
```
Exécutez la commande suivante dans le répertoire de votre projet pour installer la [trousse SDK Laravel Auth0](https://github.com/auth0/laravel-auth0) :
```
composer require auth0/login:^7.8 --update-with-all-dependencies
```
Générez ensuite un fichier de configuration de la trousse SDK pour votre application :
```
php artisan vendor:publish --tag auth0
```
Exécuter la commande suivante à partir du répertoire de votre projet pour télécharger le [Interface de ligne de commande (CLI) Auth0](https://github.com/auth0/auth0-cli) :
```
curl -sSfL https://raw.githubusercontent.com/auth0/auth0-cli/main/install.sh | sh -s -- -b .
```
Authentifiez ensuite la CLI avec votre compte Auth0 en choisissant « as a user (en tant qu’utilisateur) » lorsque vous y êtes invité :
```
./auth0 login
```
Puis créez une nouvelle application avec Auth0 :
```
./auth0 apps create \
--name "My Laravel Backend" \
--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 Backend 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 son gardien d’autorisation avec votre application Laravel pour l’utiliser avec le logiciel médiateur `api`, que Laravel applique par défaut à toutes les routes dans le fichier `routes/api.php` de votre application.
Pour que la trousse SDK fonctionne comme prévu sans configuration supplémentaire, **vous devez définir vos routes dans le fichier** `routes/api.php`.
Vous pouvez utiliser la protection d’autorisation de la trousse SDK Auth0 pour restreindre l’accès aux routes de votre application.
Pour rejeter les demandes qui ne contiennent pas de jeton d’accès valide dans l’en-tête `Authorization`, vous pouvez utiliser le logiciel médiateur `auth` de Laravel :
```
Route::get('/private', function () {
return response()->json([
'message' => 'Your token is valid; you are authorized.',
]);
})->middleware('auth');
```
Vous pouvez également exiger que le jeton fourni dispose des [permissions](https://auth0.com/docs/manage-users/access-control/rbac) spécifiques en le combinant avec le logiciel médiateur `can` de Laravel :
```
Route::get('/scope', function () {
return response()->json([
'message' => 'Your token is valid and has the read:messages permission; you are authorized.',
]);
})->middleware('auth')->can('read:messages');
```
Les informations sur le jeton d’accès fourni sont disponibles via la façade `Auth` de Laravel, ou 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()->json([
'message' => 'You did not provide a valid token.',
]);
}
return response()->json([
'message' => 'Your token is valid; you are authorized.',
'id' => auth()->id(),
'token' => auth()?->user()?->getAttributes(),
]);
});
```
Vous pouvez récupérer des informations sur l’utilisateur créateur du jeton d’accès à partir d’Auth0 en utilisant [Auth0 Management API](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md). La trousse SDK fournit une enveloppe pratique pour cette API, accessible par le biais de la méthode `management()` de la trousse SDK.
**Avant de faire des appels à la Management API, vous devez permettre à votre application de communiquer avec Management API.** Cela peut être fait à partir de la [page API d’Auth0 Dashboard](https://manage.auth0.com/#/apis/), en choisissant `Auth0 Management API` et en sélectionnant l’onglet Machine to Machine Applications (Communication entre machines). Autorisez votre application Laravel, puis cliquez sur la flèche vers le bas pour choisir les permissions que vous souhaitez accorder.
Dans l’exemple suivant, vous devez accorder la permission `read:users`. Une liste des points de terminaison API et les permissions requises peuvent être trouvées dans la [documentation de Management API](https://auth0.com/docs/api/management/v2).
```
use Auth0\Laravel\Facade\Auth0;
Route::get('/me', function () {
$user = auth()->id();
$profile = cache()->get($user);
if (null === $profile) {
$endpoint = Auth0::management()->users();
$profile = $endpoint->get($user);
$profile = Auth0::json($profile);
cache()->put($user, $profile, 120);
}
$name = $profile['name'] ?? 'Unknown';
$email = $profile['email'] ?? 'Unknown';
return response()->json([
'name' => $name,
'email' => $email,
]);
})->middleware('auth');
```
**Vous devez mettre en cache les informations relatives aux utilisateurs dans votre application pendant de brèves périodes.** Cela réduit le nombre de requêtes que votre application adresse à Auth0 et améliore les performances. Vous devez éviter de stocker des informations sur les utilisateurs dans votre application pendant de longues périodes, car cela peut conduire à des données obsolètes. Vous devez également éviter de stocker dans des bases de données persistantes des informations autres que l’identifiant de l’utilisateur.
Vous êtes maintenant prêt à lancer votre application Laravel, de sorte qu’elle puisse accepter les demandes :
```
php artisan serve
```
Pour en savoir plus sur la récupération des jetons d’accès, [cliquez ici](https://auth0.com/docs/secure/tokens/access-tokens/get-access-tokens). Pour ce démarrage rapide, vous pouvez simplement utiliser un jeton d’accès à partir de [l’affichage « test » des paramètres de votre API](https://manage.auth0.com/#/apis).
La route `/me` que nous avons créée ci-dessus ne fonctionnera pas avec un jeton de test car aucun utilisateur réel n’y est associé.
##### Point de contrôle
Ouvrez un shell et essayez d’envoyer des requêtes à votre application.
Commencez par demander la route publique :
`curl --request GET \ --url http://localhost:8000/api \ --header ’Accept: application/json’`
Ensuite, utilisez votre jeton d’accès dans un en-tête `Authorization` pour demander une route protégée :
`curl --request GET \ --url http://localhost:8000/api/private \ --header ’Accept: application/json’ \ --header ’Authorization : Bearer YOUR\_ACCESS\_TOKEN’`
Enfin, essayez de demander la route protégée par des permissions, qui n’aboutira que si le jeton d’accès dispose de la permission `read:messages` :
`curl --request GET \ --url http://localhost:8000/api/scope \ --header ’Accept: application/json’ \ --header ’Authorization : Bearer YOUR\_ACCESS\_TOKEN’`
### 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 et permet d’utiliser des modèles d’utilisateurs personnalisés et de stocker et de récupérer des 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 détecter les événements soulevés par la trousse SDK Laravel Auth0, pour personnaliser pleinement le comportement de votre intégration.
* Le soutien de [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/api.php lines highlight={6-16} theme={null}
json([
'message' => 'Your token is valid; you are authorized.',
]);
})->middleware('auth');
Route::get('/scope', function () {
return response()->json([
'message' => 'Your token is valid and has the `read:messages` permission; you are authorized.',
]);
})->middleware('auth')->can('read:messages');
Route::get('/', function () {
if (! auth()->check()) {
return response()->json([
'message' => 'You did not provide a valid token.',
]);
}
return response()->json([
'message' => 'Your token is valid; you are authorized.',
'id' => auth()->id(),
'token' => auth()?->user()?->getAttributes(),
]);
});
Route::get('/me', function () {
$user = auth()->id();
$profile = cache()->get($user);
if (null === $profile) {
$endpoint = Auth0::management()->users();
$profile = $endpoint->get($user);
$profile = Auth0::json($profile);
cache()->put($user, $profile, 120);
}
$name = $profile['name'] ?? 'Unknown';
$email = $profile['email'] ?? 'Unknown';
return response()->json([
'name' => $name,
'email' => $email,
]);
})->middleware('auth');
```
```php routes/api.php lines highlight={18-30} theme={null}
json([
'message' => 'Your token is valid; you are authorized.',
]);
})->middleware('auth');
Route::get('/scope', function () {
return response()->json([
'message' => 'Your token is valid and has the `read:messages` permission; you are authorized.',
]);
})->middleware('auth')->can('read:messages');
Route::get('/', function () {
if (! auth()->check()) {
return response()->json([
'message' => 'You did not provide a valid token.',
]);
}
return response()->json([
'message' => 'Your token is valid; you are authorized.',
'id' => auth()->id(),
'token' => auth()?->user()?->getAttributes(),
]);
});
Route::get('/me', function () {
$user = auth()->id();
$profile = cache()->get($user);
if (null === $profile) {
$endpoint = Auth0::management()->users();
$profile = $endpoint->get($user);
$profile = Auth0::json($profile);
cache()->put($user, $profile, 120);
}
$name = $profile['name'] ?? 'Unknown';
$email = $profile['email'] ?? 'Unknown';
return response()->json([
'name' => $name,
'email' => $email,
]);
})->middleware('auth');
```
```php routes/api.php lines highlight={32-51} theme={null}
json([
'message' => 'Your token is valid; you are authorized.',
]);
})->middleware('auth');
Route::get('/scope', function () {
return response()->json([
'message' => 'Your token is valid and has the `read:messages` permission; you are authorized.',
]);
})->middleware('auth')->can('read:messages');
Route::get('/', function () {
if (! auth()->check()) {
return response()->json([
'message' => 'You did not provide a valid token.',
]);
}
return response()->json([
'message' => 'Your token is valid; you are authorized.',
'id' => auth()->id(),
'token' => auth()?->user()?->getAttributes(),
]);
});
Route::get('/me', function () {
$user = auth()->id();
$profile = cache()->get($user);
if (null === $profile) {
$endpoint = Auth0::management()->users();
$profile = $endpoint->get($user);
$profile = Auth0::json($profile);
cache()->put($user, $profile, 120);
}
$name = $profile['name'] ?? 'Unknown';
$email = $profile['email'] ?? 'Unknown';
return response()->json([
'name' => $name,
'email' => $email,
]);
})->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.