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

> Aprenda a configurar el inicio de sesión único (SSO) de Auth0 con Amazon Web Services (AWS).

# Configurar Amazon Web Services para el inicio de sesión único

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) + "*****ENMASCARADO*****";
          }
          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>;
};

Al integrar Auth0 con AWS, permitirá que sus usuarios inicien sesión en AWS mediante cualquier <Tooltip tip="Proveedor de identidad (IdP): Servicio que almacena y gestiona identidades digitales." cta="Ver glosario" href="/es/docs/glossary?term=identity+provider">proveedor de identidad</Tooltip> compatible.

Para configurar AWS para <Tooltip tip="Inicio de sesión único (SSO): Servicio que, después de que un usuario inicia sesión en una aplicación, inicia automáticamente la sesión de ese usuario en otras aplicaciones." cta="Ver glosario" href="/es/docs/glossary?term=SSO">SSO</Tooltip>, debe completar los siguientes pasos:

1. Cree un proveedor de identidad externo en AWS.
2. Configure el complemento SAML2 Web App para su aplicación de Auth0.
3. Complete la configuración del proveedor de identidad en AWS.
4. Cree un rol de AWS IAM.
5. Asigne el rol de AWS a un usuario.

<div id="create-an-external-identity-provider-in-aws">
  ## Cree un Proveedor de identidad externo en AWS
</div>

1. Configure un Proveedor de identidad externo en AWS siguiendo la guía de AWS [Connect to your External Identity Provider](https://docs.aws.amazon.com/singlesignon/latest/userguide/manage-your-identity-source-idp.html), con un cambio.

   1. En lugar de descargar el archivo de metadatos de AWS, haga clic en **Show Individual Metadata Values**.
   2. Copie los valores de **AWS SSO issuer URL** y **AWS SSO ACS URL**. Los usará en la siguiente sección.
2. Deje esta página abierta en el navegador, ya que deberá completar la configuración en una sección posterior.

<div id="configure-saml-sso-for-auth0">
  ## Configurar SSO con SAML para Auth0
</div>

Configure el complemento SAML2 Web App para su aplicación mediante el <Tooltip tip="Auth0 Dashboard: la consola principal de Auth0 para configurar sus servicios." cta="Ver glosario" href="/es/docs/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip>. Para saber cómo hacerlo, lea [Configurar Auth0 como Proveedor de identidad para Amazon Web Services](/es/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">
  ## Complete la configuración del proveedor de identidad de AWS
</div>

1. Vuelva a la página del proveedor de identidad de AWS SSO que dejó abierta en el navegador.
2. Cargue el archivo de metadatos que descargó y guardó en la sección anterior.
3. Revise y **confirme** que está cambiando el origen de identidad.

<div id="create-aws-iam-role">
  ## Crear rol de AWS IAM
</div>

Para usar el proveedor, debe crear un rol de IAM e incluir el proveedor en la política de confianza del rol.

1. En la barra lateral, en **Access Management**, vaya a [**Roles**](https://console.aws.amazon.com/iam/home#/roles). Haga clic en **Create Role**.
2. En la página siguiente, se le pedirá que seleccione el tipo de entidad de confianza. Seleccione **SAML 2.0 Federation**.
3. Cuando se le solicite, establezca el proveedor que creó anteriormente como **SAML provider**. Seleccione **Allow programmatic and AWS Management Console access**. Haga clic en **Next** para continuar.
4. En la página **Attach Permission Policies**, seleccione las políticas adecuadas para adjuntar al rol. Estas definen los permisos que tendrán en AWS los usuarios a quienes se les asigne este rol. Por ejemplo, para conceder a sus usuarios acceso de solo lectura a IAM, filtre y seleccione la política `IAMReadOnlyAccess`. Cuando haya terminado, haga clic en **Next Step**.
5. La tercera pantalla de **Create Role** es **Add Tags**. Puede usar etiquetas para organizar los roles que cree si va a crear una cantidad considerable de ellos.
6. En la página **Review**, establezca el **Role Name** y revise la configuración. Proporcione valores para los siguientes parámetros:

   | Campo                | Descripción                  |
   | -------------------- | ---------------------------- |
   | **Role name**        | Nombre descriptivo del rol.  |
   | **Role description** | Descripción del uso del rol. |
7. Revise la información de **Trusted entities** y **Policies** y, a continuación, haga clic en **Create Role**.

<div id="map-aws-role-to-a-user">
  ## Asignar un rol de AWS a un usuario
</div>

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Para ver un ejemplo de cómo definir una Rule del servidor que asigna un rol en un caso de uso avanzado, consulte el [tutorial de Amazon API Gateway](/es/docs/customize/integrations/aws/aws-api-gateway-delegation/aws-api-gateway-delegation-5).
</Callout>

Los **roles de AWS** especificados se asociarán con una **política de IAM** que determina el tipo de acceso permitido a un recurso, incluidas las consolas de AWS. Para obtener más información sobre roles y políticas, lea [Creating IAM Roles](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html).

1. Para asignar un rol de AWS a un usuario, cree una [Rule](/es/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);

   }
   ```

   En el fragmento de código anterior, `user.awsRole` identifica el rol de AWS y el IdP. El identificador del rol de AWS va antes de la coma, y el identificador del IdP va después.

   1. La Rule puede obtener estos dos valores de varias maneras. Puede obtenerlos desde la consola de IAM seleccionando, en la barra lateral izquierda, los elementos que creó en AWS en los pasos anteriores. Tanto el Proveedor de identidad como el rol que creó tienen un ARN disponible para copiar si los selecciona en la consola.
   2. En el ejemplo anterior, ambos valores están codificados directamente en la Rule. Como alternativa, también puede almacenarlos en el perfil del usuario o derivarlos a partir de otros atributos. Por ejemplo, si usa Active Directory, puede asignar propiedades asociadas a los usuarios, como `group`, al rol de AWS correspondiente:

      ```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">
  ### Asignar varios roles
</div>

También puede asignar un array a la asignación de roles (de modo que tendría `awsRoles = [ role1, role2 ]` en lugar de `awsRoles: role1`)

Por ejemplo, supongamos que tiene grupos de Active Directory con la siguiente estructura:

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

Por lo tanto, la regla podría quedar así:

```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'; // único para cada usuario 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">
  ## Configurar la expiración de la sesión
</div>

Para ampliar el tiempo que puede transcurrir antes de que expire la sesión de AWS (3600 segundos), use una [Rule](/es/docs/customize/rules) personalizada. La Rule establece el [atributo **SessionDuration**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml_assertions.html), que modifica la duración de la sesión.

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; // tiempo hasta el vencimiento en segundos

  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">
  ## Configuración de prueba
</div>

1. Vaya a [Dashboard > Applications > Applications](https://manage.auth0.com/#/applications) y haga clic en el nombre de su aplicación.
2. En la pestaña **Addons**, seleccione el complemento **SAML2 Web App**.
3. En la pestaña **Usage**, ubique la **URL de inicio de sesión del Proveedor de identidad**. Se le redirigirá a la página de inicio de sesión de la cuenta de Auth0. Si inicia sesión correctamente, se le redirigirá a AWS.

<div id="learn-more">
  ## Más información
</div>

* [Configura Amazon Web Services como proveedor de servicios SAML](/es/docs/authenticate/single-sign-on/outbound-single-sign-on/configure-auth0-saml-identity-provider/configure-saml2-web-app-addon-for-aws)