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: "configuration-d-auth0",
title: "Configuration d’Auth0"
}, {
id: "installer-la-trousse-sdk-php-auth0",
title: "Installer la trousse SDK PHP Auth0"
}, {
id: "détecter-les-jetons-du-porteur",
title: "Détecter les jetons du porteur"
}, {
id: "créer-et-configurer-des-routes",
title: "Créer et configurer des routes"
}, {
id: "configurer-l-autorisation-des-points-de-terminaison",
title: "Configurer l’autorisation des points de terminaison"
}, {
id: "autoriser-avec-des-permissions",
title: "Autoriser avec des permissions"
}];
Auth0 vous permet d’ajouter rapidement une autorisation de point de terminaison basée sur un jeton à presque tous les types d’application. Ce guide explique comment intégrer Auth0, ajouter une autorisation basée sur un jeton et protéger les routes de l’application en utilisant la trousse SDK Auth0 PHP.
Pour utiliser ce guide rapide, vous devez :
* Vous inscrire à un compte Auth0 gratuit ou vous connecter à Auth0.
* Avoir un projet PHP fonctionnel que vous souhaitez intégrer à Auth0. Vous pouvez également consulter ou télécharger une application faisant office d’exemple lorsque vous vous connectez.
Pour utiliser les services Auth0, vous devez avoir une application enregistrée dans Auth0 Dashboard. L’application Auth0 est l’endroit où vous configurez le fonctionnement de l’authentification pour votre projet.
### Configurer une application
Utilisez le sélecteur interactif pour créer une nouvelle application Auth0 ou sélectionnez une application existante qui représente le projet que vous souhaitez intégrer. Dans Auth0, il est attribué à chaque application un identificateur client unique alphanumérique que votre code d’application utilise pour appeler les API Auth0 via la trousse SDK.
Tous les paramètres que vous configurez à l’aide de ce guide rapide seront automatiquement mis à jour pour votre application dans le [Dashboard](https://manage.auth0.com/#/), qui est l’endroit où vous pourrez gérer vos applications à l’avenir.
Si vous préférez explorer une configuration complète, consultez plutôt un exemple d’application.
### Configurer une API
De même, vous devez créer une nouvelle API Auth0 ou utiliser une API existante qui représente le projet que vous intégrez à partir du [Dashboard](https://manage.auth0.com/#/). Choisissez un identificateur unique pour l’API et notez-le. Cet identificateur vous sera nécessaire pour configurer votre application ci-dessous.
Auth0 fournit une trousse [SDK PHP](https://github.com/auth0/auth0-PHP) (Auth0-PHP) pour simplifier le processus de mise en œuvre de l’authentification et de l’autorisation Auth0 dans les applications PHP.
La trousse SDK PHP Auth0 nécessite l’installation des bibliothèques HTTP compatibles [PSR-17](https://www.php-fig.org/psr/psr-17/) et [PSR-18](https://www.php-fig.org/psr/psr-18/) pour la gestion des requêtes réseau. Si vous ne disposez pas de bibliothèques disponibles, vous pouvez installer des choix fiables en exécutant les commandes suivantes dans votre terminal :
```
cd
composer require symfony/http-client nyholm/psr7
```
Installez maintenant la trousse SDK PHP Auth0 en exécutant la commande suivante dans votre terminal :
```
composer require auth0/auth0-php
```
### Configurer la trousse SDK Auth0
Pour que la trousse SDK fonctionne correctement, vous devez définir les propriétés suivantes dans la trousse SDK Auth0 lors de l’initialisation :
* `strategy` : La stratégie aide à orienter le comportement du SDK en ce qui concerne l’utilisation de votre application. Dans ce cas, vous souhaitez la définir sur la constante
`Auth0\SDK\Configuration\SdkConfiguration::STRATEGY_API`
* domain : Le domaine de votre locataire Auth0. En général, vous le trouverez dans Auth0 Dashboard dans Application Settings (Paramètres d’application) dans le champ Domain (Domaine). Si vous utilisez un domaine personnalisé, définissez-le plutôt sur la valeur de votre domaine personnalisé.
* clientId : L’identifiant de l’application Auth0 que vous avez configurée précédemment dans le démarrage rapide. Vous pouvez le trouver dans Auth0 Dashboard, dans la rubrique des paramètres de votre application, dans le champ Client ID (ID client).
* clientSecret : Le secret de l’application Auth0 que vous avez créée plus tôt dans le démarrage rapide. Le secret client se trouve dans Auth0 Dashboard, dans Application Settings (Paramètres d’application) dans le champ Client Secret (Secret client).
* public : L’identificateur de l’API Auth0 que vous avez enregistré ci-dessus. Il doit être fourni sous la forme d’un tableau.
##### Point de contrôle
Votre trousse SDK Auth0 est maintenant correctement configurée. Exécutez votre application pour vérifier que :
la trousse SDK s’initialise correctement,
votre application ne génère aucune erreur liée à Auth0.
Développez ensuite votre application pour récupérer et traiter les jetons de porteur. Les jetons de porteur sont des jetons d’accès fournis à votre API avec des demandes de clients au nom d’un utilisateur. Les jetons d’accès approuvent ou refusent l’accès aux routes de votre application. C’est ce que l’on appelle l’autorisation de point de terminaison.
La méthode la plus simple pour récupérer les jetons d’accès à partir d’une requête est la méthode `getBearerToken()` de la trousse SDK PHP. Cette méthode récupère les jetons à partir des paramètres GET, des corps POST, des en-têtes de requête et d’autres sources. Dans ce cas, la trousse SDK PHP traite les jetons transmis par les requêtes GET dans le paramètre `token` ou dans l’en-tête HTTP `Authorization`.
Maintenant, installez une bibliothèque de routage pour aider à diriger les requêtes entrantes vers votre application. Cette étape n’est pas obligatoire, mais elle simplifie la structure de l’application pour les besoins de ce guide rapide.
```
composer require steampixel/simple-php-router
```
Créez un nouveau fichier dans votre application appelé `router.php` pour définir les routes. Copiez le code du panneau interactif à droite sous l’onglet **router.php**.
Maintenant que vous avez configuré votre application Auth0, la trousse SDK PHP Auth0, et que votre application récupère les jetons de porteur des requêtes, l’étape suivante est de configurer l’autorisation des points de terminaison pour votre projet. La méthode `getBearerToken()` que vous avez mise en œuvre ci-dessus renvoie une classe `Token` qui contient des informations sur l’accès à la requête.
Étant donné que la méthode `getBearerToken()` valide et vérifie automatiquement la requête entrante, votre application détermine les détails du jeton d’accès en évaluant la réponse de la méthode. Si la réponse est nulle, c’est qu’aucun jeton valide n’a été fourni. Dans le cas contraire, inspectez le contenu de la réponse pour en savoir plus sur la demande.
Dans le panneau interactif à droite, une validation de la réponse (null ou non) permet de filtrer l’accès à la route `/api/private`.
Dans certains cas, vous pouvez souhaiter filtrer l’accès à une route particulière en fonction des permissions demandées dans un jeton d’accès. Comme le montre le panneau interactif de droite, évaluez le contenu de la propriété ’scope’ de la réponse de la méthode `getBearerToken()` pour vérifier les permissions accordées par le jeton d’accès.
## É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 Auth0-PHP](https://github.com/auth0/auth0-php) : 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 index.php lines highlight={} theme={null}
getBearerToken(
get: ['token'],
server: ['Authorization']
);
require('router.php');
```
```php router.php lines highlight={} theme={null}
'Hello from a public endpoint! You don\'t need to be authenticated to see this.',
'token' => $token
]);
});
Route::add('/api/private', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated to see this.',
'token' => $token,
]);
});
Route::add('/api/private-scoped', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
if (! in_array('read:messages', $token['scopes'], true)) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this.',
'token' => $token,
]);
});
// The following route is just to avoid confusion.
// We're not using an 'index route' in this app, so redirect requests to /api/public.
Route::add('/', function() {
header('Location: /api/public');
});
Route::run();
```
```php index.php lines highlight={20-23} theme={null}
getBearerToken(
get: ['token'],
server: ['Authorization']
);
require('router.php');
```
```php router.php lines highlight={} theme={null}
'Hello from a public endpoint! You don\'t need to be authenticated to see this.',
'token' => $token
]);
});
Route::add('/api/private', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated to see this.',
'token' => $token,
]);
});
Route::add('/api/private-scoped', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
if (! in_array('read:messages', $token['scopes'], true)) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this.',
'token' => $token,
]);
});
// The following route is just to avoid confusion.
// We're not using an 'index route' in this app, so redirect requests to /api/public.
Route::add('/', function() {
header('Location: /api/public');
});
Route::run();
```
```php router.php lines highlight={} theme={null}
'Hello from a public endpoint! You don\'t need to be authenticated to see this.',
'token' => $token
]);
});
Route::add('/api/private', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated to see this.',
'token' => $token,
]);
});
Route::add('/api/private-scoped', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
if (! in_array('read:messages', $token['scopes'], true)) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this.',
'token' => $token,
]);
});
// The following route is just to avoid confusion.
// We're not using an 'index route' in this app, so redirect requests to /api/public.
Route::add('/', function() {
header('Location: /api/public');
});
Route::run();
```
```php index.php lines highlight={} theme={null}
getBearerToken(
get: ['token'],
server: ['Authorization']
);
require('router.php');
```
```php router.php lines highlight={21-31} theme={null}
'Hello from a public endpoint! You don\'t need to be authenticated to see this.',
'token' => $token
]);
});
Route::add('/api/private', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated to see this.',
'token' => $token,
]);
});
Route::add('/api/private-scoped', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
if (! in_array('read:messages', $token['scopes'], true)) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this.',
'token' => $token,
]);
});
// The following route is just to avoid confusion.
// We're not using an 'index route' in this app, so redirect requests to /api/public.
Route::add('/', function() {
header('Location: /api/public');
});
Route::run();
```
```php index.php lines highlight={} theme={null}
getBearerToken(
get: ['token'],
server: ['Authorization']
);
require('router.php');
```
```php router.php lines highlight={33-48} theme={null}
'Hello from a public endpoint! You don\'t need to be authenticated to see this.',
'token' => $token
]);
});
Route::add('/api/private', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated to see this.',
'token' => $token,
]);
});
Route::add('/api/private-scoped', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
if (! in_array('read:messages', $token['scopes'], true)) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this.',
'token' => $token,
]);
});
// The following route is just to avoid confusion.
// We're not using an 'index route' in this app, so redirect requests to /api/public.
Route::add('/', function() {
header('Location: /api/public');
});
Route::run();
```
```php index.php lines highlight={} theme={null}
getBearerToken(
get: ['token'],
server: ['Authorization']
);
require('router.php');
```
Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.