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

> Découvrez comment configurer l’authentification unique (SSO) dans Auth0 avec Amazon Web Services (AWS).

# Configurer Amazon Web Services pour l’authentification unique

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>;
};

En intégrant Auth0 à AWS, vous permettrez à vos utilisateurs de se connecter à AWS à l’aide de n’importe quel <Tooltip tip="Fournisseur d’identité (IdP) : service qui stocke et gère les identités numériques." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=identity+provider">fournisseur d’identité</Tooltip> pris en charge.

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

1. Créez un fournisseur d’identité externe dans AWS.
2. Configurez le module complémentaire SAML2 Web App pour votre application Auth0.
3. Terminez la configuration du fournisseur d’identité dans AWS.
4. Créez un rôle AWS IAM.
5. Associez le rôle AWS à un utilisateur.

<div id="create-an-external-identity-provider-in-aws">
  ## Créer un fournisseur d’identité externe dans AWS
</div>

1. Configurez un fournisseur d’identité externe dans AWS à l’aide du guide AWS [Connect to your External Identity Provider](https://docs.aws.amazon.com/singlesignon/latest/userguide/manage-your-identity-source-idp.html), en apportant une seule modification.

   1. Au lieu de télécharger le fichier de métadonnées AWS, cliquez sur **Show Individual Metadata Values**.
   2. Copiez les valeurs **URL de l’émetteur AWS SSO** et **URL ACS AWS SSO**. Vous les utiliserez dans la section suivante.
2. Laissez cette page ouverte dans votre navigateur, car vous devrez terminer la configuration dans une section ultérieure.

<div id="configure-saml-sso-for-auth0">
  ## Configurer SAML SSO pour Auth0
</div>

Configurez l’add-on SAML2 Web App pour votre application à l’aide du <Tooltip tip="Auth0 Dashboard : le principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip>. Pour savoir comment faire, consultez [Configurer Auth0 comme fournisseur d’identité pour Amazon Web Services](/docs/fr-ca/authenticate/single-sign-on/outbound-single-sign-on/configure-auth0-saml-identity-provider/configure-saml2-web-app-addon-for-aws).

<div id="complete-aws-identity-provider-configuration">
  ## Terminez la configuration du fournisseur d’identité AWS
</div>

1. Retournez à la page du fournisseur d’identité AWS SSO déjà ouverte dans votre navigateur.
2. Téléversez le fichier de métadonnées que vous avez téléchargé et enregistré dans la section précédente.
3. Vérifiez et **confirmez** que vous modifiez la source d’identité.

<div id="create-aws-iam-role">
  ## Créer un rôle AWS IAM
</div>

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 des accès**, accédez à [**Rôles**](https://console.aws.amazon.com/iam/home#/roles). Cliquez sur **Créer un rôle**.
2. À la page suivante, vous devrez sélectionner le type d’entité de confiance. Sélectionnez **Fédération SAML 2.0**.
3. Lorsque vous y êtes invité, définissez le fournisseur créé ci-dessus comme **fournisseur SAML**. Sélectionnez **Autoriser l’accès programmatique et l’accès à AWS Management Console**. Cliquez sur **Suivant** pour continuer.
4. À la page **Joindre des politiques d’autorisation**, sélectionnez les politiques appropriées à joindre au rôle. Elles définissent les permissions dont disposeront les utilisateurs auxquels ce rôle est attribué dans AWS. Par exemple, pour accorder à vos utilisateurs un accès en lecture seule à IAM, filtrez et sélectionnez la politique `IAMReadOnlyAccess`. Une fois terminé, cliquez sur **Étape suivante**.
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 prévoyez en créer un grand nombre.
6. À la page **Révision**, définissez le **Nom du rôle** et passez vos paramètres en revue. Fournissez des valeurs pour les paramètres suivants :

   | Champ                   | Description                           |
   | ----------------------- | ------------------------------------- |
   | **Nom du rôle**         | Nom descriptif de votre rôle.         |
   | **Description du rôle** | Description de l’usage de votre rôle. |
7. Passez en revue les renseignements sur les **Entités de confiance** et les **Politiques**, puis cliquez sur **Créer un rôle**.

<div id="map-aws-role-to-a-user">
  ## Mapper un rôle AWS à un utilisateur
</div>

<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é, consultez 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 **politique IAM** qui régit le type d’accès autorisé à une ressource, y compris aux consoles AWS. Pour en savoir plus sur les rôles et les politiques, consultez [Creating IAM Roles](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html).

1. Pour mapper un rôle AWS à 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-dessus, `user.awsRole` identifie le rôle AWS et l’IdP. L’identifiant du rôle AWS se trouve avant la virgule, et celui de l’IdP après la virgule.

   1. Votre règle peut obtenir ces deux valeurs de plusieurs façons. Vous pouvez les récupérer dans la console IAM en sélectionnant, dans le menu latéral de gauche, les éléments que vous avez créés dans AWS aux étapes précédentes. Le fournisseur d’identité et le rôle que vous avez créés ont tous deux un ARN que vous pouvez copier en les sélectionnant dans la console.
   2. Dans l’exemple ci-dessus, ces deux valeurs sont codées en dur dans la règle. Vous pouvez aussi les stocker dans le profil utilisateur ou les déduire à l’aide d’autres attributs. Par exemple, si vous utilisez Active Directory, vous pouvez mapper des propriétés associées aux utilisateurs, comme `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',
      };
      ```

<div id="map-multiple-roles">
  ### Mapper plusieurs rôles
</div>

Vous pouvez aussi attribuer un tableau au mappage des rôles (vous auriez donc `awsRoles = [ role1, role2 ]` au lieu de `awsRoles: role1`)

Par exemple, supposons que vous ayez des 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 pour chaque utilisateur 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);

}
```

<div id="configure-session-expiration">
  ## Configurer l’expiration de la session
</div>

Pour prolonger le délai 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; // délai avant l’expiration, en secondes

  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" />

<div id="test-configuration">
  ## Tester la configuration
</div>

1. Accédez à [Dashboard > Applications > Applications](https://manage.auth0.com/#/applications) et cliquez sur le nom de votre application.
2. Dans l’onglet **Addons**, sélectionnez l’add-on **SAML2 Web App**.
3. Dans l’onglet **Usage**, repérez l’**Identity Provider Login URL**. Vous devriez être redirigé vers la page de connexion à votre compte Auth0. Si la connexion réussit, vous serez redirigé vers AWS.

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

* [Configurer Amazon Web Services comme 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)