;
};
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 renseignements sur 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 par jeton et un contrôle d'accès aux routes de votre application Laravel. Ce guide
démontre 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`** dans les requêtes afin de contrôler l'accès aux routes.**
Des applications frontales distinctes sont généralement conçues pour interagir avec ces types de backends. Il peut s'agir de tout type d'application, des [applications monopages](https://auth0.com/docs/quickstart/spa) aux [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 à l'aide de l'application front-end. L'application front-end obtient 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 les questions de contrôle d'accès (autorisation) et ne contiennent pas d'informations sur
l'utilisateur. **Les applications backend fonctionnent exclusivement avec des jetons d'accès.** Vous pouvez récupérer des informations sur
l'utilisateur qui a créé le jeton à l'aide de l'[API Management
](https://auth0.com/docs/api/management/v2), ce que nous verrons plus loin.
**Si vous n'avez pas encore mis en place 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 à partir de la racine du répertoire de votre projet Laravel, donc
vous devriez donc vous placer 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 l’[Auth0 Laravel SDK](https://github.com/auth0/laravel-auth0) :
```bash lines theme={null}
composer require auth0/login:^7.8 --update-with-all-dependencies
```
Générez ensuite un fichier de configuration du SDK pour votre application :
```bash lines theme={null}
php artisan vendor:publish --tag auth0
```
Exécutez la commande suivante à partir du 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 .
```
Ensuite, authentifiez le CLI à l’aide de votre compte Auth0, en choisissant "comme utilisateur" lorsqu’on vous le demande :
```bash lines theme={null}
./auth0 login
```
Ensuite, créez une nouvelle 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 devriez é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 inclure dans votre 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 dans 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 token fourni ait des [permissions](https://auth0.com/docs/manage-users/access-control/rbac) précises en le combinant
au 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 renseignements sur le jeton d’accès fourni sont accessibles via la façade `Auth` de Laravel ou la
fonction utilitaire `auth()`.
Par exemple, pour récupérer l’identifiant et l’adresse 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 renseignements sur l’utilisateur qui a créé le jeton d’accès depuis Auth0 à l’aide de l’[Auth0 Management API](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md). Le SDK fournit une interface pratique pour cette API,
accessible par la méthode `management()` du SDK.
**Avant d’effectuer des appels à la Management API, vous devez activer votre application pour qu’elle puisse 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`. Une liste des endpoints d’API et des
scopes requis se trouve 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 pendant 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 les renseignements sur l’utilisateur
dans votre application pendant de longues périodes, car cela peut entraîner des données périmées. Évitez aussi
de conserver, dans des bases de données permanentes, des renseignements sur l’utilisateur autres que son identifiant.
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 apprendre davantage sur [la façon d’obtenir des jetons d’accès ici](https://auth0.com/docs/secure/tokens/access-tokens/get-access-tokens). Pour ce Quickstart, 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 véritable utilisateur
n’y est associé.
##### Checkpoint
Ouvrez un shell et essayez d’effectuer des requêtes vers 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 le `scope`, qui ne fonctionnera 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
* [Répertoires et modèles d’utilisateurs](https://github.com/auth0/laravel-auth0/blob/main/docs/Users.md) montre comment étendre l’Auth0 Laravel SDK pour utiliser des modèles d’utilisateur
personnalisés, et comment stocker et récupérer des utilisateurs dans une base de données.
* [Écoute des événements](https://github.com/auth0/laravel-auth0/blob/main/docs/Events.md) explique comment écouter les événements déclenchés par l’Auth0 Laravel
SDK, afin de personnaliser entièrement le comportement de votre intégration.
* La prise en charge de [Management API](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md) est intégrée à l’Auth0 Laravel SDK, 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 le login, le logout et les renseignements du profil utilisateur qui fonctionnent dans votre application.
Ceci conclut notre tutoriel de démarrage rapide, 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) - Apprenez à configurer et à gérer votre tenant Auth0 et vos applications
* [laravel-auth0 SDK](https://github.com/auth0/laravel-auth0) - Explorez plus en détail le SDK utilisé dans ce tutoriel
* [Auth0 Marketplace](https://marketplace.auth0.com/) - Découvrez les 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');
```
Créez un{" "}
compte Auth0
{" "}
ou{" "}
console.log("log in")}>
connectez-vous
{" "}
à votre compte existant pour vous intégrer directement à votre propre tenant.