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

# Ajouter la connexion à votre application .NET Android et iOS

export const HowToSchema = () => <script type="application/ld+json">
    {'{"@context":"https://schema.org","@type":"HowTo"}'}
  </script>;

<HowToSchema />

<Accordion title="Utiliser l’IA pour intégrer Auth0" icon="microchip-ai" iconType="solid" defaultOpen>
  Si vous utilisez un assistant de codage par IA comme Claude Code, Cursor ou GitHub Copilot, vous pouvez ajouter automatiquement l’authentification Auth0 en quelques minutes à l’aide des [agent skills](https://agentskills.io/home).

  **Installation :**

  ```bash theme={null}
  npx skills add auth0/agent-skills --skill auth0-quickstart --skill auth0-net-android --skill auth0-net-ios
  ```

  **Demandez ensuite à votre assistant IA :**

  ```text theme={null}
  Add Auth0 authentication to my .NET Android & iOS app
  ```

  Votre assistant IA créera automatiquement votre application Auth0, récupérera les informations d’identification, installera le SDK Auth0 OidcClient, configurera les paramètres propres à la plateforme et mettra en place les flux de connexion et de déconnexion. [Documentation complète sur les agent skills →](/fr-CA/docs/quickstart/agent-skills)
</Accordion>

<div id="get-started">
  ## Premiers pas
</div>

<Steps>
  <Step title="Créer un projet .NET" stepNumber={1}>
    Créez un nouveau projet .NET MAUI ou .NET Android/iOS pour ce guide de démarrage rapide.

    <Tabs>
      <Tab title=".NET MAUI">
        **Dans Visual Studio 2022 ou une version ultérieure :**

        1. **Fichier** → **Nouveau** → **Projet**
        2. Sélectionnez le modèle **.NET MAUI App**
        3. Configurez votre projet :
           * **Nom du projet** : `Auth0MauiSample`
           * **Emplacement** : Choisissez l’emplacement souhaité
           * **Framework** : **.NET 8.0 ou version ultérieure**
        4. Cliquez sur **Créer**
      </Tab>

      <Tab title=".NET Android">
        **Dans Visual Studio 2022 ou une version ultérieure :**

        1. **Fichier** → **Nouveau** → **Projet**
        2. Sélectionnez le modèle **Android App (.NET)**
        3. Configurez votre projet :
           * **Nom du projet** : `Auth0AndroidSample`
           * **Framework** : **.NET 8.0 ou version ultérieure**
        4. Cliquez sur **Créer**
      </Tab>

      <Tab title=".NET iOS">
        **Dans Visual Studio 2022 (Mac) ou Visual Studio for Mac :**

        1. **Fichier** → **Nouveau** → **Projet**
        2. Sélectionnez le modèle **iOS App (.NET)**
        3. Configurez votre projet :
           * **Nom du projet** : `Auth0iOSSample`
           * **Framework** : **.NET 8.0 ou version ultérieure**
        4. Cliquez sur **Créer**
      </Tab>
    </Tabs>

    <Info>
      Ce guide de démarrage rapide met l’accent sur .NET Android et iOS, qui constituent la nouvelle génération de Xamarin.Android et Xamarin.iOS. Si vous utilisez encore Xamarin, vous pouvez suivre ce guide, car l’intégration est identique et les SDK sont compatibles.
    </Info>
  </Step>

  <Step title="Installer le SDK d’Auth0" stepNumber={2}>
    Ajoutez le SDK client OIDC Auth0 à votre projet.

    <Tabs>
      <Tab title="Console du gestionnaire de packages">
        Ouvrez la console du gestionnaire de packages (**View** → **Other Windows** → **Package Manager Console**) et installez le package approprié :

        **Pour .NET Android :**

        ```bash Package Manager Console theme={null}
        Install-Package Auth0.OidcClient.AndroidX
        ```

        **Pour .NET iOS :**

        ```bash Package Manager Console theme={null}
        Install-Package Auth0.OidcClient.iOS
        ```

        **Pour .NET MAUI (les deux plateformes) :**

        ```bash Package Manager Console theme={null}
        Install-Package Auth0.OidcClient.MAUI
        ```
      </Tab>

      <Tab title="Visual Studio pour Mac">
        1. Dans le **Solution Pad**, faites Ctrl+clic (ou clic droit) sur le dossier **Packages**
        2. Sélectionnez **Add Packages...**
        3. Recherchez :
           * `Auth0.OidcClient.AndroidX` pour Android
           * `Auth0.OidcClient.iOS` pour iOS
           * `Auth0.OidcClient.MAUI` pour les projets MAUI
        4. Sélectionnez le package, puis cliquez sur **Add Package**
      </Tab>

      <Tab title=".NET CLI">
        Exécutez la commande suivante dans le répertoire de votre projet :

        **Pour .NET Android :**

        ```bash Terminal theme={null}
        dotnet add package Auth0.OidcClient.AndroidX
        ```

        **Pour .NET iOS :**

        ```bash Terminal theme={null}
        dotnet add package Auth0.OidcClient.iOS
        ```

        **Pour .NET MAUI :**

        ```bash Terminal theme={null}
        dotnet add package Auth0.OidcClient.MAUI
        ```
      </Tab>
    </Tabs>

    <Tip>
      Le SDK client OIDC Auth0 gère tous les détails des protocoles OAuth 2.0 et OIDC et fournit une API simple pour l’authentification.
    </Tip>
  </Step>

  <Step title="Configurez votre application Auth0" stepNumber={3}>
    Créez une nouvelle application dans votre locataire Auth0 et configurez-la pour le mobile.

    1. Accédez au [Auth0 Dashboard](https://manage.auth0.com/dashboard/)
    2. Cliquez sur **Applications** → **Applications** → **Create Application**
    3. Saisissez un nom pour votre application, sélectionnez **Native** comme type d’application, puis cliquez sur **Create**
    4. Ouvrez l’onglet **Settings** sur la page des détails de l’application
    5. Prenez note de votre **Domaine** et de votre **ID client** : vous en aurez besoin à l’étape suivante

    **Configurer les URL de rappel :**

    Dans l’onglet **Settings**, ajoutez les URL suivantes :

    **Allowed Callback URLs:**

    <Tabs>
      <Tab title="Android">
        ```
        YOUR_ANDROID_PACKAGE_NAME://{yourDomain}/android/YOUR_ANDROID_PACKAGE_NAME/callback
        ```

        Remplacez :

        * `YOUR_ANDROID_PACKAGE_NAME` par le nom du package de votre application (p. ex., `com.mycompany.myapp`)
        * `{yourDomain}` par votre domaine Auth0 (p. ex., `dev-abc123.us.auth0.com`)

        Exemple : `com.mycompany.myapp://dev-abc123.us.auth0.com/android/com.mycompany.myapp/callback`
      </Tab>

      <Tab title="iOS">
        ```
        YOUR_BUNDLE_IDENTIFIER://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback
        ```

        Remplacez :

        * `YOUR_BUNDLE_IDENTIFIER` par l’identifiant du bundle de votre application (p. ex., `com.mycompany.myapp`)
        * `{yourDomain}` par votre domaine Auth0 (p. ex., `dev-abc123.us.auth0.com`)

        Exemple : `com.mycompany.myapp://dev-abc123.us.auth0.com/ios/com.mycompany.myapp/callback`
      </Tab>
    </Tabs>

    **Allowed Logout URLs:**

    Utilisez les mêmes URL que pour vos URL de rappel.

    <Warning>
      Assurez-vous que les URL de rappel et de déconnexion sont en **minuscules**. Si les URL ne correspondent pas, l’authentification échouera.
    </Warning>

    <Info>
      Les **Allowed Callback URLs** sont essentielles à la sécurité : elles garantissent que les utilisateurs sont redirigés de façon sécuritaire vers votre application après l’authentification. Sans URL correspondante, le processus de connexion échouera.

      Les **Allowed Logout URLs** offrent une expérience fluide lorsque les utilisateurs se déconnectent, en les redirigeant vers votre application au lieu de les laisser sur une page Auth0.
    </Info>
  </Step>

  <Step title="Initialiser l’application Auth0" stepNumber={4}>
    Créez une instance d’`Auth0Client` pour communiquer avec Auth0.

    <Tabs>
      <Tab title="Android - MainActivity">
        ```cs MainActivity.cs lines theme={null}
        using Auth0.OidcClient;
        using Android.App;
        using Android.Content;

        [Activity(Label = "Auth0Sample", MainLauncher = true, Icon = "@drawable/icon",
            LaunchMode = LaunchMode.SingleTask)]
        [IntentFilter(
            new[] { Intent.ActionView },
            Categories = new[] { Intent.CategoryDefault, Intent.CategoryBrowsable },
            DataScheme = "YOUR_ANDROID_PACKAGE_NAME",
            DataHost = "{yourDomain}",
            DataPathPrefix = "/android/YOUR_ANDROID_PACKAGE_NAME/callback")]
        public class MainActivity : Activity
        {
            private Auth0Client auth0Client;

            protected override void OnCreate(Bundle savedInstanceState)
            {
                base.OnCreate(savedInstanceState);

                // Initialiser le client Auth0
                auth0Client = new Auth0Client(new Auth0ClientOptions
                {
                    Domain = "{yourDomain}",
                    ClientId = "{yourClientId}"
                }, this);
            }

            protected override async void OnNewIntent(Intent intent)
            {
                base.OnNewIntent(intent);
                Auth0.OidcClient.ActivityMediator.Instance.Send(intent.DataString);
            }
        }
        ```

        <Warning>
          Remplacez `YOUR_ANDROID_PACKAGE_NAME`, `{yourDomain}` et `{yourClientId}` par vos valeurs. Assurez-vous que tout le texte dans `DataScheme`, `DataHost` et `DataPathPrefix` est en **minuscules**.
        </Warning>

        <Info>
          `IntentFilter` enregistre votre application pour traiter l’URL de rappel. `LaunchMode.SingleTask` garantit qu’Android ne crée pas une nouvelle instance d’activité lorsque l’URL de rappel est appelée.
        </Info>
      </Tab>

      <Tab title="iOS - AppDelegate">
        Commencez par enregistrer le schéma d’URL dans votre `Info.plist` :

        ```xml Info.plist lines theme={null}
        <key>CFBundleURLTypes</key>
        <array>
            <dict>
                <key>CFBundleTypeRole</key>
                <string>None</string>
                <key>CFBundleURLName</key>
                <string>Auth0</string>
                <key>CFBundleURLSchemes</key>
                <array>
                    <string>YOUR_BUNDLE_IDENTIFIER</string>
                </array>
            </dict>
        </array>
        ```

        Ensuite, configurez votre `AppDelegate.cs` :

        ```cs AppDelegate.cs lines theme={null}
        using Auth0.OidcClient;
        using Foundation;
        using UIKit;

        [Register("AppDelegate")]
        public class AppDelegate : UIApplicationDelegate
        {
            private Auth0Client auth0Client;

            public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions)
            {
                // Initialiser le client Auth0
                auth0Client = new Auth0Client(new Auth0ClientOptions
                {
                    Domain = "{yourDomain}",
                    ClientId = "{yourClientId}"
                });

                return true;
            }

            public override bool OpenUrl(UIApplication application, NSUrl url,
                string sourceApplication, NSObject annotation)
            {
                ActivityMediator.Instance.Send(url.AbsoluteString);
                return true;
            }
        }
        ```

        <Warning>
          Remplacez `YOUR_BUNDLE_IDENTIFIER`, `{yourDomain}` et `{yourClientId}` par vos valeurs.
        </Warning>
      </Tab>
    </Tabs>

    <Tip>
      Stockez votre domaine Auth0 et votre ID client dans un fichier de configuration ou dans les paramètres de l’application au lieu de les coder en dur, afin de faciliter la maintenance.
    </Tip>
  </Step>

  <Step title="Mettre en œuvre la connexion et la déconnexion" stepNumber={5}>
    Ajoutez des méthodes pour gérer l’authentification de l’utilisateur.

    **Implémentez la connexion :**

    ```cs Authentication.cs lines theme={null}
    public async Task LoginAsync()
    {
        var loginResult = await auth0Client.LoginAsync();

        if (!loginResult.IsError)
        {
            // Authentification réussie
            var accessToken = loginResult.AccessToken;
            var idToken = loginResult.IdentityToken;
            var user = loginResult.User;

            // Enregistrer les informations d'identification et mettre à jour l'interface
            Console.WriteLine($"Logged in as: {user.FindFirst("name")?.Value}");
        }
        else
        {
            // Gérer l'erreur d'authentification
            Console.WriteLine($"Login error: {loginResult.Error}");
        }
    }
    ```

    **Implémentez la déconnexion :**

    ```cs Authentication.cs lines theme={null}
    public async Task LogoutAsync()
    {
        var logoutResult = await auth0Client.LogoutAsync();

        if (logoutResult == BrowserResultType.Success)
        {
            // Effacer les informations d'identification stockées
            // Mettre à jour l'interface pour l'état déconnecté
            Console.WriteLine("Logged out successfully");
        }
    }
    ```

    <Info>
      La méthode `LoginAsync()` lance le navigateur du système (ou Chrome Custom Tabs sur Android) pour afficher la page Universal Login d’Auth0. Après l’authentification, l’utilisateur est redirigé vers votre application au moyen de l’URL de rappel.
    </Info>

    <Tip>
      Ajoutez ces méthodes à votre MainActivity (Android) ou à un ViewController (iOS), puis appelez-les lorsque les utilisateurs appuient sur les boutons de connexion/déconnexion.
    </Tip>
  </Step>

  <Step title="Lancez votre application" stepNumber={6}>
    Compilez et exécutez votre application.

    <Tabs>
      <Tab title="Visual Studio (Windows)">
        **Pour Android :**

        1. Sélectionnez un émulateur Android ou un appareil connecté dans la liste déroulante des appareils
        2. Appuyez sur **F5** ou cliquez sur le bouton **Run**
        3. L’application sera compilée, déployée et lancée

        **Pour iOS (nécessite un hôte de compilation Mac) :**

        1. Connectez-vous à votre hôte de compilation Mac
        2. Sélectionnez un simulateur ou un appareil iOS dans la liste déroulante des appareils
        3. Appuyez sur **F5** ou cliquez sur le bouton **Run**
      </Tab>

      <Tab title="Visual Studio pour Mac">
        1. Sélectionnez votre plateforme cible (Android/iOS) dans la liste déroulante des appareils
        2. Sélectionnez un émulateur, un simulateur ou un appareil connecté
        3. Appuyez sur **⌘+Return** ou cliquez sur le bouton **Run**
        4. L’application sera compilée et lancée
      </Tab>

      <Tab title=".NET CLI">
        **Pour Android :**

        ```bash Terminal theme={null}
        dotnet build -f net8.0-android
        dotnet run -f net8.0-android
        ```

        **Pour iOS :**

        ```bash Terminal theme={null}
        dotnet build -f net8.0-ios
        dotnet run -f net8.0-ios
        ```
      </Tab>
    </Tabs>

    **Flux attendu :**

    1. L’application s’ouvre avec un bouton Login
    2. Touchez **Log In** → Le navigateur ou un onglet personnalisé Chrome s’ouvre → Terminez l’authentification
    3. Redirection automatique vers votre application
    4. L’utilisateur est authentifié avec succès

    <Tip>
      Au premier lancement, iOS peut vous demander de confirmer l’ouverture du navigateur pour l’authentification. Il s’agit d’un comportement normal.
    </Tip>
  </Step>
</Steps>

<Check>
  **Point de contrôle**

  Vous disposez maintenant d’une expérience de connexion Auth0 entièrement fonctionnelle dans votre application .NET pour Android ou iOS. L’application utilise le navigateur système pour une authentification sécurisée et gère automatiquement le flux de redirection.
</Check>

***

<div id="access-user-information">
  ## Accéder aux informations de l’utilisateur
</div>

Après une authentification réussie, vous pouvez accéder aux informations de l’utilisateur dans le résultat de connexion.

<div id="authentication-result">
  ### Résultat de l’authentification
</div>

La méthode `LoginAsync()` renvoie un objet `LoginResult` contenant :

```cs UserInfo.cs lines theme={null}
var loginResult = await auth0Client.LoginAsync();

if (!loginResult.IsError)
{
    // Jetons d'accès
    var accessToken = loginResult.AccessToken;
    var idToken = loginResult.IdentityToken;
    var refreshToken = loginResult.RefreshToken;

    // Accéder aux revendications de l'utilisateur
    var user = loginResult.User;
    var name = user.FindFirst("name")?.Value;
    var email = user.FindFirst("email")?.Value;
    var picture = user.FindFirst("picture")?.Value;

    Console.WriteLine($"Name: {name}");
    Console.WriteLine($"Email: {email}");
}
```

<div id="iterate-through-all-claims">
  ### Parcourir l’ensemble des revendications
</div>

Pour voir toutes les informations disponibles sur l’utilisateur :

```cs UserClaims.cs lines theme={null}
if (!loginResult.IsError)
{
    foreach (var claim in loginResult.User.Claims)
    {
        Console.WriteLine($"{claim.Type}: {claim.Value}");
    }
}
```

<Info>
  Les revendications renvoyées dépendent exactement des scopes demandés. Pour en savoir plus, consultez [Utilisation des scopes](https://auth0.github.io/auth0-oidc-client-net/documentation/advanced-scenarios/scopes.html) dans la documentation du client OIDC Auth0.
</Info>

<div id="request-custom-scopes">
  ### Demander des scopes personnalisés
</div>

Pour demander des informations supplémentaires sur l’utilisateur, précisez les scopes lors de la création de l’Auth0Client :

```cs CustomScopes.cs lines theme={null}
var auth0Client = new Auth0Client(new Auth0ClientOptions
{
    Domain = "{yourDomain}",
    ClientId = "{yourClientId}",
    Scope = "openid profile email offline_access read:posts"
});
```

***

<div id="troubleshooting-advanced">
  ## Dépannage et aspects avancés
</div>

<Accordion title="Problèmes courants et solutions">
  ### Le navigateur ne redirige pas vers l’application

  **Solutions :**

  1. Vérifiez que les URL de rappel dans le Auth0 Dashboard correspondent exactement au nom du package ou à l’identifiant de bundle de votre application
  2. Assurez-vous que les URL de rappel sont en **minuscules**
  3. Vérifiez que `DataScheme`, `DataHost` et `DataPathPrefix` (Android), ou le schéma d’URL (iOS), correspondent à votre configuration
  4. Nettoyez et recompilez votre projet

  ### L’authentification échoue avec l’erreur "Invalid Callback URL"

  **Correctif :**

  * Vérifiez de nouveau que votre URL de rappel dans le Auth0 Dashboard respecte le format suivant :
    * Android : `packagename://yourdomain/android/packagename/callback`
    * iOS : `bundleidentifier://yourdomain/ios/bundleidentifier/callback`
  * Assurez-vous que l’URL est en minuscules
  * Vérifiez que le Domaine dans votre code correspond au Domaine dans le Auth0 Dashboard

  ### LoginAsync() bloque ou ne se termine jamais

  **Solutions :**

  * Assurez-vous que le filtre d’intent (Android) ou le schéma d’URL (iOS) est correctement configuré
  * Vérifiez que `OnNewIntent()` (Android) ou `OpenUrl()` (iOS) appelle `ActivityMediator`
  * Vérifiez que votre application peut ouvrir le navigateur système
  * Vérifiez la connexion réseau

  ### Erreur : "Default App must use Token Endpoint Authentication Method 'None'"

  **Correctif :**

  1. Accédez aux paramètres de votre application Auth0 dans le Dashboard
  2. Faites défiler jusqu’à **Application Properties**
  3. Réglez **Application Type** sur **Native**
  4. Réglez **Token Endpoint Authentication Method** sur **None**
  5. Cliquez sur **Save Changes**

  ### iOS : Le navigateur ne s’ouvre pas

  **Solutions :**

  * Vérifiez que `Info.plist` contient la bonne configuration de schéma d’URL
  * Vérifiez que `OpenUrl()` est implémenté dans `AppDelegate`
  * Assurez-vous que la cible de déploiement iOS est compatible avec la version de votre SDK Auth0
</Accordion>

<Accordion title="Considérations pour la production">
  ### Bonnes pratiques de sécurité

  * **Stockage sécurisé des jetons** : Utilisez le stockage sécurisé propre à la plateforme (Android Keystore, iOS Keychain) pour stocker les jetons
  * **Actualisation des jetons** : Implémentez la gestion des jetons d’actualisation afin de maintenir les sessions utilisateur
  * **Épinglage de certificats** : Envisagez l’épinglage de certificats pour renforcer la sécurité de l’API
  * **ProGuard/obfuscation du code** : Ajoutez les règles appropriées si vous utilisez l’obfuscation du code sur Android

  ### Exigences des boutiques d’applications

  * **Politique de confidentialité** : Assurez-vous que votre application dispose d’une politique de confidentialité qui décrit l’utilisation d’Auth0
  * **Gestion des données des utilisateurs** : Suivez les directives de la plateforme pour gérer les données d’authentification des utilisateurs
  * **Liens profonds** : Testez minutieusement la gestion des URL de rappel dans différents scénarios
  * **Exigences réseau** : Gérez correctement les scénarios hors ligne

  ### Optimisation des performances

  * **Mettre Auth0Client en cache** : Créez une seule instance et réutilisez-la dans toute votre application
  * **Chargement différé** : Initialisez Auth0Client uniquement au besoin
  * **Actualisation en arrière-plan** : Implémentez l’actualisation des jetons en arrière-plan pour les sessions de longue durée
</Accordion>

<Accordion title="Configuration avancée">
  ### Scopes personnalisés et audience

  Demandez des scopes précis et définissez une audience pour votre API :

  ```cs AdvancedAuth.cs expandable lines theme={null}
  var auth0Client = new Auth0Client(new Auth0ClientOptions
  {
      Domain = "{yourDomain}",
      ClientId = "{yourClientId}",
      Scope = "openid profile email offline_access read:posts write:posts",
      Audience = "https://myapi.example.com"
  });

  var loginResult = await auth0Client.LoginAsync();
  ```

  ### Paramètres supplémentaires

  Ajoutez des paramètres supplémentaires à la requête d’autorisation :

  ```cs ExtraParams.cs expandable lines theme={null}
  var extraParameters = new Dictionary<string, string>
  {
      { "prompt", "login" },
      { "ui_locales", "es" },
      { "custom_param", "value" }
  };

  var loginResult = await auth0Client.LoginAsync(extraParameters);
  ```

  ### Jetons d’actualisation

  Utilisez des jetons d’actualisation pour obtenir de nouveaux jetons d’accès sans intervention de l’utilisateur :

  ```cs RefreshToken.cs expandable lines theme={null}
  var refreshResult = await auth0Client.RefreshTokenAsync(loginResult.RefreshToken);

  if (!refreshResult.IsError)
  {
      var newAccessToken = refreshResult.AccessToken;
      var newIdToken = refreshResult.IdentityToken;
      // Stockez les nouveaux jetons
  }
  ```

  <Info>
    Pour recevoir un jeton d’actualisation, incluez le scope `offline_access` dans votre requête d’authentification.
  </Info>

  ### Configuration du navigateur selon la plateforme

  **Android - Utiliser Chrome Custom Tabs avec des couleurs personnalisées :**

  ```cs AndroidBrowser.cs expandable lines theme={null}
  var auth0Client = new Auth0Client(new Auth0ClientOptions
  {
      Domain = "{yourDomain}",
      ClientId = "{yourClientId}",
      Browser = new AndroidBrowser
      {
          ToolbarColor = Android.Graphics.Color.ParseColor("#FF6B35")
      }
  }, this);
  ```

  **iOS - Utiliser SFSafariViewController avec une présentation personnalisée :**

  ```cs iOSBrowser.cs expandable lines theme={null}
  var auth0Client = new Auth0Client(new Auth0ClientOptions
  {
      Domain = "{yourDomain}",
      ClientId = "{yourClientId}",
      Browser = new ASWebAuthenticationSessionBrowser
      {
          PrefersEphemeralWebBrowserSession = false
      }
  });
  ```
</Accordion>

***

<div id="next-steps">
  ## Prochaines étapes
</div>

<CardGroup cols={2}>
  <Card title="Configurer des fournisseurs d’identité" icon="key" href="/fr-CA/docs/authenticate/identity-providers" iconType="solid">
    Ajoutez des fournisseurs de connexion sociale comme Google, Facebook et GitHub
  </Card>

  <Card title="Activer l’authentification multifacteur" icon="shield-halved" href="/fr-CA/docs/secure/multi-factor-authentication" iconType="solid">
    Ajoutez une couche de sécurité supplémentaire avec MFA
  </Card>

  <Card title="Protection contre les attaques" icon="shield" href="/fr-CA/docs/secure/attack-protection" iconType="solid">
    Découvrez comment vous protéger contre les attaques par force brute et les bots
  </Card>

  <Card title="Personnaliser l’expérience de connexion" icon="paintbrush" href="/fr-CA/docs/customize/universal-login-pages" iconType="solid">
    Personnalisez la page Universal Login pour qu’elle reflète votre image de marque
  </Card>
</CardGroup>