> ## 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.

# Créer une interface libre-service de sécurité du compte avec API My Account sur iOS

> Explique comment utiliser Universal Components pour créer des interfaces libre-service de sécurité du compte avec API My Account d’Auth0 sur iOS.

export const ReleaseStageNotice = ({feature, stage, plans, contact, terms}) => {
  const stageTextMap = {
    "beta": "bêta",
    "ea": "Accès anticipé"
  };
  const stageText = stageTextMap[stage] || "une phase de lancement du produit";
  const prsLink = "/docs/troubleshoot/product-lifecycle/product-release-stages";
  const linkify = (text, url) => {
    return <a href={url} target="_blank" rel="noreferrer" class="link">{text}</a>;
  };
  const includeDetails = (plans, contact, terms) => {
    const hasDetails = terms || plans || contact;
    if (!hasDetails) return null;
    return <span data-as="p">
            {plans && <>Cette fonctionnalité est offerte avec les forfaits {linkify(`${plans}`, "https://auth0.com/pricing")}. </>}
            {contact && "Pour y participer, communiquez avec " + contact + ". "}
            {terms && <>En utilisant cette fonctionnalité, vous acceptez les conditions applicables de l’essai gratuit énoncées dans le {linkify("Master Subscription Agreement", "https://www.okta.com/legal")} d’Okta.</>}
        </span>;
  };
  return <Warning>
            <span data-as="p">
                <strong>La fonctionnalité {feature} est en {linkify(stageText, prsLink)}.</strong>
            </span>

            {includeDetails(plans, contact, terms)}
        </Warning>;
};

<ReleaseStageNotice feature="Auth0 Universal Components" stage="beta" terms="true" contact="Auth0 Support" />

Auth0 Universal Components pour iOS vous permettent de créer une interface libre-service de sécurité de compte dans votre [application iOS native](/docs/fr-ca/get-started/auth0-overview/create-applications#create-application-in-auth0).

Grâce au composant `MyAccountAuthMethodsView`, les utilisateurs peuvent gérer leurs propres méthodes d’authentification — facteurs d’authentification multifacteur (AMF), clés d’accès et codes de récupération — directement dans votre application native, sans avoir à ouvrir un navigateur Web ni à communiquer avec le soutien.

<div id="how-it-works">
  ## Fonctionnement
</div>

Le composant `MyAccountAuthMethodsView` utilise les [méthodes d’authentification de l’API My Account](/docs/fr-ca/manage-users/my-account-api#manage-authentication-methods) d’Auth0 pour afficher une interface permettant de gérer les méthodes d’authentification dans votre application.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  L’API My Account impose actuellement des limites de débit peu élevées, particulièrement pour les tenants du niveau Free. Cela peut entraîner des erreurs lors de l’utilisation de ces composants.
</Callout>

Lorsqu’un utilisateur authentifié ouvre l’écran des paramètres de son compte, le SDK [Auth0.swift](https://github.com/auth0/Auth0.swift) récupère un [jeton d’accès](/docs/fr-ca/secure/tokens/access-tokens) associé à l’audience de l’API My Account.

Le composant `MyAccountAuthMethodsView` utilise le jeton d’accès pour envoyer des requêtes aux endpoints [`/me/v1/authentication-methods`](/docs/fr-ca/api/myaccount/authentication-methods/get-authentication-methods) de l’API My Account au nom de l’utilisateur connecté, de sorte que chaque utilisateur ne peut modifier que ses propres méthodes d’authentification.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  * Le composant `MyAccountAuthMethodsView` crée des interfaces de **libre-service destinées aux utilisateurs finaux**. Les utilisateurs finaux peuvent inscrire, afficher et supprimer toutes les méthodes d’authentification de leur compte : OTP par courriel, OTP par SMS, TOTP (application d’authentification), notifications push par Auth0 Guardian, clés d’accès et codes de récupération.

  * Pour les interfaces d’**administration déléguée** dans lesquelles un utilisateur gère une organisation Auth0, consultez [Créer une interface d’administration déléguée](/docs/fr-ca/get-started/universal-components/web/components/build-delegated-admin).
</Callout>

<div id="prerequisites">
  ## Prérequis
</div>

<div id="enable-auth0-my-account-api">
  ### Activer l’API My Account d’Auth0
</div>

1. Accédez à [Dashboard > Applications > APIs](https://manage.auth0.com/#/apis).
2. Sélectionnez **Activate My Account API** pour l’activer dans votre tenant.

<div id="create-the-application-and-configure-my-account-api-permissions">
  ### Créer l’application et configurer les permissions de l’API My Account
</div>

1. Accédez à [Dashboard > Applications](https://manage.auth0.com/#/applications).

2. Sélectionnez **Create Application**.

3. Sélectionnez **Native**.

4. Sélectionnez l’onglet **Settings** pour ajouter les URL de callback suivantes dans **Allowed Callback URLs** :

   ```text theme={null}
   https://YOUR_AUTH0_DOMAIN/ios/YOUR_BUNDLE_ID/callback, YOUR_BUNDLE_ID://YOUR_AUTH0_DOMAIN/ios/YOUR_BUNDLE_ID/callback
   ```

5. Ajoutez les mêmes URL dans **Allowed Logout URLs**.

   ```text theme={null}
   https://YOUR_AUTH0_DOMAIN/ios/YOUR_BUNDLE_ID/callback, YOUR_BUNDLE_ID://YOUR_AUTH0_DOMAIN/ios/YOUR_BUNDLE_ID/callback
   ```

6. Sélectionnez l’onglet **API Access**.

7. Pour **l’API My Account d’Auth0**, sélectionnez **Edit** afin d’ajouter les permissions **User-delegated Access** :

   `create:me:authentication_methods`
   `read:me:authentication_methods`
   `update:me:authentication_methods`
   `delete:me:authentication_methods`

8. Sélectionnez **Save** pour enregistrer les permissions.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  * Le jeton d’accès de l’utilisateur inclut uniquement les permissions accordées lors de la connexion.
  * Demandez les quatre scopes pour permettre aux utilisateurs d’inscrire, de consulter et de supprimer des méthodes d’authentification.
</Callout>

<div id="install-the-sdk">
  ### Installer le SDK
</div>

Utilisez Swift Package Manager ou Carthage pour installer le package `Auth0UniversalComponents`.

Pour en savoir plus sur les exigences et les détails d’installation, consultez [Auth0 Universal Components for iOS](/docs/fr-ca/get-started/universal-components/ios/ios-overview).

<div id="initialize-the-sdk">
  ### Initialiser le SDK
</div>

Pour initialiser le SDK, appelez une seule fois la méthode `Auth0UniversalComponentsSDKInitializer.initialize(...)` au démarrage de l’application, généralement dans l’`init` de la structure de votre application.

Si votre application utilise déjà `Auth0.plist` pour configurer Auth0.swift, ajoutez les clés `ClientId`, `Domain` et `Audience`, puis appelez :

```swift App.swift wrap lines theme={null}
import SwiftUI
import Auth0
import Auth0UniversalComponents

@main
struct MyApp: App {
    init() {
        Auth0UniversalComponentsSDKInitializer.initialize(
            tokenProvider: CredentialsManager(authentication: Auth0.authentication())
        )
    }

    var body: some Scene {
        WindowGroup { ContentView() }
    }
}
```

Ou transmettez directement les valeurs dans le code :

```swift App.swift wrap lines theme={null}
Auth0UniversalComponentsSDKInitializer.initialize(
    domain: "YOUR_AUTH0_DOMAIN",
    clientId: "YOUR_CLIENT_ID",
    audience: "https://YOUR_AUTH0_DOMAIN/me/",
    tokenProvider: CredentialsManager(authentication: Auth0.authentication())
)
```

<div id="configure-the-token-provider">
  ### Configurer le fournisseur de jetons
</div>

Utilisez le `TokenProvider`, qui encapsule le `CredentialsManager` de [`Auth0.swift`](https://github.com/auth0/Auth0.swift), pour demander des informations d’identification à votre application.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Auth0 recommande d’utiliser le `CredentialsManager` d’Auth0.swift pour les intégrations en production. Implémentez un `TokenProvider` personnalisé uniquement si le SDK Auth0.swift ne répond pas à vos exigences de stockage.
</Callout>

Pour gérer les informations d’identification sans passer par le `CredentialsManager` du SDK Auth0.iOS, implémentez directement l’interface :

```swift wrap lines theme={null}
struct AppTokenProvider: TokenProvider {
    func fetchCredentials() async throws -> Credentials {
        // Retourner les credentials de login de l'utilisateur.
    }
    func storeCredentials(credentials: Credentials) {
        // Enregistrer les credentials nouveaux ou actualisés.
    }
    func store(apiCredentials: APICredentials, for audience: String) {
        // Enregistrer les credentials de la My Account API, indexés par audience.
    }
    func fetchAPICredentials(audience: String, scope: String) async throws -> APICredentials {
        // Retourner les credentials de la My Account API mis en cache, en les actualisant s'ils sont expirés.
    }
}
```

<Check>
  Les utilisateurs doivent être authentifiés avant d’afficher un composant. Une fois le SDK initialisé et votre protocole `TokenProvider` configuré, ajoutez le composant [`MyAccountAuthMethodsView`](/docs/fr-ca/get-started/universal-components/ios/components/auth-methods-management) à votre écran de paramètres afin d’offrir aux utilisateurs la gestion en libre-service complète de l’AMF, des clés d’accès et des codes de récupération.
</Check>

<div id="learn-more">
  ## En savoir plus
</div>

<CardGroup cols={2}>
  <Card title="Gestion des méthodes d’authentification" icon="shield" href="/docs/fr-ca/get-started/universal-components/ios/components/auth-methods-management">
    Consultez la référence du composant `MyAccountAuthMethodsView`, les facteurs pris en charge et des exemples de navigation intégrée.
  </Card>

  <Card title="Personnaliser le style et les thèmes" icon="palette" href="/docs/fr-ca/get-started/universal-components/ios/ios-theming">
    Personnalisez les jetons de couleur, de typographie, d’espacement, de rayon et de taille à l’aide du système de jetons de conception Auth0.
  </Card>
</CardGroup>