> ## 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) pour 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) + "*****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 à 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="/fr-CA/docs/glossary?term=identity+provider">fournisseur d’identité</Tooltip> pris en charge.

Pour configurer le <Tooltip tip="authentification unique (SSO) : service qui, après qu’un utilisateur a ouvert une session dans une application, connecte automatiquement cet utilisateur à d’autres applications." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=SSO">SSO</Tooltip> dans AWS, vous devez effectuer 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. Attribuez 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 en suivant le guide AWS [Connect to your External Identity Provider](https://docs.aws.amazon.com/singlesignon/latest/userguide/manage-your-identity-source-idp.html), avec 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 **AWS SSO issuer URL** et **AWS SSO ACS URL**. 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 le SSO SAML pour Auth0
</div>

Configurez le module complémentaire SAML2 Web App pour votre application à l’aide de <Tooltip tip="Auth0 Dashboard : la console principale d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip>. Pour savoir comment procéder, consultez [Configurer Auth0 comme fournisseur d’identité pour Amazon Web Services](/fr-CA/docs/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">
  ## Finaliser la configuration du fournisseur d’identité AWS
</div>

1. Revenez à la page du fournisseur d’identité AWS SSO 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, puis **confirmez** que vous changez 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 qui utilise ce fournisseur dans la politique d’approbation du rôle.

1. Dans la barre latérale, sous **Access Management**, accédez à [**Roles**](https://console.aws.amazon.com/iam/home#/roles). Cliquez sur **Create Role**.
2. Sur la page suivante, vous devrez sélectionner le type d’entité approuvée. Sélectionnez **SAML 2.0 Federation**.
3. Lorsque vous y êtes invité, définissez le fournisseur que vous avez créé ci-dessus comme **SAML provider**. Sélectionnez **Allow programmatic and AWS Management Console access**. Cliquez sur **Next** pour continuer.
4. Sur la page **Attach Permission Policies**, sélectionnez les politiques appropriées à associer au rôle. Elles définissent les autorisations dont disposeront dans AWS les utilisateurs auxquels ce rôle est attribué. 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 **Next Step**.
5. Le troisième écran **Create Role** est **Add Tags**. 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. Sur la page **Review**, définissez le **Role Name** et passez en revue vos paramètres. Fournissez des valeurs pour les paramètres suivants :

   | Champ                | Description                           |
   | -------------------- | ------------------------------------- |
   | **Role name**        | Nom descriptif de votre rôle.         |
   | **Role description** | Description de l’utilisation du rôle. |
7. Passez en revue les renseignements **Trusted entities** et **Policies**, puis cliquez sur **Create Role**.

<div id="map-aws-role-to-a-user">
  ## Associer 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](/fr-CA/docs/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 détermine le type d’accès autorisé à une ressource, y compris les 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 associer un rôle AWS à un utilisateur, créez une [Rule](/fr-CA/docs/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 l’identifiant de l’IdP se trouve après la virgule.

   1. Votre Rule peut obtenir ces deux valeurs de plusieurs façons. Vous pouvez les récupérer à partir de la console IAM en sélectionnant, dans la barre latérale gauche, les éléments que vous avez créés dans AWS aux étapes précédentes. Le fournisseur d’identité (IdP) 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 Rule. Vous pouvez aussi les stocker dans le profil de l’utilisateur ou les dériver à partir d’autres attributs. Par exemple, si vous utilisez Active Directory, vous pouvez associer des propriétés lié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">
  ### Associer plusieurs rôles
</div>

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

Par exemple, supposons que vous avez des groupes Active Directory ayant 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 Rule pourrait donc se présenter ainsi :

```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 allonger la durée avant l’expiration de la session AWS (3 600 secondes), utilisez une [Rule](/fr-CA/docs/customize/rules) personnalisée. Cette Rule 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; // durée avant 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), puis cliquez sur le nom de votre application.
2. Dans l’onglet **Addons**, sélectionnez le module complémentaire **SAML2 Web App**.
3. Dans l’onglet **Usage**, repérez l’**URL de connexion du fournisseur d’identité**. Vous devriez être redirigé vers la page de connexion de 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](/fr-CA/docs/authenticate/single-sign-on/outbound-single-sign-on/configure-auth0-saml-identity-provider/configure-saml2-web-app-addon-for-aws)