IBM Cloud Docs
设置访问组

设置访问组

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

为访问组分配了用于向该组的成员授予角色和许可权的策略。 访问组的成员可以包含多种身份类型，例如用户，服务标识和可信概要文件。 成员将继承分配给访问组的策略，角色和许可权，还将保留单独分配给他们的角色。

例如，如果向用户分配了计费服务上的 viewer 角色，并将其添加到在目录管理服务上具有 publisher 角色的访问组，那么他们将保留其 viewer 角色，尽管这不是访问组许可权的一部分。

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

准备工作

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

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

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

准备工作

在使用 Terraform 设置访问组之前，请确保已完成以下操作:

  • 安装 Terraform CLI 并为 Terraform 配置 IBM Cloud 提供程序插件。 有关更多信息，请参阅 Terraform on IBM Cloud®入门 教程。 该插件对用于完成此任务的 IBM Cloud API 进行抽象。
  • 创建一个名为 main.tf 的Terraform配置文件。 在此文件中，您使用 HashiCorp 配置语言来定义资源。 有关更多信息，请参阅 Terraform 文档。

在控制台中创建访问组

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

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

接下来，继续通过添加用户，服务标识或可信概要文件来设置组。 您可以手动或通过 创建动态规则 来添加用户。 或者，您可以开始分配组访问权，并决定以后要添加到访问组的人员。

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

使用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: {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) 页面上的参数参考详细信息。

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

    terraform init

  3. 从 main.tf 文件供应资源。 有关更多信息，请参阅 使用 Terraform 供应基础架构。

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

      terraform plan

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

      terraform apply

在控制台中分配对组的访问权

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

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

使用以下步骤在控制台中分配对组的访问权:

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

使用 API 分配对组的访问权

您可以通过调用 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 标识才能完成该任务。

    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) 页面上的参数参考详细信息。

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

    terraform init

  3. 从 main.tf 文件供应资源。 有关更多信息，请参阅 使用 Terraform 供应基础架构。

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

      terraform plan

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

      terraform apply

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

成员可以是用户，服务标识和可信概要文件。

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

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

  3. 添加成员。

    1. 单击添加用户。
    2. 单击 服务标识> 添加服务标识。
    3. 单击 可信概要文件> 添加可信概要文件。

    如果未看到用于添加成员的按钮，那么您可能没有访问权。 查看 访问权需求，并与帐户管理员联系以获取访问权。

  4. 选择要添加到组的用户，服务标识或可信概要文件，然后单击 添加到组。

添加到组的成员可以使用分配给组的访问级别。

使用 CLI 将成员添加到访问组

成员可以是用户，服务标识和可信概要文件。 添加到组的成员可以使用分配给组的访问级别。

  1. 获取帐户中的用户，服务标识或可信概要文件。 请注意针对要添加到访问组的成员返回的详细信息。

    获取所有用户:

    ibmcloud account users [-c, --account-id ACCOUNT_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 命令将服务标识添加到访问组。 以下示例将服务标识 example-service 添加到访问组 example_group:

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

    使用 ibmcloud iam access-group-trusted profile-add 命令将可信概要文件添加到访问组。 以下示例将服务标识 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 将成员添加到访问组

成员可以是用户，服务标识和可信概要文件。

  1. 列示帐户中的用户，服务标识或可信概要文件，如以下示例请求中所示。 请注意针对要添加到访问组的成员返回的 IBMid，服务标识或可信概要文件标识。

    列出用户:

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

    列出服务标识:

    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 将成员添加到访问组

成员可以是用户，服务标识和可信概要文件。

  1. 在 main.tf 文件中创建自变量。 以下示例将服务标识，可信概要文件和标识为 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]
}

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

    terraform init

  3. 从 main.tf 文件供应资源。 有关更多信息，请参阅 使用 Terraform 供应基础架构。

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

      terraform plan

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

      terraform apply

添加到组的成员可以使用分配给组的访问级别。