Antes de Iniciar

Para gerenciar ou criar novos grupos de acesso, deve-se ter o tipo de acesso a seguir:

• Administrador ou editor no serviço de gerenciamento de conta do IAM Access Groups na conta
• Administrador ou editor para todos os Serviços de gerenciamento de conta
• Você deve ser o proprietário da conta

Além disso, um administrador ou editor pode ter o acesso designado para gerenciar um grupo individual, criando uma política de acesso na qual o recurso é o ID do grupo de acesso. Para obter mais informações sobre políticas de acesso e funções para o serviço de Grupos de acesso do IAM, veja Acesso do IAM.

Antes de Iniciar

Antes de configurar grupos de acesso usando o Terraform, verifique se você concluiu o seguinte:

• Instale a CLI do Terraform e configure o plug-in do provedor IBM Cloud para o Terraform. Para obter mais informações, consulte o tutorial Getting started with Terraform em IBM Cloud®. O plug-in abstrai as APIs do IBM Cloud que são usadas para concluir esta tarefa.
• Crie um arquivo de configuração do Terraform que seja denominado main.tf. Nesse arquivo, você define os recursos usando a HashiCorp Configuration Language. Para obter mais informações, consulte a documentação do Terraform.

Criando um grupo de acesso no console

É necessário um nome exclusivo para diferenciar grupos de acesso na conta. Para criar um grupo de acesso, conclua as etapas a seguir:

1. No console do IBM Cloud®, clique em Gerenciar > Acesso (IAM) e selecione Grupos de acesso.
2. Clique em Criar.
3. Insira um nome exclusivo para identificar seu grupo de acesso, uma descrição opcional e clique em Criar.

Em seguida, continue a configurar seus grupos incluindo usuários, IDs de serviço ou perfis confiáveis. É possível incluir usuários manualmente ou criando regras dinâmicas. Ou é possível começar a designar o grupo de acesso e decidir quem você deseja incluir no grupo de acesso posteriormente.

É possível excluir um grupo selecionando a opção Remover grupo. Ao remover um grupo da conta, você está removendo todos os usuários e IDs de serviço do grupo e todo o acesso que é designado ao grupo.

Criando um grupo de acesso usando a CLI

Para criar um grupo de acesso usando a CLI, é possível usar o comando ibmcloud iam access-group-create.

ibmcloud iam access-group-create GROUP_NAME [-d, --description DESCRIPTION]

É necessário um nome exclusivo para diferenciar grupos de acesso na conta.

Criando um grupo de acesso usando a API

Você pode criar grupos de acesso de forma programática chamando a API IBM Cloud® Identity and Access Management(IAM)Access Groups, conforme mostrado na solicitação de amostra a seguir. O exemplo cria um grupo de acesso para gerenciadores na conta:

curl -X POST -H "Authorization: Bearer {iam_token}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-d '{ "name": "Managers", "description": "Group for managers" }' \
"{base_url}/groups?account_id={account_id}"

CreateAccessGroupOptions createAccessGroupOptions = new CreateAccessGroupOptions.Builder()
  .accountId(testAccountId)
  .name("Managers")
  .description("Group for managers")
  .build();

Response<Group> response = service.createAccessGroup(createAccessGroupOptions).execute();
Group group = response.getResult();

System.out.println(group);

const params = {
  accountId: testAccountId,
  name: 'Managers',
  description: 'Group for managers'
};

iamAccessGroupsService.createAccessGroup(params)
  .then(res => {
    testGroupId = res.result.id;
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch(err => {
    console.warn(err)
  });

group = iam_access_groups_service.create_access_group(
  account_id=test_account_id,
  name='Managers',
  description='Group for managers'
).get_result()

print(json.dumps(group, indent=2))

createAccessGroupOptions := iamAccessGroupsService.NewCreateAccessGroupOptions(testAccountID, "Managers")
createAccessGroupOptions.SetDescription("Group for managers")
group, response, err := iamAccessGroupsService.CreateAccessGroup(createAccessGroupOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(group, "", "  ")
fmt.Println(string(b))

É necessário um nome exclusivo para diferenciar grupos de acesso na conta.

Criando um grupo de acesso usando o Terraform

Use as etapas a seguir para criar grupos de acesso usando o Terraform:

1. Crie um argumento em seu arquivo main.tf. O exemplo a seguir cria um grupo de acesso usando o recurso ibm_iam_access_group, em que name é um nome exclusivo para identificar o grupo de acesso.

   resource "ibm_iam_access_group" "accgrp" {
    name        = "test"
    description = "New access group"
   }
   

   Também é possível especificar a descrição do grupo de acesso na opção description. Para obter mais informações, consulte os detalhes de referência do argumento na página do Terraform Identity and Access Management(IAM).

Simplifique o gerenciamento de acesso agrupando usuários e IDs de serviço com o Terraform IBM Modules(TIM) for IAM Access Groups.

1. Depois de concluir a criação do arquivo de configuração, inicialize a CLI do Terraform. Para obter mais informações, consulte Inicialização de diretórios de trabalho.

   terraform init
   

2. Provisione os recursos do arquivo main.tf. Para obter mais informações, consulte Provisionamento de infraestrutura com o Terraform.

   1. Execute terraform plan para gerar um plano de execução do Terraform para visualizar as ações propostas.

      terraform plan
      

   2. Execute o site terraform apply para criar os recursos definidos no plano.

      terraform apply
      

Designando acesso a um grupo no console

Depois de configurar seu grupo com usuários e IDs de serviço, é possível designar uma política de acesso comum para o grupo. Lembre-se, qualquer política que você configura para o grupo se aplica a todas as entidades dentro do grupo. Por exemplo, a atribuição de políticas de acesso a um grupo de acesso delega a capacidade de conceder ou revogar o acesso a usuários, IDs de serviço ou perfis confiáveis aos administradores desse grupo de acesso.

O acesso de administrador a tudo na conta inclui a capacidade de revogar o acesso de outros usuários com a função de administrador.

Use as etapas a seguir para atribuir acesso a um grupo no console:

1. No console do IBM Cloud, clique em Gerenciar > Acesso (IAM) e selecione Grupos de acesso.

2. Para o grupo que você deseja designar acesso, selecione o ícone Ações e clique em Designar acesso.

3. É possível designar acesso a apenas recursos que você gerencia. Deve-se designar pelo menos uma opção de acesso. Para todas as opções de acesso que você não incluir e configurar, é designado o valor padrão No access. Dependendo das opções que você está autorizado a gerenciar, é possível designar os tipos de acesso a seguir:

   • Um grupo de serviços, como todos os serviços habilitados para identidade e acesso, todos os serviços de gerenciamento de contas ou todos os serviços de gerenciamento de contas de IAM.
   • Um serviço específico

4. Em seguida, é possível definir o escopo do acesso a todos os recursos ou a recursos específicos com base nos atributos de recurso selecionados, como tags de gerenciamento de acesso, localização ou grupo de recursos.

5. Selecione todas as funções que se aplicam. Para visualizar quais ações são mapeadas para cada função, clique nos números listados ao lado de cada função. Alguns serviços suportam o uso de operadores avançados para conceder acesso a recursos que atendem às convenções de nomenclatura específicas. Consulte Designando acesso usando políticas curingas para obter mais informações.

6. Clique em Revisar.

7. Clique em Incluir para incluir sua configuração de política em seu resumo de política.

8. Clique em Designar.

Também é possível atribuir acesso usando tags de gerenciamento de acesso. Para obter mais informações, consulte Controlando o acesso aos recursos usando tags.

Designando acesso a um grupo usando a CLI

Para criar uma política de grupo de acesso usando a CLI, é possível usar o comando ibmcloud iam access-group-policy-create.

ibmcloud iam access-group-policy-create GROUP_NAME {-f, --file @JSON_FILE | --roles ROLE_NAME1,ROLE_NAME2... [--service-name SERVICE_NAME] [--service-instance SERVICE_INSTANCE] [--region REGION] [--resource-type RESOURCE_TYPE] [--resource RESOURCE] [--resource-group-name RESOURCE_GROUP_NAME] [--resource-group-id RESOURCE_GROUP_ID]}

Designando acesso a um grupo usando a API

Você pode atribuir acesso a um grupo de forma programática chamando a API de gerenciamento de políticas IBM Cloud® Identity and Access Management(IAM), conforme mostrado na solicitação de amostra a seguir. O exemplo designa uma função Editor do grupo de acesso para uma instância de um serviço:

curl -X POST 'https://iam.cloud.ibm.com/v1/policies' \
-H 'Authorization: Bearer $TOKEN' \
-H 'Content-Type: application/json' \
-d '{
  "type": "access",
  "description": "Editor role for SERVICE_NAME's RESOURCE_NAME",
  "subjects": [
    {
      "attributes": [
        {
          "name": "access_group_id",
          "value": "exampleAccessGroupId"
        }
      ]
    }'
  ],
  "roles":[
    {
      "role_id": "crn:v1:bluemix:public:iam::::role:Editor"
    }
  ],
  "resources":[
    {
      "attributes": [
        {
          "name": "accountId",
          "value": "$ACCOUNT_ID"
        },
        {
          "name": "serviceName",
          "value": "$SERVICE_NAME"
        },
        {
          "name": "resource",
          "value": "$RESOURCE_NAME",
          "operator": "stringEquals"
        }
      ]
    }
  ]
}'

SubjectAttribute subjectAttribute = new SubjectAttribute.Builder()
        .name("access_group_id")
        .value(exampleAccessGroupId)
        .build();

PolicySubject policySubjects = new PolicySubject.Builder()
        .addAttributes(subjectAttribute)
        .build();

PolicyRole policyRoles = new PolicyRole.Builder()
        .roleId("crn:v1:bluemix:public:iam::::role:Editor")
        .build();

ResourceAttribute accountIdResourceAttribute = new ResourceAttribute.Builder()
        .name("accountId")
        .value(exampleAccountId)
        .operator("stringEquals")
        .build();

ResourceAttribute serviceNameResourceAttribute = new ResourceAttribute.Builder()
        .name("serviceType")
        .value("service")
        .operator("stringEquals")
        .build();

PolicyResource policyResources = new PolicyResource.Builder()
        .addAttributes(accountIdResourceAttribute)
        .addAttributes(serviceNameResourceAttribute)
        .build();

CreatePolicyOptions options = new CreatePolicyOptions.Builder()
        .type("access")
        .subjects(Arrays.asList(policySubjects))
        .roles(Arrays.asList(policyRoles))
        .resources(Arrays.asList(policyResources))
        .build();

Response<Policy> response = service.createPolicy(options).execute();
Policy policy = response.getResult();

System.out.println(policy);

const policySubjects = [
  {
    attributes: [
      {
        name: 'access_group_id',
        value: exampleAccessGroupId,
      },
    ],
  },
];
const policyRoles = [
  {
    role_id: 'crn:v1:bluemix:public:iam::::role:Editor',
  },
];
const accountIdResourceAttribute = {
  name: 'accountId',
  value: exampleAccountId,
  operator: 'stringEquals',
};
const serviceNameResourceAttribute = {
  name: 'serviceType',
  value: 'service',
  operator: 'stringEquals',
};
const policyResources = [
  {
    attributes: [accountIdResourceAttribute, serviceNameResourceAttribute],
  },
];
const params = {
  type: 'access',
  subjects: policySubjects,
  roles: policyRoles,
  resources: policyResources,
};

iamPolicyManagementService.createPolicy(params)
  .then(res => {
    examplePolicyId = res.result.id;
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch(err => {
    console.warn(err)
  });

policy_subjects = PolicySubject(
  attributes=[SubjectAttribute(name='access_group_id', value=exampleAccessGroupId)])
policy_roles = PolicyRole(
  role_id='crn:v1:bluemix:public:iam::::role:Editor')
account_id_resource_attribute = ResourceAttribute(
  name='accountId', value=example_account_id)
service_name_resource_attribute = ResourceAttribute(
  name='serviceType', value='service')
policy_resources = PolicyResource(
  attributes=[account_id_resource_attribute,
        service_name_resource_attribute])

policy = iam_policy_management_service.create_policy(
  type='access',
  subjects=[policy_subjects],
  roles=[policy_roles],
  resources=[policy_resources]
).get_result()

print(json.dumps(policy, indent=2))

subjectAttribute := &iampolicymanagementv1.SubjectAttribute{
  Name:  core.StringPtr("access_group_id"),
  Value: &exampleAccessGroupId,
}
policySubjects := &iampolicymanagementv1.PolicySubject{
  Attributes: []iampolicymanagementv1.SubjectAttribute{*subjectAttribute},
}
policyRoles := &iampolicymanagementv1.PolicyRole{
  RoleID: core.StringPtr("crn:v1:bluemix:public:iam::::role:Editor"),
}
accountIDResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
  Name:     core.StringPtr("accountId"),
  Value:    core.StringPtr(exampleAccountID),
  Operator: core.StringPtr("stringEquals"),
}
serviceNameResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
  Name:     core.StringPtr("serviceType"),
  Value:    core.StringPtr("service"),
  Operator: core.StringPtr("stringEquals"),
}
policyResources := &iampolicymanagementv1.PolicyResource{
  Attributes: []iampolicymanagementv1.ResourceAttribute{
    *accountIDResourceAttribute, *serviceNameResourceAttribute}
}

options := iamPolicyManagementService.NewCreatePolicyOptions(
  "access",
  []iampolicymanagementv1.PolicySubject{*policySubjects},
  []iampolicymanagementv1.PolicyRole{*policyRoles},
  []iampolicymanagementv1.PolicyResource{*policyResources},
)

policy, response, err := iamPolicyManagementService.CreatePolicy(options)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(policy, "", "  ")
fmt.Println(string(b))

Você pode atribuir acesso a um grupo de serviços. Para atribuir acesso a todos os serviços habilitados para identidade e acesso, especifique serviceType para o atributo name e use o atributo value service. Para atribuir acesso aos serviços do All Account Management, especifique serviceType para o atributo name e use o atributo value platform_service. Para atribuir acesso ao subconjunto de serviços de gerenciamento de contas Todos os serviços de gerenciamento de contas do IAM, especifique service_group_id para o atributo name e use o atributo value IAM.

Atribuindo acesso a um grupo usando o Terraform

Depois de configurar o grupo, use as etapas a seguir para atribuir acesso a ele usando o Terraform.

1. Crie um argumento em seu arquivo main.tf. Os exemplos a seguir criam uma política do IAM que concede aos membros do grupo de acesso a função de plataforma do IAM de Viewer a todos os serviços ativados para IAM usando o recurso ibm_iam_access_group_policy. Deve-se ter um ID de IAM existente de um grupo de acesso para concluir a tarefa.

   resource "ibm_iam_access_group" "accgrp" {
    name = "test"
   }
   

   resource "ibm_iam_access_group_policy" "policy" {
    access_group_id = ibm_iam_access_group.accgrp.id
    roles           = ["Viewer"]
   }
   

   Para obter mais informações, consulte os detalhes de referência do argumento na página do Terraform Identity and Access Management(IAM).

Você também pode usar o módulo IAM Access Groups para gerenciar grupos e políticas de acesso em escala. O exemplo a seguir demonstra o uso do módulo:

module "access_group" {
  source  = "terraform-ibm-modules/iam-access-group/ibm"
  version = "latest"

  access_group_name        = "my-access-group"
  access_group_description = "Access group for team members"

  policies = [
    {
      roles = ["Viewer"]
      resources = [{
        service = "cloud-object-storage"
      }]
    }
  ]
}

Para obter mais informações sobre os módulos do Terraform IBM, consulte Sobre os módulos do Terraform IBM.

1. Depois de concluir a criação do arquivo de configuração, inicialize a CLI do Terraform. Para obter mais informações, consulte Inicialização de diretórios de trabalho.

   terraform init
   

2. Provisione os recursos do arquivo main.tf. Para obter mais informações, consulte Provisionamento de infraestrutura com o Terraform.

   1. Execute terraform plan para gerar um plano de execução do Terraform para visualizar as ações propostas.

      terraform plan
      

   2. Execute o site terraform apply para criar os recursos definidos no plano.

      terraform apply
      

Adição de membros a um grupo de acesso no console

Os membros podem ser usuários, IDs de serviço e perfis confiáveis.

1. No console do IBM Cloud®, clique em Gerenciar > Acesso (IAM) e selecione Grupos de acesso.

2. Clique no grupo de acesso que você criou.

3. Adicionar membros.

   1. Clique em Incluir usuários.
   2. Clique em Service IDs > Add Service IDs.
   3. Clique em Perfis confiáveis > Adicionar perfis confiáveis.

   Se você não vir o botão para adicionar membros, talvez não tenha acesso. Analise os requisitos de acesso e entre em contato com o administrador da sua conta para obter acesso.

4. Selecione os usuários, IDs de serviço ou perfis confiáveis que deseja adicionar ao grupo e clique em Add to group (Adicionar ao grupo ).

Os membros que você adiciona ao grupo podem usar o nível de acesso que você atribui ao grupo.

Adição de membros a um grupo de acesso usando a CLI

Os membros podem ser usuários, IDs de serviço e perfis confiáveis. Os membros que você adiciona ao grupo podem usar o nível de acesso que você atribui ao grupo.

1. Obtenha os usuários, IDs de serviço ou perfis confiáveis em sua conta. Observe os detalhes que são retornados para o membro que você deseja adicionar ao grupo de acesso.

   Obtenha todos os usuários:

   ibmcloud account users [-c, --account-id ACCOUNT_ID]
   

   Liste todas as IDs de serviço:

   ibmcloud iam service-ids [--uuid]
   

   Obter todos os perfis confiáveis:

   ibmcloud iam trusted-profiles [--id | --output FORMAT] [-q, --quiet]
   

2. Adicionar membros ao grupo de acesso:

   Use o comando ibmcloud iam access-group-user-add para adicionar usuários a um grupo de acesso. O exemplo a seguir adiciona o usuário name@example.com ao grupo de acesso example_group usando a CLI.

   ibmcloud iam access-group-user-add example_group name@example.com
   

   Use o comando ibmcloud iam access-group-service-id-add para adicionar IDs de serviço a um grupo de acesso. O exemplo a seguir adiciona o ID de serviço example-service ao grupo de acesso example_group:

   ibmcloud iam access-group-service-id-add example_group example-service
   

   Use o comando ibmcloud iam access-group-trusted profile-add para adicionar perfis confiáveis a um grupo de acesso. O exemplo a seguir adiciona o ID de serviço PROFILE_ID ao grupo de acesso example_group:

   ibmcloud iam access-group-trusted-profile-add GROUP_NAME (PROFILE_NAME | PROFILE_ID) [PROFILE_NAME2 | PROFILE_ID2...] [--output FORMAT] [-q, --quiet]
   

Adição de membros a um grupo de acesso usando a API

Os membros podem ser usuários, IDs de serviço e perfis confiáveis.

1. Liste os usuários, IDs de serviço ou perfis confiáveis em sua conta, conforme mostrado no exemplo de solicitação a seguir. Observe a IBMid, a ID de serviço ou a ID de perfil confiável que é retornada para o membro que você deseja adicionar ao grupo de acesso.

   Usuários da lista:

   curl -X GET https://user-management.cloud.ibm.com/v2/accounts/987d4cfd77b04e9b9e1a6asdcc861234/users -H 'Authorization: Bearer <IAM_TOKEN>'
   

   ListUsersOptions listUsersOptions = new ListUsersOptions.Builder()
     .accountId(accountId)
     .build();
   
   UsersPager pager = new UsersPager(userManagementService, listUsersOptions);
   List<UserProfile> allResults = new ArrayList<>();
   while (pager.hasNext()) {
     List<UserProfile> nextPage = pager.getNext();
     allResults.addAll(nextPage);
   }
   
   System.out.println(GsonSingleton.getGson().toJson(allResults));
   

   const params = {
     accountId: accountId,
   };
   
   const allResults = [];
   try {
     const pager = new UserManagementV1.UsersPager(userManagementService, params);
     while (pager.hasNext()) {
       const nextPage = await pager.getNext();
       expect(nextPage).not.toBeNull();
       allResults.push(...nextPage);
     }
     console.log(JSON.stringify(allResults, null, 2));
   } catch (err) {
     console.warn(err);
   }
   

   all_results = []
   pager = UsersPager(
     client=user_management_service,
     account_id=account_id,
   )
   while pager.has_next():
     next_page = pager.get_next()
     assert next_page is not None
     all_results.extend(next_page)
   
   print(json.dumps(all_results, indent=2))
   

   listUsersOptions := &usermanagementv1.ListUsersOptions{
     AccountID: &accountID,
   }
   
   pager, err := userManagementService.NewUsersPager(listUsersOptions)
   if err != nil {
     panic(err)
   }
   
   var allResults []usermanagementv1.UserProfile
   for pager.HasNext() {
     nextPage, err := pager.GetNext()
     if err != nil {
       panic(err)
     }
     allResults = append(allResults, nextPage...)
   }
   b, _ := json.MarshalIndent(allResults, "", "  ")
   fmt.Println(string(b))
   

   Listar IDs de serviço:

   curl -X GET 'https://iam.cloud.ibm.com/v1/serviceids?account_id=ACCOUNT_ID&name=My-serviceID' -H 'Authorization: Bearer TOKEN' -H 'Content-Type: application/json'
   

   ListServiceIdsOptions listServiceIdsOptions = new ListServiceIdsOptions.Builder()
       .accountId(accountId)
       .name(serviceIdName)
       .build();
   
   Response<ServiceIdList> response = service.listServiceIds(listServiceIdsOptions).execute();
   ServiceIdList serviceIdList = response.getResult();
   
   System.out.println(serviceIdList);
   

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

   service_id_list = iam_identity_service.list_service_ids(
     account_id=account_id, name=serviceid_name
   ).get_result()
   
   print(json.dumps(service_id_list, indent=2))
   

   listServiceIdsOptions := iamIdentityService.NewListServiceIdsOptions()
   listServiceIdsOptions.SetAccountID(accountID)
   listServiceIdsOptions.SetName(serviceIDName)
   
   serviceIDList, response, err := iamIdentityService.ListServiceIds(listServiceIdsOptions)
   if err != nil {
     panic(err)
   }
   b, _ := json.MarshalIndent(serviceIDList, "", "  ")
   fmt.Println(string(b))
   

   Listar perfis confiáveis:

   curl -X GET 'https://iam.cloud.ibm.com/v1/profiles?account_id=ACCOUNT_ID' -H 'Authorization: Bearer TOKEN' -H 'Accept: application/json'
   

   ListProfilesOptions listProfilesOptions = new ListProfilesOptions.Builder()
       .accountId(accountId)
       .includeHistory(false)
       .build();
   
   Response<TrustedProfilesList> response = service.listProfiles(listProfilesOptions).execute();
   TrustedProfilesList profiles = response.getResult();
   
   System.out.println(profiles);
   

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

   profile_list = iam_identity_service.list_profiles(account_id=account_id, include_history=True).get_result()
   
   print(json.dumps(profile_list, indent=2))
   

   listProfilesOptions := iamIdentityService.NewListProfilesOptions(accountID)
   listProfilesOptions.SetIncludeHistory(false)
   
   trustedProfiles, response, err := iamIdentityService.ListProfiles(listProfilesOptions)
   if err != nil {
     panic(err)
   }
   b, _ := json.MarshalIndent(trustedProfiles, "", "  ")
   fmt.Println(string(b))
   

2. Adicione membros ao grupo de acesso chamando a API IAM Access Groups, conforme mostrado no exemplo de solicitação a seguir.

   O tipo de membro deve ser user, service ou profile.

   curl -X PUT --location --header "Authorization: Bearer {iam_token}" --header "Accept: application/json" --header "Content-Type: application/json" --data '{ "members": [ { "iam_id": "IBMid-user1", "type": "user" }, { "iam_id": "iam-ServiceId-123", "type": "service" }, { "iam_id": "iam-Profile-123", "type": "profile" } ] }' "{base_url}/v2/groups/{access_group_id}/members"
   

   AddGroupMembersRequestMembersItem member1 = new AddGroupMembersRequestMembersItem.Builder()
     .iamId("IBMid-user1")
     .type("user")
     .build();
   AddGroupMembersRequestMembersItem member2 = new AddGroupMembersRequestMembersItem.Builder()
     .iamId("iam-ServiceId-123")
     .type("service")
     .build();
     AddGroupMembersRequestMembersItem member3 = new AddGroupMembersRequestMembersItem.Builder()
     .iamId(testProfileId)
     .type("profile")
     .build();
   AddMembersToAccessGroupOptions addMembersToAccessGroupOptions = new AddMembersToAccessGroupOptions.Builder()
     .accessGroupId(testGroupId)
     .addMembers(member1)
     .addMembers(member2)
     .addMembers(member3)
     .build();
   Response<AddGroupMembersResponse> response = iamAccessGroupsService.addMembersToAccessGroup(addMembersToAccessGroupOptions).execute();
   AddGroupMembersResponse addGroupMembersResponse = response.getResult();
   
   System.out.println(addGroupMembersResponse);
   

   const groupMember1 = {
     iam_id: 'IBMid-user1',
     type: 'user',
   };
   const groupMember2 = {
     iam_id: 'iam-ServiceId-123',
     type: 'service',
   };
   var groupMember3 = {
     iam_id: profileId,
     type: 'profile',
   }
   
   const params = {
     accessGroupId: testGroupId,
     members: [groupMember1, groupMember2, groupMember3],
   };
   
   try {
     const res = await iamAccessGroupsService.addMembersToAccessGroup(params);
     console.log(JSON.stringify(res.result, null, 2));
   } catch (err) {
     console.warn(err);
   }
   

   member1 = AddGroupMembersRequestMembersItem(iam_id='IBMid-user1', type='user')
   member2 = AddGroupMembersRequestMembersItem(iam_id='iam-ServiceId-123', type='service')
   member3 = AddGroupMembersRequestMembersItem(iam_id=test_profile_id, type='profile')
   members = [member1, member2, member3]
   
   response = iam_access_groups_service.add_members_to_access_group(
     access_group_id=test_group_id,
     members=members,
   )
   add_group_members_response = response.get_result()
   
   print(json.dumps(add_group_members_response, indent=2))
   

   groupMembers := []iamaccessgroupsv2.AddGroupMembersRequestMembersItem{
     iamaccessgroupsv2.AddGroupMembersRequestMembersItem{
       IamID: core.StringPtr("IBMid-user1"),
       Type:  core.StringPtr("user"),
     },
     iamaccessgroupsv2.AddGroupMembersRequestMembersItem{
       IamID: core.StringPtr("iam-ServiceId-123"),
       Type:  core.StringPtr("service"),
     },
     iamaccessgroupsv2.AddGroupMembersRequestMembersItem{
       IamID: core.StringPtr(testProfileID),
       Type:  core.StringPtr("profile"),
     },
   }
   
   addMembersToAccessGroupOptions := iamAccessGroupsService.NewAddMembersToAccessGroupOptions(
     accessGroupIDLink,
   )
   addMembersToAccessGroupOptions.SetMembers(groupMembers)
   
   addGroupMembersResponse, response, err := iamAccessGroupsService.AddMembersToAccessGroup(addMembersToAccessGroupOptions)
   if err != nil {
     panic(err)
   }
   b, _ := json.MarshalIndent(addGroupMembersResponse, "", "  ")
   fmt.Println(string(b))
   

Os membros que você adiciona ao grupo podem usar o nível de acesso que você atribui ao grupo.

Adição de membros a um grupo de acesso usando o Terraform

Os membros podem ser usuários, IDs de serviço e perfis confiáveis.

1. Crie um argumento em seu arquivo main.tf. O exemplo a seguir adiciona um ID de serviço, um perfil confiável e um usuário com o ID user@ibm.com a um grupo de acesso.

   resource "ibm_iam_access_group_members" "accgroupmem" {
     access_group_id = ibm_iam_access_group.accgroup.id
     ibm_ids         = ["user@ibm.com"]
     iam_service_ids = [ibm_iam_service_id.serviceID.id]
     iam_profile_ids = [ibm_iam_trusted_profile.profileID.id]
   }
   

Gerencie a associação de grupos de forma programática com o módulo IAM Access Groups para provisionamento automatizado de usuários. Explore o Terraform IBM Modules para gerenciamento de membros.

1. Depois de concluir a criação do arquivo de configuração, inicialize a CLI do Terraform. Para obter mais informações, consulte Inicialização de diretórios de trabalho.

   terraform init
   

2. Provisione os recursos do arquivo main.tf. Para obter mais informações, consulte Provisionamento de infraestrutura com o Terraform.

   1. Execute terraform plan para gerar um plano de execução do Terraform para visualizar as ações propostas.

      terraform plan
      

   2. Execute o site terraform apply para criar os recursos definidos no plano.

      terraform apply
      

Os membros que você adiciona ao grupo podem usar o nível de acesso que você atribui ao grupo.