> ## Documentation Index > Fetch the complete documentation index at: https://docs-dev-actions-triggers-prototype.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Libre-service machine-machine (M2M) > Décrit comment s’intégrer avec une étude de cas M2M. export const AuthCodeGroup = ({children, dropdown}) => { const [processedChildren, setProcessedChildren] = useState(children); useEffect(() => { let unsubscribe = null; function init() { unsubscribe = window.autorun(() => { const processChildren = node => { if (typeof node === "string") { let processedNode = node; for (const [key, value] of window.rootStore.variableStore.values.entries()) { const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`); processedNode = processedNode.replaceAll(new RegExp(escapedKey, "g"), value); } return processedNode; } else if (Array.isArray(node)) { return node.map(processChildren); } else if (node && node.props && node.props.children) { return { ...node, props: { ...node.props, children: processChildren(node.props.children) } }; } return node; }; setProcessedChildren(processChildren(children)); }); } if (window.rootStore) { init(); } else { window.addEventListener("adu:storeReady", init); } return () => { window.removeEventListener("adu:storeReady", init); unsubscribe?.(); }; }, [children]); return {processedChildren}; }; 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) + "*****MASKED*****"; } 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
{displayText}
; }; Si votre cas d’utilisation s’adresse à une audience non interactive comme des API ou des serveurs dorsaux, vous serez intégré avec une configuration machine-machine (M2M). ## Cas d’utilisation Utilisez le parcours d’intégration M2M si vous êtes concerné par (ou si vous utilisez) ce qui suit : * Prise en charge des communications de service à service. * Exécution de tâches planifiées ou de tâches cron sur des serveurs qui doivent accéder à des ressources protégées ou à des API. * Appareils IoT autorisés à communiquer avec des services dorsaux ou des API. * Couche API qui doit communiquer avec d’autres couches API sans intervention de l’utilisateur ou après l’expiration d’un jeton utilisateur. * API privilégiée qui peut devoir être appelée avant qu’un utilisateur ne se soit authentifié (par exemple, à partir d’une action à partir d’une règle ou d’un script de base de données personnalisé dans votre locataire Auth0). * Passerelle API pour gérer les services dorsaux. * Applications non interactives ou des outils sans intervention humaine, tels que des démons ou des services dorsaux. Ces services auront toujours besoin d’un jeton d’accès M2M pour l’authentification. ## Comment utiliser ce guide Ce guide vous accompagne dans la création de votre implémentation M2M dans Auth0. Nous vous proposons des recommandations, des bonnes pratiques et des concepts clés à prendre en compte. * En matière d’architecture, nous vous recommandons de configurer Auth0 de manière à soutenir votre cycle de vie de développement logiciel ainsi que votre infrastructure actuelle. * Dans la section Créer un compte, nous expliquons comment configurer une instance d’API dans Auth0 et créer une application afin de prendre en charge le flux d’authentification (ou le type d’autorisation) requis pour l’authentification machine-machine. * Dans la section Authentification, nous détaillons le type d’autorisation à utiliser pour l’authentification, ainsi que les jetons d’accès et les permissions que vous pouvez définir. * Dans la section Image de marque, nous expliquons où trouver les informations nécessaires pour configurer des domaines personnalisés, en fonction de la manière dont vous compter gérer les certificats. * Dans la section Automatisations de déploiement, vous découvrirez nos outils conçus pour faciliter vos processus de déploiement. * Dans la section Assurance qualité, vous trouverez des informations sur les tests unitaires et les contrôles de préparation disponibles dans le tableau de bord Auth0. ## Architecture Avant de configurer votre compte et votre locataire Auth0, ou d’organiser les groupes et structures de vos services Auth0, il est recommandé de cartographier votre infrastructure existante. Cela vous permettra de tirer pleinement parti des capacités d’Auth0 au sein de votre écosystème actuel. Comme indiqué dans les scénarios courants, il se peut que vous disposiez d’autres technologies non interactives dans vos domaines d’applications, de réseaux ou d’appareils M2M, qu’il est important de prendre en considération avant de procéder à la configuration d’Auth0. Pour consulter un exemple de scénario M2M, veuillez consulter [Serveur + API](/docs/fr-ca/get-started/architecture-scenarios/server-application-api/part-1). Pour mettre en place un laboratoire pratique avec Node et tester le déploiement de l’API, veuillez consulter notre [référentiel GitHub](https://www.google.com/url?q=https://github.com/auth0-training/labs-node-working-with-apis\&sa=D\&source=docs\&ust=1723578190947730\&usg=AOvVaw3IXRQG9ogH4pW6LEY047T6). Il pourra être utile de créer une visualisation de votre environnement technologique actuel ainsi que de planifier la manière dont Auth0 s’intègre à votre cycle de vie de développement logiciel (SDLC) actuel. Cela pourra vous aider à déterminer le nombre de locataires dont vous pourriez avoir besoin. ### Considérations Avant de créer un nouveau compte ou de configurer votre premier locataire, il peut être utile de prendre en compte les éléments suivants : * Comment vous partitionnez ou regroupez vos API pour appeler des points de terminaison spécifiques. * Cela peut déterminer l'audience et d’autres demandes sur les jetons d’accès. * Tout consommateur tiers de votre ressource peut demander un jeton d’accès pour chaque appel. Les appels excessifs pourraient affecter votre [limite anti-attaques](/docs/fr-ca/troubleshoot/customer-support/operational-policies/rate-limit-policy/rate-limit-configurations/self-service-public). ## Créer un compte Maintenant que vous avez un plan pour votre architecture, vous allez configurer votre compte Auth0 et vos locataires. Lorsque vous vous inscrivez aux services Auth0, vous créez votre premier [locataire](/docs/fr-ca/get-started/auth0-overview/create-tenants). Vous y configurez les actifs, les services et les ressources Auth0. [Inscrivez-vous](https://auth0.com/signup) pour commencer. Dans l’Auth0 Dashboard ou Management API, créez : * Une API qui représente votre API * Une application de communication entre machines (M-M) qui utilise le flux des d’identifiants client. Vous pouvez planifier certains détails de configuration avant de créer un compte. * Le nom de votre locataire joue un rôle dans votre domaine Auth0. Avant d’en définir un, vous devriez passez en revue les [caractéristiques du locataire](https://auth0.com/docs/get-started/auth0-overview/create-tenants#create-a-tenant-and-domain). * Les fonctionnalités d’Auth0 dont vous avez besoin selon l’utilisation que vous en faites. Certaines fonctionnalités ne sont disponibles qu’avec les abonnements Professionnel et Entreprise. * Déterminez si vous devez prendre en charge plusieurs environnements, notamment pour le développement, la simulation et la production. Pour en savoir plus, consultez [Configurer plusieurs environnements](/docs/fr-ca/get-started/auth0-overview/create-tenants/set-up-multiple-environments). * Si votre cas d’utilisation implique des applications tierces que vous souhaitez enregistrer dans un locataire, vous pouvez utiliser l’[Enregistrement dynamique d'applications](/docs/fr-ca/get-started/applications/dynamic-client-registration) basé sur le [protocole OIDC pour l’enregistrement des clients](https://openid.net/specs/openid-connect-registration-1_0.html). * Passez en revue nos [services dorsaux et nos librairies d’API](https://auth0.com/docs/libraries#backend) pour essayer l’un de nos démarrages rapides. ### Provisionner un locataire Maintenant que vous avez un plan pour votre architecture, vous allez configurer votre compte Auth0 et Locataire. Une fois que vous créez une API dans Auth0 Dashboard, une application de test pour l’API est automatiquement générée. Si vous créez une API de manière programmatique dans [Management API](https://auth0.com/docs/api/management/v2/), vous allez devoir créer une application de test dans un appel séparé. #### Enregistrer une API Dans cette section, vous allez créez votre API dans Auth0. Vous pouvez toujours mettre à jour votre API dans Auth0 Dashboard ou en appelant la mise à jour de Management API un point de terminaison de serveur de ressources Commencez par créer une instance dans Auth0 Dashboard pour vos API. 1. Suivez les instructions pour [enregistrer votre API](/docs/fr-ca/get-started/auth0-overview/set-up-apis). Dans la section [Authentification](https://auth0.com/docs/get-started/onboarding/self-service-m2m#authentication), configurez vos paramètres API pour l’authentification M2M. Pour enregistrer une API de manière programmatique, utilisez Management API. Vous aurez besoin d’un jeton d’accès pour utiliser Management API. Pour en savoir plus, lisez [Jetons Management API](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens). Utilisez l’exemple fourni dans Management API Explorer pour appeler le point de terminaison [Create a Resource Server (Créer un serveur de ressources)](https://auth0.com/docs/api/management/v2/resource-servers/post-resource-servers) de Management API et incluez les paramètres suivants dans le corps : | Champ | Description | Exemple | | --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | | **Nom** | Nom informel de l’API. N’affecte aucune fonctionnalité. | `yourDomain` | | **Identificateur** | Identifiant unique de l’API. Auth0 recommande d’utiliser une URL. Auth0 fait la différence entre les URL qui incluent la dernière barre oblique. Par exemple, `https://example.com` et `https://example.com/` sont deux identificateurs différents. L’URL ne doit pas nécessairement être une URL accessible au public. Auth0 n’appellera pas votre API. Cette valeur ne peut pas être modifiée par la suite. | `https://{yourDomain}` | | **Profil du jeton Web JSON (JWT)** | Le profil détermine le format des jetons d’accès émis pour l’API. Les valeurs possibles sont `Auth0` et `RFC 9068`. Pour en savoir plus, lisez la section [Profils de jeton d’accès](/docs/fr-ca/secure/tokens/access-tokens/access-token-profiles). | `access_token` | | **JSON Web Token (JWT) Signing Algorithm (Algorithme de signature de jetons Web JSON)** | Algorithme avec lequel signer les jetons d’accès. Les valeurs disponibles sont `HS256`, `PS256`, `RS256`. Si vous sélectionnez `RS256` (recommandé), le jeton sera signé avec la clé privée de votre locataire. | `HS256` | ### Associer une application Il est nécessaire d’établir une association entre votre application et votre API pour permettre à votre application de solliciter des jetons d’accès. Vous en apprendrez plus sur les autorisations client dans la section Authentification. L’API d’Auth0 a plusieurs paramètres que vous devriez passer en revue avant la configuration. Pour en savoir plus, consultez[Paramètres de l’API](/docs/fr-ca/get-started/apis/api-settings). Si vous créez votre API dans Dashboard, Auth0 génère automatiquement une application de test et l’associe à votre API. 1. Allez à [Auth0 Dashboard > Applications](https://manage.auth0.com/#/applications). 2. Sélectionnez l’application de test de communication entre machines (M2M) créée lors de la création de votre API Vous pouvez créer une autre application pour le développement ou la production ultérieurement en suivant les instructions pour [Enregistrer les applications de communication entre machines](/docs/fr-ca/get-started/auth0-overview/create-applications/machine-to-machine-apps). . 3. Passez à la vue **API**, puis localisez l’API que vous souhaitez activer pour cette application. 4. Activez la bascule **Authorize (Autoriser)**, puis sélectionnez le bouton fléché à droite pour développer la carte. 5. Sélectionnez **Update (Mise à jour)**. Dashboard > Applications > APIs Dans cette vue, vous pouvez sélectionner la liste déroulante et choisir les permissions que vous souhaitez ajouter. Nous en apprendrons davantage sur les permissions lorsque nous aborderons les jetons d’accès dans la section Authentification. Utilisez l’exemple fourni dans Management API Explorer pour : 1. tous les points de terminaison [Create a Client (Créer un client)](https://auth0.com/docs/api/management/v2/clients/post-clients). Vous devez définir le `app_type` sur `non-interactive`. 2. Appelez le point de terminaison [Create Client Grant (Créer une autorisation client)](https://auth0.com/docs/api/management/v2/client-grants/post-client-grants) pour associer votre application à votre API. Pour en savoir plus sur les réglages de l’application et du locataire, lisez [Paramètres du locataire](/docs/fr-ca/get-started/tenant-settings). ## Authentification Lorsque vous appelez une API depuis une autre API, ou depuis toute situation où il n’y a pas de contexte d’utilisateur authentifié, vous aurez besoin d’un moyen d’autoriser l’application au lieu d’un utilisateur. Il s’agit d’un processus en une seule étape au cours duquel l’application est authentifiée (à l’aide d’un `client_id` et `client_secret`), puis autorisée en un seul appel. Pour les applications ou services non interactifs à authentifier, vous devez sélectionner une autorisation client ou un flux d’authentification. Le [Flux des identifiants client](https://tools.ietf.org/html/rfc6749#section-4.4) OAuth 2.0, ne nécessite pas d’interaction humaine et est particulièrement adapté aux applications M2M. Dans Auth0 Dasboard ou Management API, vous pourrez : * Configurer votre application pour qu’elle utilise le Flux des identifiants client. * Mettre à jour les permissions de vos jetons d’accès M2M. Avant de configurer votre méthode d’authentification : * Examinez le [Flux des identifiants client](/docs/fr-ca/get-started/authentication-and-authorization-flow/client-credentials-flow) pour l’authentification machine à machine. Voici le flux de travail pour l’authentification et l’autorisation non interactive. * Déterminez le niveau d’accès pour vos API. Cela permet de déterminer quelles [permissions](/docs/fr-ca/get-started/apis/scopes/api-scopes) vous configurerez lors de la création de votre API. ### Configurer le flux des identifiants client Vous pouvez utiliser Auth0 Dashboard ou Management API pour configurer le flux d’authentification, permettant ainsi de fournir des informations d’authentification client en échange d’un jeton d’accès. Suivez les instructions de la section [Mettre à jour les types d’autorisation](/docs/fr-ca/get-started/applications/update-grant-types) pour utiliser Auth0 Dashboard ou Management API. ### Jetons d’accès M2M Dans l’authentification basée sur des jetons, les clients non interactifs fournissent `client_id` et `client_secret` dans un appel au [point de terminaison du jeton Authentication API](https://auth0.com/docs/customize/actions/flows-and-triggers/machine-to-machine-flow) pour obtenir un [jeton d’accès](/docs/fr-ca/secure/tokens/access-tokens). Ce jeton d’accès permet d’accéder à votre API protégée. Le profil ou format par défaut est le profil de jeton Auth0 associé à deux profils de jeton. Vous pouvez choisir de modifier le profil du jeton en choisissant RFC 9068. Pour en savoir plus, lisez [Profils de jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/access-token-profiles). Pour vérifier que le jeton est valide, votre API vérifiera les [Algorithmes de signature](/docs/fr-ca/get-started/applications/signing-algorithms). L’algorithme de signature par défaut est RSA256, un algorithme basé sur une clé. Auth0 prend en charge d’autres méthodes d’authentification client en plus de fournir l’ID client et le secret client en tant qu’identifiants. Ces méthodes, y compris notre recommandation de [Clé privée JWT](/docs/fr-ca/get-started/authentication-and-authorization-flow/authenticate-with-private-key-jwt) pour les configurations M2M, sont disponibles avec un plan Entreprise. Pour en savoir plus, consultez [Identifiants d’application](/docs/fr-ca/secure/application-credentials). #### Exemple Une demande au point de terminaison `/oauth/token` doit être similaire à l’exemple ci-dessous : ```bash cURL theme={null} curl --request POST \ --url 'https://{yourDomain}/oauth/token' \ --header 'content-type: application/x-www-form-urlencoded' \ --data grant_type=client_credentials \ --data client_id={yourClientId} \ --data client_secret={yourClientSecret} \ --data audience=YOUR_API_IDENTIFIER ``` ```csharp C# theme={null} var client = new RestClient("https://{yourDomain}/oauth/token"); var request = new RestRequest(Method.POST); request.AddHeader("content-type", "application/x-www-form-urlencoded"); request.AddParameter("application/x-www-form-urlencoded", "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER", ParameterType.RequestBody); IRestResponse response = client.Execute(request); ``` ```go Go theme={null} package main import ( "fmt" "strings" "net/http" "io/ioutil" ) func main() { url := "https://{yourDomain}/oauth/token" payload := strings.NewReader("grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER") req, _ := http.NewRequest("POST", url, payload) req.Header.Add("content-type", "application/x-www-form-urlencoded") res, _ := http.DefaultClient.Do(req) defer res.Body.Close() body, _ := ioutil.ReadAll(res.Body) fmt.Println(res) fmt.Println(string(body)) } ``` ```java Java theme={null} HttpResponse response = Unirest.post("https://{yourDomain}/oauth/token") .header("content-type", "application/x-www-form-urlencoded") .body("grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER") .asString(); ``` ```javascript Node.JS theme={null} var axios = require("axios").default; var options = { method: 'POST', url: 'https://{yourDomain}/oauth/token', headers: {'content-type': 'application/x-www-form-urlencoded'}, data: new URLSearchParams({ grant_type: 'client_credentials', client_id: '{yourClientId}', client_secret: '{yourClientSecret}', audience: 'YOUR_API_IDENTIFIER' }) }; axios.request(options).then(function (response) { console.log(response.data); }).catch(function (error) { console.error(error); }); ``` ```objc Obj-C theme={null} #import NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" }; NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"grant_type=client_credentials" dataUsingEncoding:NSUTF8StringEncoding]]; [postData appendData:[@"&client_id={yourClientId}" dataUsingEncoding:NSUTF8StringEncoding]]; [postData appendData:[@"&client_secret={yourClientSecret}" dataUsingEncoding:NSUTF8StringEncoding]]; [postData appendData:[@"&audience=YOUR_API_IDENTIFIER" dataUsingEncoding:NSUTF8StringEncoding]]; NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://{yourDomain}/oauth/token"] cachePolicy:NSURLRequestUseProtocolCachePolicy timeoutInterval:10.0]; [request setHTTPMethod:@"POST"]; [request setAllHTTPHeaderFields:headers]; [request setHTTPBody:postData]; NSURLSession *session = [NSURLSession sharedSession]; NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) { if (error) { NSLog(@"%@", error); } else { NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response; NSLog(@"%@", httpResponse); } }]; [dataTask resume]; ``` ```php PHP theme={null} $curl = curl_init(); curl_setopt_array($curl, [ CURLOPT_URL => "https://{yourDomain}/oauth/token", CURLOPT_RETURNTRANSFER => true, CURLOPT_ENCODING => "", CURLOPT_MAXREDIRS => 10, CURLOPT_TIMEOUT => 30, CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1, CURLOPT_CUSTOMREQUEST => "POST", CURLOPT_POSTFIELDS => "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER", CURLOPT_HTTPHEADER => [ "content-type: application/x-www-form-urlencoded" ], ]); $response = curl_exec($curl); $err = curl_error($curl); curl_close($curl); if ($err) { echo "cURL Error #:" . $err; } else { echo $response; } ``` ```python Python theme={null} import http.client conn = http.client.HTTPSConnection("") payload = "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER" headers = { 'content-type': "application/x-www-form-urlencoded" } conn.request("POST", "/{yourDomain}/oauth/token", payload, headers) res = conn.getresponse() data = res.read() print(data.decode("utf-8")) ``` ```ruby Ruby theme={null} require 'uri' require 'net/http' require 'openssl' url = URI("https://{yourDomain}/oauth/token") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE request = Net::HTTP::Post.new(url) request["content-type"] = 'application/x-www-form-urlencoded' request.body = "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER" response = http.request(request) puts response.read_body ``` ```swift Swift theme={null} import Foundation let headers = ["content-type": "application/x-www-form-urlencoded"] let postData = NSMutableData(data: "grant_type=client_credentials".data(using: String.Encoding.utf8)!) postData.append("&client_id={yourClientId}".data(using: String.Encoding.utf8)!) postData.append("&client_secret={yourClientSecret}".data(using: String.Encoding.utf8)!) postData.append("&audience=YOUR_API_IDENTIFIER".data(using: String.Encoding.utf8)!) let request = NSMutableURLRequest(url: NSURL(string: "https://{yourDomain}/oauth/token")! as URL, cachePolicy: .useProtocolCachePolicy, timeoutInterval: 10.0) request.httpMethod = "POST" request.allHTTPHeaderFields = headers request.httpBody = postData as Data let session = URLSession.shared let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in if (error != nil) { print(error) } else { let httpResponse = response as? HTTPURLResponse print(httpResponse) } }) dataTask.resume() ``` La réponse devrait être similaire à l’exemple ci-dessous : ```lines theme={null} HTTP/1.1 200 OK Content-Type: application/json { "access_token":"eyJz93a...k4laUWw", "token_type":"Bearer", "expires_in":86400 } ``` #### Expiration du jeton Vos jetons d’accès ont une limite de durée de validité. Étant donné que vos communications se déroulent sur le canal d'appui, l’utilisation de jetons d’actualisation pour prolonger les sessions n’est pas possible. Il est donc recommandé de configurer vos jetons d’accès avec un délai d’expiration d’une heure. Il vous faudra peut-être trouver le bon équilibre entre sécurité et performance en fonction des besoins spécifiques de votre environnement. Pour en savoir plus, veuillez consulter [Mettre à jour la durée de vie du jeton d’accès](/docs/fr-ca/secure/tokens/access-tokens/update-access-token-lifetime). ### Permissions Avant que tout client ou service non interactif n’appelle votre API, vous devez définir les autorisations ou les portées autorisées par votre API. Vous pouvez définir les permissions dans Auth0 Dashboard afin de les inclure dans votre demande à l’Authentication API. Pour lire plus d’exemples de façons d’utiliser les permissions des API, veuillez consulter [Permissions des API](/docs/fr-ca/get-started/apis/scopes/api-scopes). Pour configurer les permissions, veuillez consulter les instructions [Ajouter des autorisations API](/docs/fr-ca/get-started/apis/add-api-permissions) pour Auth0 Dashboard ou utilisez l’exemple fourni pour Management API. Pour ajouter des demandes personnalisées à un jeton d’accès, vous pouvez utiliser le flux de communication entre machines des actions. Pour en savoir plus, consultez Flux de communication entre machines. ## Image de marque Même si vous offrez des services à des clients non interactifs ou à des clients opérant sur le canal d’appui, vous pouvez toujours personnaliser votre expérience pour l’aligner sur l’apparence de votre marque existante. ### Domaines personnalisés Auth0 prend en charge l’utilisation de domaines personnalisés lors de l’appel du point de terminaison `/authorize` pour demander des jetons d’accès. Dans Auth0 Dashboard, vous devez : * Enregistrer et vérifier votre domaine avant de pouvoir l’utiliser avec vos services Auth0. * Déterminer si vous souhaitez gérer votre propre certificat ou utiliser un certificat géré par Auth0. Pour en savoir plus sur les certificats, lisez [Options de gestion des certificats](https://auth0.com/docs/customize/custom-domains#certificate-management-options). * Vérifiez que la version TLS (SSL) et le chiffre que vous souhaitez utiliser pour les certificats autogérés sont pris en charge par Auth0. Pour en savoir plus, lisez [Versions et chiffres TLS (SSL)](/docs/fr-ca/customize/custom-domains/self-managed-certificates/tls-ssl). 1. Pour configurer votre domaine personnalisé avec des certificats gérés par Auth0, suivez les instructions fournies à la section [Configurer des domaines personnalisés avec des certificats gérés par Auth0](/docs/fr-ca/customize/custom-domains/auth0-managed-certificates). 1. Si vous souhaitez gérer vos propres certificats, suivez les instructions fournies à la section [Configurer des domaines personnalisés avec des certificats autogérés](/docs/fr-ca/customize/custom-domains/self-managed-certificates). Vous devez avoir un abonnement Enterprise pour gérer les certificats dans votre domaine personnalisé. Pour en savoir plus, lisez [Tarification](https://auth0.com/pricing/) et [connexion](/docs/fr-ca/authenticate/login) Auth0. 2. Lisez [Configuration de l’API avec des domaines personnalisés](https://auth0.com/docs/customize/custom-domains/configure-features-to-use-custom-domains#apis). Vous devrez peut-être ajuster vos paramètres API pour intégrer un domaine personnalisé. Si vous rencontrez des problèmes avec votre domaine personnalisé, veuillez consulter la section [Dépannage des domaines personnalisés](/docs/fr-ca/troubleshoot/integration-extensibility-issues/troubleshoot-custom-domains). ## Automatisation du déploiement Auth0 offre une prise en charge pour plusieurs options différentes concernant les approches d’automatisation du déploiement que vous pouvez utiliser, chacune pouvant être utilisée conjointement avec l’autre. Quelle que soit la manière dont vous configurez l’automatisation du déploiement, nous vous recommandons de tester votre code personnalisé et vos actions avant le déploiement, et d’exécuter des tests d’intégration avec votre locataire après le déploiement. ### Outil Deploy CLI Comme indiqué dans la section Architecture, il est recommandé d’avoir des locataires Auth0 distincts pour le développement, les tests et la production. Ces locataires doivent partager des configurations identiques pour garantir la qualité et les tests. Cependant, des erreurs peuvent survenir si des configurations incompatibles existent entre vos différents environnements. Par exemple, chaque environnement aura des ID client et des secrets client différents. Pour réduire les erreurs de non-concordance, vous pouvez utiliser l’outil Deploy CLI afin d’intégrer votre instance Auth0 à votre pipeline CI/CD existant. Avec le remplacement dynamique des mots-clés, vous pouvez substituer les variables d’environnement des locataires partageant des configurations similaires. Pour en savoir plus, veuillez consulter [Outil Deploy CLI](/docs/fr-ca/deploy-monitor/deploy-cli-tool) et [Remplacement de mots-clés](/docs/fr-ca/deploy-monitor/deploy-cli-tool/keyword-replacement). ### Extension des journaux Webtask en temps réel L’extension Actions Real-time Logs affiche tous les journaux du code personnalisé en temps réel, y compris la sortie `console.log` et autres exceptions. Si vous utilisez Auth0 Actions ou une autre logique personnalisée, vous pouvez utiliser cette pour déboguer et dépanner les problèmes. Pour en savoir plus sur l’installation et la configuration, veuillez consulter [Journaux d'actions en temps réel](/docs/fr-ca/customize/actions/actions-real-time-logs). ## Assurance qualité L’assurance qualité est importante pour identifier les problèmes avant la mise en service. En fonction de la nature de votre projet, il existe plusieurs types différents de tests d’assurance qualité que vous voudrez envisager dans le cadre de votre intégration avec Auth0 : * Comment votre API se comportera-t-elle lorsqu’elle seront soumise à des charges de production inattendues? * Comment vos limites anti-attaques seront-elles affectées par les applications tierces? Si vous n’utilisez pas les gadgets logiciels ou les fonctionnalités Auth0, comme la connexion universelle, vous ne profiterez pas des meilleures pratiques d’utilisation et d’accessibilité intégrées, prêtes à l’emploi sur une large gamme de navigateurs et d’appareils. Pour assurer que les exigences fonctionnelles sont respectées et que les événements inattendus sont gérés correctement, des conseils sont fournis pour tester l’intégration entre votre ou vos applications et Auth0, et pour des tests unitaires de modules d’extensibilité individuels, comme Auth0 Actions. Nous vous recommandons également de consulter la [politique de tests de pénétration d’Auth0](/docs/fr-ca/troubleshoot/customer-support/operational-policies/penetration-testing-policy) et les tests simulés complets que vous pouvez exploiter en conjonction avec notre [politique de test de charge](/docs/fr-ca/troubleshoot/customer-support/operational-policies/load-testing-policy) pour garantir que votre/vos application(s) fonctionnent sous une charge inattendue. ### Tests unitaires Les tests unitaires vérifient les unités d’extensibilité, comme Auth0 Actions. Si vous utilisez du code personnalisé, nous vous recommandons d’utiliser un cadre d'applications (tel que [Mocha](https://mochajs.org/)) pour tester le code supplémentaire avant le déploiement. ### Tests de simulation Pour trouver un équilibre entre la [politique de test de charge](/docs/fr-ca/troubleshoot/customer-support/operational-policies/load-testing-policy) d’Auth0 et votre souhait de réaliser des tests de charge, il est courant de créer un test simulé des points de terminaison d’Auth0. Cette pratique est précieuse pour garantir que votre application fonctionne avec les interfaces attendues sans avoir à restreindre vos tests, et des outils tels que [MockServer](http://www.mock-server.com/), [JSON Server](https://github.com/typicode/json-server) ou même [Postman](https://learning.getpostman.com/docs/postman/mock_servers/setting_up_mock/) peuvent être utilisés à cette fin. ## Déploiement Notre section [Déployer et surveiller](/docs/fr-ca/deploy-monitor) fournit des conseils sur les meilleures pratiques de déploiement. Nous vous recommandons de lire [Vérifications de prédéploiement](/docs/fr-ca/deploy-monitor/pre-deployment-checks), en particulier la section traitant des [Vérifications de préparation Auth0 Dashboard intégrées](/docs/fr-ca/deploy-monitor/pre-deployment-checks/how-to-run-production-checks). Pour consulter la Vérification de préparation, sélectionnez le menu déroulant sous le nom de votre locataire et l’étiquette environnementale dans [Auth0 Dashboard > Run Readiness Checks (Exécuter les vérifications de préparation)](https://manage.auth0.com/#/production-checks). Auth0 Dashboard > Readiness Checklist Vous pouvez utiliser le filtre pour appliquer les vérifications de préparation aux applications sélectionnées. **Ces vérifications ne s’appliquent pas à vos API configurées**. Pour les vérifications qui ne s’appliquent pas à votre configuration spécifique, vous pouvez sélectionner **Dismiss (Rejeter)** pour les retirer des résultats finaux. Nous vous conseillons de lire [Bonnes pratiques de déploiement](/docs/fr-ca/deploy-monitor/deployment-best-practices) pour les dernières vérifications avant de passer en situation réelle et de tirer parti des [Logs](/docs/fr-ca/deploy-monitor/logs) (Journaux) pour surveiller vos services. ## En savoir plus * [Présentation d’Auth0](/docs/fr-ca/get-started/auth0-overview) * [Aperçu de solution (Applications serveur + ](/docs/images/s/fr-ca/get-started/architecture-scenarios/server-application-api/part-1) * [Effectuer une requête à votre API à l’aide du Flux des identifiants client](/docs/fr-ca/get-started/authentication-and-authorization-flow/client-credentials-flow/call-your-api-using-the-client-credentials-flow) * [Récupérer les événements de journal à l’aide de Management API](/docs/fr-ca/deploy-monitor/logs/retrieve-log-events-using-mgmt-api) * [Obtenir des jetons d’accès à Management API pour la production](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production)