Gestión de accesos racionalizada con grupos de acceso

Organice usuarios, ID de servicio y perfiles de confianza en grupos de acceso para una gestión eficaz de los permisos. Asigne políticas detalladas una sola vez a todo el grupo para aplicar el mínimo privilegio a escala.

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
  • Usted 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

Antes de configurar grupos de acceso mediante Terraform, asegúrese de haber completado lo siguiente:

  • Instale Terraform CLI y configure el complemento IBM Cloud Provider para Terraform. Para más información, consulte el tutorial de Introducció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 se definen los recursos utilizando el lenguaje de configuración HashiCorp. 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 IBM Cloud® Identity and Access Management(IAM ), 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: 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))

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

Creación de un grupo de acceso utilizando Terraform

Siga los siguientes pasos para crear grupos de acceso mediante Terraform:

  1. Cree un argumento en su 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 los argumentos en la página de Terraform Identity and Access Management(IAM).

Agilice la gestión de accesos agrupando usuarios e ID de servicio con los módulos Terraform IBM(TIM) para grupos de acceso IAM.

  1. Después de terminar de crear el archivo de configuración, inicializa Terraform CLI. Para más información, consulte Inicializar directorios de trabajo.

    terraform init

  2. Aprovisione los recursos desde el archivo main.tf. Para obtener más información, consulte Aprovisionamiento de infraestructura con Terraform.

    1. Ejecute terraform plan para generar un plan de ejecución Terraform para previsualizar 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, la asignación de políticas de acceso a un grupo de acceso delega la capacidad de conceder o revocar el acceso a usuarios, service-ids o perfiles de confianza a los administradores de dicho grupo de acceso.

El acceso de administrador a todo en la cuenta incluye la capacidad de revocar el acceso a otros usuarios con el rol de administrador.

Siga los siguientes pasos 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 de 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 IBM Cloud® Identity and Access Management(IAM ), como se muestra en la siguiente solicitud de ejemplo. 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 los servicios All Identity and Access Enabled, especifique serviceType para el atributo name, y utilice el atributo value service. Para asignar acceso a los servicios de gestión de todas las cuentas, especifique serviceType para el atributo name y utilice el atributo value platform_service. Para asignar acceso al subconjunto de servicios de gestión de cuentas Todos los servicios de gestión de cuentas IAM, especifique service_group_id para el atributo name y utilice el atributo value IAM.

Asignación del acceso a un grupo utilizando Terraform

Después de configurar su grupo, siga los siguientes pasos para asignarle acceso mediante Terraform.

  1. Cree un argumento en su 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 los argumentos en la página de Terraform Identity and Access Management(IAM).

También puede utilizar el módulo IAM Access Groups para gestionar grupos de acceso y políticas a escala. El siguiente ejemplo demuestra el uso del 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 obtener más información sobre los módulos de Terraform IBM, consulte Acerca de los módulos de Terraform IBM.

  1. Después de terminar de crear el archivo de configuración, inicializa Terraform CLI. Para más información, consulte Inicializar directorios de trabajo.

    terraform init

  2. Aprovisione los recursos desde el archivo main.tf. Para obtener más información, consulte Aprovisionamiento de infraestructura con Terraform.

    1. Ejecute terraform plan para generar un plan de ejecución Terraform para previsualizar las acciones propuestas.

      terraform plan

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

      terraform apply

Añadir 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. Haga clic en el grupo de acceso que ha creado.

  3. Añade miembros.

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

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

  4. Seleccione los usuarios, ID de servicio o perfiles de confianza que desee añadir al grupo y haga clic en Añadir al grupo.

Los miembros que añadas al grupo pueden utilizar el nivel de acceso que asignes al grupo.

Añadir miembros a un grupo de acceso mediante la CLI

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

  1. Obtenga los usuarios, ID de servicio o perfiles de confianza de su cuenta. Observe 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]

    Enumere 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ñade miembros al grupo de acceso:

    Utilice el comando ibmcloud iam access-group-user-add para añadir usuarios a un grupo de acceso. El siguiente ejemplo 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 comando ibmcloud iam access-group-service-id-add para añadir ID de servicio a un grupo de acceso. El siguiente ejemplo 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 comando ibmcloud iam access-group-trusted profile-add para añadir perfiles de confianza a un grupo de acceso. El siguiente ejemplo 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]

Añadir miembros a un grupo de acceso mediante la API

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

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

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

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

    Lista de 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 de grupos de acceso de IAM como se muestra en la siguiente solicitud de ejemplo.

    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ñadas al grupo pueden utilizar el nivel de acceso que asignes al grupo.

Añadir miembros a un grupo de acceso mediante Terraform

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

  1. Cree un argumento en su archivo main.tf. El siguiente ejemplo 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]
}

Gestione la pertenencia a grupos mediante programación con el módulo IAM Access Groups para el aprovisionamiento automatizado de usuarios. Explore los módulos Terraform IBM para la gestión de miembros.

  1. Después de terminar de crear el archivo de configuración, inicializa Terraform CLI. Para más información, consulte Inicializar directorios de trabajo.

    terraform init

  2. Aprovisione los recursos desde el archivo main.tf. Para obtener más información, consulte Aprovisionamiento de infraestructura con Terraform.

    1. Ejecute terraform plan para generar un plan de ejecución Terraform para previsualizar las acciones propuestas.

      terraform plan

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

      terraform apply

Los miembros que añadas al grupo pueden utilizar el nivel de acceso que asignes al grupo.