Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utiliser le plugin TIP pour accéder Services AWS
<a name="access-tip"></a>

 La propagation d'identité sécurisée (TIP) est une fonctionnalité AWS IAM Identity Center qui permet aux administrateurs d' Services AWS accorder des autorisations en fonction d'attributs utilisateur tels que les associations de groupes. Avec la propagation d'identité sécurisée, un contexte d'identité est ajouté à un rôle IAM pour identifier l'utilisateur qui demande l'accès aux AWS ressources. Ce contexte est propagé à d'autres Services AWS. 

 Le contexte d'identité comprend les informations Services AWS utilisées pour prendre des décisions d'autorisation lorsqu'ils reçoivent des demandes d'accès. Ces informations incluent des métadonnées qui identifient le demandeur (par exemple, un utilisateur IAM Identity Center), la personne Service AWS à laquelle l'accès est demandé (par exemple, Amazon Redshift) et l'étendue de l'accès (par exemple, accès en lecture seule). La réception Service AWS utilise ce contexte et toutes les autorisations attribuées à l'utilisateur pour autoriser l'accès à ses ressources. Pour plus d'informations, consultez la présentation de la propagation d'identité [ sécurisée ](https://docs.aws.amazon.com/singlesignon/latest/userguide/trustedidentitypropagation-overview.html) dans le Guide de AWS IAM Identity Center l'utilisateur. 

 Le plugin TIP peut être utilisé avec un Services AWS support de propagation d'identité fiable. À titre de cas d'utilisation de référence, consultez [ la section Configuration d'une application Amazon Q Business AWS IAM Identity Center](https://docs.aws.amazon.com/amazonq/latest/qbusiness-ug/create-application.html) à l'aide du guide de l'utilisateur * Amazon Q Business*. 

**Note**  
 Si vous utilisez Amazon Q Business, consultez [ Configuration d'une application Amazon Q Business à l'aide d'Amazon Q Business AWS IAM Identity Center](https://docs.aws.amazon.com/amazonq/latest/qbusiness-ug/create-application.html) pour obtenir des instructions spécifiques au service. 

## Prérequis pour utiliser le plugin TIP
<a name="prereq-tip"></a>

Les ressources suivantes sont requises pour que le plugin fonctionne : 

1. Vous devez utiliser soit le, AWS SDK pour Java soit le AWS SDK pour JavaScript. 

1. Vérifiez que le service que vous utilisez prend en charge la propagation d'identité sécurisée.

   Consultez la ** colonne ** Active la propagation sécurisée des identités via IAM Identity Center du [ tableau des applications ](https://docs.aws.amazon.com/singlesignon/latest/userguide/awsapps-that-work-with-identity-center.html)AWS gérées qui s'intègrent à IAM Identity Center du Guide de l'*AWS IAM Identity Center utilisateur. * 

1. Activez IAM Identity Center et la propagation fiable des identités.

   Consultez les conditions préalables et les considérations relatives [ au ](https://docs.aws.amazon.com/singlesignon/latest/userguide/trustedidentitypropagation-overall-prerequisites.html) TIP dans le Guide * de *AWS IAM Identity Center l'utilisateur. 

1. Vous devez présenter une Identity-Center-integrated demande. 

   Consultez les applications [AWS gérées ](https://docs.aws.amazon.com/singlesignon/latest/userguide/awsapps-quick-start-setting-up-identity-center-to-test-awsmanagedapps.html) ou les applications gérées par le [ client ](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-trusted-identity-propagation-set-up-your-own-app-OAuth2.html) dans le Guide de *AWS IAM Identity Center l'utilisateur*. 

1. Vous devez configurer un émetteur de jetons de confiance (TTI) et connecter votre service à IAM Identity Center. 

   Consultez [ les sections Conditions requises pour les émetteurs de jetons de confiance ](https://docs.aws.amazon.com/singlesignon/latest/userguide/using-apps-with-trusted-token-issuer.html#trusted-token-issuer-prerequisites) et [ Tâches relatives à la configuration d'un émetteur de jetons de confiance ](https://docs.aws.amazon.com/singlesignon/latest/userguide/setuptrustedtokenissuer.html#setuptrustedtokenissuer-tasks) dans le Guide de l'*AWS IAM Identity Center utilisateur. *

## Pour utiliser le plugin TIP dans votre code
<a name="using-tip"></a>

1. Créez une instance du plug-in Trusted Identity Propagation.

1. Créez une instance de client de service pour interagir avec votre client de service Service AWS et personnalisez-le en ajoutant le plug-in Trusted Identity Propagation. 

Le plugin TIP prend les paramètres d'entrée suivants :
+ **`webTokenProvider`**: fonction que le client met en œuvre pour obtenir un jeton OpenID auprès de son fournisseur d'identité externe. 
+ **`accessRoleArn`**: L'ARN du rôle IAM à assumer par le plugin avec le contexte d'identité de l'utilisateur pour obtenir les informations d'identification améliorées. 
+ **`applicationArn`**: chaîne d'identification unique du client ou de l'application. Cette valeur est un ARN d'application pour lequel les autorisations OAuth sont configurées. 
+ **`ssoOidcClient`**: (Facultatif) Un client OIDC SSO, par exemple [`SsoOidcClient`](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/ssooidc/SsoOidcClient.html) pour Java ou [`client-sso-oidc`](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sso-oidc/) pour JavaScript, avec des configurations définies par le client. S’il n’est pas fourni, un client OIDC utilisant `applicationRoleArn` sera instancié et utilisé. 
+  **`stsClient`**: (Facultatif) Un AWS STS client avec des configurations définies par le client, utilisé pour tenir compte du `accessRoleArn` contexte d'identité de l'utilisateur. S'il n'est pas fourni, un AWS STS client utilisant `applicationRoleArn` sera instancié et utilisé. 
+ **`applicationRoleArn`**: (Facultatif) L'ARN du rôle IAM à utiliser pour que l'OIDC et les AWS STS clients puissent être démarrés. `AssumeRoleWithWebIdentity`
  + S'ils ne sont pas fournis, ** ** les `stsClient` paramètres `ssoOidcClient` et doivent être fournis à la fois.
  + Si elle est fournie, la valeur ne `applicationRoleArn` peut pas être la même que celle du `accessRoleArn` paramètre. `applicationRoleArn`est utilisé pour créer le StsClient, qui est utilisé pour assumer AccessRole. Si le même rôle est utilisé pour les deux `applicationRole` et`accessRole`, cela signifierait utiliser un rôle pour s'assumer (hypothèse du rôle personnel), ce qui est déconseillé par. AWS Consultez l'[annonce ](https://aws.amazon.com/blogs/security/announcing-an-update-to-iam-role-trust-policy-behavior/) pour plus de détails.

### Considérations relatives au `SSO OidcClient`, à `STSClient et aux paramètres d'`application `RoleArn`
<a name="considerations-tip"></a>

Lors de la configuration du plug-in TIP, tenez compte des exigences d'autorisation suivantes en fonction des paramètres que vous fournissez :
+ Si vous fournissez `ssoOidcClient` et `stsClient` :
  + Les informations d'identification sur le `ssoOidcClient` doivent être `oauth:CreateTokenWithIAM` autorisées à appeler le centre d'identité afin d'obtenir le contexte utilisateur spécifique au centre d'identité.
  + Les informations d'identification `stsClient` doivent être activées et `sts:AssumeRole` les `sts:SetContext` autorisations doivent être activées`accessRole`. `accessRole`doit également être configuré avec une relation de confiance avec les informations d'identification activées`stsClient`.
+ Si vous fournissez `applicationRoleArn` :
  + `applicationRole`doit disposer des `oauth:CreateTokenWithIAM` `sts:SetContext` autorisations `sts:AssumeRole` et des autorisations requises sur les ressources requises (instance iDC`accessRole`) car elles seront utilisées pour créer des clients OIDC et STS.
  + `applicationRole`doit avoir une relation de confiance avec le fournisseur d'identité utilisé pour générer le`webToken`, car il `webToken` sera utilisé pour assumer le ApplicationRole via l'[AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)appel du plugin.

**Exemple ApplicationRole de configuration : **

Politique de confiance avec le fournisseur de jetons 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"
                }
            }
        }
    ]
}
```

Politique d'autorisation :

```
{
    "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": [
                "*"
            ]
        }
    ]
}
```

## Exemples de code utilisant TIP
<a name="tip-code-example"></a>

Les exemples ci-dessous montrent comment implémenter le plugin TIP dans votre code à l'aide du AWS SDK pour Java ou du AWS SDK pour JavaScript.

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

Pour utiliser le plugin TIP dans votre AWS SDK pour Java projet, vous devez le déclarer en tant que dépendance dans le `pom.xml` fichier de votre projet. 

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

Dans votre code source, incluez la déclaration de package requise pour`software.amazon.awssdk.trustedidentitypropagation`. 

Les exemples suivants montrent deux manières de créer une instance du plug-in Trusted Identity Propagation et de l'ajouter à un client de service. Les deux exemples utilisent Amazon S3 comme service et permettent de gérer les autorisations spécifiques `S3AccessGrantsPlugin` aux utilisateurs, mais peuvent être appliqués à tous ceux Service AWS qui prennent en charge la propagation d'identité sécurisée (TIP). 

**Note**  
Pour ces exemples, vous devez configurer les autorisations spécifiques à l'utilisateur à partir de S3 Access Grants. Reportez-vous à la documentation [ S3 Access Grants ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-grants.html) pour plus de détails.

**Option 1 : créer et transmettre des clients OIDC et 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());
```

**Option 2 : transmettre l'application RoleArn et reporter la création du client au 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());
```

Pour plus de détails et la source, voir [https://github.com/aws-sdk-plugin/trusted-identity-propagation-java](https://github.com/aws-sdk-plugin/trusted-identity-propagation-java) trusted-identity-propagation-java sur. GitHub

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

Exécutez la commande suivante pour installer le module d'extension d'authentification TIP dans votre AWS SDK pour JavaScript projet : 

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

La version finale `package.json` doit inclure une dépendance similaire à la suivante : 

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

 Dans votre code source, importez la `TrustedIdentityPropagationExtension` dépendance requise. 

 Les exemples suivants montrent deux manières de créer une instance du plug-in Trusted Identity Propagation et de l'ajouter à un client de service. Les deux exemples utilisent Amazon S3 comme service et utilisent Amazon S3 Access Grants pour gérer les autorisations spécifiques aux utilisateurs, mais peuvent être appliqués à tout Service AWS ce qui prend en charge la propagation d'identité sécurisée (TIP). 

**Note**  
Pour ces exemples, vous devez configurer les autorisations spécifiques à l'utilisateur à partir d'Amazon S3 Access Grants. Consultez la documentation [ Amazon S3 Access Grants ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-grants.html) pour plus de détails.

**Option 1 : créer et transmettre des clients OIDC et 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);
}
```

**Option 2 : transmettre l'application RoleArn et reporter la création du client au plugin **

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

Pour plus de détails et la source, consultez [https://github.com/aws-sdk-plugin/trusted-identity-propagation-js](https://github.com/aws-sdk-plugin/trusted-identity-propagation-js) trusted-identity-propagation-js sur. GitHub

------