Création d'un modèle de profil de confiance

Envisagez d'utiliser des modèles de profil de confiance lorsque les utilisateurs ont besoin d'accéder à de nombreux comptes enfants ou si un groupe d'utilisateurs a besoin d'un accès temporaire à plusieurs comptes enfants.

Pour créer un modèle de profil de confiance, procédez comme suit :

1. Allez dans Gérer > Accès (IAM) > Modèles, et sélectionnez Profils de confiance dans la console IBM Cloud.

2. Cliquez sur Créer.

3. Saisissez un nom et une description pour le modèle de profil de confiance qui décrivent son objectif pour les utilisateurs de l'entreprise.

4. Entrez un nom, une adresse e-mail et une description pour le profil approuvé géré par l'entreprise qui décrit son objectif pour les utilisateurs de comptes enfants, et veillez à inclure une liste des actions disponibles pour ce profil approuvé dans la description.

   Dans l'e-mail, vous pouvez ajouter soit une adresse e-mail personnelle, soit une liste de distribution.

   Vous pouvez utiliser des variables de remplacement dans le nom du profil pour le personnaliser pour chaque compte. Les variables suivantes sont prises en charge :

   • ${template_id}: Sera remplacé par un identifiant unique pour le modèle de profil de confiance.
   • ${template_name}: Sera remplacé par le nom actuel du modèle de profil de confiance.
   • ${template_version}: Sera remplacé par la version actuelle du modèle de profil de confiance.
   • ${account_id}: Sera remplacé par l'identifiant du compte auquel le modèle de profil de confiance est attribué.
   • ${account_name}: Sera remplacé par le nom du compte auquel le modèle de profil de confiance est attribué.

   Les modifications apportées à des valeurs telles que le nom du compte n'entraînent pas la mise à jour du nom du profil de confiance. Le nom du profil est défini lorsque vous affectez le modèle à un compte ou lorsque vous mettez à jour la version du modèle. Cela signifie que si le nom du compte change ultérieurement, le nom du profil ne sera pas mis à jour automatiquement. Le nouveau nom de compte ne sera utilisé que la prochaine fois que vous attribuerez le modèle ou que vous le mettrez à niveau.

5. Cliquez sur Créer.

Mise à jour des détails du modèle

Vous pouvez mettre à jour le nom du modèle, le nom du profil de confiance et les descriptions à tout moment avant de valider le modèle. Pour mettre à jour les informations relatives au modèle, procédez comme suit :

1. Accédez à « Gérer » > « Accès (IAM) » > « Modèles ».
2. Sélectionnez le modèle de profil de confiance que vous souhaitez mettre à jour.
3. Cliquez sur l'icône dans la section Détails.
4. Effectuez les mises à jour nécessaires au nom du modèle, au nom du profil de confiance et aux descriptions.
5. Cliquez sur Sauvegarder.

Si vous avez besoin d'effectuer des mises à jour après avoir validé le modèle, créez une nouvelle version.

Vérification de votre modèle de profil de confiance

Réviser et valider le modèle de profil de confiance afin qu'aucune autre modification ne puisse être apportée à la version. De cette façon, l'administrateur de l'attribution des modèles peut être sûr qu'il n'attribue la version que lorsque vous avez confirmé qu'elle est prête.

1. Cliquez sur Vue d'ensemble > Révision.
2. Vérifiez que le modèle de profil de confiance est configuré comme vous le souhaitez.
3. Cochez la case pour confirmer que vous ne pouvez pas apporter de modifications à la version.
4. Cliquez sur Valider.

Attribution d'un modèle de profil de confiance aux comptes enfants

Attribuez le modèle de profil approuvé aux comptes enfants de votre entreprise.

Vous pouvez attribuer un modèle IAM uniquement aux comptes enfants et aux groupes de comptes, et non au compte entreprise.

1. Cliquez sur Affecter des comptes.

2. Sélectionnez les comptes et les groupes de comptes auxquels vous souhaitez affecter le modèle.

   Dans chacun des comptes enfants auxquels vous attribuez le modèle, vous créez un profil de confiance géré par l'entreprise. Les utilisateurs du compte enfant peuvent déterminer qu'un profil de confiance provient d'un modèle IAM géré par l'entreprise grâce à la balise d'{: tag-cyan}, [gérée par l'entreprise], sur le profil.

3. Cliquez sur Affecter.

Si une affectation échoue, cliquez sur Réessayer.

Création d'une nouvelle version

Si vous souhaitez modifier un modèle de profil approuvé, engagé ou attribué, créez une nouvelle version. Vous pouvez créer une nouvelle version basée sur votre dernière version, ou une version différente que vous sélectionnez.

Pour créer une nouvelle version d'un modèle de profil de confiance, procédez comme suit :

1. Accédez à « Gérer > Accès (IAM) > Modèles » dans la console IBM Cloud.

2. Choisissez le modèle de profil qui vous convient le mieux.

3. Cliquez sur l'icône Nouvelle version .

4. Sélectionnez la version que vous souhaitez utiliser comme base pour votre nouvelle version.

5. Saisissez un nouveau nom et une nouvelle description pour le modèle ou conservez ceux que vous utilisez déjà.

   La saisie d'un nouveau nom de modèle met à jour le nom du modèle pour cette version et toutes les versions précédentes. La description du modèle est stockée séparément pour chaque version.

6. Saisissez un nouveau nom et une nouvelle description de profil de confiance ou conservez ceux que vous utilisez déjà.

   La saisie d'un nouveau nom de profil de confiance remplace l'ancien nom de profil de confiance qui s'affiche dans les comptes enfants une fois que vous avez attribué la nouvelle version.

7. Sélectionnez les objets que vous souhaitez transférer vers votre nouvelle version.

   1. (Facultatif) Sélectionnez Relations de confiance.
   2. (Facultatif) Sélectionnez Accéder.

8. Cliquez sur Créer.

9. Effectuez les autres modifications nécessaires à la configuration.

10. Cliquez sur Réviser et validez la nouvelle version. Pour plus d'informations, consultez la rubrique Révision de votre modèle de profil de confiance.

Pour attribuer une nouvelle version d'un modèle de profil approuvé, procédez comme suit :

1. Accédez à « Gérer > Accès (IAM) > Modèles » dans la console IBM Cloud.
2. Cliquez sur Profils de confiance.
3. Cliquez sur l'icône Développer le tableau sur le modèle avec lequel vous souhaitez travailler.
4. Sélectionnez la version actuellement attribuée aux comptes enfants.
5. Cliquez sur Affectations.
6. Cliquez sur Mettre à jour dans l'affectation de compte ou de groupe de comptes à laquelle vous souhaitez affecter une version différente.
7. Cliquez sur « Sélectionner une version ».
   1. Sélectionnez la version que vous souhaitez remplacer par la version actuelle.
8. Cliquez sur Mettre à jour.
9. Répétez ces étapes pour chaque compte ou groupe de comptes auquel vous souhaitez attribuer une version différente.

La nouvelle version du modèle que vous attribuez remplace l'ancienne version. En savoir plus sur l'attribution d'une nouvelle version.

Supprimer une affectation

Vous pouvez supprimer l'affectation d'un modèle à un ou plusieurs comptes auxquels le modèle est affecté. Vous pouvez le faire si le modèle ne fonctionne pas comme prévu. Lorsque vous supprimez l'affectation d'un modèle à un compte, la version précédente du modèle est rétablie par défaut. Si la cession que vous supprimez concerne la première ou la seule version d'un modèle, le profil de confiance du compte enfant est supprimé.

Pour supprimer une affectation, procédez comme suit :

1. Accédez à « Gérer > Accès (IAM) > Modèles » dans la console IBM Cloud.
2. Cliquez sur Profils de confiance et sélectionnez votre modèle de profil de confiance.
3. Cliquez sur Mettre à jour les affectations.
   1. Pour supprimer une affectation d'un ou de plusieurs comptes, désélectionnez les comptes pour lesquels vous souhaitez supprimer l'affectation du modèle.
   2. Pour supprimer une affectation de tous les comptes auxquels le modèle est affecté, cliquez sur Annuler toutes les affectations.

Création d'un modèle de profil de confiance à l'aide de l'interface de ligne de commande

Envisagez d'utiliser des modèles de profil de confiance lorsque vous avez de nombreux comptes enfants qui nécessitent le même profil de confiance. Par exemple, votre organisation peut avoir des normes internes ou exiger le respect des réglementations sectorielles.

Pour créer un modèle de profil de confiance à l'aide de l'interface de ligne de commande (CLI), procédez comme suit :

1. Créer un fichier JSON qui configure la définition du modèle de profil de confiance. Pour plus d'informations sur les attributs que vous pouvez utiliser dans votre fichier JSON, consultez l'API d'identité IAM.

   L'exemple de fichier JSON suivant spécifie l' account_id e du compte d'entreprise, l' name e du modèle et la configuration de l' profile. Ce profil de confiance est destiné aux administrateurs de bases de données. Un utilisateur spécifique est autorisé à appliquer le modèle tel qu'il est défini à l'adresse identities. L'adresse rules est également définie, ce qui permet d'accéder au profil sur la base des attributs de l'adresse SAML.

      {
      "account_id": "5bbe28be34524sdbdaa34d37d1f2294a",
      "name": "dbadmintemplate",
      "profile": {
         "name": "Profile for DB Admins",
         "description": "allows users to admin db instances",
         "identities": [
               {
                  "type": "user",
                  "identifier": "IBMid-123456789",
                  "accounts": [
                     "5bbe28be34524sdbdaa34d37d1f2294a"
                  ]
               }
         ],
         "rules": [
               {
                  "type": "Profile",
                  "realm_name": "${IDP_REALM_NAME}",
                  "expiration": 43200,
                  "conditions": [
                     {
                           "claim": "group",
                           "operator": "EQUALS",
                           "value": "\"admins\""
                     }
                  ]
               }
         ]
      },
      "policy_template_references": [
         {
               "id": "Policy Template-12345",
               "version": 1
         }
      ]
   }
   

2. Créez le modèle de profil de confiance en utilisant la commande trusted-profile-template-create comme indiqué dans l'exemple de requête suivant :

   ibmcloud iam trustedprofile-template-create dbadmintemplate --file /path/to/db_trusted-profile_template.json
   

Mise à jour d'un modèle de profil de confiance à l'aide de l'interface de ligne de commande

Vous pouvez mettre à jour un modèle de profil approuvé à tout moment avant de l'enregistrer. Pour mettre à jour une version spécifique d'un modèle de profil de confiance, procédez comme suit :

1. Mettez à jour votre fichier JSON avec la nouvelle définition de modèle de profil de confiance. Pour plus d'informations sur les attributs que vous pouvez utiliser dans votre fichier JSON, consultez l'API d'identité IAM.

     {
     "account_id": "5bbe28be34524sdbdaa34d37d1f2294a",
     "name": "DBAdministrator",
     "profile": {
        "name": "Profile for DB Admins",
        "description": "allows users to admin db instances",
        "identities": [
              {
                 "type": "user",
                 "identifier": "IBMid-123456789",
                 "accounts": [
                    "5bbe28be34524sdbdaa34d37d1f2294a"
                 ]
              }
        ],
        "rules": [
              {
                 "type": "Profile",
                 "realm_name": "${IDP_REALM_NAME}",
                 "expiration": 43200,
                 "conditions": [
                    {
                          "claim": "group",
                          "operator": "EQUALS",
                          "value": "\"admins\""
                    }
                 ]
              }
        ]
     },
     "policy_template_references": [
        {
              "id": "Policy Template-12345",
              "version": 1
        }
     ]
   }
   

 Lorsque vous mettez à jour le nom du modèle, le nom de chaque version est également mis à jour.
 {: note}

  1. Pour mettre à jour une version spécifique d'un modèle de profil de confiance, utilisez la commande `trusted-profile-template-version-update` comme indiqué dans l'exemple de requête suivant :

 ```bash {: codeblock}
 ibmcloud iam trustedpprofile-template-version-update DBAdministrator 1 --file /path/to/db_trusted-profile_template.json

## Validation d'un modèle de profil de confiance à l'aide de l'interface de ligne de commande
{: #commit-trusted-profile-template-cli cli}

Passez en revue le modèle de profil de confiance et validez-le afin qu'aucune modification ne puisse être apportée à la version. L'engagement d'une version est une étape nécessaire avant de pouvoir l'attribuer à des comptes enfants. De cette façon, l'administrateur de l'attribution des modèles peut être sûr qu'il n'attribue la version que lorsque vous avez confirmé qu'elle est prête.

L'exemple de requête suivant engage la version `1` du modèle de profil de confiance nommé `DBAdministrator`:

```bash {: codeblock}

ibmcloud iam trusted-profile-template-version-commit DBAdministrator 1

  ## Attribution d'un modèle de profil de confiance aux comptes enfants à l'aide de l'interface de ligne de commande
  {: #assign-trusted-profile-template-cli cli}

  Attribuez le modèle de profil approuvé aux comptes enfants de votre entreprise.

  Vous pouvez attribuer un modèle IAM uniquement aux comptes enfants et aux groupes de comptes, et non au compte entreprise.
  {: note}

  Pour créer une affectation pour un modèle de profil de confiance, procédez comme suit :
  1. Listez les modèles de profil de confiance dans votre compte d'entreprise et notez le nom du modèle et le numéro de version du modèle de profil de confiance que vous souhaitez attribuer aux comptes enfants :

 ```bash {: codeblock}
 ibmcloud iam trusted-profile-templates

1. Assignez le modèle à un `Account` ou `AccountGroup` en utilisant la commande `account-trusted profile-assignment-create`.

ibmcloud iam trusted-profile-assignment-create DBAdministrator 1 AccountGroup 955fc2274567474f8da802d5c376504b

Si une affectation échoue, utilisez la méthode `trusted-profile-assignment-update` pour réessayer.
{: tip}

## Création d'une nouvelle version à l'aide de l'interface de ligne de commande (CLI)
{: #new-version-trusted-profile-template cli}

Si vous souhaitez modifier un modèle de profil approuvé, engagé ou attribué, créez une nouvelle version.

1. Mettez à jour votre fichier JSON avec la nouvelle définition de modèle de profil de confiance. Pour plus d'informations sur les attributs que vous pouvez utiliser dans votre fichier JSON, consultez [l'API d'identité IAM](/docs/apis/iam-identity-token-api#create-profile-template-version).
1. Utilisez la méthode « `trusted-profile-template-version-create` » pour créer une nouvelle version. L'exemple de requête suivant crée une nouvelle version du modèle `DBAdministrator`.

ibmcloud iam trusted-profile-template-version-create DBAdministrator --file /path/to/db_trusted-profile_template.json

## Mise à jour d'une affectation à l'aide de l'interface de ligne de commande (CLI)
{: #update-assignment-trusted-profile-cli cli}

Mettre à jour une affectation pour migrer vers une nouvelle version ou réessayer une affectation ayant échoué.

La nouvelle version du modèle que vous attribuez remplace l'ancienne version. En savoir plus sur [l'attribution d'une nouvelle version](/docs/enterprise-management?topic=enterprise-management-working-with-versions#new-version).
{: note}

1. Listez les affectations de profils de confiance dans votre compte d'entreprise et notez l' `template_id` s pour l'affectation que vous souhaitez mettre à jour :

ibmcloud iam trusted-profile-assignments

1. Mettez à jour l'affectation du profil de confiance. Si vous réessayez une affectation, utilisez le même numéro de version. L'exemple de requête suivant migre l'affectation `ProfileTemplate-cac1b203-5956-4981-bdec-0a4af4feab4d` vers la version 2.

ibmcloud iam trusted-profile-assignment-update ProfileTemplate-cac1b203-5956-4981-bdec-0a4af4feab4d 2

## Supprimer une affectation à l'aide de l'interface de ligne de commande (CLI)
{: #remove-assignment-trusted-profile-cli cli}

Vous pouvez supprimer l'affectation d'un modèle d'un compte ou d'un groupe de comptes auquel le modèle est affecté. Vous pouvez le faire si le modèle ne fonctionne pas comme prévu. Lorsque vous supprimez l'affectation d'un modèle à un compte, la version précédente du modèle est rétablie par défaut. Si la cession que vous supprimez concerne la première ou la seule version d'un modèle, le profil de confiance géré par l'entreprise dans le compte enfant est supprimé.

Pour supprimer une affectation, procédez comme suit :

1. Listez les affectations dans le compte en utilisant la méthode de l' `account-trusted profile-assignments`. Prenez note de l' `ASSIGNMENT_ID` e de la cession que vous souhaitez supprimer.
1. Supprimez l'affectation en utilisant la méthode `account-trusted profile-assigment-delete`. L'exemple de requête suivant supprime l'affectation `AccountSettingsAssignment-63d65ed159ff463b8ec09ea77d22a05b`.

ibmcloud iam account-trusted profile-assignment-delete AccountSettingsAssignment-63d65ed159ff463b8ec09ea77d22a05b

## Suppression d'une version à l'aide de l'interface de ligne de commande (CLI)
{: #delete-trusted-profile-template-version-cli cli}

Avant de pouvoir supprimer une version de modèle de profil de confiance, vous devez supprimer toutes les affectations de cette version du modèle. Supprimer une version spécifique en suivant les étapes suivantes :

1. Listez les modèles de profil de confiance dans votre compte d'entreprise et notez le nom du modèle et le numéro de version de la version que vous souhaitez supprimer :

ibmcloud iam account-trusted profile-templates

1. Supprimer la version :

ibmcloud iam account-trusted profile-template-delete AccountSettingsTemplateUpdated 2

1. Pour supprimer toutes les versions, répétez ces étapes. Assurez-vous d'abord de supprimer les affectations pour chaque version.

## Création d'un modèle de profil de confiance à l'aide de l'API
{: #create-trusted-profile-template-api api}

Envisagez d'utiliser des modèles de profil de confiance lorsque vous avez de nombreux comptes enfants qui nécessitent le même profil de confiance. Par exemple, votre organisation peut avoir des normes internes ou exiger le respect des réglementations sectorielles.

Pour créer un modèle de profil de confiance à l'aide de l'API, procédez comme suit :

1. Configurer la définition du modèle de profil de confiance. Pour plus d'informations sur les attributs que vous pouvez utiliser, consultez [l'API d'identité IAM](/docs/apis/iam-identity-token-api#create-profile-template).

L'exemple suivant spécifie l' account_id e du compte entreprise, l' name e du modèle et la configuration de l' profile. Ce profil de confiance est destiné aux administrateurs de bases de données. Un utilisateur spécifique est autorisé à appliquer le modèle tel qu'il est défini à l'adresse identities. L'adresse rules est également définie, ce qui permet d'accéder au profil sur la base des attributs de l'adresse SAML.

   {
   "account_id": "5bbe28be34524sdbdaa34d37d1f2294a",
   "name": "dbadmintemplate",
   "profile": {
      "name": "Profile for DB Admins",
      "description": "allows users to admin db instances",
      "identities": [
            {
               "type": "user",
               "identifier": "IBMid-123456789",
               "accounts": [
                  "5bbe28be34524sdbdaa34d37d1f2294a"
               ]
            }
      ],
      "rules": [
            {
               "type": "Profile",
               "realm_name": "${IDP_REALM_NAME}",
               "expiration": 43200,
               "conditions": [
                  {
                        "claim": "group",
                        "operator": "EQUALS",
                        "value": "\"admins\""
                  }
               ]
            }
      ]
   },
   "policy_template_references": [
      {
            "id": "Policy Template-12345",
            "version": 1
      }
   ]
}

   ProfileClaimRuleConditions condition = new ProfileClaimRuleConditions.Builder()
      .claim("blueGroups")
      .operator("EQUALS")
      .value("\"cloud-docs-dev\"")
      .build();
   List<ProfileClaimRuleConditions> conditions = new ArrayList<>();
   conditions.add(condition);
   TrustedProfileTemplateClaimRule claimRule = new TrustedProfileTemplateClaimRule.Builder()
      .name("My Rule")
      .realmName(realmName)
      .type(claimRuleType)
      .expiration(43200)
      .conditions(conditions)
      .build();
   TemplateProfileComponentRequest profile = new TemplateProfileComponentRequest.Builder()
      .addRules(claimRule)
      .name(profileTemplateProfileName)
      .description("Trusted profile created from a template")
      .build();
   CreateProfileTemplateOptions createProfileTemplateOptions = new CreateProfileTemplateOptions.Builder()
      .name(profileTemplateName)
      .description("IAM enterprise trusted profile template example")
      .accountId(enterpriseAccountId)
      .profile(profile)
      .build();
   Response<TrustedProfileTemplateResponse> response = service.createProfileTemplate(createProfileTemplateOptions).execute();
   TrustedProfileTemplateResponse trustedProfileTemplateResult = response.getResult();
   // Save the id for use by other test methods.
   profileTemplateId = trustedProfileTemplateResult.getId();
   profileTemplateVersion = trustedProfileTemplateResult.getVersion().longValue();
   System.out.println(trustedProfileTemplateResult);
   ```
   ```javascript {: javascript codeblock}
   const condition = {
   claim: "blueGroups",
   operator: "EQUALS",
   value: "\"cloud-docs-dev\"",
   }
   const claimRule = {
      name: "My Rule",
      realm_name: realmName,
      type: 'Profile-SAML',
      expiration: 43200,
      conditions: [condition],
   }
   const profile = {
   rules: [claimRule],
   name: "Profile-From-Example-Template",
   description: "Trusted profile created from a template",
   }
   const templateParams = {
   name: "Example-Profile-Template",
   description: "IAM enterprise trusted profile template example",
   accountId: enterpriseAccountId,
   profile: profile,
   }
   try {
   const res = await iamIdentityService.createProfileTemplate(templateParams);
   profileTemplateEtag = res.headers.etag;
   const { result } = res;
   profileTemplateId = result.id;
   profileTemplateVersion = result.version;
   console.log(JSON.stringify(result, null, 2));
   } catch (err) {
   console.warn(err);
   }
   ```
   ```python {: python codeblock}
   profile_claim_rule_conditions = {}
   profile_claim_rule_conditions['claim'] = 'blueGroups'
   profile_claim_rule_conditions['operator'] = 'EQUALS'
   profile_claim_rule_conditions['value'] = '\"cloud-docs-dev\"'
   profile_claim_rule = {}
   profile_claim_rule['name'] = 'My Rule'
   profile_claim_rule['realm_name'] = 'https://sdk.test.realm/1234'
   profile_claim_rule['type'] = 'Profile-SAML'
   profile_claim_rule['expiration'] = 43200
   profile_claim_rule['conditions'] = [profile_claim_rule_conditions]
   profile = {}
   profile['name'] = 'Profile-From-Example-Template'
   profile['description'] = 'Trusted profile created from a template'
   profile['rules'] = [profile_claim_rule]
   create_response = iam_identity_service.create_profile_template(
   name='Example-Profile-Template',
   description='IAM enterprise trusted profile template example',
   account_id=enterprise_account_id,
   profile=profile,
   )
   profile_template = create_response.get_result()
   print('\ncreate_profile_template() response: ', json.dumps(profile_template, indent=2))
   global profile_template_id
   profile_template_id = profile_template['id']
   global profile_template_version
   profile_template_version = profile_template['version']
   ```
   ```go {: go codeblock}
   profileClaimRuleConditions := new(iamidentityv1.ProfileClaimRuleConditions)
   profileClaimRuleConditions.Claim = core.StringPtr("blueGroups")
   profileClaimRuleConditions.Operator = core.StringPtr("EQUALS")
   profileClaimRuleConditions.Value = core.StringPtr("\"cloud-docs-dev\"")
   profileTemplateClaimRule := new(iamidentityv1.TrustedProfileTemplateClaimRule)
   profileTemplateClaimRule.Name = core.StringPtr("My Rule")
   profileTemplateClaimRule.RealmName = &realmName
   profileTemplateClaimRule.Type = &claimRuleType
   profileTemplateClaimRule.Expiration = core.Int64Ptr(int64(43200))
   profileTemplateClaimRule.Conditions = []iamidentityv1.ProfileClaimRuleConditions{*profileClaimRuleConditions}
   profile := new(iamidentityv1.TemplateProfileComponentRequest)
   profile.Name = &profileTemplateProfileName
   profile.Description = core.StringPtr("Example Profile created from Profile Template")
   profile.Rules = []iamidentityv1.TrustedProfileTemplateClaimRule{*profileTemplateClaimRule}
   createOptions := &iamidentityv1.CreateProfileTemplateOptions{
   Name:        &profileTemplateName,
   Description: core.StringPtr("Example Profile Template"),
   AccountID:   &enterpriseAccountID,
   Profile:     profile,
   }
   createResponse, response, err := iamIdentityService.CreateProfileTemplate(createOptions)
   b, _ := json.MarshalIndent(createResponse, "", "  ")
   fmt.Println(string(b))
   // Grab the ID and Etag value from the response for use in the update operation
   profileTemplateId = *createResponse.ID
   profileTemplateVersion = *createResponse.Version
   profileTemplateEtag = response.GetHeaders().Get("Etag")
   ```
 Enregistrez l'identifiant ProfileTemplate et la valeur entity_tag de la réponse pour les utiliser dans les opérations de mise à jour.
 { tip}

 ## Mise à jour d'un modèle de profil de confiance à l'aide de l'API
 {: #update-trusted-profile-template-api api}

 Vous pouvez mettre à jour un modèle de profil approuvé à tout moment avant de l'enregistrer. Pour plus d'informations sur les attributs que vous pouvez utiliser dans votre fichier JSON, consultez [l'API d'identité IAM](/docs/apis/iam-identity-token-api#update-profile-template-version). Pour mettre à jour une version spécifique d'un modèle de profil de confiance, procédez comme suit :

 1. Listez les modèles de profil de confiance dans votre compte d'entreprise et notez l'ID d' `ProfileTemplate` s et l'ETag dans la réponse pour la version du modèle que vous souhaitez mettre à jour.

```bash {: curl codeblock}
curl -X GET 'https://iam.cloud.ibm.com/v1/profile_templates?account_id=5bbe28be34524sdbdaa34d37d1f2294a' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN'

ListProfileTemplatesOptions listOptions = new ListProfileTemplatesOptions.Builder()
   .accountId(enterpriseAccountId)
   .build();
Response<TrustedProfileTemplateList> response = service.listProfileTemplates(listOptions).execute();
TrustedProfileTemplateList listResult = response.getResult();
System.out.println(listResult);

const params = {
accountId: enterpriseAccountId,
}
try {
const res = await iamIdentityService.listProfileTemplates(params);
console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
console.warn(err);
}

list_response = iam_identity_service.list_profile_templates(account_id=enterprise_account_id)
profile_template_list = list_response.get_result()
print('\nlist_profile_templates response: ', json.dumps(profile_template_list, indent=2))

listOptions := &iamidentityv1.ListProfileTemplatesOptions{
AccountID: &enterpriseAccountID,
}
listResponse, response, err := iamIdentityService.ListProfileTemplates(listOptions)
b, _ := json.MarshalIndent(listResponse, "", "  ")
fmt.Println(string(b))

1. Mettre à jour la définition du modèle de profil approuvé.

```bash {: curl codeblock}

curl -X PUT 'https://iam.cloud.ibm.com/v1/profile_templates/{template_id}/versions/{version}' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN' -d '{ "account_id": "5bbe28be34524sdbdaa34d37d1f2294a", "name": "db admin template", "profile": { "name": "Profile for DB Admins", "description": "allows users to admin db instances", "rules": [ { "type": "Profile", "realm_name": "${IDP_REALM_NAME}", "expiration": 43200, "conditions": [ { "claim": "name", "operator": "EQUALS", "value": ""My Name"" } ] } ] }, "policy_template_references": [ { "id": "Policy Template-12345", "version": 1 } ] }'

 ```java {: java codeblock}
 UpdateProfileTemplateVersionOptions updateOptions = new UpdateProfileTemplateVersionOptions.Builder()
    .accountId(enterpriseAccountId)
    .templateId(profileTemplateId)
    .version(Long.toString(profileTemplateVersion))
    .ifMatch(profileTemplateEtag)
    .name(profileTemplateName)
    .description("IAM enterprise trusted profile template example - updated")
    .build();
 Response<TrustedProfileTemplateResponse> updateResponse = service.updateProfileTemplateVersion(updateOptions).execute();
 TrustedProfileTemplateResponse updateResult = updateResponse.getResult();
 // Grab the Etag value from the response for use in the update operation.
 profileTemplateEtag = updateResponse.getHeaders().values("Etag").get(0);
 System.out.println(updateResult);

const params = {
accountId: enterpriseAccountId,
templateId: profileTemplateId,
version: profileTemplateVersion,
ifMatch: profileTemplateEtag,
name: "Example-Profile-Template",
description: "IAM enterprise trusted profile template example - updated",
}
try {
const res = await iamIdentityService.updateProfileTemplateVersion(params);
profileTemplateEtag = res.headers.etag;
console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
console.warn(err);
}

{
"id": "ProfileTemplate-767fc1f6-c77c-4196-b3d6-a009a5a536e9",
"version": 1,
"account_id": "5bbe28be34524sdbdaa34d37d1f2294a",
"name": "db admin template",
"committed": false,
"profile": {
   "name": "Profile for DB Admins",
   "description": "allows users to admin db instances",
   "rules": [
      {
      "type": "Profile-SAML",
      "realm_name": "${IDP_REALM_NAME}",
      "expiration": 43200,
      "conditions": [
         {
            "claim": "name",
            "operator": "EQUALS",
            "value": "\"My Name\""
         }
      ]
      }
   ]
},
"policy_template_references": [
   {
      "id": "Policy Template-12345",
      "version": "1"
   }
],
"created_at": "2023-03-07T13:55:33:428+0000",
"created_by_id": "IBMid-12345678901",
"last_modified_at": "2023-03-07T13:55:33:428+0000",
"last_modified_by_id": "IBMid-12345678901",
"entity_tag": "1-2da85a8f1172fc3527378318d3182778",
"crn": "crn:v1:staging:public:iam-identity::a/5bbe28be34524sdbdaa34d37d1f2294a::template:ProfileTemplate-767fc1f6-c77c-4196-b3d6-a009a5a536e9"
}

{
"id": "ProfileTemplate-767fc1f6-c77c-4196-b3d6-a009a5a536e9",
"version": 1,
"account_id": "5bbe28be34524sdbdaa34d37d1f2294a",
"name": "db admin template",
"committed": false,
"profile": {
   "name": "Profile for DB Admins",
   "description": "allows users to admin db instances",
   "rules": [
      {
      "type": "Profile-SAML",
      "realm_name": "${IDP_REALM_NAME}",
      "expiration": 43200,
      "conditions": [
         {
            "claim": "name",
            "operator": "EQUALS",
            "value": "\"My Name\""
         }
      ]
      }
   ]
},
"policy_template_references": [
   {
      "id": "Policy Template-12345",
      "version": "1"
   }
],
"created_at": "2023-03-07T13:55:33:428+0000",
"created_by_id": "IBMid-12345678901",
"last_modified_at": "2023-03-07T13:55:33:428+0000",
"last_modified_by_id": "IBMid-12345678901",
"entity_tag": "1-2da85a8f1172fc3527378318d3182778",
"crn": "crn:v1:staging:public:iam-identity::a/5bbe28be34524sdbdaa34d37d1f2294a::template:ProfileTemplate-767fc1f6-c77c-4196-b3d6-a009a5a536e9"
}

Lorsque vous mettez à jour le nom du modèle, le nom de chaque version est également mis à jour.