Invitation d'utilisateurs dans la console

Pour inviter des utilisateurs, procédez comme suit :

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

2. Cliquez sur Inviter des utilisateurs.

3. 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. Vous pouvez restreindre l'appartenance à votre compte en fonction du domaine des utilisateurs invités. Ainsi, seuls les utilisateurs d'un domaine spécifique peuvent être invités au compte.

   Pour plus d'informations, voir Restreindre les domaines utilisateur pour les invitations de compte.

4. Ajoutez une ou plusieurs options d'accès 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 :

   • Ajouter des utilisateurs à des groupes d'accès. Cliquez sur Ajouter pour chaque groupe d'accès auquel les utilisateurs doivent appartenir.
   • Affecter manuellement un accès à des utilisateurs. Développez la section pour attribuer des politiques d'accès IAM individuelles ou des autorisations d'infrastructure classiques.
     • Sélectionnez Infrastructure classique, puis choisissez l'un des trois ensembles de droits.
     • Sélectionnez un groupe de services comme Tous les services d'identité et d'accès, Tous les services de gestion de compte, et Tous les services de gestion de compte IAM, ou un service spécifique. Ensuite, vous pouvez étendre l'accès à l'ensemble du compte ou à un seul groupe de ressources. Sélectionnez enfin tous les rôles applicables. 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.
     • Sélectionnez Gestion des comptes, puis choisissez l'option "Tous les services de gestion des comptes" ou sélectionnez un service spécifique. Sélectionnez enfin tous les rôles applicables.

5. Sélectionnez Ajouter pour sauvegarder l'affectation d'accès dans l'invitation.

6. Une fois que vous avez ajouté toutes les affectations d'accès nécessaires, cliquez sur Inviter.

Vous pouvez annuler une invitation pour tous les utilisateurs affichés dans l'état Traitement ou En attente dans la colonne État de la Page Utilisateurs. Si un utilisateur invité n'a pas reçu d'invitation, vous pouvez renvoyer l'invitation à n'importe quel utilisateur dont l'état indique En attente. Vous ne pouvez ajouter d'autres règles et droits qu'une fois que l'utilisateur a accepté l'invitation.

Ajout d'utilisateurs VPN uniquement

N'importe quel utilisateur disposant des droits suivants peuvent ajouter un utilisateur VPN uniquement :

• Pour l'infrastructure classique, vous devez disposer du droit Gérer les utilisateurs dans le compte.
• Pour l'accès IAM, vous devez disposer du rôle Administrateur ou Editeur sur le service de gestion des comptes Gestion des utilisateurs.

Pour ajouter un utilisateur VPN uniquement, procédez comme suit :

1. Sur la page Utilisateurs, cliquez sur Ajouter un utilisateur VPN uniquement.
2. Entrez les détails des informations personnelles de l'utilisateur.
3. Cliquez sur Sauvegarder.

Invitation d'utilisateur via l'interface de ligne de commande

Pour inviter des utilisateurs à l'aide de l'interface de ligne de commande, exécutez la commande suivante :

ibmcloud account user-invite USER_EMAIL [-o ORG [--org-role ORG_ROLE] [-s SPACE, --space-role SPACE_ROLE]]

En utilisant le CLI, vous pouvez choisir de ne pas attribuer d'accès et de travailler sur l'attribution d'accès plus tard. Pour plus d'informations sur les paramètres de commande, voir ibmcloud account user-invite.

Invitation d'utilisateur via API

Vous pouvez utiliser l'API pour inviter des utilisateurs en masse. Tous les utilisateurs figurant dans une seule invitation reçoivent le même accès. Lorsque vous invitez des utilisateurs via l'API, vous entrez dans une liste les adresses e-mail séparées par des virgules. chaque entrée étant placée entre guillemets. Cet exemple affecte l'accès en ajoutant l'utilisateur à un groupe d'accès.

curl -X POST https://user-management.cloud.ibm.com/v2/accounts/987d4cfd77b04e9b9e1a6asdcc861234/users -H 'Authorization: Bearer <IAM_TOKEN>'
  -H 'Content-Type: application/json' -d '{
      "users": [
      {
        "email": "cloud_api_example_member@ibm.com",
        "account_role": "Member"
      }],
      "iam_policy": [{
        "type": "access",
        "roles": [{
          "role_id": "crn:v1:bluemix:public:iam::::role:Viewer"
        }],
        "resources": [{
          "attributes": [{
              "name": "accountId",
              "value": "987d4cfd77b04e9b9e1a6asdcc861234"
            },
            {
              "name": "resourceType",
              "value": "resource-group"
            },
            {
              "name": "resource",
              "value": "2c7449dd871049c29ec3a53853ce123e"
            }
          ]
        }]
      }],
      "access_groups":[
        "AccessGroupId-******-0f54-4d4f-89c2-e5fdc0b9a28c",
        "AccessGroupId-******-3087-4395-a382-a8e8ff9ccc23"
      ]
    }'

InviteUser inviteUserModel = new InviteUser.Builder()
        .email(memberEmail)
        .accountRole("Member")
        .build();
Role roleModel = new Role.Builder()
        .roleId(viewerRoleId)
        .build();
Attribute attributeModel = new Attribute.Builder()
        .name("accountId")
        .value(accountId)
        .build();
Attribute attributeModel2 = new Attribute.Builder()
        .name("resourceGroupId")
        .value("*")
        .build();
Resource resourceModel = new Resource.Builder()
        .addAttributes(attributeModel)
        .addAttributes(attributeModel2)
        .build();
InviteUserIamPolicy inviteUserIamPolicyModel = new InviteUserIamPolicy.Builder()
        .type("access")
        .addRoles(roleModel)
        .addResources(resourceModel)
        .build();
InviteUsersOptions inviteUsersOptions = new InviteUsersOptions.Builder()
        .accountId(accountId)
        .addUsers(inviteUserModel)
        .addIamPolicy(inviteUserIamPolicyModel)
        .addAccessGroups(accessGroupId)
        .build();
Response<InvitedUserList> response = adminService.inviteUsers(inviteUsersOptions).execute();
InvitedUserList invitedUserList = response.getResult();
System.out.println(invitedUserList);

const inviteUserModel = {
  email: memberEmail,
  account_role: 'Member',
};
const roleModel = {
  role_id: viewerRoleId,
};
const attributeModel = {
  name: 'accountId',
  value: accountId,
};
const attributeModel2 = {
  name: 'resourceGroupId',
  value: '*',
};
const resourceModel = {
  attributes: [attributeModel, attributeModel2],
};
const inviteUserIamPolicyModel = {
  type: 'access',
  roles: [roleModel],
  resources: [resourceModel],
};
const params = {
  accountId: accountId,
  users: [inviteUserModel],
  iamPolicy: [inviteUserIamPolicyModel],
  accessGroups: [accessGroupId],
};
userManagementAdminService.inviteUsers(params)
  .then(res => {
    deleteUserId = res.result.resources[0].id;
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch(err => {
    console.warn(err)
  });

invite_user_model = {
  'email': member_email,
  'account_role': 'Member'
}
role_model = {'role_id': viewer_role_id}
attribute_model = {'name': 'accountId', 'value': account_id}
attribute_model2 = {'name': 'resourceGroupId', 'value': '*'}
resource_model = {'attributes': [attribute_model, attribute_model2]}
invite_user_iam_policy_model = {
  'type': 'access',
  'roles': [role_model],
  'resources': [resource_model]
}
invite_user_response = user_management_admin_service.invite_users(
  account_id=account_id,
  users=[invite_user_model],
  iam_policy=[invite_user_iam_policy_model],
  access_groups=[access_group_id]
).get_result()
print(json.dumps(invite_user_response, indent=2))

inviteUserModel := &usermanagementv1.InviteUser{
  Email:       &memberEmail,
  AccountRole: core.StringPtr("Member"),
}
roleModel := &usermanagementv1.Role{
  RoleID: &viewerRoleID,
}
attributeModel := &usermanagementv1.Attribute{
  Name:  core.StringPtr("accountId"),
  Value: &accountID,
}
attributeModel2 := &usermanagementv1.Attribute{
  Name:  core.StringPtr("resourceGroupId"),
  Value: core.StringPtr("*"),
}
resourceModel := &usermanagementv1.Resource{
  Attributes: []usermanagementv1.Attribute{*attributeModel, *attributeModel2},
}
inviteUserIamPolicyModel := &usermanagementv1.InviteUserIamPolicy{
  Type:      core.StringPtr("access"),
  Roles:     []usermanagementv1.Role{*roleModel},
  Resources: []usermanagementv1.Resource{*resourceModel},
}
inviteUsersOptions := &usermanagementv1.InviteUsersOptions{
  AccountID:    &accountID,
  Users:        []usermanagementv1.InviteUser{*inviteUserModel},
  IamPolicy:    []usermanagementv1.InviteUserIamPolicy{*inviteUserIamPolicyModel},
  AccessGroups: []string{accessGroupID},
}
invitedUserList, response, err := userManagementAdminService.InviteUsers(inviteUsersOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(invitedUserList, "", "  ")
fmt.Println(string(b))

Vous pouvez attribuer un accès à un groupe de services. Pour attribuer l'accès à tous les services d'identité et d'accès, spécifiez " serviceType pour l'attribut " name " et utilisez les attributs " value et " service. Pour attribuer l'accès aux services de gestion de tous les comptes, spécifiez " serviceType pour l'attribut " name " et utilisez les attributs " value et " 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 les attributs " value et " IAM.

Invitation d'utilisateurs à l'aide de Terraform

Vous pouvez inviter des utilisateurs à votre compte IBM Cloud en utilisant Terraform.

1. Créez un argument dans votre fichier " main.tf. L'exemple suivant invite les utilisateurs en utilisant la ressource ibm_iam_user_invite, où users est la liste des identifiants électroniques des utilisateurs à inviter.

   resource "ibm_iam_user_invite" "invite_user" {
    users = ["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 ).
2. Fournir les ressources 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 " terraform apply pour créer les ressources définies dans le plan.

      terraform apply
      

Annulation ou renvoi des invitations en attente

Après avoir invité de nouveaux utilisateurs à rejoindre votre compte, IBM Cloud oblige tous les utilisateurs, à l'exception des utilisateurs VPN uniquement, à accepter l'invitation à devenir un utilisateur actif de votre compte.

L'invitation expire au bout de 30 jours. Les nouveaux utilisateurs d'IBM Cloud peuvent uniquement accepter une invitation en cliquant sur le lien d'invitation qu'ils ont reçu par courrier électronique.

Vous pouvez annuler une invitation pour tous les utilisateurs affichés dans l'état Traitement ou En attente dans la colonne État de la Page Utilisateurs. Si un utilisateur invité n'a pas reçu d'invitation, vous pouvez renvoyer l'invitation à n'importe quel utilisateur dont l'état indique En attente.

1. Accédez à Page Utilisateurs.
2. Localisez la ligne pour l'utilisateur dans l'état Processing ou Pending.
3. Cliquez sur l'icône Actions , puis choisissez Renvoyer l'invitation ou Annuler l'invitation.

Acceptation des invitations dans la console

Si l'utilisateur invité est déjà membre d'IBM Cloud, il reçoit un lien d'invitation dans ses notifications et par courrier électronique. Sur la page Notifications, les utilisateurs peuvent utiliser le champ de recherche pour localiser une invitation ou filtrer par le type de notification appelé account. Pour plus d'informations, voir Gérer les notifications d'invitation et Afficher les notifications.

Acceptation des invitations à l'aide de l'interface de ligne de commande

Si l'utilisateur invité est déjà membre de IBM Cloud, il peut accepter des invitations à l'aide de l'interface de ligne de commande. Dans la commande ibmcloud login suivante, ACCOUNT_ID est l'ID du compte ciblé que l'utilisateur est invité à rejoindre.

ibmcloud login -c ACCOUNT_ID --accept

Acceptation des invitations à l'aide de l'API

Si l'utilisateur invité est déjà membre de IBM Cloud, il peut accepter des invitations à l'aide de l'API. Dans l'exemple suivant, ACCOUNT_ID est l'ID du compte ciblé que l'utilisateur est invité à rejoindre et IAM_TOKEN appartient à l'invité.

curl -X POST \
  'https://iam.cloud.ibm.com/v2/users/accept' \
  --header 'Authorization: Bearer <IAM_TOKEN>' \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "account_id": "<ACCOUNT ID>"
  }

Suppression d'un utilisateur d'un compte à l'aide de la console

Lorsque vous supprimez un utilisateur d'un compte, celui-ci ne peut plus se connecter à la console, ni basculer dans votre compte ou accéder aux ressources du compte. La suppression d'un utilisateur d'un compte ne supprime pas l'IBMid de l'utilisateur.

Pour retirer un utilisateur d'un compte, procédez comme suit :

1. Dans la console IBM Cloud®, cliquez sur Gérer > Accès (IAM), puis sélectionnez Utilisateurs.
2. Dans la ligne de l'utilisateur auquel vous souhaitez attribuer l'accès, sélectionnez l'icône Actions > Supprimer un utilisateur.

Toutes les ressources créées par l'utilisateur restent dans le compte, mais toutes les clés d'API IBM Cloud créées par l'utilisateur sont supprimées. L'utilisateur n'a plus accès au travail avec les ressources qu'il a créées. Le propriétaire du compte ou un administrateur de ce service ou de cette instance de service peut affecter d'autres utilisateurs au travail avec les ressources, ou les supprimer du compte.

Si vous recevez un message d'erreur indiquant qu'un utilisateur d'infrastructure classique ne peut pas être supprimé, vérifiez qu'un nouveau parent a été affecté à tous les descendants dans la hiérarchie de cet utilisateur ou que ceux-ci ont été désactivés dans le compte, ou supprimés. Puis, vous pouvez réessayer.

Au lieu de supprimer un utilisateur de votre compte, vous pouvez lui attribuer une politique d'accès assortie d'une condition temporaire basée sur la durée. Ainsi, l'utilisateur peut se connecter à la console et voir le compte dans sa liste de comptes, mais il ne peut pas accéder aux ressources du compte avant le début de la politique ou après son expiration. Pour plus d'informations, voir Création d'une condition temporaire basée sur le temps.

Retrait d'un utilisateur d'un compte à l'aide de l'interface de ligne de commande

Pour retirer un utilisateur d'un compte, exécutez la commande suivante :

ibmcloud account user-remove USER_ID [-c ACCOUNT_ID] [-f, --force]

Pour les options de commande, voir Commandes CLI de gestion des comptes et des utilisateurs.

Retrait d'un utilisateur d'un compte à l'aide de l'API

Pour retirer un utilisateur d'un compte, appelez l'API Gestion des utilisateurs, comme illustré dans l'exemple de demande suivant.

Remplacez les variables par l'ID IAM de l'utilisateur. Vous devez utiliser un jeton utilisateur pour l'autorisation. Les ID de service ne peuvent pas retirer des utilisateurs d'un compte.

curl -X DELETE https://user-management.cloud.ibm.com/v2/accounts/987d4cfd77b04e9b9e1a6asdcc861234/users/IBMid-1000000000 -H 'Authorization: Bearer <IAM_TOKEN>' -H 'Content-Type: application/json'

RemoveUserOptions removeUserOptions = new RemoveUserOptions.Builder()
  .accountId(accountId)
  .iamId(deleteUserId)
  .build();
service.removeUser(removeUserOptions).execute();

const params = {
  accountId: accountId,
  iamId: deleteUserId,
};
userManagementAdminService.removeUser(params)
  .then(res => {
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch(err => {
    console.warn(err)
  });

response = user_management_admin_service.remove_user(
  account_id=account_id,
  iam_id=delete_user_id,
).get_result()
print(json.dumps(response, indent=2))

removeUserOptions := userManagementService.NewRemoveUserOptions(
  accountID,
  deleteUserID,
)
response, err := userManagementAdminService.RemoveUser(removeUserOptions)
if err != nil {
  panic(err)
}

Vous pouvez également supprimer un utilisateur en fonction de son identifiant ou de son adresse électronique et de son domaine. L'identifiant de l'utilisateur ou l'adresse électronique et le domaine sont requis. Pour plus d'informations, voir Supprimer un utilisateur d'un compte par son ID ou son e-mail.

curl -X DELETE https://user-management.cloud.ibm.com/v2/accounts/987d4cfd77b04e9b9e1a6asdcc861234/users?user_id=user%40ibm.com&email=user.email%40ibm.com&realm=ibmid -H 'Authorization: Bearer <IAM_TOKEN>' -H 'Content-Type: application/json'

Modifier l'IBMid 'un utilisateur à l'aide de la console

En tant que propriétaire de compte, vous pouvez mettre à jour l'IBMid d'un utilisateur. Le nouvel IBMid que vous utilisez pour remplacer l'IBMid en cours doit exister préalablement. L'IBMid que vous remplacez est retiré du compte. Si l'IBMid existant doit rester membre du compte, vous devez inviter l'utilisateur à nouveau et rétablir son accès.

Les propriétaires de compte ne peuvent pas changer leur propre IBMid.

Une fois que l'utilisateur s'est assuré que le nouveau " IBMid existe, il faut suivre les étapes suivantes pour modifier le " IBMid de l'utilisateur :

1. Accédez à Gérer > Accès (IAM) > Utilisateurs dans la console IBM Cloud® et sélectionnez l'utilisateur dont vous souhaitez mettre à jour IBMid.
2. Dans la section Détails, cliquez sur Mettre à jour l'IBMid.
3. Entrez le nouvel IBMid, puis cliquez sur Mettre à jour.

A présent, l'utilisateur peut se connecter avec son nouvel IBMid et continuer de travailler dans le compte IBM Cloud alors que l'accès est affecté à l'IBMid qu'il utilisait précédemment.