Avant de commencer

Pour gérer ou créer de nouveaux groupes d'accès, vous devez disposer du type d'accès suivant :

• Administrateur ou éditeur sur le service de gestion des comptes Groupes d'accès IAM associé au compte
• Administrateur ou éditeur pour tous les services de gestion des comptes
• Vous devez être le propriétaire du compte

En outre, un accès peut être affecté à un administrateur ou à un éditeur afin de gérer un groupe spécifique en créant une règle d'accès où la ressource correspond à l'ID du groupe d'accès. Pour plus d'informations sur les règles d'accès et les rôles pour le service Groupes d'accès IAM, voir Accès IAM.

Avant de commencer

Avant de pouvoir configurer des groupes d'accès à l'aide de Terraform, assurez-vous d'avoir effectué les opérations suivantes :

• Installez le CLI Terraform et configurez le plug-in IBM Cloud Provider pour Terraform. Pour plus d'informations, voir le tutoriel Getting started with Terraform sur IBM Cloud®. Ce plug-in résume les API IBM Cloud utilisées pour effectuer cette tâche.
• Créez un fichier de configuration Terraform nommé main.tf. Dans ce fichier, vous définissez les ressources en utilisant le langage de configuration HashiCorp. Pour plus d'informations, voir la documentation de Terraform.

Création d'un groupe d'accès dans la console

Un nom unique est requis pour différencier les groupes d'accès dans le compte. Pour créer un groupe d'accès, procédez comme suit :

1. Dans la console IBM Cloud®, cliquez sur Gérer > Accès (IAM), puis sélectionnez Groupes d'accès.
2. Cliquez sur Créer.
3. Entrez un nom unique permettant d'identifier votre groupe d'accès et une description (facultatif), puis cliquez sur Créer.

Continuez ensuite à configurer vos groupes en ajoutant des utilisateurs, des ID de service ou des profils sécurisés. Vous pouvez ajouter des utilisateurs manuellement ou en créant des règles dynamiques. Ou, vous pouvez commencer à affecter l'accès au groupe et déterminer ultérieurement la personne que vous souhaitez ajouter au groupe d'accès.

Vous pouvez supprimer un groupe en sélectionnant l'option Retirer le groupe. Lorsque vous retirez un groupe du compte, vous retirez tous les utilisateurs et ID de service du groupe et tous les accès affectés à ce dernier.

Création d'un groupe d'accès à l'aide de l'interface de ligne de commande

Pour créer un groupe d'accès en utilisant l'interface de ligne de commande, vous pouvez utiliser la commande ibmcloud iam access-group-create.

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

Un nom unique est requis pour différencier les groupes d'accès dans le compte.

Création d'un groupe d'accès à l'aide de l'API

Vous pouvez créer des groupes d'accès de manière programmatique en appelant l'API IBM Cloud® Identity and Access Management(IAM)Access Groups, comme le montre l'exemple de demande suivant. L'exemple crée un groupe d'accès pour les responsables du compte :

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

Un nom unique est requis pour différencier les groupes d'accès dans le compte.

Création d'un groupe d'accès à l'aide de Terraform

Suivez les étapes suivantes pour créer des groupes d'accès à l'aide de Terraform :

1. Créez un argument dans votre fichier main.tf. L'exemple ci-après crée un groupe d'accès à l'aide de la ressource ibm_iam_access_group, name représentant un nom unique permettant d'identifier le groupe d'accès.

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

   Vous pouvez également spécifier la description du groupe d'accès dans l'option description. Pour plus d'informations, voir les détails de la référence des arguments sur la page Terraform Identity and Access Management(IAM ).

Rationalisez la gestion des accès en regroupant les utilisateurs et les identifiants de service avec les modules Terraform IBM(TIM) pour les groupes d'accès IAM.

1. Une fois que vous avez terminé de construire votre fichier de configuration, initialisez le CLI Terraform. Pour plus d'informations, voir Initialisation des répertoires de travail.

   terraform init
   

2. Fournir les ressources à partir du fichier main.tf. Pour plus d'informations, voir Provisionnement de l'infrastructure avec Terraform.

   1. Exécutez terraform plan pour générer un plan d'exécution Terraform afin de prévisualiser les actions proposées.

      terraform plan
      

   2. Exécutez le site terraform apply pour créer les ressources définies dans le plan.

      terraform apply
      

Affectation d'un accès à un groupe dans la console

Après avoir configuré votre groupe avec des utilisateurs et des ID de service, vous pouvez affecter une règle d'accès commune au groupe. N'oubliez pas que les règles que vous définissez pour le groupe s'appliquent à toutes les entités qu'il contient. Par exemple, l'attribution de stratégies d'accès à un groupe d'accès délègue aux administrateurs de ce groupe d'accès la possibilité d'accorder ou de révoquer l'accès à des utilisateurs, à des services ou à des profils de confiance.

L'accès de l'administrateur à tous les éléments du compte inclut la possibilité de révoquer l'accès d'autres utilisateurs ayant le rôle d'administrateur.

Procédez comme suit pour attribuer un accès à un groupe dans la console :

1. Dans la console IBM Cloud, cliquez sur Gérer > Accès (IAM), puis sélectionnez Groupes d'accès.

2. Pour le groupe auquel vous souhaitez affecter un accès, sélectionnez l'icône Actions , puis cliquez sur Attribuer un accès.

3. Vous pouvez affecter l'accès aux seules ressources que vous gérez. Vous devez affecter au moins une option d'accès. Pour les options d'accès que vous n'ajoutez ou ne configurez pas, la valeur par défaut Aucun accès lui est affectée. Selon les options que vous êtes autorisé à gérer, vous pouvez affecter les types d'accès suivants :

   • Un groupe de services, comme tous les services d'identité et d'accès, tous les services de gestion des comptes ou tous les services de gestion des comptes IAM.
   • Un service spécifique

4. Vous pouvez ensuite étendre l'accès à toutes les ressources ou à des ressources spécifiques en fonction des attributs de ressource sélectionnés, tels que les balises de gestion des accès, l'emplacement ou le groupe de ressources.

5. Sélectionnez tous les rôles qui s'appliquent. Pour afficher les actions mappées à chaque rôle, cliquez sur les numéros figurant en regard de chaque rôle. Certains services prennent en charge l'utilisation d'opérateurs avancés pour accorder l'accès aux ressources qui correspondent à des conventions de dénomination particulières. Voir Affectation d'accès à l'aide de règles génériques pour plus d'informations.

6. Cliquez sur Vérifier.

7. Cliquez sur Ajouter pour ajouter votre configuration de règles à votre récapitulatif de règles.

8. Cliquez sur Affecter.

Vous pouvez également affecter des droits d'accès en utilisant des balises de gestion d'accès. Pour plus d'informations, voir Contrôle de l'accès aux ressources à l'aide d'étiquettes.

Affectation d'un accès à un groupe à l'aide de l'interface de ligne de commande

Pour créer une règle de groupe d'accès en utilisant l'interface de ligne de commande, vous pouvez utiliser la commande 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]}

Affectation d'un accès à un groupe à l'aide de l'API

Vous pouvez programmer l'attribution d'un accès à un groupe en appelant l'API de gestion des politiques IBM Cloud® Identity and Access Management(IAM), comme le montre l'exemple de demande suivant. L'exemple affecte le rôle Editor à un groupe d'accès pour une instance d'un service :

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

Vous pouvez attribuer un accès à un groupe de services. Pour attribuer l'accès aux services "All Identity and Access Enabled ", spécifiez serviceType pour l'attribut name et utilisez l'attribut value service. Pour attribuer l'accès aux services de gestion de tous les comptes, spécifiez serviceType pour l'attribut name et utilisez l'attribut value platform_service. Pour attribuer l'accès au sous-ensemble de services de gestion de comptes Tous les services de gestion de comptes IAM, spécifiez service_group_id pour l'attribut name et utilisez l'attribut value IAM.

Affectation d'un accès à un groupe à l'aide de Terraform

Après avoir configuré votre groupe, suivez les étapes suivantes pour lui attribuer un accès à l'aide de Terraform.

1. Créez un argument dans votre fichier main.tf. Les exemples ci-après créent une règle IAM qui octroie aux membres du groupe d'accès le rôle de plateforme IAM Viewer à tous les services IAM à l'aide de la ressource ibm_iam_access_group_policy. Pour effectuer cette tâche, vous devez disposer d'un ID IAM existant d'un groupe d'accès.

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

   Pour plus d'informations, voir les détails de la référence des arguments sur la page Terraform Identity and Access Management(IAM ).

Vous pouvez également utiliser le module IAM Access Groups pour gérer les groupes d'accès et les politiques à l'échelle. L'exemple suivant illustre l'utilisation du module :

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

Pour plus d'informations sur les modules Terraform IBM, voir À propos des modules Terraform IBM.

1. Une fois que vous avez terminé de construire votre fichier de configuration, initialisez le CLI Terraform. Pour plus d'informations, voir Initialisation des répertoires de travail.

   terraform init
   

2. Fournir les ressources à partir du fichier main.tf. Pour plus d'informations, voir Provisionnement de l'infrastructure avec Terraform.

   1. Exécutez terraform plan pour générer un plan d'exécution Terraform afin de prévisualiser les actions proposées.

      terraform plan
      

   2. Exécutez le site terraform apply pour créer les ressources définies dans le plan.

      terraform apply
      

Ajouter des membres à un groupe d'accès dans la console

Les membres peuvent être des utilisateurs, des identifiants de service et des profils de confiance.

1. Dans la console IBM Cloud®, cliquez sur Gérer > Accès (IAM), puis sélectionnez Groupes d'accès.

2. Cliquez sur le groupe d'accès que vous avez créé.

3. Ajouter des membres.

   1. Cliquez sur Ajouter des utilisateurs.
   2. Cliquez sur Service IDs > Add Service IDs.
   3. Cliquez sur Profils de confiance > Ajouter des profils de confiance.

   Si vous ne voyez pas le bouton permettant d'ajouter des membres, il se peut que vous n'y ayez pas accès. Examinez les conditions d'accès et contactez votre administrateur de compte pour obtenir l'accès.

4. Sélectionnez les utilisateurs, les identifiants de service ou les profils de confiance que vous souhaitez ajouter au groupe et cliquez sur Ajouter au groupe.

Les membres que vous ajoutez au groupe peuvent utiliser le niveau d'accès que vous attribuez au groupe.

Ajouter des membres à un groupe d'accès à l'aide de la CLI

Les membres peuvent être des utilisateurs, des identifiants de service et des profils de confiance. Les membres que vous ajoutez au groupe peuvent utiliser le niveau d'accès que vous attribuez au groupe.

1. Obtenir les utilisateurs, les identifiants de service ou les profils de confiance de votre compte. Notez les détails qui sont renvoyés pour le membre que vous voulez ajouter au groupe d'accès.

   Obtenir tous les utilisateurs:

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

   Dresser la liste de tous les identifiants de service:

   ibmcloud iam service-ids [--uuid]
   

   Obtenir tous les profils de confiance:

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

2. Ajouter des membres au groupe d'accès :

   Utilisez la commande ibmcloud iam access-group-user-add pour ajouter des utilisateurs à un groupe d'accès. L'exemple suivant ajoute l'utilisateur name@example.com au groupe d'accès example_group à l'aide de la CLI.

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

   Utilisez la commande ibmcloud iam access-group-service-id-add pour ajouter des identifiants de service à un groupe d'accès. L'exemple suivant ajoute l'ID de service example-service au groupe d'accès example_group:

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

   Utilisez la commande ibmcloud iam access-group-trusted profile-add pour ajouter des profils approuvés à un groupe d'accès. L'exemple suivant ajoute l'ID de service PROFILE_ID au groupe d'accès example_group:

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

Ajouter des membres à un groupe d'accès en utilisant l'API

Les membres peuvent être des utilisateurs, des identifiants de service et des profils de confiance.

1. Dressez la liste des utilisateurs, des identifiants de service ou des profils de confiance de votre compte, comme indiqué dans l'exemple de demande suivant. Notez l'adresse IBMid, l'ID de service ou l'ID de profil de confiance qui est renvoyé pour le membre que vous souhaitez ajouter au groupe d'accès.

   Utilisateurs de la liste:

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

   Liste des identifiants de service:

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

   Liste des profils de confiance:

   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. Ajoutez des membres au groupe d'accès en appelant l'API IAM Access Groups, comme indiqué dans l'exemple de demande suivant.

   Le type de membre doit être user, service ou profile.

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

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

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

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

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

Les membres que vous ajoutez au groupe peuvent utiliser le niveau d'accès que vous attribuez au groupe.

Ajouter des membres à un groupe d'accès en utilisant Terraform

Les membres peuvent être des utilisateurs, des identifiants de service et des profils de confiance.

1. Créez un argument dans votre fichier main.tf. L'exemple suivant ajoute à un groupe d'accès un identifiant de service, un profil de confiance et un utilisateur portant l'identifiant 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]
   }
   

Gérer l'appartenance à un groupe de manière programmatique avec le module IAM Access Groups pour un provisionnement automatisé des utilisateurs. Explorez les modules Terraform IBM pour la gestion des membres.

1. Une fois que vous avez terminé de construire votre fichier de configuration, initialisez le CLI Terraform. Pour plus d'informations, voir Initialisation des répertoires de travail.

   terraform init
   

2. Fournir les ressources à partir du fichier main.tf. Pour plus d'informations, voir Provisionnement de l'infrastructure avec Terraform.

   1. Exécutez terraform plan pour générer un plan d'exécution Terraform afin de prévisualiser les actions proposées.

      terraform plan
      

   2. Exécutez le site terraform apply pour créer les ressources définies dans le plan.

      terraform apply
      

Les membres que vous ajoutez au groupe peuvent utiliser le niveau d'accès que vous attribuez au groupe.