利用访问组简化访问管理

将用户、服务 ID 和可信配置文件组织到访问组中，以实现高效的权限管理。 将细粒度策略一次性分配给整个群组，以大规模实施最小权限。

可以创建一个访问组，将一组用户、服务 ID 和受信任的配置文件组织成一个单一的实体，方便你分配访问权限。 您可以为组分配单个策略，而不是为单个用户或服务 ID 分配多次相同的访问权限。

为访问组分配了用于向该组的成员授予角色和许可权的策略。 访问组的成员可包括多种身份类型，如用户、服务 ID 和受信任配置文件。 成员会继承分配给访问组的策略、角色和权限，并保留各自被分配的角色。

例如，如果用户在计费服务中被分配了 viewer 角色，而他们又被添加到了一个在目录管理服务中拥有 publisher 角色的访问组中，那么他们就会保留 viewer 角色，尽管这并不是访问组权限的一部分。

要更轻松地分配和管理访问权，可以设置资源组来组织希望用户组有权访问的一组资源。 设置资源组后，可以为其分配策略，用于授予对该组内所有资源的访问权，而不用为帐户内的各个服务实例分别创建访问策略。

准备工作

要管理或创建新的访问组，您必须具有以下类型的访问权：

  • 账户中 IAM 访问组账户管理服务的管理员或编辑器
  • 所有帐户管理服务的管理员或编辑者
  • 您必须是账户所有者

此外，可以通过创建访问策略（其中的资源是访问组标识），向管理员或编辑者分配管理单个组的访问权。 有关 IAM 访问组服务的访问策略和角色的更多信息，请参阅 IAM 访问权。

准备工作

在使用 Terraform 设置访问组之前，请确保已完成以下步骤：

  • 安装 Terraform CLI 并为 Terraform 配置 IBM Cloud Provider 插件。 更多信息，请参见 IBM Cloud® 上的 Terraform 入门 教程。 该插件抽象了用于完成这项任务的 IBM Cloud API。
  • 创建名为 main.tf 的 Terraform 配置文件。 在该文件中，您可以使用 HashiCorp 配置语言定义资源。 更多信息，请参阅 Terraform 文档。

在控制台中创建访问组

需要一个唯一的名称来区分账户中的访问组。 要创建访问组，请完成以下步骤：

  1. 在 IBM Cloud® 控制台中，单击管理 > 访问 (IAM)，然后选择访问组。
  2. 单击创建。
  3. 输入标识访问组的唯一名称和可选描述，然后单击“创建”。

接下来，继续通过添加用户、服务 ID 或受信任配置文件来设置群组。 您可以手动或通过 创建动态规则 来添加用户。 或者，可以先分配组的访问权限，然后再决定要将谁添加到访问组。

可以通过选择除去组选项来删除组。 从帐户中除去组时，将除去该组中的所有用户和服务标识以及分配给该组的所有访问权。

使用 CLI 创建访问组

要使用 CLI 创建访问组，可以使用 ibmcloud iam access-group-create 命令。

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

需要一个唯一的名称来区分账户中的访问组。

使用 API 创建访问组

您可以通过调用 IBM Cloud® Identity and Access Management(IAM)访问组 API 以编程方式创建访问组，如下示例请求所示。 该示例为账户中的经理创建了一个访问组：

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

需要一个唯一的名称来区分账户中的访问组。

使用 Terraform 创建访问组

使用 Terraform 创建访问组的步骤如下：

  1. 在 main.tf 文件中创建一个参数。 下面的示例通过使用 ibm_iam_access_group 资源创建了一个访问组，其中 name 是标识访问组的唯一名称。

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

    您还可以在 description 选项中指定访问组的描述。 更多信息，请参阅 Terraform Identity and Access Management(IAM) 页面上的参数参考详情。

利用 Terraform IBM Modules(TIM) for IAM Access Groups 对用户和服务 ID 进行分组，从而简化访问管理。

  1. 完成构建配置文件后，初始化 Terraform CLI。 更多信息，请参阅 初始化工作目录。

    terraform init

  2. 从 main.tf 文件调配资源。 如需了解更多信息，请参阅 使用 Terraform 配置基础架构。

    1. 运行 terraform plan 生成 Terraform 执行计划，以预览建议的操作。

      terraform plan

    2. 运行 terraform apply 以创建计划中定义的资源。

      terraform apply

为控制台中的组指定访问权限

使用用户和服务标识设置组后，可以为该组分配公共访问策略。 请记住，您为该组设置的任何策略都将应用于该组内的所有实体。 例如，将访问策略分配给访问组，可将授予或撤销用户、服务标识或受信任配置文件访问权限的能力委托给该访问组的管理员。

管理员可以访问账户中的所有内容，包括撤销其他具有管理员角色的用户的访问权限。

使用以下步骤为控制台中的组分配访问权限：

  1. 在 IBM Cloud 控制台中，单击管理 > 访问 (IAM)，然后选择访问组。

  2. 对于要分配访问权限的组，选择操作图标操作图标，然后单击分配访问权限。

  3. 您可以只为自己管理的资源分配访问权限。 必须至少分配一个访问权选项。 对于未添加和配置的任何访问权选项，都会分配缺省值无访问权。 根据您有权管理的选项，可以分配以下类型的访问权：

    • 一组服务，如所有启用身份和访问的服务、所有账户管理服务或所有 IAM 账户管理服务。
    • 特定服务

  4. 然后，您可以根据所选的资源属性（如访问管理标记、位置或资源组），确定所有资源或特定资源的访问范围。

  5. 选择适用的所有角色。 要查看映射到每个角色的操作，请单击每个角色旁边列出的数字。 有些服务支持使用高级操作符，以允许访问符合特定命名约定的资源。 更多信息，请参阅 使用通配符策略分配访问权限。

  6. 点击回顾。

  7. 单击添加，将策略配置添加到策略摘要中。

  8. 单击分配。

您还可以使用访问管理标签来分配访问权限。 如需了解更多信息，请参阅 使用标记控制对资源的访问。

使用 CLI 为组分配访问权限

要使用 CLI 创建访问组策略，可以使用 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]}

使用应用程序接口将访问权限分配给一个组

您可以通过调用 IBM Cloud® Identity and Access Management(IAM)策略管理 API 以编程方式为组分配访问权限，如下示例请求所示。 该示例为服务实例分配了一个访问组 Editor 角色：

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

您可以为一组服务分配访问权限。 要分配对所有已启用身份和访问的服务的访问权限，请为 name 属性指定 serviceType，并使用 value service。 要分配对所有帐户管理服务的访问权限，请为 name 属性指定 serviceType，并使用 value platform_service。 要分配对账户管理服务子集“**所有 IAM 账户管理服务 **”的访问权限，请为 name 属性指定 service_group_id，并使用 value IAM。

使用 Terraform 为组分配访问权限

设置组后，使用 Terraform 通过以下步骤分配访问权限。

  1. 在 main.tf 文件中创建一个参数。 下面的示例创建了一个 IAM 策略，通过使用 ibm_iam_access_group_policy 资源将 IAM Viewer 平台角色授予所有启用了 IAM 的服务的访问组的成员。 您必须有一个访问组的现有 IAM ID 才能完成任务。

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

    更多信息，请参阅 Terraform Identity and Access Management(IAM) 页面上的参数参考详情。

您还可以使用 IAM 访问组模块来大规模管理访问组和策略。 下面的示例演示了如何使用该模块：

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

有关 Terraform IBM 模块的更多信息，请参阅 关于 Terraform IBM 模块。

  1. 完成构建配置文件后，初始化 Terraform CLI。 更多信息，请参阅 初始化工作目录。

    terraform init

  2. 从 main.tf 文件调配资源。 如需了解更多信息，请参阅 使用 Terraform 配置基础架构。

    1. 运行 terraform plan 生成 Terraform 执行计划，以预览建议的操作。

      terraform plan

    2. 运行 terraform apply 以创建计划中定义的资源。

      terraform apply

在控制台中为访问组添加成员

成员可以是用户、服务 ID 和可信配置文件。

  1. 在 IBM Cloud® 控制台中，单击管理 > 访问 (IAM)，然后选择访问组。

  2. 单击您创建的访问组。

  3. 添加成员。

    1. 单击添加用户。
    2. 单击服务 ID > 添加服务 ID。
    3. 单击受信任的配置文件 > 添加受信任的配置文件。

    如果您没有看到添加成员的按钮，您可能没有访问权限。 查看 访问要求 并联系您的账户管理员以获取访问权限。

  4. 选择要添加到组的用户、服务 ID 或受信任配置文件，然后单击添加到组。

您添加到组中的成员可以使用您为组指定的访问级别。

使用 CLI 为访问组添加成员

成员可以是用户、服务 ID 和可信配置文件。 您添加到组中的成员可以使用您为组指定的访问级别。

  1. 获取账户中的用户、服务 ID 或受信任配置文件。 注意要添加到访问组的成员的详细信息。

    获取所有用户：

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

    列出所有服务 ID：

    ibmcloud iam service-ids [--uuid]

    获取所有受信任的配置文件：

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

  2. 为访问组添加成员：

    使用 ibmcloud iam access-group-user-add 命令将用户添加到访问组。 下面的示例通过 CLI 将用户 name@example.com 添加到访问组 example_group。

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

    使用 ibmcloud iam access-group-service-id-add 命令将服务 ID 添加到访问组。 下面的示例将服务 ID example-service 添加到访问组 example_group 中：

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

    使用 ibmcloud iam access-group-trusted profile-add 命令将受信任的配置文件添加到访问组。 下面的示例将服务 ID PROFILE_ID 添加到访问组 example_group 中：

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

使用 API 向访问组添加成员

成员可以是用户、服务 ID 和可信配置文件。

  1. 如以下请求示例所示，列出账户中的用户、服务 ID 或受信任配置文件。 注意要添加到访问组的成员返回的 IBMid、服务 ID 或受信任配置文件 ID。

    名单用户：

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

    列出服务 ID：

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

    列出受信任的配置文件：

    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. 通过调用 IAM 访问组 API 将成员添加到访问组，如下例请求所示。

    成员类型必须是 user、service 或 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))

您添加到组中的成员可以使用您为组指定的访问级别。

使用 Terraform 为访问组添加成员

成员可以是用户、服务 ID 和可信配置文件。

  1. 在 main.tf 文件中创建一个参数。 下面的示例将服务 ID、受信任配置文件和 ID 为 user@ibm.com 的用户添加到访问组。

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

利用 IAM 访问组模块以编程方式管理组员资格，实现自动用户配置。 探索用于成员管理的 Terraform IBM 模块。

  1. 完成构建配置文件后，初始化 Terraform CLI。 更多信息，请参阅 初始化工作目录。

    terraform init

  2. 从 main.tf 文件调配资源。 如需了解更多信息，请参阅 使用 Terraform 配置基础架构。

    1. 运行 terraform plan 生成 Terraform 执行计划，以预览建议的操作。

      terraform plan

    2. 运行 terraform apply 以创建计划中定义的资源。

      terraform apply

您添加到组中的成员可以使用您为组指定的访问级别。