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

# Configurer les Services Web Amazon pour l’authentification unique (SSO)

> Apprenez comment configurer l’authentification unique (SSO) pour Auth0 avec les Services Web Amazon (AWS).

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 <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

En intégrant Auth0 à AWS, vous permettrez à vos utilisateurs de se connecter à AWS en utilisant le fournisseur d’identité.

Pour configurer AWS pour <Tooltip href="/docs/fr-ca/glossary?term=single-sign-on" tip="Authentification unique (SSO)
Service qui, après qu’un utilisateur se soit connecté à une application, le connecte automatiquement à d’autres applications." cta="Voir le glossaire">SSO</Tooltip>, vous devez compléter les étapes suivantes :

1. Créez un fournisseur d’identité externe dans AWS.
2. Configurez le Module complémentaire d’application Web SAML2 pour votre application Auth0.
3. Complétez la configuration du fournisseur d’identité AWS.
4. Créez un rôle IAM AWS.
5. Mappez le rôle AWS pour un utilisateur.

## Créez un fournisseur d’identité externe dans AWS

1. Réglez un fournisseur d’identité externe dans AWS en utilisant le guide [Connectez-vous à votre fournisseur d’identité externe](https://docs.aws.amazon.com/singlesignon/latest/userguide/manage-your-identity-source-idp.html) AWS avec un changement.

   1. Plutôt que de téléverser le fichier de métadonnées AWS, cliquez sur **Afficher les valeurs de métadonnées individuelles**.
   2. Copiez les valeurs de l’**URL de l’émetteur de SSO AWS** et de l’**URL ACS de SSO AWS**. Vous utiliserez ces dernières dans la prochaine section.
2. Laissez cette page ouverte dans votre navigateur, car vous devrez terminer la configuration dans une section à venir.

## Configurer SAML SSO pour Auth0

Configurez le Module complémentaire d’application Web SAML2 pour votre application à l’aide d’<Tooltip href="/docs/fr-ca/glossary?term=auth0-dashboard" tip="Auth0 Dashboard
Principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire">Auth0 Dashboard</Tooltip>. Pour apprendre comment, consultez [Configurer Auth0 comme fournisseur d’identité pour les services Web Amazon (AWS)](/docs/fr-ca/authenticate/single-sign-on/outbound-single-sign-on/configure-auth0-saml-identity-provider/configure-saml2-web-app-addon-for-aws).

## Compléter la configuration du fournisseur d’identité AWS

1. Retournez à la page de fournisseurs d’identité SSO AWS ouverte dans votre navigateur.
2. Téléchargez le fichier de métadonnées téléversé et sauvegardé dans la section précédente.
3. Révisez et **confirmez** le changement de source d’identité.

## Créer un rôle IAM AWS

Pour utiliser le fournisseur, vous devez créer un rôle IAM en utilisant le fournisseur dans la politique de confiance du rôle.

1. Dans la barre latérale, sous **Gestion de l’accès**, naviguez vers [**Rôles**](https://console.aws.amazon.com/iam/home#/roles). Cliquez sur **Créer un rôle**.
2. À la page suivante, il vous sera demandé de sélectionner le type d’identité de confiance. Sélectionnez **SAML 2.0 Federation**.
3. Lorsqu’invité, réglez le fournisseur créé ci-haut en tant que **fournisseur SAML**. Sélectionnez **Autoriser l’accès programmatique et l’accès à la console de gestion AWS**. Cliquez sur **Suivant** pour continuer.
4. Sur la page **Joindre les politiques d’autorisations**, sélectionnez les autorisations appropriées à joindre au rôle. Ces dernières définissent les autorisations que les utilisateurs ayant ce rôle auront avec AWS. Par exemple, pour donner à vos utilisateurs un accès en lecture seule au IAM, filtrez et sélectionnez l’autorisation `IAMReadOnlyAccess`. Une fois terminé, cliquez sur **Prochaine étape**.
5. Le troisième écran **Créer un rôle** est **Ajouter des balises**. Vous pouvez utiliser des balises pour organiser les rôles que vous créez si vous en prévoyez un grand nombre.
6. Sur la page **Révision**, indiquez le **Nom du rôle** et révisez vos paramètres. Fournissez les valeurs des paramètres suivants :

   \| Field (Champ) | Description |
   \| --- | --- |
   \| **Role name (Nom du rôle)** | Nom descriptif de votre rôle. |
   \| **Role description ( Description du rôle)** | Description de la fonction pour laquelle votre rôle est utilisé. |
7. Révisez l’information des **Entités de confiance** et des **Autorisations**, puis cliquez sur **Créer un rôle**.

## Mapper un rôle AWS pour un utilisateur

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Pour voir un exemple de définition d’une règle côté serveur qui attribue un rôle dans un cas d’utilisation avancé, voir le [tutoriel Amazon API Gateway](/docs/fr-ca/customize/integrations/aws/aws-api-gateway-delegation/aws-api-gateway-delegation-5).
</Callout>

Les **rôles AWS** indiqués seront associés à une **autorisation IAM** qui applique le type d’accès autorisé pour une ressource, y compris les consoles AWS. Pour en savoir plus sur les rôles et les autorisations, consultez [Création de rôles IAM](http://docs.aws.amazon.com/IAM/latest/UserGuide/roles-creatingrole.html).

1. Pour mapper un rôle AWS pour un utilisateur, créez une [règle](/docs/fr-ca/customize/rules) :

   ```javascript lines theme={null}
   function (user, context, callback) {

     user.awsRole = 'arn:aws:iam::951887872838:role/TestSAML,arn:aws:iam::951887872838:saml-provider/MyAuth0';
     user.awsRoleSession = user.name;

     context.samlConfiguration.mappings = {
       'https://aws.amazon.com/SAML/Attributes/Role': 'awsRole',
       'https://aws.amazon.com/SAML/Attributes/RoleSessionName': 'awsRoleSession'
     };

     callback(null, user, context);

   }
   ```

   Dans l’extrait de code ci-haut, `user.awsRole` identifiez le rôle AWS et l’IdP. L’identifiant de rôle AWS se trouve devant la virgule, et l’identifiant IdP se trouve après la virgule.

   1. Votre règle peut obtenir ces deux valeurs de plusieurs façons. Vous pouvez obtenir ces valeurs à partir de la console IAM en sélectionnant les éléments créés dans AWS lors des étapes précédentes dans la barre latérale gauche. Le fournisseur d’identité et le rôle que vous avez créé ont tous deux un ARN qui peut être copié si vous les sélectionnez dans la console.
   2. Dans l’exemple ci-dessus, ces deux valeurs sont codées en dur dans la règle. Vous pouvez également stocker ces valeurs dans le profil utilisateur ou les obtenir à l’aide d’autres attributs. Par exemple, si vous utilisez Active Directory, vous pouvez mapper les propriétés associées aux utilisateurs, telles que le `group`, au rôle AWS approprié :

      ```text lines theme={null}
      var awsRoles = {
        'DomainUser': 'arn:aws:iam::951887872838:role/TestSAML,arn:aws:iam::95123456838:saml-provider/MyAuth0',
        'DomainAdmins': 'arn:aws:iam::957483571234:role/SysAdmins,arn:aws:iam::95123456838:saml-provider/MyAuth0'
      };
      user.awsRole = awsRoles[user.group];
      user.awsRoleSession = user.email;

      context.samlConfiguration.mappings = {
        'https://aws.amazon.com/SAML/Attributes/Role': 'awsRole',
        'https://aws.amazon.com/SAML/Attributes/RoleSessionName': 'awsRoleSession',
      };
      ```

### Mapper plusieurs rôles

Vous pouvez également attribuer un tableau au mappage de rôles (vous auriez donc  `awsRoles = [ role1, role2 ]` plutôt que `awsRoles: role1`)

Par exemple, disons que vous disposez de groupes Active Directory avec la structure suivante :

```javascript lines theme={null}
var user = {
  app_metadata: {
    ad_groups: {
      "admins": "some info not aws related",
      "aws_dev_Admin": "arn:aws:iam::123456789111:role/Admin,arn:aws:iam::123456789111:saml-provider / Auth0",
      "aws_prod_ReadOnly": "arn:aws:iam::123456789999:role/ReadOnly,arn:aws:iam::123456789999:saml-provider / Auth0"
    }
  }
};
```

Votre règle pourrait donc ressembler à ceci :

```javascript lines theme={null}
function (user, context, callback) {

  var userGroups = user.app_metadata.ad_groups;

  function awsFilter(group) {
    return group.startsWith('aws_');
  }

  function mapGroupToRole(awsGroup) {
    return userGroups[awsGroup];
  }

  user.awsRole = Object.keys(userGroups).filter(awsFilter).map(mapGroupToRole);
  user.awsRoleSession = 'myawsuser'; // unique per user http://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html

  context.samlConfiguration.mappings = {
    'https://aws.amazon.com/SAML/Attributes/Role': 'awsRole',
    'https://aws.amazon.com/SAML/Attributes/RoleSessionName': 'awsRoleSession'
  };

  callback(null, user, context);

}
```

## Configurer l’expiration de la session

Pour prolonger le délai autorisé avant l’expiration de la session AWS (3 600 secondes), utilisez une [règle](/docs/fr-ca/customize/rules) personnalisée. Votre règle définit l’[attribut **SessionDuration**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml_assertions.html) qui modifie la durée de la session.

export const codeExample = `function (user, context, callback) {
    if(context.clientID !== '{yourClientId}'){
      return callback(null, user, context);
    }

  user.awsRole = '{yourArn}';
  user.awsRoleSession = '{yourRoleSession}';
  user.time = 1000; // time until expiration in seconds

  context.samlConfiguration.mappings = {
    'https://aws.amazon.com/SAML/Attributes/Role': '{yourAwsRoleName}',
    'https://aws.amazon.com/SAML/Attributes/RoleSessionName': '{yourAwsRoleSessionName}',
    'https://aws.amazon.com/SAML/Attributes/SessionDuration': 'time'   };

  callback(null, user, context);
}`;

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

## Tester la configuration

1. Rendez-vous à [Dashboard > Applications > Applications](https://manage.auth0.com/#/applications), et cliquez sur le nom de votre application.
2. Sous l’onglet **Modules complémentaires**, sélectionnez le module complémentaire **SAML2 Web App**.
3. Sous l’onglet **Utilisation**, localisez l’**URL de connexion du fournisseur d’identité**. Vous devriez être redirigé vers la page de connexion du compte Auth0. Si la connexion réussit, vous serez redirigé vers AWS.

## En savoir plus

* [Configurer Amazon Web Services en tant que fournisseur de services SAML](/docs/fr-ca/authenticate/single-sign-on/outbound-single-sign-on/configure-auth0-saml-identity-provider/configure-saml2-web-app-addon-for-aws)