IBM Cloud Docs
Configuración de grupos de acceso

Configuración de grupos de acceso

Se puede crear un grupo de acceso para organizar un conjunto de usuarios, ID de servicio y perfiles de confianza en una sola entidad, lo que facilita la asignación de acceso. Puede asignar una única política al grupo en lugar de asignar el mismo acceso varias veces para un ID de usuario o servicio individual.

A los grupos de acceso se les asignan políticas que otorgan roles y permisos a los miembros de ese grupo. Los miembros de un grupo de acceso pueden incluir varios tipos de identidad, como usuarios, ID de servicio y perfiles de confianza. Los miembros heredan las políticas, los roles y los permisos que se asignan al grupo de acceso y también conservan los roles que se asignan individualmente.

Por ejemplo, si a un usuario se le asigna el rol viewer en el servicio de facturación y se le añade a un grupo de acceso que tiene el rol de publisher en el servicio de gestión de catálogos, mantiene su rol de viewer aunque no forme parte de los permisos del grupo de acceso.

Para facilitar aún más la asignación y gestión de accesos, puede configurar grupos de recursos para organizar el conjunto de recursos al que desea que un grupo de usuarios tenga acceso. Cuando el grupo de recursos esté configurado, podrá asignar una política que otorgue acceso a todos los recursos del grupo, en lugar de crear políticas de acceso para instancias de servicio individuales de su cuenta.

Antes de empezar

Para gestionar o crear nuevos grupos de acceso, debe tener el siguiente tipo de acceso:

  • Administrador o editor en el servicio de gestión de cuentas de IAM Access Groups en la cuenta
  • Administrador o editor para todos los servicios de gestión de cuentas
  • Debe ser el titular de la cuenta

Además, se puede asignar a un administrador o editor acceso para gestionar un grupo individual creando una política de acceso donde el recurso es el ID del grupo de acceso. Para obtener más información sobre las políticas de acceso y los roles correspondientes al servicio IAM Access Groups, consulte Acceso de IAM.

Antes de empezar

Para poder configurar grupos de acceso utilizando Terraform, asegúrese de que ha completado lo siguiente:

  • Instale la CLI de Terraform y configure el plugin de proveedor de IBM Cloud para Terraform. Para obtener más información, consulte la guía de aprendizaje de Iniciación a Terraform en IBM Cloud®. El plug-in abstrae las API de IBM Cloud que se utilizan para completar esta tarea.
  • Cree un archivo de configuración de Terraform denominado main.tf. En este archivo, puede definir recursos utilizando HashiCorp Configuration Language. Para más información, consulte la documentación de Terraform.

Creación de un grupo de acceso en la consola

Se requiere un nombre exclusivo para diferenciar los grupos de acceso de la cuenta. Para crear un grupo de acceso, complete los pasos siguientes:

  1. En la consola de IBM Cloud®, pulse Gestionar > Acceso (IAM) y seleccione Grupos de acceso.
  2. Pulse Crear.
  3. Especifique un nombre exclusivo para identificar el grupo de acceso y una descripción opcional y pulse Crear.

A continuación, continúe la configuración de los grupos añadiendo usuarios, ID de servicio o perfiles de confianza. Puede añadir usuarios manualmente o mediante la creación de reglas dinámicas. O bien, puede empezar a asignar acceso al grupo y decidir quién desea añadir al grupo de acceso más tarde.

Puede suprimir un grupo seleccionando la opción Eliminar grupo. Cuando elimina un grupo de la cuenta, también elimina todos los usuarios e ID de servicio del grupo y todo el acceso asignado al grupo.

Creación de un grupo de acceso mediante la CLI

Para crear un grupo de acceso utilizando la CLI, puede utilizar el mandato ibmcloud iam access-group-create.

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

Se requiere un nombre exclusivo para diferenciar los grupos de acceso de la cuenta.

Creación de un grupo de acceso mediante la API

Puede crear grupos de acceso mediante programación llamando a la API de grupos de acceso de IAM(IBM Cloud® Identity and Access Management ), como se muestra en la siguiente solicitud de ejemplo. En el ejemplo se crea un grupo de acceso para los gestores de la cuenta:

curl -X POST -H "Authorization: {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))

Se requiere un nombre exclusivo para diferenciar los grupos de acceso de la cuenta.

Creación de un grupo de acceso utilizando Terraform

Utilice los pasos siguientes para crear grupos de acceso utilizando Terraform:

  1. Cree un argumento en el archivo main.tf. El ejemplo siguiente crea un grupo de acceso utilizando el recurso ibm_iam_access_group, donde name es un nombre exclusivo para identificar el grupo de acceso.

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

    También puede especificar la descripción del grupo de acceso en la opción description. Para obtener más información, consulte los detalles de referencia de argumentos en la página de Terraform(Identity and Access Management, IAM ).

  2. Después de terminar de crear el archivo de configuración, inicialice la CLI de Terraform. Para obtener más información, consulte Inicialización de directorios de trabajo.

    terraform init

  3. Suministre los recursos desde el archivo main.tf. Para obtener más información, consulte Infraestructura de suministro con Terraform.

    1. Ejecute terraform plan para generar un plan de ejecución de Terraform para obtener una vista previa de las acciones propuestas.

      terraform plan

    2. Ejecute terraform apply para crear los recursos definidos en el plan.

      terraform apply

Asignación de acceso a un grupo en la consola

Después de configurar el grupo con usuarios e ID de servicio, puede asignar una política de acceso común al grupo. Recuerde que cualquier política que establezca para el grupo se aplica a todas las entidades del mismo. Por ejemplo, asignar políticas de acceso a un grupo de acceso delega la capacidad de otorgar o revocar acceso a usuarios, identificadores de servicio o perfiles confiables a los administradores de ese grupo de acceso.

El acceso de administrador a todo lo que hay en la cuenta incluye la capacidad de revocar el acceso de otros usuarios con la función de administrador.

Utilice los pasos siguientes para asignar acceso a un grupo en la consola:

  1. En la consola de IBM Cloud, pulse Gestionar > Acceso (IAM) y seleccione Grupos de acceso.

  2. Para el grupo al que desea asignar acceso, seleccione el icono Acciones Icono Acciones y pulse Asignar acceso.

  3. Solo puede asignar acceso a los recursos que gestione. Debe asignar al menos una opción de acceso. Para las opciones de acceso que no añada y configure, se asigna el valor predeterminado Sin acceso. Según las opciones que esté autorizado a gestionar, puede asignar los siguientes tipos de acceso:

    • Un grupo de servicios, como Todos los servicios habilitados para identidad y acceso, Todos los servicios de gestión de cuentas o Todos los servicios de gestión de cuentas de IAM.
    • Un servicio específico

  4. A continuación, puede delimitar el acceso a todos los recursos o recursos específicos en función de los atributos de recursos seleccionados, como las etiquetas de gestión de accesos, la ubicación o el grupo de recursos.

  5. Seleccione todos los roles que se apliquen. Para ver las acciones que se correlacionan con cada rol, pulse los números que se muestran junto a cada rol. Algunos servicios permiten el uso de operadores avanzados para otorgar acceso a recursos que satisfagan convenios de denominación específicos. Consulte Asignación de acceso mediante el uso de políticas comodín para obtener más información.

  6. Pulse Revisar.

  7. Pulse Añadir para añadir la configuración de política a su resumen de políticas.

  8. Pulse Asignar.

También puede asignar acceso utilizando códigos de gestión de acceso. Para obtener más información, consulte Control del acceso a los recursos mediante etiquetas.

Asignación de acceso a un grupo mediante la CLI

Para crear una política de grupo de acceso utilizando la CLI, puede utilizar el mandato 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]}

Asignación de acceso a un grupo mediante la API

Puede asignar acceso a un grupo mediante programación llamando a la API de gestión de políticas de gestión de identidades y acceso(IBM Cloud® Identity and Access Management, IAM) como se muestra en la siguiente solicitud de muestra. En el ejemplo se asigna el rol de grupo de acceso de Editor para una instancia de un servicio:

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))

Puede asignar acceso a un grupo de servicios. Para asignar acceso a Todos los servicios de identidad y acceso habilitados, especifique serviceType para el atributo name y utilice value service. Para asignar acceso a Todos los servicios de gestión de cuentas, especifique serviceType para el atributo name y utilice value platform_service. Para asignar acceso al subconjunto de servicios de gestión de cuentas Todos los servicios de gestión de cuentas de IAM, especifique service_group_id para el atributo name y utilice value IAM.

Asignación del acceso a un grupo utilizando Terraform

Después de configurar el grupo, utilice los pasos siguientes para asignar acceso al mismo utilizando Terraform.

  1. Cree un argumento en el archivo main.tf. Los ejemplos siguientes crean una política de IAM que otorga a los miembros del grupo de acceso el rol de plataforma Viewer de IAM en todos los servicios habilitados para IAM utilizando el recurso ibm_iam_access_group_policy. Debe tener un ID de IAM existente de un grupo de acceso para poder realizar la tarea.

    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 obtener más información, consulte los detalles de referencia de argumentos en la página de Terraform(Identity and Access Management, IAM ).

  2. Después de terminar de crear el archivo de configuración, inicialice la CLI de Terraform. Para obtener más información, consulte Inicialización de directorios de trabajo.

    terraform init

  3. Suministre los recursos desde el archivo main.tf. Para obtener más información, consulte Infraestructura de suministro con Terraform.

    1. Ejecute terraform plan para generar un plan de ejecución de Terraform para obtener una vista previa de las acciones propuestas.

      terraform plan

    2. Ejecute terraform apply para crear los recursos definidos en el plan.

      terraform apply

Adición de miembros a un grupo de acceso en la consola

Los miembros pueden ser usuarios, ID de servicio y perfiles de confianza.

  1. En la consola de IBM Cloud®, pulse Gestionar > Acceso (IAM) y seleccione Grupos de acceso.

  2. Pulse el grupo de acceso que ha creado.

  3. Añada miembros.

    1. Pulse Añadir usuarios.
    2. Pulse ID de servicio > Añadir ID de servicio.
    3. Pulse Perfiles de confianza > Añadir perfiles de confianza.

    Si no ve el botón para añadir miembros, es posible que no tenga acceso. Revise los requisitos de acceso y póngase en contacto con el administrador de la cuenta para obtener acceso.

  4. Seleccione los usuarios, ID de servicio o perfiles de confianza que desea añadir al grupo y pulse Añadir a grupo.

Los miembros que añada al grupo pueden utilizar el nivel de acceso que asigne al grupo.

Adición de miembros a un grupo de acceso utilizando la CLI

Los miembros pueden ser usuarios, ID de servicio y perfiles de confianza. Los miembros que añada al grupo pueden utilizar el nivel de acceso que asigne al grupo.

  1. Obtenga los usuarios, los ID de servicio o los perfiles de confianza de su cuenta. Anote los detalles que se devuelven para el miembro que desea añadir al grupo de acceso.

    Obtener todos los usuarios:

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

    Listar todos los ID de servicio:

    ibmcloud iam service-ids [--uuid]

    Obtener todos los perfiles de confianza:

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

  2. Añadir miembros al grupo de acceso:

    Utilice el mandato ibmcloud iam access-group-user-add para añadir usuarios a un grupo de acceso. El ejemplo siguiente añade el usuario name@example.com al grupo de acceso example_group utilizando la CLI.

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

    Utilice el mandato ibmcloud iam access-group-service-id-add para añadir ID de servicio a un grupo de acceso. El ejemplo siguiente añade el ID de servicio example-service al grupo de acceso example_group:

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

    Utilice el mandato ibmcloud iam access-group-trusted profile-add para añadir perfiles de confianza a un grupo de acceso. El ejemplo siguiente añade el ID de servicio PROFILE_ID al grupo de acceso example_group:

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

Adición de miembros a un grupo de acceso utilizando la API

Los miembros pueden ser usuarios, ID de servicio y perfiles de confianza.

  1. Liste los usuarios, los ID de servicio o los perfiles de confianza de su cuenta tal como se muestra en la siguiente solicitud de ejemplo. Anote el IBMid, el ID de servicio o el ID de perfil de confianza que se devuelve para el miembro que desea añadir al grupo de acceso.

    Listar usuarios:

    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 ID de servicio:

    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 perfiles de confianza:

    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. Añada miembros al grupo de acceso llamando a la API Grupos de acceso de IAM tal como se muestra en la solicitud de ejemplo siguiente.

    El tipo de miembro debe ser user, service o 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))

Los miembros que añada al grupo pueden utilizar el nivel de acceso que asigne al grupo.

Adición de miembros a un grupo de acceso utilizando Terraform

Los miembros pueden ser usuarios, ID de servicio y perfiles de confianza.

  1. Cree un argumento en el archivo main.tf. El ejemplo siguiente añade un ID de servicio, un perfil de confianza y un usuario con el ID user@ibm.com a un grupo de acceso.

    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]
}

  2. Después de terminar de crear el archivo de configuración, inicialice la CLI de Terraform. Para obtener más información, consulte Inicialización de directorios de trabajo.

    terraform init

  3. Suministre los recursos desde el archivo main.tf. Para obtener más información, consulte Infraestructura de suministro con Terraform.

    1. Ejecute terraform plan para generar un plan de ejecución de Terraform para obtener una vista previa de las acciones propuestas.

      terraform plan

    2. Ejecute terraform apply para crear los recursos definidos en el plan.

      terraform apply

Los miembros que añada al grupo pueden utilizar el nivel de acceso que asigne al grupo.