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: "configure-auth0",
title: "Configurer Auth0"
}, {
id: "install-the-auth0-php-sdk",
title: "Installer le SDK PHP d’Auth0"
}, {
id: "listen-for-the-bearer-tokens",
title: "Détecter les jetons Bearer"
}, {
id: "create-and-configure-routes",
title: "Créer et configurer des routes"
}, {
id: "configure-endpoint-authorization",
title: "Configurer l’autorisation du point de terminaison"
}, {
id: "authorize-with-scopes",
title: "Autoriser à l’aide de scopes"
}];
Auth0 vous permet d'ajouter rapidement une autorisation d'endpoint basée sur les tokens à presque n'importe quel type d'application. Ce guide
explique comment intégrer Auth0, ajouter une autorisation basée sur les tokens et protéger les routes d'application à l'aide du SDK
PHP Auth0.
Pour utiliser ce démarrage rapide, vous aurez besoin de :
Pour utiliser les services Auth0, vous devez avoir une application enregistrée dans l’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électionner une application existante qui représente
le projet que vous souhaitez intégrer. Chaque application dans Auth0 se voit attribuer un ID client unique et alphanumérique que
le code de votre application utilise pour appeler les API Auth0 au moyen du SDK.
Tous les paramètres que vous configurez à l’aide de ce guide de démarrage rapide sont automatiquement mis à jour pour votre application dans le [Dashboard](https://manage.auth0.com/#/), où vous
pourrez gérer vos applications par la suite.
Si vous préférez consulter une configuration complète, vous pouvez plutôt afficher 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 identifiant unique pour l’API et prenez-en note. Vous en avez besoin
pour configurer votre application ci-dessous.
Auth0 fournit un [SDK
PHP](https://github.com/auth0/auth0-PHP) (Auth0-PHP) pour simplifier la mise en œuvre de l’authentification et de l’autorisation Auth0 dans les applications PHP.
Le SDK PHP d’Auth0 nécessite [PSR-17](https://www.php-fig.org/psr/psr-17/) et [PSR-18](https://www.php-fig.org/psr/psr-18/), soit des bibliothèques HTTP compatibles pour gérer les requêtes réseau. Si vous
n'avez pas encore ces bibliothèques, vous pouvez installer des options fiables en exécutant les commandes suivantes dans votre
terminal :
```bash lines theme={null}
cd
composer require symfony/http-client nyholm/psr7
```
Maintenant, installez le SDK PHP d’Auth0 en exécutant la commande suivante dans votre terminal :
```bash lines theme={null}
composer require auth0/auth0-php
```
### Configurer le SDK Auth0
Pour que le SDK fonctionne correctement, vous devez définir les propriétés suivantes dans le SDK Auth0 lors de l’initialisation :
* `strategy` : Cette stratégie détermine le comportement du SDK selon le cas d’utilisation de votre application. Dans ce
cas, vous devez 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 l’Auth0 Dashboard, sous les
paramètres de votre application, dans le champ Domaine. Si vous utilisez un domaine personnalisé, définissez plutôt cette valeur sur celui-ci.
* clientId : L’ID de l’application Auth0 que vous avez configurée plus tôt dans ce guide de démarrage rapide. Vous pouvez le trouver dans l’Auth0 Dashboard, sous les
paramètres de votre application, dans le champ ID client.
* clientSecret : Le secret de l’application Auth0 que vous avez créée plus tôt dans ce guide de démarrage rapide. Le secret client se trouve dans
l’Auth0 Dashboard, sous les paramètres de votre application, dans le champ Secret client.
* audience : L’identifiant de l’API Auth0 que vous avez enregistrée ci-dessus. Cette valeur doit être fournie sous forme de tableau.
##### Point de contrôle
Votre SDK Auth0 est maintenant correctement configuré. Exécutez votre application pour vérifier que :
* Le SDK s’initialise correctement.
* Votre application ne génère aucune erreur liée à Auth0.
Ensuite, développez votre application pour récupérer et traiter les jetons Bearer. Les jetons Bearer sont des jetons d’accès fournis à
votre API avec les requêtes envoyées par des applications au nom des utilisateurs. Les jetons d’accès autorisent ou refusent l’accès aux routes de votre
application. On parle alors d’autorisation des points de terminaison.
La façon la plus simple de récupérer des jetons d’accès à partir d’une requête consiste à utiliser la méthode `getBearerToken()`
du SDK PHP. Cette méthode récupère les jetons à partir des paramètres GET, du corps des requêtes POST, des en-têtes de requête et d’autres sources. Dans ce
cas, le SDK PHP traite les jetons transmis dans des requêtes GET au moyen du paramètre `token` ou de l’en-tête HTTP
`Authorization`.
Maintenant, installez une bibliothèque de routage pour acheminer les requêtes entrantes vers votre application. Cette étape n'est pas obligatoire,
mais elle simplifie la structure de l'application dans le cadre de ce guide de démarrage rapide.
```bash lines theme={null}
composer require steampixel/simple-php-router
```
Créez un nouveau fichier dans votre application, nommé `router.php`, pour définir les routes. Copiez-y le code du
panneau interactif à droite, sous l’onglet **router.php**.
Maintenant que vous avez configuré votre application Auth0, le SDK PHP Auth0, et que votre application récupère les
jetons Bearer à partir des requêtes, l’étape suivante consiste à configurer l’autorisation des points de terminaison pour votre projet. La
méthode `getBearerToken()` que vous avez implémentée ci-dessus renvoie une instance de la classe `Token` qui comprend
des renseignements sur l’accès associé à la requête.
Puisque 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. Lorsque la réponse est
null, aucun jeton valide n’a été fourni. Sinon, examinez le contenu de la réponse pour en apprendre davantage sur la
requête.
Dans le panneau interactif à droite, vous pouvez voir une vérification indiquant si la réponse est null ou non afin de contrôler l’accès à
votre route `/api/private`.
Dans certains cas, vous pourriez vouloir filtrer l’accès à une route précise en fonction des scopes demandés dans un jeton d’accès.
Comme l’illustre le panneau interactif à droite, évaluez le contenu de la propriété 'scope' dans la réponse de la méthode
`getBearerToken()` pour vérifier les scopes accordés par le jeton d’accès.
## Prochaines étapes
Excellent travail ! Si vous êtes arrivé jusqu'ici, vous devriez maintenant avoir les fonctionnalités de connexion, de déconnexion et de profil utilisateur opérationnelles 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 et vos applications
* [Auth0-PHP SDK](https://github.com/auth0/auth0-php) - Découvrez 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 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,
]);
});
// La route suivante sert uniquement à éviter toute confusion.
// Nous n'utilisons pas de « route d'indice » dans cette application, donc les requêtes sont redirigées vers /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,
]);
});
// La route suivante sert uniquement à éviter toute confusion.
// Nous n'utilisons pas de « route d'indice » dans cette application, donc les requêtes sont redirigées vers /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,
]);
});
// La route suivante sert uniquement à éviter toute confusion.
// Nous n'utilisons pas de « route d'indice » dans cette application, donc les requêtes sont redirigées vers /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,
]);
});
// La route suivante sert uniquement à éviter toute confusion.
// Nous n'utilisons pas de « route d'index » dans cette application, donc les requêtes sont redirigées vers /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,
]);
});
// La route suivante sert uniquement à éviter toute confusion.
// Nous n'utilisons pas de « route d'index » dans cette application, donc les requêtes sont redirigées vers /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');
```
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.