Affectation d'accès aux catalogues

En tant que propriétaire de compte, vous accordez des droits d'accès spécifiques à la gestion des catalogues aux utilisateurs, en fonction des tâches qu'ils doivent réaliser. Pour faciliter le processus d'affectation des accès, vous pouvez créer des groupes d'accès pour organiser un ensemble d'utilisateurs dans une même entité. Ainsi, vous pouvez affecter une règle au groupe en une seule fois, puis ajouter ou supprimer des utilisateurs dans le groupe si nécessaire.

Pour plus de détails, voir Gestion des accès dans IBM Cloud.

Configuration de vos groupes d'accès dans la console

Consultez les sections ci-dessous pour en savoir plus sur la création de groupes d'accès et sur l'affectation de règles IAM spécifiques à chaque groupe.

Accès administrateur dans la console

Un accès administrateur est requis pour définir des filtres de niveau de compte dans le catalogue IBM Cloud.

Connectez-vous à votre compte IBM Cloud.
Accédez à Gérer > Accès (IAM) > Groupes d'accès dans la console IBM Cloud.
Cliquez sur Créer.
Entrez private-catalog-admins comme nom de groupe et cliquez sur Créer.
Cliquez sur Accès > Attribuer un accès.
Sélectionnez Gestion des catalogues dans la liste des services.
Sélectionnez le catalogue auquel les utilisateurs doivent accéder.
Dans la section Accès à la plateforme, sélectionnez le rôle Administrateur.
Cliquez sur Ajouter > Affecter.

Accès éditeur dans la console

Un accès éditeur est requis pour créer des catalogues privés, définir des filtres au niveau du catalogue privé, ajouter votre offre logicielle au catalogue privé et mettre à jour, déprécier et restaurer votre logiciel.

Accédez à Groupes d'accès et cliquez sur Créer.
Entrez private-catalog-editors comme nom de groupe et cliquez sur Créer.
Cliquez sur Accès > Attribuer un accès.
Sélectionnez Gestion des catalogues dans la liste des services.
Sélectionnez le catalogue auquel les utilisateurs doivent accéder.
Dans la section Accès à la plateforme, sélectionnez le rôle Editeur.
Cliquez sur Ajouter.
Sélectionnez Servic;e Kubernetes dans la liste des services.
Sélectionnez votre cluster, puis choisissez les rôles Administrateur et Responsable.
Cliquez sur Ajouter.
Sélectionnez Schematics dans la liste des services.
Sélectionnez le rôle Responsable.
Cliquez sur Ajouter > Affecter.

Accès afficheur dans la console

Un accès afficheur est requis pour visualiser les catalogues privés, le catalogue IBM Cloud filtré et les paramètres de filtre.

Accédez à Groupes d'accès et cliquez sur Créer.
Entrez private-catalog-viewers comme nom de groupe et cliquez sur Créer.
Cliquez sur Accès > Attribuer un accès.
Sélectionnez Gestion des catalogues dans la liste des services.
Sélectionnez le catalogue auquel les utilisateurs doivent accéder.
Dans la section Accès à la plateforme, sélectionnez le rôle Afficheur.
Cliquez sur Ajouter > Affecter.

Vous devez également disposer d'un accès Afficheur sur le groupe de ressources auquel votre catalogue privé est affecté. Vous pouvez affecter votre catalogue privé à un groupe de ressources lorsque vous effectuez les étapes de création de votre catalogue privé. Pour plus d'informations, voir Personnalisation du catalogue IBM Cloud pour tous les utilisateurs du compte.

Pour affecter l'accès Afficheur au groupe de ressources de votre catalogue privé, procédez comme suit :

Accédez à Utilisateurs et sélectionnez l'utilisateur.
Sélectionnez Accès > Attribuer un accès.
Sélectionnez Tous les services activés pour l'identité et l'accès dans la liste des services.
Etendez l'accès aux Ressources spécifiques en fonction des attributs sélectionnés et sélectionnez votre groupe de ressources de catalogues privés.
Pour l'accès à la plateforme, sélectionnez le rôle Afficheur.
Cliquez sur Ajouter > Affecter.

Ajout d'utilisateurs à vos groupes d'accès dans la console

Après avoir configuré vos groupes d'accès, procédez comme suit pour ajouter des utilisateurs aux groupes :

Accédez à Utilisateurs et cliquez sur Inviter des utilisateurs.
Indiquez les adresses électroniques des utilisateurs. Si vous invitez plusieurs utilisateurs avec une même invitation, ils bénéficient tous du même droit d'accès.
Sélectionnez l'un des trois groupes d'accès que vous avez précédemment créés et cliquez sur Ajouter > Inviter.
Répétez ces étapes pour ajouter des utilisateurs à vos autres groupes d'accès.

Vous pouvez également accorder l'accès aux utilisateurs en ajoutant des profils sécurisés à vos groupes d'accès. Pour plus d'informations, voir What makes a good trusted profiles strategy? et Création de profils sécurisés.

Configuration de vos groupes d'accès à l'aide de l'interface de ligne de commande

Pour affecter des accès, exécutez la commande ibmcloud iam user-policy-create.

Accès administrateur à l'aide de l'interface de ligne de commande

Exécutez la commande suivante pour affecter l'accès Administrateur :

ibmcloud iam user-policy-create USER_NAME --roles Administrator --service-name globalcatalog-collection

Accès éditeur à l'aide de l'interface de ligne de commande

Exécutez la commande suivante pour affecter l'accès Editeur :

ibmcloud iam user-policy-create USER_NAME --roles Editor --service-name globalcatalog-collection

Accès afficheur à l'aide de l'interface de ligne de commande

Exécutez la commande suivante pour définir l'accès Afficheur :

ibmcloud iam user-policy-create USER_NAME --roles Viewer --service-name globalcatalog-collection

Ajout d'utilisateurs à vos groupes d'accès l'aide de l'interface de ligne de commande

Pour ajouter des utilisateurs à un groupe d'accès à l'aide de l'interface de ligne de commande, exécutez la commande ibmcloud iam access-group-user-add.

ibmcloud iam access-group-user-add GROUP_NAME USER_NAME [USER_NAME2...]

Par exemple, la commande suivante ajoute l'utilisateur name@example.com au groupe d'accès example_group.

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

Configuration de vos groupes d'accès à l'aide de l'API

Pour affecter l'accès, appelez l'API de gestion des règles IAM, comme illustré dans l'exemple ci-après. Remplacez la variable role_id par le rôle à affecter : Viewer, Editor ou Administrator.

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 RESOURCE_NAME",
  "subjects": [
    {
      "attributes": [
        {
          "name": "iam_id",
          "value": "IBMid-123453user"
        }
      ]
    }
  ],
  "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("iam_id")
        .value(EXAMPLE_USER_ID)
        .build();

PolicySubject policySubjects = new PolicySubject.Builder()
        .addAttributes(subjectAttribute)
        .build();

PolicyRole policyRoles = new PolicyRole.Builder()
        .roleId("crn:v1:bluemix:public:iam::::role:Viewer")
        .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();

ResourceTag policyResourceTag = new ResourceTag.Builder()
        .name("project")
        .value("prototype")
        .operator("stringEquals")
        .build();

PolicyResource policyResources = new PolicyResource.Builder()
        .addAttributes(accountIdResourceAttribute)
        .addAttributes(serviceNameResourceAttribute)
        .addTags(policyResourceTag)
        .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: 'iam_id',
        value: exampleUserId,
      },
    ],
  },
];
const policyRoles = [
  {
    role_id: 'crn:v1:bluemix:public:iam::::role:Viewer',
  },
];
const accountIdResourceAttribute = {
  name: 'accountId',
  value: exampleAccountId,
  operator: 'stringEquals',
};
const serviceNameResourceAttribute = {
  name: 'serviceType',
  value: 'service',
  operator: 'stringEquals',
};
const policyResourceTag = {
  name: 'project',
  operator: 'stringEquals',
  value: 'prototype',
};
const policyResources = [
  {
    attributes: [accountIdResourceAttribute, serviceNameResourceAttribute],
    tags: [policyResourceTag],
  },
];
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='iam_id', value=example_user_id)])
policy_roles = PolicyRole(
  role_id='crn:v1:bluemix:public:iam::::role:Viewer')
account_id_resource_attribute = ResourceAttribute(
  name='accountId', value=example_account_id)
service_name_resource_attribute = ResourceAttribute(
  name='serviceType', value='service')
policy_resource_tag = ResourceTag(
  name='project', value='prototype')
policy_resources = PolicyResource(
  attributes=[account_id_resource_attribute,
        service_name_resource_attribute],
  tags=[policy_resource_tag])

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("iam_id"),
  Value: &exampleUserID,
}
policySubjects := &iampolicymanagementv1.PolicySubject{
  Attributes: []iampolicymanagementv1.SubjectAttribute{*subjectAttribute},
}
policyRoles := &iampolicymanagementv1.PolicyRole{
  RoleID: core.StringPtr("crn:v1:bluemix:public:iam::::role:Viewer"),
}
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"),
}
policyResourceTag := &iampolicymanagementv1.ResourceTag{
  Name:     core.StringPtr("project"),
  Value:    core.StringPtr("prototype"),
  Operator: core.StringPtr("stringEquals"),
}
policyResources := &iampolicymanagementv1.PolicyResource{
  Attributes: []iampolicymanagementv1.ResourceAttribute{
    *accountIDResourceAttribute, *serviceNameResourceAttribute},
  Tags: []iampolicymanagementv1.ResourceTag{*policyResourceTag},
}

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

Configuration de la réponse attendue de l'accès

{
  "id": "12345678-abcd-1a2b-a1b2-1234567890ab",
  "type": "access",
  "description": "Viewer role access for all instances of SERVICE_NAME in the account.",
  "subjects": [
    {
      "attributes": [
        {
          "name": "iam_id",
          "value": "IBMid-123453user"
        }
      ]
    }
  ],
  "roles": [
    {
      "roles_id": "crn:v1:bluemix:public:iam::::role:Viewer"
    }
  ],
  "resources": [
    {
      "attributes": [
        {
          "name": "accountId",
          "value": "ACCOUNT_ID",
          "operator": "stringEquals"
        },
        {
          "name": "serviceName",
          "value": "SERVICE_NAME",
          "operator": "stringEquals"
        }
      ]
    },
    {
      "tags": [
        {
          "name": "project",
          "value": "moonshot",
          "operator": "stringEquals"
        },
        {
          "name": "pipeline",
          "value": "test",
          "operator": "stringEquals"
        }
      ]
    }
  ],
  "href": "https://iam.cloud.ibm.com/v1/policies/12345678-abcd-1a2b-a1b2-1234567890ab",
  "created_at": "2018-08-30T14:09:09.907Z",
  "created_by_id": "USER_ID",
  "last_modified_at": "2018-08-30T14:09:09.907Z",
  "last_modified_by_id": "USER_ID",
  "state": "active"
}

{
  "id": "12345678-abcd-1a2b-a1b2-1234567890ab",
  "type": "access",
  "description": "Viewer role access for all instances of SERVICE_NAME in the account.",
  "subjects": [
    {
      "attributes": [
        {
          "name": "iam_id",
          "value": "IBMid-123453user"
        }
      ]
    }
  ],
  "roles": [
    {
      "roles_id": "crn:v1:bluemix:public:iam::::role:Viewer"
    }
  ],
  "resources": [
    {
      "attributes": [
        {
          "name": "accountId",
          "value": "ACCOUNT_ID",
          "operator": "stringEquals"
        },
        {
          "name": "serviceName",
          "value": "SERVICE_NAME",
          "operator": "stringEquals"
        }
      ]
    },
    {
      "tags": [
        {
          "name": "project",
          "value": "moonshot",
          "operator": "stringEquals"
        },
        {
          "name": "pipeline",
          "value": "test",
          "operator": "stringEquals"
        }
      ]
    }
  ],
  "href": "https://iam.cloud.ibm.com/v1/policies/12345678-abcd-1a2b-a1b2-1234567890ab",
  "created_at": "2018-08-30T14:09:09.907Z",
  "created_by_id": "USER_ID",
  "last_modified_at": "2018-08-30T14:09:09.907Z",
  "last_modified_by_id": "USER_ID",
  "state": "active"
}

{
  "id": "12345678-abcd-1a2b-a1b2-1234567890ab",
  "type": "access",
  "description": "Viewer role access for all instances of SERVICE_NAME in the account.",
  "subjects": [
    {
      "attributes": [
        {
          "name": "iam_id",
          "value": "IBMid-123453user"
        }
      ]
    }
  ],
  "roles": [
    {
      "roles_id": "crn:v1:bluemix:public:iam::::role:Viewer"
    }
  ],
  "resources": [
    {
      "attributes": [
        {
          "name": "accountId",
          "value": "ACCOUNT_ID",
          "operator": "stringEquals"
        },
        {
          "name": "serviceName",
          "value": "SERVICE_NAME",
          "operator": "stringEquals"
        }
      ]
    },
    {
      "tags": [
        {
          "name": "project",
          "value": "moonshot",
          "operator": "stringEquals"
        },
        {
          "name": "pipeline",
          "value": "test",
          "operator": "stringEquals"
        }
      ]
    }
  ],
  "href": "https://iam.cloud.ibm.com/v1/policies/12345678-abcd-1a2b-a1b2-1234567890ab",
  "created_at": "2018-08-30T14:09:09.907Z",
  "created_by_id": "USER_ID",
  "last_modified_at": "2018-08-30T14:09:09.907Z",
  "last_modified_by_id": "USER_ID",
  "state": "active"
}

{
  "id": "12345678-abcd-1a2b-a1b2-1234567890ab",
  "type": "access",
  "description": "Viewer role access for all instances of SERVICE_NAME in the account.",
  "subjects": [
    {
      "attributes": [
        {
          "name": "iam_id",
          "value": "IBMid-123453user"
        }
      ]
    }
  ],
  "roles": [
    {
      "roles_id": "crn:v1:bluemix:public:iam::::role:Viewer"
    }
  ],
  "resources": [
    {
      "attributes": [
        {
          "name": "accountId",
          "value": "ACCOUNT_ID",
          "operator": "stringEquals"
        },
        {
          "name": "serviceName",
          "value": "SERVICE_NAME",
          "operator": "stringEquals"
        }
      ]
    },
    {
      "tags": [
        {
          "name": "project",
          "value": "moonshot",
          "operator": "stringEquals"
        },
        {
          "name": "pipeline",
          "value": "test",
          "operator": "stringEquals"
        }
      ]
    }
  ],
  "href": "https://iam.cloud.ibm.com/v1/policies/12345678-abcd-1a2b-a1b2-1234567890ab",
  "created_at": "2018-08-30T14:09:09.907Z",
  "created_by_id": "USER_ID",
  "last_modified_at": "2018-08-30T14:09:09.907Z",
  "last_modified_by_id": "USER_ID",
  "state": "active"
}

{
  "id": "12345678-abcd-1a2b-a1b2-1234567890ab",
  "type": "access",
  "description": "Viewer role access for all instances of SERVICE_NAME in the account.",
  "subjects": [
    {
      "attributes": [
        {
          "name": "iam_id",
          "value": "IBMid-123453user"
        }
      ]
    }
  ],
  "roles": [
    {
      "roles_id": "crn:v1:bluemix:public:iam::::role:Viewer"
    }
  ],
  "resources": [
    {
      "attributes": [
        {
          "name": "accountId",
          "value": "ACCOUNT_ID",
          "operator": "stringEquals"
        },
        {
          "name": "serviceName",
          "value": "SERVICE_NAME",
          "operator": "stringEquals"
        }
      ]
    },
    {
      "tags": [
        {
          "name": "project",
          "value": "moonshot",
          "operator": "stringEquals"
        },
        {
          "name": "pipeline",
          "value": "test",
          "operator": "stringEquals"
        }
      ]
    }
  ],
  "href": "https://iam.cloud.ibm.com/v1/policies/12345678-abcd-1a2b-a1b2-1234567890ab",
  "created_at": "2018-08-30T14:09:09.907Z",
  "created_by_id": "USER_ID",
  "last_modified_at": "2018-08-30T14:09:09.907Z",
  "last_modified_by_id": "USER_ID",
  "state": "active"
}

Ajout d'utilisateurs à vos groupes d'accès l'aide de l'API

Pour ajouter des utilisateurs à un groupe d'accès à l'aide de l'API, appelez l'API IAM Access Groups comme indiqué dans l'exemple suivant.

curl -X PUT -H "Authorization: {iam_token}" -H "Accept: application/json" -H "Content-Type: application/json" -d '{"members": [ {"iam_id": "IBMid-user1", "type": "user"}, {"iam_id": "iam-ServiceId-123", "type": "service"} ]}' "{base_url}/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();
AddMembersToAccessGroupOptions addMembersToAccessGroupOptions = new AddMembersToAccessGroupOptions.Builder()
  .accessGroupId(testGroupId)
  .addMembers(member1)
  .addMembers(member2)
  .build();
Response<AddGroupMembersResponse> response = service.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',
};
const params = {
  accessGroupId: testGroupId,
  members: [groupMember1, groupMember2],
};

iamAccessGroupsService.addMembersToAccessGroup(params)
  .then(res => {
    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')
members = [member1, member2]

add_group_members_response = iam_access_groups_service.add_members_to_access_group(
  access_group_id=test_group_id,
  members=members
).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"),
  },
}
addMembersToAccessGroupOptions := iamAccessGroupsService.NewAddMembersToAccessGroupOptions(testGroupID)
addMembersToAccessGroupOptions.SetMembers(groupMembers)
addGroupMembersResponse, response, err := iamAccessGroupsService.AddMembersToAccessGroup(addMembersToAccessGroupOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(addGroupMembersResponse, "", "  ")
fmt.Println(string(b))

Ajout d'une réponse attendue par les utilisateurs

{
  "members": [
    {
      "iam_id": "$IBM_ID",
      "type": "user",
      "created_at": "2019-01-01T01:01:00Z",
      "created_by_id": "CREATOR_ID",
      "status_code": 200
    },
    {
      "iam_id": "$SERVICE_ID",
      "status_code": 400,
      "trace": "12345678-abcd-1a2b-a1b2-1234567890ab",
      "errors": [
        {
          "code": "error_occurred",
          "message": "The service id is missing or incorrect"
        }
      ]
    }
  ]
}

{
  "members": [
    {
      "iam_id": "$IBM_ID",
      "type": "user",
      "created_at": "2019-01-01T01:01:00Z",
      "created_by_id": "CREATOR_ID",
      "status_code": 200
    },
    {
      "iam_id": "$SERVICE_ID",
      "status_code": 400,
      "trace": "12345678-abcd-1a2b-a1b2-1234567890ab",
      "errors": [
        {
          "code": "error_occurred",
          "message": "The service id is missing or incorrect"
        }
      ]
    }
  ]
}

{
  "members": [
    {
      "iam_id": "$IBM_ID",
      "type": "user",
      "created_at": "2019-01-01T01:01:00Z",
      "created_by_id": "CREATOR_ID",
      "status_code": 200
    },
    {
      "iam_id": "$SERVICE_ID",
      "status_code": 400,
      "trace": "12345678-abcd-1a2b-a1b2-1234567890ab",
      "errors": [
        {
          "code": "error_occurred",
          "message": "The service id is missing or incorrect"
        }
      ]
    }
  ]
}

{
  "members": [
    {
      "iam_id": "$IBM_ID",
      "type": "user",
      "created_at": "2019-01-01T01:01:00Z",
      "created_by_id": "CREATOR_ID",
      "status_code": 200
    },
    {
      "iam_id": "$SERVICE_ID",
      "status_code": 400,
      "trace": "12345678-abcd-1a2b-a1b2-1234567890ab",
      "errors": [
        {
          "code": "error_occurred",
          "message": "The service id is missing or incorrect"
        }
      ]
    }
  ]
}

{
  "members": [
    {
      "iam_id": "$IBM_ID",
      "type": "user",
      "created_at": "2019-01-01T01:01:00Z",
      "created_by_id": "CREATOR_ID",
      "status_code": 200
    },
    {
      "iam_id": "$SERVICE_ID",
      "status_code": 400,
      "trace": "12345678-abcd-1a2b-a1b2-1234567890ab",
      "errors": [
        {
          "code": "error_occurred",
          "message": "The service id is missing or incorrect"
        }
      ]
    }
  ]
}

Ajout d'utilisateurs à vos groupes d'accès l'aide de Terraform

Avant de pouvoir ajouter des utilisateurs à vos groupes d'accès à l'aide de Terraform, vérifiez que vous avez effectué les opérations suivantes:

Installez l'interface de ligne de commande Terraform et configurez le plug-in IBM Cloud Provider pour Terraform. Pour plus d'informations, voir le tutoriel Initiation à 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 des ressources à l'aide du langage de configuration HashiCorp. Pour plus d'informations, voir la documentation de Terraform.

Procédez comme suit pour ajouter des utilisateurs à vos groupes d'accès :

Dans votre fichier de configuration Terraform, recherchez le code Terraform que vous avez utilisé pour créer le groupe d'accès et notez la valeur access_group_id affectée à votre groupe d'accès.
Ajoutez un membre au groupe d'accès.
```
resource "ibm_iam_access_group_members" "accgroupmem" {
access_group_id = ibm_iam_access_group.accgroup.id
ibm_ids = ["test@in.ibm.com"]
}
```
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 Group de Terraform IBM Modules(TIM) pour gérer l'appartenance à un groupe d'accès ainsi que les politiques dans une configuration cohérente et réutilisable.
Une fois que vous avez terminé de générer votre fichier de configuration, initialisez l'interface de ligne de commande Terraform. Pour plus d'informations, voir Initialisation des répertoires de travail.
```
terraform init
```
Mettez à disposition les ressources à partir du fichier main.tf. Pour plus d'informations, voir Mise à disposition d'une 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 terraform apply pour créer les ressources définies dans le plan.
```
terraform apply
```