Criação de um modelo de perfil confiável

Considere o uso de modelos de perfis confiáveis quando os usuários precisarem acessar muitas contas-filhas ou se um grupo de usuários precisar de acesso temporário a várias contas-filhas.

Para criar um modelo de perfil confiável, siga estas etapas:

1. Vá para Gerenciar > Acesso (IAM) > Modelos e selecione Perfis confiáveis no console IBM Cloud.

2. Clique em Criar.

3. Digite um nome e uma descrição para o modelo de perfil confiável que descreva sua finalidade para os usuários corporativos.

4. Insira um nome, e-mail e descrição para o perfil confiável gerenciado pela empresa que descreva sua finalidade para usuários de contas secundárias e certifique-se de incluir uma lista de ações disponíveis para esse perfil confiável na descrição.

   No e-mail, você pode adicionar um endereço de e-mail pessoal ou uma lista de distribuição.

   Você pode usar variáveis de substituição no nome do perfil para personalizá-lo para cada conta. São suportadas as seguintes variáveis:

   • ${template_id}: Será substituído por um identificador exclusivo para o modelo de perfil confiável.
   • ${template_name}: Será substituído pelo nome atual do modelo de perfil confiável.
   • ${template_version}: Será substituído pela versão atual do modelo de perfil confiável.
   • ${account_id}: Será substituído pelo identificador da conta à qual o modelo de perfil confiável está atribuído.
   • ${account_name}: Será substituído pelo nome da conta à qual o modelo de perfil confiável está atribuído.

   As alterações em valores como o nome da conta não causam a atualização do nome do perfil confiável. O nome do perfil é definido quando você atribui o modelo a uma conta ou atualiza a versão do modelo. Isso significa que, se o nome da conta for alterado posteriormente, o nome do perfil não será atualizado automaticamente. O novo nome da conta só será usado na próxima vez que você atribuir o modelo ou atualizá-lo.

5. Clique em Criar.

Atualização dos detalhes do modelo

Você pode atualizar o nome do modelo, o nome do perfil confiável e as descrições a qualquer momento antes de confirmar o modelo. Para atualizar os detalhes do modelo, siga estas etapas:

1. Vá para Gerenciar > Acesso (IAM) > Modelos.
2. Selecione o modelo de perfil confiável que você deseja atualizar.
3. Clique no ícone Editar na seção Detalhes.
4. Faça as atualizações necessárias no nome do modelo, no nome do perfil confiável e nas descrições.
5. Clique em Salvar.

Se você precisar fazer atualizações depois de confirmar o modelo, crie uma nova versão.

Revisando seu modelo de perfil de confiança

Revise e confirme o modelo de perfil confiável para que nenhuma outra alteração possa ser feita na versão. Dessa forma, o administrador de atribuição de modelos pode ter certeza de que atribuirá a versão somente quando você confirmar que ela está pronta.

1. Clique em Overview > Review.
2. Verifique se o modelo de perfil confiável está configurado de acordo com suas expectativas.
3. Clique na caixa de seleção para confirmar que você não pode fazer alterações na versão.
4. Clique em Confirmar.

Atribuição de um modelo de perfil confiável a contas secundárias

Atribua o modelo de perfil confiável a contas secundárias em sua empresa.

Você pode atribuir um modelo de IAM apenas a contas e grupos de contas secundárias, não à conta corporativa.

1. Clique em Assign accounts (Atribuir contas ).

2. Selecione as contas e os grupos de contas aos quais você deseja atribuir o modelo.

   Em cada uma das contas secundárias às quais você atribui o modelo, você cria um perfil confiável gerenciado pela empresa. Os usuários da conta secundária podem determinar que um perfil confiável é proveniente de um modelo de IAM gerenciado pela empresa por meio da tag{: tag-cyan} [gerenciada] pela empresa no perfil.

3. Clique em Designar.

Se uma atribuição falhar, clique em Retry (Tentar novamente ).

Criação de uma nova versão

Se você quiser fazer alterações em um modelo de perfil confiável que tenha sido confirmado ou atribuído, crie uma nova versão. Você pode criar uma nova versão com base em sua versão mais recente ou em uma versão diferente que você selecionar.

Para criar uma nova versão de um modelo de perfil confiável, siga estas etapas:

1. Acesse Gerenciar > Acesso (IAM) > Modelos no console do IBM Cloud.

2. Escolha o modelo de perfil em que você confia.

3. Clique no ícone Nova versão Ícone .

4. Selecione a versão que você deseja usar como base para sua nova versão.

5. Insira um novo nome e descrição de modelo ou mantenha os que já estão sendo usados.

   A inserção de um novo nome de modelo atualiza o nome do modelo desta versão e de todas as versões anteriores. A descrição do modelo é armazenada separadamente para cada versão.

6. Insira um novo nome e descrição de perfil confiável ou mantenha os que já está usando.

   Ao inserir um novo nome de perfil confiável, o nome anterior exibido nas contas secundárias será substituído após a atribuição da nova versão.

7. Selecione os objetos que você deseja transferir para a nova versão.

   1. (Opcional) Selecione Relações de confiança.
   2. (Opcional) Selecione Acesso.

8. Clique em Criar.

9. Faça quaisquer outros ajustes na configuração.

10. Clique em Review e confirme a nova versão. Para obter mais informações, consulte Revisão do modelo de perfil confiável.

Para atribuir uma nova versão de um modelo de perfil confiável, conclua as etapas a seguir:

1. Acesse Gerenciar > Acesso (IAM) > Modelos no console do IBM Cloud.
2. Clique em Perfis confiáveis.
3. Clique no ícone de expansão da tabela no modelo com o qual você deseja trabalhar.
4. Selecione a versão que está atualmente atribuída às contas secundárias.
5. Clique em Assignments (Atribuições ).
6. Clique em Update (Atualizar ) na atribuição de conta ou grupo de contas à qual você deseja atribuir uma versão diferente.
7. Clique em “Selecionar uma versão ”.
   1. Selecione a versão que você deseja substituir a versão atual.
8. Clique em Atualizar.
9. Repita essas etapas para cada conta ou grupo de contas ao qual você deseja atribuir uma versão diferente.

A nova versão do modelo que você atribui substitui a versão antiga. Saiba mais sobre a atribuição de uma nova versão.

Remoção de uma atribuição

Você pode remover uma atribuição de modelo de uma ou mais contas às quais o modelo está atribuído. Talvez você queira fazer isso se o modelo não estiver funcionando como pretendido. Quando você remove uma atribuição de modelo de uma conta, por padrão, a versão anterior do modelo é restabelecida. Se a atribuição que você remover for para a primeira ou única versão de um modelo, o perfil confiável na conta secundária será removido.

Para remover uma atribuição, siga estas etapas:

1. Acesse Gerenciar > Acesso (IAM) > Modelos no console do IBM Cloud.
2. Clique em Perfis confiáveis e selecione seu modelo de perfil confiável.
3. Clique em Atualizar atribuições.
   1. Para remover uma atribuição de uma ou algumas contas, desmarque as contas em que você deseja remover a atribuição de modelo.
   2. Para remover uma atribuição de todas as contas às quais o modelo está atribuído, clique em Unassign all (Desatribuir tudo ).

Criação de um modelo de perfil confiável usando a CLI

Considere o uso de modelos de perfis confiáveis quando você tiver muitas contas secundárias que exijam o mesmo perfil confiável. Por exemplo, sua organização pode ter padrões internos ou exigir conformidade com as normas do setor.

Para criar um modelo de perfil confiável usando a CLI, siga estas etapas:

1. Crie um arquivo JSON que configure a definição do modelo de perfil confiável. Para obter mais informações sobre os atributos que você pode usar em seu arquivo JSON, consulte a API de identidade do IAM.

   O exemplo de arquivo JSON a seguir especifica o endereço account_id da conta corporativa, o endereço name do modelo e a configuração profile. Esse perfil confiável é para administradores de bancos de dados. Um usuário específico tem permissão para aplicar o modelo conforme definido em identities. rules também é definido, o que concede acesso ao perfil com base nos atributos de 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. Crie o modelo de perfil confiável usando o comando trusted-profile-template-create, conforme mostrado na solicitação de exemplo a seguir:

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

Atualização de um modelo de perfil confiável usando a CLI

Você pode atualizar um modelo de perfil confiável a qualquer momento antes de confirmá-lo. Para atualizar uma versão específica de um modelo de perfil confiável, conclua as etapas a seguir:

1. Atualize seu arquivo JSON com a nova definição de modelo de perfil confiável. Para obter mais informações sobre os atributos que você pode usar em seu arquivo JSON, consulte a API de identidade do 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
        }
     ]
   }
   

 Quando você atualiza o nome do modelo, isso atualiza o nome de todas as versões.
 {: note}

  1. Para atualizar uma versão específica de um modelo de perfil confiável, use o comando `trusted-profile-template-version-update`, conforme mostrado no exemplo de solicitação a seguir:

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

## Confirmação de um modelo de perfil confiável usando a CLI
{: #commit-trusted-profile-template-cli cli}

Revise o modelo de perfil confiável e confirme-o para que nenhuma outra alteração possa ser feita na versão. A confirmação de uma versão é uma etapa necessária para que você possa atribuí-la a contas secundárias. Dessa forma, o administrador de atribuição de modelos pode ter certeza de que atribuirá a versão somente quando você confirmar que ela está pronta.

A solicitação de exemplo a seguir faz o commit da versão `1` do modelo de perfil confiável denominado `DBAdministrator`:

```bash {: codeblock}

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

  ## Atribuição de um modelo de perfil confiável a contas secundárias usando a CLI
  {: #assign-trusted-profile-template-cli cli}

  Atribua o modelo de perfil confiável a contas secundárias em sua empresa.

  Você pode atribuir um modelo de IAM apenas a contas e grupos de contas secundárias, não à conta corporativa.
  {: note}

  Para criar uma atribuição para um modelo de perfil confiável, conclua as etapas a seguir:
  1. Liste os modelos de perfis confiáveis em sua conta corporativa e anote o nome do modelo e o número da versão do modelo de perfil confiável que você deseja atribuir às contas secundárias:

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

1. Atribua o modelo a um `Account` ou `AccountGroup` usando o comando `account-trusted profile-assignment-create`.

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

Se uma atribuição falhar, use o método `trusted-profile-assignment-update` para tentar novamente.
{: tip}

## Criação de uma nova versão usando a CLI
{: #new-version-trusted-profile-template cli}

Se você quiser fazer alterações em um modelo de perfil confiável que tenha sido confirmado ou atribuído, crie uma nova versão.

1. Atualize seu arquivo JSON com a nova definição de modelo de perfil confiável. Para obter mais informações sobre os atributos que você pode usar em seu arquivo JSON, consulte a [API de identidade do IAM](/docs/apis/iam-identity-token-api#create-profile-template-version).
1. Use o método `trusted-profile-template-version-create` para criar uma nova versão. O exemplo de solicitação a seguir cria uma nova versão do modelo `DBAdministrator`.

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

## Atualização de uma atribuição por meio da CLI
{: #update-assignment-trusted-profile-cli cli}

Atualizar uma atribuição para migrar para uma nova versão ou tentar novamente uma atribuição com falha.

A nova versão do modelo que você atribui substitui a versão antiga. Saiba mais sobre a [atribuição de uma nova versão](/docs/enterprise-management?topic=enterprise-management-working-with-versions#new-version).
{: note}

1. Liste as atribuições de perfis confiáveis em sua conta corporativa e anote o endereço `template_id` para a atribuição que deseja atualizar:

ibmcloud iam trusted-profile-assignments

1. Atualize a atribuição do perfil confiável. Se estiver tentando novamente uma atribuição, use o mesmo número de versão. A solicitação de exemplo a seguir migra a atribuição `ProfileTemplate-cac1b203-5956-4981-bdec-0a4af4feab4d` para a versão 2.

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

## Removendo uma atribuição usando a CLI
{: #remove-assignment-trusted-profile-cli cli}

Você pode remover uma atribuição de modelo de uma conta ou grupo de contas ao qual o modelo está atribuído. Talvez você queira fazer isso se o modelo não estiver funcionando como pretendido. Quando você remove uma atribuição de modelo de uma conta, por padrão, a versão anterior do modelo é restabelecida. Se a atribuição que você remover for para a primeira ou única versão de um modelo, o perfil confiável gerenciado pela empresa na conta secundária será removido.

Para remover uma atribuição, siga estas etapas:

1. Liste as atribuições na conta usando o método `account-trusted profile-assignments`. Anote o endereço `ASSIGNMENT_ID` para a atribuição que você deseja remover.
1. Remova a atribuição usando o método `account-trusted profile-assigment-delete`. O exemplo de solicitação a seguir remove a atribuição `AccountSettingsAssignment-63d65ed159ff463b8ec09ea77d22a05b`.

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

## Excluindo uma versão usando a CLI
{: #delete-trusted-profile-template-version-cli cli}

Antes de excluir uma versão de modelo de perfil confiável, você deve remover todas as atribuições dessa versão do modelo. Exclua uma versão específica executando as etapas a seguir:

1. Liste os modelos de perfis confiáveis em sua conta corporativa e anote o nome do modelo e o número da versão que você deseja excluir:

ibmcloud iam account-trusted profile-templates

1. Excluir a versão:

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

1. Para excluir todas as versões, repita essas etapas. Certifique-se de remover primeiro as atribuições de cada versão.

## Criação de um modelo de perfil confiável usando a API
{: #create-trusted-profile-template-api api}

Considere o uso de modelos de perfis confiáveis quando você tiver muitas contas secundárias que exijam o mesmo perfil confiável. Por exemplo, sua organização pode ter padrões internos ou exigir conformidade com as normas do setor.

Para criar um modelo de perfil confiável usando a API, conclua as etapas a seguir:

1. Configure a definição do modelo de perfil confiável. Para obter mais informações sobre os atributos que você pode usar, consulte a [API de identidade do IAM](/docs/apis/iam-identity-token-api#create-profile-template).

O exemplo a seguir especifica o endereço account_id da conta corporativa, o endereço name do modelo e a configuração profile. Esse perfil confiável é para administradores de bancos de dados. Um usuário específico tem permissão para aplicar o modelo conforme definido em identities. rules também é definido, o que concede acesso ao perfil com base nos atributos de 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")
   ```
 Salve o valor de ProfileTemplate ID e entity_tag da resposta para uso em operações de atualização.
 { tip}

 ## Atualização de um modelo de perfil confiável usando a API
 {: #update-trusted-profile-template-api api}

 Você pode atualizar um modelo de perfil confiável a qualquer momento antes de confirmá-lo. Para obter mais informações sobre os atributos que você pode usar em seu arquivo JSON, consulte a [API de identidade do IAM](/docs/apis/iam-identity-token-api#update-profile-template-version). Para atualizar uma versão específica de um modelo de perfil confiável, conclua as etapas a seguir:

 1. Liste os modelos de perfil confiáveis em sua conta corporativa e anote a ID `ProfileTemplate` e o ETag na resposta da versão do modelo que você deseja atualizar.

```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. Atualize a definição do modelo de perfil confiável.

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

Quando você atualiza o nome do modelo, isso atualiza o nome de todas as versões.