> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# API PHP

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****MASQUÉ*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

<div id="by-evan-sims">
  ##### Par Evan Sims
</div>

Ce guide explique comment intégrer Auth0 à une API backend PHP à l’aide de l’Auth0 PHP SDK.Nous vous recommandons de vous connecter pour suivre ce Quickstart avec des exemples configurés pour votre compte.

<Info>
  **Vous découvrez Auth0?** Découvrez [comment fonctionne Auth0](/docs/fr-ca/get-started/auth0-overview) et apprenez-en davantage sur [l’implémentation de l’authentification et de l’autorisation des API](/docs/fr-ca/get-started/authentication-and-authorization-flow) à l’aide du framework OAuth 2.0.
</Info>

<div id="configure-auth0-apis">
  ## Configurer les API Auth0
</div>

<div id="create-an-api">
  ### Créer une API
</div>

Dans la section [APIs](https://manage.auth0.com/#/apis) du tableau de bord Auth0, cliquez sur **Create API**. Saisissez un nom et un identifiant pour votre API, par exemple `https://quickstarts/api`. Vous utiliserez ensuite cet identifiant comme `audience` lors de la configuration de la vérification du jeton d’accès. Laissez **Signing Algorithm** à **RS256**.

<Frame>![Créer une API](https://cdn2.auth0.com/docs/1.14550.0/media/articles/server-apis/create-api.png)</Frame>

Par défaut, votre API utilise RS256 comme algorithme de signature des jetons. Comme RS256 utilise une paire de clés privée et publique, les jetons sont vérifiés à l’aide de la clé publique de votre compte Auth0. La clé publique est au format [JSON Web Key Set (JWKS)](/docs/fr-ca/secure/tokens/json-web-tokens/json-web-key-sets) et peut être consultée [ici](https://\{yourDomain}/.well-known/jwks.json).

<div id="define-permissions">
  ### Définir les permissions
</div>

Les permissions vous permettent de définir comment les ressources peuvent être consultées au nom de l’utilisateur à l’aide d’un jeton d’accès donné. Par exemple, vous pourriez choisir d’accorder un accès en lecture à la ressource `messages` si les utilisateurs ont le niveau d’accès Manager, et un accès en écriture à cette ressource s’ils ont le niveau d’accès administrateur.

Vous pouvez définir les permissions autorisées dans la vue **Permissions** de la section [APIs](https://manage.auth0.com/#/apis) de l’Auth0 Dashboard.

<Frame>![Configurer les permissions](https://cdn2.auth0.com/docs/1.14550.0/media/articles/server-apis/configure-permissions.png)</Frame>

<Info>
  Cet exemple utilise le scope `read:messages`.
</Info>

Cet exemple montre :

* Comment vérifier la présence d’un JSON Web Token (JWT) dans l’en-tête `Authorization` d’une requête HTTP entrante.
* Comment vérifier si le jeton est valide à l’aide du [JSON Web Key Set (JWKS)](/docs/fr-ca/secure/tokens/json-web-tokens/json-web-key-sets) de votre compte Auth0. Pour en savoir plus sur la validation des jetons d’accès, consultez [Valider les jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/validate-access-tokens).

<div id="integrating-your-php-backend-api">
  ## Intégration de votre API backend PHP
</div>

Créons un exemple d’application qui utilise une API backend écrite en PHP pour autoriser un jeton signé par Auth0. Nous adopterons ici une approche simple, adaptée au format de cette documentation. Cela dit, consultez l’[application Quickstart sur GitHub](https://github.com/auth0-samples/auth0-php-api-samples/) pour un exemple plus complet.

<div id="installing-http-client-and-messaging-factories">
  ### Installation du client HTTP et des fabriques de messages
</div>

Le SDK Auth0 PHP prend en charge de nombreuses normes PHP-FIG afin d’offrir une interopérabilité maximale avec l’architecture de votre projet, mais deux d’entre elles sont particulièrement importantes : [PSR-17](https://www.php-fig.org/psr/psr-17/) et [PSR-18](https://www.php-fig.org/psr/psr-18/). Ces normes vous permettent de « brancher » les composants réseau de votre choix pour gérer la messagerie et les requête. Vous devrez installer des bibliothèques compatibles dans votre projet pour que le SDK puisse les utiliser.

Guzzle est la bibliothèque réseau la plus répandue pour PHP, bien qu’il en existe plusieurs autres dans la communauté PHP. Utilisons Guzzle pour cet exemple d’application :

```bash theme={null}
composer require guzzlehttp/guzzle guzzlehttp/psr7 http-interop/http-factory-guzzle
```

<div id="installing-the-php-sdk">
  ### Installation du SDK PHP
</div>

L’Auth0 PHP SDK requiert [Composer](https://getcomposer.org/doc/00-intro.md#installation-linux-unix-macos), un outil de gestion des dépendances en PHP. Composer vous permet de déclarer les bibliothèques dont votre projet dépend et les installe pour vous. Assurez-vous que Composer est installé et accessible à partir de votre shell avant de continuer.

Exécutez la commande shell suivante dans le répertoire de votre projet pour installer l’Auth0 PHP SDK :

```bash theme={null}
composer require auth0/auth0-php
```

Cela créera un dossier `vendor` dans votre projet et téléchargera toutes les dépendances nécessaires pour utiliser l’Auth0 PHP SDK. Cela créera aussi un fichier `vendor/autoload.php`, utilisé dans l’exemple pour charger toutes les classes nécessaires au bon fonctionnement de votre application. Il est important d’inclure ce fichier de chargement automatique dans votre projet pour que le SDK fonctionne.

<div id="configure-the-sdk">
  ### Configurer le SDK
</div>

Pour commencer, créons un fichier `.env` à la racine du répertoire de votre projet pour y stocker la configuration de notre application exemple, puis renseignons les variables d’environnement :

export const codeExample = `# L’URL du domaine de notre tenant Auth0.
# Si nous utilisons un domaine personnalisé, veillez à utiliser cette valeur à la place.
AUTH0_DOMAIN='https://{yourDomain}'

# L’ID client de notre application Auth0.
AUTH0_CLIENT_ID='{yourClientId}'

# Le secret client de notre application Auth0.
AUTH0_CLIENT_SECRET='{yourClientSecret}'

# L’identifiant de notre API Auth0.
AUTH0_AUDIENCE='YOUR_API_IDENTIFIER'`;

<AuthCodeBlock children={codeExample} language="env" />

Comme PHP ne peut pas lire à lui seul notre fichier `.env`, nous allons installer une bibliothèque pour nous y aider. Même si nous utiliserons une bibliothèque précise pour les besoins de notre application exemple, n'importe quel chargeur « dotenv » conviendra dans une application réelle. À partir du répertoire de notre projet, exécutons la commande shell suivante pour installer la bibliothèque :

```bash lines theme={null}
composer require vlucas/phpdotenv
```

Ensuite, créons le fichier source PHP que nous utiliserons pour ces exemples de code, `index.php`, et configurons une instance de l’Auth0 PHP SDK pour notre application d’exemple :

```php lines theme={null}
<?php

// Importation du chargeur automatique Composer pour rendre les classes du SDK accessibles :
require 'vendor/autoload.php';

// Chargement de nos variables d'environnement depuis le fichier .env :
(Dotenv\Dotenv::createImmutable(__DIR__))->load();

// Instanciation de la classe Auth0 avec notre configuration :
$auth0 = new \Auth0\SDK\Auth0([
    'strategy' => \Auth0\SDK\Configuration\SdkConfiguration::STRATEGY_API,
    'domain' => $_ENV['AUTH0_DOMAIN'],
    'clientId' => $_ENV['AUTH0_CLIENT_ID'],
    'clientSecret' => $_ENV['AUTH0_CLIENT_SECRET'],
    'audience' => ($_ENV['AUTH0_AUDIENCE'] ?? null) !== null ? [trim($_ENV['AUTH0_AUDIENCE'])] : null,
]);
```

<div id="authenticating-the-user">
  ### Authentifier l’utilisateur
</div>

Pour cet exemple d’application, nous nous concentrons sur l’[autorisation](https://auth0.com/intro-to-iam/authentication-vs-authorization/). Il existe de nombreuses façons d’authentifier vos utilisateurs avant qu’ils n’accèdent à votre API backend pour l’autorisation, par exemple en utilisant la [bibliothèque SPA.js d’Auth0](https://github.com/auth0/auth0-spa-js). Cette approche est présentée dans [ce projet Github qui accompagne l’application Quickstart](https://github.com/auth0-samples/auth0-php-api-samples/). Quelle que soit l’approche choisie, pour fonctionner, cet exemple d’application s’attend à ce que vous lui transmettiez votre jeton d’accès au moyen d’un paramètre de requête ou d’un en-tête.

<div id="authorizing-an-access-token">
  ### Autoriser un jeton d’accès
</div>

D’abord, nous devons extraire le JSON Web Token (JWT) de la requête HTTP entrante. Recherchons un paramètre `?token` dans une requête GET, ou un en-tête `HTTP_AUTHORIZATION` ou `Authorization`.

```php lines theme={null}
// 👆 Nous continuons à partir des étapes précédentes. Ajoutez ceci à votre fichier index.php.

$jwt = $_GET['token'] ?? $_SERVER['HTTP_AUTHORIZATION'] ?? $_SERVER['Authorization'] ?? null;
```

Ensuite, décodons le jeton, s’il est présent :

```php lines theme={null}
// 👆 Nous continuons à partir des étapes précédentes. Ajoutez ceci à votre fichier index.php.

// Si un jeton est présent, le traiter.
if ($jwt !== null) {
    // Supprimer les espaces en début et fin de la chaîne du jeton.
    $jwt = trim($jwt);

    // Supprimer le préfixe 'Bearer ' s'il est présent, au cas où l'en-tête Authorization le contiendrait.
    if (substr($jwt, 0, 7) === 'Bearer ') {
        $jwt = substr($jwt, 7);
    }

    // Tenter de décoder le jeton :
    try {
        $token = $auth0->decode($jwt, null, null, null, null, null, null, \Auth0\SDK\Token::TYPE_TOKEN);
        define('ENDPOINT_AUTHORIZED', true);
    } catch (\Auth0\SDK\Exception\InvalidTokenException $exception) {
        // Le jeton n'était pas valide. Affichons le message d'erreur provenant du Auth0 SDK.
        // Dans une application réelle, on voudrait probablement afficher une erreur personnalisée ici.
        die($exception->getMessage());
    }
}
```

Selon la manière dont vous configurez le routage de votre API, la façon précise d’intégrer ces vérifications peut varier légèrement, mais le principe reste le même : vérifiez le jeton et, si votre API endpoint exige une autorisation, rejetez l’accès si le jeton n'est pas valide ou acceptable :

```php lines theme={null}
// 👆 Nous continuons à partir des étapes ci-dessus. Ajoutez ceci à votre fichier index.php.

// La requête est-elle autorisée ?
if (defined('ENDPOINT_AUTHORIZED')) {
    // Répondre avec une réponse JSON :
    echo json_encode([
        'authorized' => true,
        'data' => $token->toArray()
    ], JSON_PRETTY_PRINT);

    exit;
}

// Retourner un statut HTTP 401 Non autorisé :
http_response_code(401);

// Répondre avec une réponse JSON :
echo json_encode([
    'authorized' => false,
    'error' => [
        'message' => 'You are NOT authorized to be here!'
    ]
], JSON_PRETTY_PRINT);
```

<div id="caching">
  ### Mise en cache
</div>

Cela fonctionne, mais dans une application réelle, nous voudrons utiliser la mise en cache pour éviter d’atteindre les limites de taux d’Auth0 ou de ralentir notre application avec des requêtes réseau inutiles. L’Auth0 PHP SDK prend en charge une interface de mise en cache appelée [PSR-6](https://www.php-fig.org/psr/psr-6), à laquelle vous pouvez brancher [n’importe quelle bibliothèque de mise en cache compatible](https://packagist.org/providers/psr/cache-implementation), afin que le SDK s’intègre naturellement à votre architecture.

Pour notre exemple, utilisons la bibliothèque du [composant de cache Symfony](https://symfony.com/doc/current/components/cache.html). À partir du répertoire racine de notre projet, exécutez la commande shell suivante :

```bash lines theme={null}
composer require symfony/cache
```

Ensuite, nous devons mettre à jour notre SdkConfiguration pour que le SDK l’utilise :

```php lines theme={null}
// ✋ Insérez ceci AVANT la gestion du jeton ajoutée à l'étape ci-dessus, afin que le SDK utilise le cache.

$tokenCache = new \Symfony\Component\Cache\Adapter\FilesystemAdapter();
$auth0->configuration()->setTokenCache($tokenCache);
```

Notre application d’exemple mettra maintenant en cache les requêtes réseau liées aux jetons.

<Info>
  ##### Que pouvez-vous faire ensuite ?

  | [Configurer d’autres fournisseurs d’identité](/docs/fr-ca/authenticate/identity-providers)                                          | [Activer l’authentification multifactorielle](/docs/fr-ca/secure/multi-factor-authentication) |
  | ----------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
  | [En savoir plus sur la protection contre les attaques](/docs/fr-ca/secure/attack-protection)                                        | [En savoir plus sur Rules](/docs/fr-ca/customize/rules)                                       |
  | [Modifier sur GitHub](https://github.com/auth0/docs/edit/master/articles/quickstart/backend/aspnet-core-webapi/01-authorization.md) |                                                                                               |
</Info>

***