Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Uso del complemento TIP para acceder Servicios de AWS
<a name="access-tip"></a>

 La propagación confiable de identidades (TIP) es una función AWS IAM Identity Center que permite Servicios de AWS a los administradores conceder permisos en función de los atributos de los usuarios, como las asociaciones de grupos. Con la propagación de identidades confiable, el contexto de identidad se agrega a una función de IAM para identificar al usuario que solicita el acceso a AWS los recursos. Este contexto se propaga a otros Servicios de AWS. 

 El contexto de identidad comprende la información que se Servicios de AWS utiliza para tomar decisiones de autorización cuando reciben solicitudes de acceso. Esta información incluye los metadatos que identifican al solicitante (por ejemplo, un usuario del centro de identidad de IAM), Servicio de AWS a quién se solicita el acceso (por ejemplo, Amazon Redshift) y el alcance del acceso (por ejemplo, el acceso de solo lectura). El receptor Servicio de AWS usa este contexto y cualquier permiso asignado al usuario para autorizar el acceso a sus recursos. Para obtener más información, consulte la descripción general sobre la propagación de identidades [ confiables ](https://docs.aws.amazon.com/singlesignon/latest/userguide/trustedidentitypropagation-overview.html) de la Guía del AWS IAM Identity Center usuario. 

 El complemento TIP se puede usar para respaldar la propagación de identidades confiable. Servicios de AWS Como caso de uso de referencia, consulte [Configuración de una aplicación de Amazon Q Business mediante AWS IAM Identity Center](https://docs.aws.amazon.com/amazonq/latest/qbusiness-ug/create-application.html) en la *Guía del usuario de Amazon Q Business*. 

**nota**  
 Si utilizas Amazon Q Business, consulta [Configuración de una aplicación de Amazon Q Business mediante AWS IAM Identity Center](https://docs.aws.amazon.com/amazonq/latest/qbusiness-ug/create-application.html) para obtener las instrucciones específicas del servicio. 

## Requisitos previos para utilizar el complemento de TIP
<a name="prereq-tip"></a>

Los recursos siguientes son necesarios para que el complemento funcione: 

1. Debe utilizar el AWS SDK para Java o el AWS SDK para JavaScript. 

1. Compruebe que el servicio que está utilizando es compatible con la propagación de identidades de confianza.

   Consulte la columna **Permite la propagación de identidades de confianza a través del IAM Identity Center** de la tabla de [aplicaciones administradas de AWS que se integran con el IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/awsapps-that-work-with-identity-center.html) de la *Guía del usuario de AWS IAM Identity Center *. 

1. Puede habilitar IAM Identity Center y utilizarlo únicamente para la propagación de identidades de confianza.

   Consulte los [requisitos previos y las consideraciones de la TIP](https://docs.aws.amazon.com/singlesignon/latest/userguide/trustedidentitypropagation-overall-prerequisites.html) en la *Guía del usuario de AWS IAM Identity Center *. 

1. Debe tener una Identity-Center-integrated solicitud. 

   Consulte [las aplicaciones administradas de AWS](https://docs.aws.amazon.com/singlesignon/latest/userguide/awsapps-quick-start-setting-up-identity-center-to-test-awsmanagedapps.html) o las [aplicaciones administradas por el cliente](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-trusted-identity-propagation-set-up-your-own-app-OAuth2.html) en la *Guía del usuario de AWS IAM Identity Center *. 

1. Debe configurar un emisor de token de confianza (TTI) y conectar su servicio al IAM Identity Center. 

   Consulte los [requisitos previos para emisores de tokens de confianza](https://docs.aws.amazon.com/singlesignon/latest/userguide/using-apps-with-trusted-token-issuer.html#trusted-token-issuer-prerequisites) y las [tareas para configurar un emisor de token de confianza](https://docs.aws.amazon.com/singlesignon/latest/userguide/setuptrustedtokenissuer.html#setuptrustedtokenissuer-tasks) en la *Guía del usuario de AWS IAM Identity Center *.

## Para usar el complemento de TIP en su código
<a name="using-tip"></a>

1. Cree una instancia del complemento de propagación de identidades de confianza.

1. Crea una instancia de cliente de servicio para interactuar con tu cliente de servicio Servicio de AWS y personalízalo añadiendo el complemento confiable de propagación de identidades. 

El complemento de TIP usa los siguientes parámetros:
+ **`webTokenProvider`**: una función que el cliente implementa para obtener un token OpenID de su proveedor de identidad externo. 
+ **`accessRoleArn`**: el ARN del rol de IAM que debe asumir el complemento con el contexto de identidad del usuario para obtener las credenciales de identidad mejorada. 
+ **`applicationArn`**: la cadena del identificador único del cliente o de la aplicación. Este valor es un ARN de aplicación que tiene configuradas las concesiones de OAuth. 
+ **`ssoOidcClient`**: (Opcional) Un cliente OIDC de SSO, como [`SsoOidcClient`](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/ssooidc/SsoOidcClient.html) para Java o para JavaScript, con configuraciones definidas [`client-sso-oidc`](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sso-oidc/) por el cliente. Si no se proporciona, se creará una instancia y se utilizará un cliente OIDC que utilice `applicationRoleArn`. 
+  **`stsClient`**: (opcional) Un cliente de AWS STS con configuraciones definidas por el cliente, que se utiliza para asumir `accessRoleArn` con el contexto de identidad del usuario. Si no se proporciona, se creará una instancia y se utilizará un AWS STS cliente que `applicationRoleArn` lo utilice. 
+ **`applicationRoleArn`**: (Opcional) El ARN del rol de IAM que se asumirá para `AssumeRoleWithWebIdentity` poder arrancar el OIDC y los clientes. AWS STS 
  + Si no se proporciona, se deben proporcionar **ambos** parámetros `ssoOidcClient` y `stsClient`.
  + Si se proporciona, `applicationRoleArn` no puede tener el mismo valor que el parámetro `accessRoleArn`. `applicationRoleArn` se utiliza para crear el stsClient, que se utiliza para asumir accessRole. Si se usa el mismo rol para ambos `applicationRole` y`accessRole`, significaría usar un rol para asumirse a sí mismo (asunción del rol propio), lo cual no se recomienda. AWS Consulte el [anuncio](https://aws.amazon.com/blogs/security/announcing-an-update-to-iam-role-trust-policy-behavior/) para obtener más detalles.

### Consideraciones sobre el `sso OidcClient`, `` STSClient y los parámetros de la aplicación `RoleArn`
<a name="considerations-tip"></a>

Al configurar el complemento de TIP, tenga en cuenta los siguientes requisitos de permiso en función de los parámetros que proporcione:
+ Si proporciona `ssoOidcClient` y `stsClient`:
  + Las credenciales en `ssoOidcClient` deben tener permiso `oauth:CreateTokenWithIAM` para llamar al centro de identidad y obtener el contexto de usuario específico del centro de identidad.
  + Las credenciales en `stsClient` deben contar con `sts:AssumeRole` y permisos `sts:SetContext` en `accessRole`. `accessRole` también debe configurarse con una relación de confianza con las credenciales activadas en `stsClient`.
+ Si proporciona `applicationRoleArn`:
  + `applicationRole` debe tener los permisos `oauth:CreateTokenWithIAM`, `sts:AssumeRole` y `sts:SetContext` necesarios en los recursos requeridos (instancia deIdC, `accessRole`), ya que se utilizará para crear clientes OIDC y STS.
  + `applicationRole`debe tener una relación de confianza con el proveedor de identidad que se utiliza para generar el`webToken`, ya que se `webToken` utilizará para asumir el ApplicationRole mediante la [ AssumeRoleWithWebIdentity ](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) llamada del complemento.

**Ejemplo de ApplicationRole configuración: **

Política de confianza con el proveedor de tokens web:

```
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Federated": "arn:aws:iam::{{111122223333}}:oidc-provider/IDENTITY_PROVIDER_URL"
            },
            "Action": "sts:AssumeRoleWithWebIdentity",
            "Condition": {
                "StringEquals": {
                    "IDENTITY_PROVIDER_URL:aud": "CLIENT_ID_TO_BE_TRUSTED"
                }
            }
        }
    ]
}
```

Política de permisos:

```
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "sts:AssumeRole",
                "sts:SetContext"
            ],
            "Resource": [
                "arn:aws:iam::{{111122223333}}:role/{{accessRole}}"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "sso-oauth:CreateTokenWithIAM"
            ],
            "Resource": [
                "*"
            ]
        }
    ]
}
```

## Ejemplos de código que utilizan TIP
<a name="tip-code-example"></a>

Los siguientes ejemplos muestran cómo implementar el complemento TIP en su código mediante el AWS SDK para Java o el AWS SDK para JavaScript.

------
#### [ Java ]

Para usar el complemento TIP en tu AWS SDK para Java proyecto, debes declararlo como una dependencia en el `pom.xml` archivo de tu proyecto. 

```
<dependency>
<groupId>software.amazon.awsidentity.trustedIdentityPropagation</groupId>
<artifactId>aws-sdk-java-trustedIdentityPropagation-java-plugin</artifactId>
   <version>2.0.0</version>
</dependency>
```

En su código fuente, incluya la declaración de paquete requerida para `software.amazon.awssdk.trustedidentitypropagation`. 

Los siguientes ejemplos muestran dos formas de crear una instancia del complemento de propagación de identidades de confianza y agregarla a un cliente de servicio. Ambos ejemplos utilizan Amazon S3 como servicio y se utilizan `S3AccessGrantsPlugin` para administrar los permisos específicos de los usuarios, pero se pueden aplicar a cualquier otro Servicio de AWS que admita la propagación de identidades confiables (TIP). 

**nota**  
Para estos ejemplos, debe configurar los permisos específicos de usuario de S3 Access Grants. Consulte la [documentación de concesiones de acceso de S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-grants.html) para obtener más información.

**Opción 1: Cree y transfiera clientes OIDC y STS**

```
SsoOidcClient oidcClient = SsoOidcClient.builder()
    .region(Region.US_EAST_1)
    .credentialsProvider(credentialsProvider).build();

StsClient stsClient = StsClient.builder()
    .region(Region.US_EAST_1)
    .credentialsProvider(credentialsProvider).build();

TrustedIdentityPropagationPlugin trustedIdentityPropagationPlugin = TrustedIdentityPropagationPlugin.builder()
        .webTokenProvider(() -> webToken)
        .applicationArn(idcApplicationArn)
        .accessRoleArn(accessRoleArn)
        .ssoOidcClient(oidcClient)
        .stsClient(stsClient)
        .build();

S3AccessGrantsPlugin accessGrantsPlugin = S3AccessGrantsPlugin.builder()
        .build();

S3Client s3Client =
        S3Client.builder().region(Region.US_EAST_1)
                .crossRegionAccessEnabled(true)
                .addPlugin(trustedIdentityPropagationPlugin)
                .addPlugin(accessGrantsPlugin)
                .build();

final var resp = s3Client.getObject(GetObjectRequest.builder()
        .key("path/to/object/fileName")
        .bucket("bucketName")
        .build());
```

**Opción 2: pasar la solicitud RoleArn y aplazar la creación de clientes al plugin **

```
TrustedIdentityPropagationPlugin trustedIdentityPropagationPlugin = TrustedIdentityPropagationPlugin.builder()
        .webTokenProvider(() -> webToken)
        .applicationArn(idcApplicationArn)
        .accessRoleArn(accessRoleArn)
        .applicationRoleArn(applicationRoleArn)
        .build();

S3AccessGrantsPlugin accessGrantsPlugin = S3AccessGrantsPlugin.builder()
        .build();

S3Client s3Client =
        S3Client.builder().region(Region.US_EAST_1)
                .crossRegionAccessEnabled(true)
                .addPlugin(trustedIdentityPropagationPlugin)
                .addPlugin(accessGrantsPlugin)
                .build();

final var resp = s3Client.getObject(GetObjectRequest.builder()
        .key("path/to/object/fileName")
        .bucket("bucketName")
        .build());
```

Para obtener información y fuentes adicionales, consulta [https://github.com/aws-sdk-plugin/trusted-identity-propagation-java](https://github.com/aws-sdk-plugin/trusted-identity-propagation-java) trusted-identity-propagation-java en. GitHub

------
#### [ JavaScript ]

Ejecuta el siguiente comando para instalar el paquete del plugin de autenticación TIP en tu proyecto: AWS SDK para JavaScript 

```
$  npm i @aws-sdk-extension/trusted-identity-propagation
```

El `package.json` final debería incluir una dependencia similar a la siguiente: 

```
  "dependencies": {
"@aws-sdk-extension/trusted-identity-propagation": "^2.0.0"
  },
```

 En su código fuente, importe la dependencia de `TrustedIdentityPropagationExtension` requerida. 

 Los siguientes ejemplos muestran dos formas de crear una instancia del complemento de propagación de identidades de confianza y agregarla a un cliente de servicio. En ambos ejemplos se usa Amazon S3 como servicio y se utilizan las concesiones de acceso de Amazon S3 para administrar los permisos específicos de los usuarios, pero se pueden aplicar a cualquiera Servicio de AWS que admita la propagación de identidades confiables (TIP). 

**nota**  
Para estos ejemplos, debe configurar los permisos específicos de usuario de concesiones de acceso a Amazon S3; consulte la [documentación de concesiones de acceso a Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-grants.html) para obtener más información.

**Opción 1: Cree y transfiera clientes OIDC y STS**

```
import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
import { S3ControlClient, GetDataAccessCommand } from "@aws-sdk/client-s3-control";
import { TrustedIdentityPropagationExtension } from "@aws-sdk-extension/trusted-identity-propagation";

const s3ControlClient = new S3ControlClient({
    region: "us-east-1",
    extensions: [
        TrustedIdentityPropagationExtension.create({
            webTokenProvider: async () => {
                return 'ID_TOKEN_FROM_YOUR_IDENTITY_PROVIDER';
            },
            ssoOidcClient: customOidcClient,
            stsClient: customStsClient,
            accessRoleArn: accessRoleArn,
            applicationArn: applicationArn,
        }),
    ],
});

const getDataAccessParams = {
  Target: "S3_URI_PATH",
  Permission: "READ",
  AccountId: ACCOUNT_ID,
  InstanceArn: S3_ACCESS_GRANTS_ARN,
  TargetType: "Object",
};

try {
  const command = new GetDataAccessCommand(getDataAccessParams);
  const response = await s3ControlClient.send(command);

  const credentials = response.Credentials;

  // Create a new S3 client with the temporary credentials
  const temporaryS3Client = new S3Client({
    region: "us-east-1",
    credentials: {
      accessKeyId: credentials.AccessKeyId,
      secretAccessKey: credentials.SecretAccessKey,
      sessionToken: credentials.SessionToken,
    },
  });

  // Use the temporary S3 client to perform the operation
  const s3Params = {
    Bucket: "BUCKET_NAME",
    Key: "S3_OBJECT_KEY",
  };
  const getObjectCommand = new GetObjectCommand(s3Params);
  const s3Object = await temporaryS3Client.send(getObjectCommand);

  const fileContent = await s3Object.Body.transformToString();

  // Process the S3 object data
  console.log("Successfully retrieved S3 object:", fileContent);
} catch (error) {
  console.error("Error accessing S3 data:", error);
}
```

**Opción 2: pasar la solicitud RoleArn y aplazar la creación de clientes al complemento **

```
import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
import { S3ControlClient, GetDataAccessCommand } from "@aws-sdk/client-s3-control";
import { TrustedIdentityPropagationExtension } from "@aws-sdk-extension/trusted-identity-propagation";

const s3ControlClient = new S3ControlClient({
    region: "us-east-1",
    extensions: [
        TrustedIdentityPropagationExtension.create({
            webTokenProvider: async () => {
                return 'ID_TOKEN_FROM_YOUR_IDENTITY_PROVIDER';
            },
            accessRoleArn: accessRoleArn,
            applicationRoleArn: applicationRoleArn,
            applicationArn: applicationArn,
        }),
    ],
});

// Same S3 AccessGrants workflow as Option 1
const getDataAccessParams = {
  Target: "S3_URI_PATH",
  Permission: "READ",
  AccountId: ACCOUNT_ID,
  InstanceArn: S3_ACCESS_GRANTS_ARN,
  TargetType: "Object",
};

try {
  const command = new GetDataAccessCommand(getDataAccessParams);
  const response = await s3ControlClient.send(command);

  const credentials = response.Credentials;

  const temporaryS3Client = new S3Client({
    region: "us-east-1",
    credentials: {
      accessKeyId: credentials.AccessKeyId,
      secretAccessKey: credentials.SecretAccessKey,
      sessionToken: credentials.SessionToken,
    },
  });

  const s3Params = {
    Bucket: "BUCKET_NAME",
    Key: "S3_OBJECT_KEY",
  };
  const getObjectCommand = new GetObjectCommand(s3Params);
  const s3Object = await temporaryS3Client.send(getObjectCommand);

  const fileContent = await s3Object.Body.transformToString();

  console.log("Successfully retrieved S3 object:", fileContent);
} catch (error) {
  console.error("Error accessing S3 data:", error);
}
```

Para obtener información y fuentes adicionales, consulta [https://github.com/aws-sdk-plugin/trusted-identity-propagation-js](https://github.com/aws-sdk-plugin/trusted-identity-propagation-js) trusted-identity-propagation-js en. GitHub

------