Inscrivez-vous pour obtenir un{" "}
compte Auth0
{" "}
ou{" "}
console.log("log in")}>
connectez-vous
{" "}
à votre compte existant pour vous intégrer directement à votre propre locataire.
;
};
export const sections = [{
id: "laravel-installation",
title: "Installation de Laravel"
}, {
id: "sdk-installation",
title: "Installation du SDK"
}, {
id: "sdk-configuration",
title: "Configuration du SDK"
}, {
id: "access-control",
title: "Contrôle d’accès"
}, {
id: "token-information",
title: "Informations sur le jeton"
}, {
id: "retrieve-user-information",
title: "Récupérer les informations de l’utilisateur"
}, {
id: "run-the-application",
title: "Exécuter l’application"
}, {
id: "retrieve-a-test-token",
title: "Récupérer un jeton de test"
}];
[Auth0's Laravel SDK](https://github.com/auth0/laravel-auth0)
vous permet d'ajouter rapidement une autorisation basée sur les jetons et un contrôle d'accès aux routes de votre application Laravel. Ce guide
explique comment intégrer Auth0 à une application [Laravel 9
ou 10](https://github.com/auth0/laravel-auth0#support-policy) nouvelle ou existante.
**Les applications backend se distinguent des applications web traditionnelles en ce qu'elles ne gèrent pas l'authentification des utilisateurs et ne disposent pas d'interface utilisateur. Elles exposent une API avec laquelle d'autres applications peuvent interagir. Elles acceptent des **[jetons d'accès](https://auth0.com/docs/secure/tokens/access-tokens)** provenant des en-têtes **`Authorization`** des requêtes afin de contrôler l'accès aux routes.**
Des applications front-end distinctes sont généralement conçues pour interagir avec ces types de backends. Il peut s'agir de [applications monopage](https://auth0.com/docs/quickstart/spa) ou d'[applications natives ou mobiles](https://auth0.com/docs/quickstart/native) (pour lesquelles Auth0 fournit également des SDK !)
Lorsque les utilisateurs doivent interagir avec votre application back-end, ils s'authentifient d'abord auprès d'Auth0 via l'application front-end.
L'application front-end récupère ensuite un jeton d'accès auprès d'Auth0, qu'elle peut utiliser pour envoyer des requêtes
à votre application back-end 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 gérer le contrôle d'accès (autorisation) et ne contiennent pas d'informations sur l'utilisateur. **Les applications back-end fonctionnent exclusivement avec des jetons d'accès.** Vous pouvez récupérer les informations sur l'utilisateur qui a créé le jeton à l'aide de l'[API de gestion](https://auth0.com/docs/api/management/v2), ce que nous verrons plus loin.
**Si vous n’avez pas encore configuré d’application Laravel**, ouvrez un terminal dans un répertoire approprié pour un nouveau
projet et exécutez la commande suivante :
```bash lines wrap theme={null}
composer create-project --prefer-dist laravel/laravel auth0-laravel-api ^9.0
```
Toutes les commandes de ce guide supposent que vous les exécutez depuis le répertoire racine de votre projet Laravel, donc
placez-vous dans le répertoire du nouveau projet avec `cd` :
```bash lines theme={null}
cd auth0-laravel-api
```
Exécutez la commande suivante dans le répertoire de votre projet pour installer le [SDK Auth0 pour Laravel](https://github.com/auth0/laravel-auth0) :
```bash lines theme={null}
composer require auth0/login:^7.8 --update-with-all-dependencies
```
Ensuite, générez un fichier de configuration SDK pour votre application :
```bash lines theme={null}
php artisan vendor:publish --tag auth0
```
Exécutez la commande suivante depuis le répertoire de votre projet pour télécharger l’[Auth0 CLI](https://github.com/auth0/auth0-cli) :
```bash lines wrap theme={null}
curl -sSfL https://raw.githubusercontent.com/auth0/auth0-cli/main/install.sh | sh -s -- -b .
```
Authentifiez ensuite le CLI avec votre compte Auth0 en choisissant "en tant qu’utilisateur" lorsque l’invite s’affiche :
```bash lines theme={null}
./auth0 login
```
Ensuite, créez une application dans Auth0 :
```bash lines theme={null}
./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 :
```bash lines theme={null}
./auth0 apis create \
--name "My Laravel Backend API" \
--identifier "https://github.com/auth0/laravel-auth0" \
--offline-access \
--no-input \
--json > .auth0.api.json
```
Cela génère deux fichiers dans le répertoire de votre projet qui configurent le SDK.
Comme ces fichiers contiennent des identifiants, il est important de les traiter comme des données sensibles. Vous devez vous assurer de ne pas
les enregistrer dans votre système de contrôle de version. Si vous utilisez Git, vous devriez les ajouter à votre fichier `.gitignore` :
```bash lines theme={null}
echo ".auth0.*.json" >> .gitignore
```
Le SDK enregistre automatiquement son guard d’autorisation auprès de votre application Laravel pour l’utiliser avec le
middleware `api`, que Laravel applique par défaut à toutes les routes du fichier
`routes/api.php` de votre application.
Pour que le SDK fonctionne comme prévu sans configuration supplémentaire, **vous devriez définir vos routes dans
le fichier **`routes/api.php`**.**
Vous pouvez utiliser le guard d’autorisation du SDK Auth0 pour restreindre l’accès aux routes de votre application.
Pour rejeter les requêtes qui ne contiennent pas de jeton d’accès valide dans l’en-tête `Authorization`, vous pouvez utiliser
le middleware `auth` de Laravel :
```php lines theme={null}
Route::get('/private', function () {
return response()->json([
'message' => 'Your token is valid; you are authorized.',
]);
})->middleware('auth');
```
Vous pouvez aussi exiger que le jeton fourni ait des [autorisations](https://auth0.com/docs/manage-users/access-control/rbac) précises en combinant cette approche
avec le middleware `can` de Laravel :
```php lines theme={null}
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');
```
Des informations sur le jeton d’accès fourni sont disponibles au moyen de la façade `Auth` de Laravel, ou de la
fonction utilitaire `auth()`.
Par exemple, pour récupérer l’identifiant et l’adresse de courriel de l’utilisateur :
```php lines theme={null}
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 qui a créé le jeton d’accès depuis Auth0 à l’aide de la [Auth0 Management API](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md). Le SDK fournit un wrapper pratique pour cette API,
accessible au moyen de la méthode `management()` du SDK.
**Avant d’effectuer des appels à la Management API, vous devez autoriser votre application à communiquer avec la Management
API.** Vous pouvez le faire à partir de [la page API de l’Auth0 Dashboard](https://manage.auth0.com/#/apis/), en choisissant `Auth0 Management API`, puis
en sélectionnant l’onglet 'Machine to Machine Applications'. Autorisez votre application Laravel, puis cliquez sur la flèche vers le bas
pour choisir les scopes que vous souhaitez accorder.
Pour l’exemple suivant, vous devez accorder le scope `read:users`. Vous trouverez une liste des points de terminaison de l’API et des
scopes requis dans [la documentation de la Management
API](https://auth0.com/docs/api/management/v2).
```php lines theme={null}
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 devriez mettre en cache les renseignements sur l’utilisateur dans votre application pour de courtes périodes.** Cela réduit le nombre
de requêtes que votre application envoie à Auth0 et améliore les performances. Évitez de conserver des renseignements sur l’utilisateur
dans votre application pendant de longues périodes, car cela peut entraîner des données périmées. Évitez également
de stocker dans des bases de données persistantes des renseignements sur l’utilisateur autres que l’identifiant de l’utilisateur.
Vous êtes maintenant prêt à démarrer votre application Laravel pour qu’elle puisse accepter des requêtes :
```bash lines theme={null}
php artisan serve
```
Vous pouvez en savoir plus sur [l’obtention de jetons d’accès ici](https://auth0.com/docs/secure/tokens/access-tokens/get-access-tokens). Pour ce guide de démarrage rapide, toutefois, vous pouvez simplement utiliser un jeton d’accès
provenant de [la vue « 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, puisqu’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 appeler 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 appeler 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 d’appeler la route protégée par un scope, qui ne réussira que si le jeton d’accès s’est vu accorder le
scope `read:messages` :
`curl --request GET \ --url http://localhost:8000/api/scope \ --header 'Accept: application/json' \ --header 'Authorization: Bearer YOUR_ACCESS_TOKEN'`
### Lectures complémentaires
* [Dépôts et modèles d’utilisateurs](https://github.com/auth0/laravel-auth0/blob/main/docs/Users.md) étend le SDK Auth0 pour Laravel afin d’utiliser des modèles d’utilisateur
personnalisés, et explique comment stocker et récupérer des utilisateurs dans une base de données.
* [Interception des événements](https://github.com/auth0/laravel-auth0/blob/main/docs/Events.md) explique comment écouter les événements émis par le SDK Auth0 pour Laravel
afin de personnaliser entièrement le comportement de votre intégration.
* La prise en charge de la [Management API](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md) est intégrée au SDK Auth0 pour Laravel, ce qui vous permet
d’interagir avec la Management API depuis votre application Laravel.
## Prochaines étapes
Excellent travail ! Si vous avez suivi toutes les étapes jusqu'ici, vous devriez maintenant avoir la connexion, la déconnexion et les informations du profil utilisateur fonctionnelles dans votre application.
Ce tutoriel de démarrage rapide est maintenant terminé, mais il reste encore beaucoup à explorer. Pour en savoir plus sur ce que vous pouvez faire avec Auth0, consultez :
* [Auth0 Dashboard](https://manage.auth0.com/dashboard/us/dev-gja8kxz4ndtex3rq) - Découvrez comment configurer et gérer votre locataire Auth0 ainsi que vos applications
* [SDK laravel-auth0](https://github.com/auth0/laravel-auth0) - Explorez plus en profondeur le SDK utilisé dans ce tutoriel
* [Auth0 Marketplace](https://marketplace.auth0.com/) - Découvrez les intégrations que vous pouvez activer pour enrichir 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');
```
Inscrivez-vous pour obtenir un{" "}
compte Auth0
{" "}
ou{" "}
console.log("log in")}>
connectez-vous
{" "}
à votre compte existant pour vous intégrer directement à votre propre locataire.