Convidando usuários no console

Para convidar usuários, conclua as etapas a seguir:

1. No console do IBM Cloud, clique em Gerenciar > Acesso (IAM) e selecione Usuários.
2. Clique em Convidar usuários.
3. Especifique os endereços de e-mail dos usuários. Se você estiver convidando mais de um usuário com um convite único, eles serão todos designados ao mesmo acesso. É possível restringir a associação à sua conta com base no domínio dos usuários que são convidados. Dessa forma, apenas os usuários de um domínio específico podem ser convidados para a conta. Para obter mais informações, consulte Restringindo domínios de usuário para convites de conta.

Os usuários não podem ser convidados automaticamente em contas gerenciadas pela empresa e devem ser adicionados manualmente.

1. Inclua uma ou mais das opções de acesso que você gerencia. Deve-se designar pelo menos uma opção de acesso. Para todas as opções de acesso que você não incluir e configurar, é designado o valor padrão No access. Dependendo das opções que você está autorizado a gerenciar, é possível designar os tipos de acesso a seguir:
   • Incluir usuários em grupos de acesso. Clique em Incluir para cada grupo de acesso ao qual você deseja que os usuários pertençam.
   • Designar manualmente o acesso de usuários. Expanda a seção para atribuir políticas de acesso IAM individuais ou permissões de infraestrutura clássicas.
     • Selecione Infraestrutura clássica e, em seguida, escolha entre os três conjuntos de permissões.
     • Selecione um grupo de serviços, como Todos os serviços habilitados para identidade e acesso, Todos os serviços de gerenciamento de contas e Todos os serviços de gerenciamento de contas IAM, ou um serviço específico. Em seguida, é possível definir o escopo de acesso para a conta inteira ou apenas para um grupo de recursos. Em seguida, selecione todas as funções que se aplicarem. Para visualizar quais ações são mapeadas para cada função, clique nos números listados ao lado de cada função. Alguns serviços suportam o uso de operadores avançados para conceder acesso a recursos que atendem às convenções de nomenclatura específicas. Consulte Designando acesso usando políticas curingas para obter mais informações.
     • Selecione Gerenciamento de conta e, em seguida, escolha entre a opção de todos os serviços de gerenciamento de conta ou selecione um serviço específico. Em seguida, selecione todas as funções que se aplicarem.
2. Selecione Incluir para salvar a designação de acesso para o convite.
3. Depois de incluir todas as designações de acesso necessárias, clique em Convidar.

É possível cancelar um convite para quaisquer usuários que sejam mostrados em um estado de Processamento ou Pendente na coluna Status da página Usuários. Se um usuário convidado não tiver recebido um convite, será possível reenviar o convite para qualquer usuário em um estado Pendente. É possível incluir mais políticas e permissões somente depois que um usuário aceitar o convite.

Incluindo usuários somente VPN

Qualquer usuário com as permissões a seguir pode incluir um usuário somente de VPN:

• Para a infraestrutura clássica, deve-se ter a permissão Gerenciar usuários na conta.
• Para o acesso do IAM, deve-se ter a função de Administrador ou do Editor no serviço de gerenciamento de conta de gerenciamento de usuários.

Para incluir um usuário somente de VPN, use as etapas a seguir:

1. Na página Usuários, clique em Incluir usuário somente VPN.
2. Insira os detalhes de informações pessoais para o usuário.
3. Clique em Salvar.

Convidando usuários usando a CLI

Para convidar os usuários usando a CLI, execute o seguinte comando:

ibmcloud account user-invite USER_EMAIL [--access-groups ACCESS_GROUP_1,ACCESS_GROUP_2...]

Ao usar a CLI, você pode optar por não atribuir acesso e trabalhar na atribuição de acesso posteriormente. Para obter mais informações sobre os parâmetros de comando, consulte ibmcloud account user-invite.

Convidando usuários por meio da API

Você pode usar a API para convidar usuários em massa. Todos os usuários que estão incluídos em um único convite são designados ao mesmo acesso. Ao convidar usuários por meio da API, insira os e-mails em uma lista separada por vírgula com cada entrada circundada por aspas. Este exemplo designa o acesso incluindo o usuário a um grupo de acesso.

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

Você pode atribuir acesso a um grupo de serviços. Para atribuir acesso a todos os serviços habilitados para Identidade e Acesso, especifique serviceType para o atributo name e use o atributo value service. Para atribuir acesso aos serviços do All Account Management, especifique serviceType para o atributo name e use o atributo value platform_service. Para atribuir acesso ao subconjunto de serviços de gerenciamento de contas Todos os serviços de gerenciamento de contas do IAM, especifique service_group_id para o atributo name e use o atributo value IAM.

Convidando usuários usando o Terraform

É possível convidar os usuários para a sua conta do IBM Cloud usando o Terraform.

1. Crie um argumento em seu arquivo main.tf. O exemplo a seguir convida usuários usando o recurso ibm_iam_user_invite, em que users é a lista de IDs de e-mail de usuários a serem convidados.

   resource "ibm_iam_user_invite" "invite_user" {
    users = ["test@in.ibm.com"]
   }
   

   Para obter mais informações, consulte os detalhes de referência do argumento na página do Terraform Identity and Access Management(IAM).
2. Provisione os recursos do arquivo main.tf. Para obter mais informações, consulte Provisionamento de infraestrutura com o Terraform.
   1. Execute terraform plan para gerar um plano de execução do Terraform para visualizar as ações propostas.

      terraform plan
      

   2. Execute o site terraform apply para criar os recursos definidos no plano.

      terraform apply
      

Cancelando ou enviando novamente convites pendentes

Depois de convidar novos usuários a se juntar à sua conta, IBM Cloud solicite que todos, exceto usuários somente VPN, aceitem o convite para se tornar um usuário ativo em sua conta.

O convite expirará após 30 dias. Novos usuários do IBM Cloud podem aceitar um convite apenas usando o link de convite que receberam por e-mail.

É possível cancelar um convite para quaisquer usuários que sejam mostrados em um estado de Processamento ou Pendente na coluna Status da página Usuários. Se um usuário convidado não tiver recebido um convite, será possível reenviar o convite para qualquer usuário em um estado Pendente.

1. Acesse a página Usuários.
2. Localize a linha para o usuário no estado Processing ou Pending.
3. Clique no ícone Ações e, em seguida, escolha Enviar novamente o convite ou Cancelar convite.

Como aceitar convites no console

Se o usuário convidado já é um membro do IBM Cloud, ele receberá um link de convite em suas notificações e por e-mail. Na página Notifications(Notificações ), os usuários podem usar o campo de pesquisa para localizar um convite ou filtrar pelo tipo de notificação chamado account. Para obter mais informações, consulte Gerenciamento de notificações de convite e Visualização de notificações.

Como aceitar convites usando a CLI

Se o usuário convidado já é um membro da IBM Cloud, ele pode aceitar convites usando a CLI. No comando ibmcloud login, o ACCOUNT_ID é o ID da conta de destino a qual o usuário foi convidado a participar.

ibmcloud login -c ACCOUNT_ID --accept

Como aceitar convites usando a API

Se o usuário convidado já é um membro da IBM Cloud, ele pode aceitar convites usando a API. No exemplo a seguir, o ACCOUNT_ID é o ID da conta de destino a qual o usuário foi convidado a participar e o IAM_TOKEN pertence ao convidado.

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

Remoção de um usuário de uma conta usando o console

Ao remover um usuário de uma conta, ele não pode mais efetuar login no console, alternar para a sua conta ou acessar recursos da conta. A remoção de um usuário de uma conta não exclui o IBMid para o usuário.

Para remover um usuário de uma conta, conclua as etapas a seguir:

1. No console do IBM Cloud®, clique em Gerenciar > Acesso (IAM) e selecione Usuários.
2. Na linha do usuário que você deseja remover, clique no ícone Ações > Remover usuário.

Todos os recursos criados pelo usuário permanecem na conta, mas todas as chaves de API do IBM Cloud criadas pelo usuário são removidas. O usuário não tem mais acesso ao trabalho com os recursos criados. O proprietário da conta ou um administrador do serviço ou da instância de serviço pode designar outros usuários para trabalhar com os recursos ou excluí-los da conta.

Se você receber uma mensagem de erro afirmando que um usuário da infraestrutura clássica não pode ser removido, certifique-se de que todos os descendentes na hierarquia do usuário para esse usuário sejam designados a um novo pai, desativados na conta ou excluídos. Em seguida, é possível tentar novamente.

Como alternativa à remoção de um usuário da sua conta, você pode atribuir a ele uma política de acesso com uma condição temporária baseada no tempo. Dessa forma, o usuário pode fazer login no console e visualizar a conta em sua lista de contas, mas não pode acessar os recursos da conta antes do início da política ou após a expiração da política. Para obter mais informações, consulte Criação de uma condição temporária baseada no tempo.

Removendo um usuário de uma conta usando a CLI

Para remover um usuário de uma conta, execute o comando a seguir:

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

Para ver as opções de comando, consulte Comandos da CLI para gerenciamento de contas e usuários.

Removendo um usuário de uma conta usando a API

Para remover um usuário de uma conta, chame a API de gerenciamento do usuário, conforme mostrado na solicitação de amostra a seguir.

Substitua variáveis pelo ID do IAM do usuário. Deve-se usar um token do usuário para autorização. Os IDs de serviço não podem remover usuários de uma conta.

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

Também é possível remover um usuário pelo seu ID de usuário ou pelo endereço de e-mail e domínio. É necessário o ID do usuário ou o e-mail e o domínio. Para obter mais informações, consulte Remover usuário da conta por ID de usuário ou 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'

Alterar o endereço IBMid de um usuário usando o console

Como proprietário de conta, é possível atualizar o IBMid de um usuário. O novo IBMid que você usa para substituir o IBMid atual já deve existir. O IBMid que você está substituindo é removido da conta. Se você precisar do IBMid existente para continuar a ser um membro da conta, deve-se convidar o usuário novamente e reestabelecer seu acesso.

Os proprietários de contas não podem mudar o próprio IBMid.

Depois que o usuário se certificar de que o novo IBMid existe, conclua as etapas a seguir para alterar o IBMid do usuário:

1. Acesse Gerenciar > Acesso (IAM) > Usuários no console da IBM Cloud® e selecione o usuário cujo IBMid deseja atualizar.
2. Na seção Detalhes, clique em Atualizar IBMid.
3. Insira o novo IBMid e clique em Atualizar.

O usuário agora pode efetuar login em ibm.com com seu novo IMBid e continuar trabalhando na conta IBM Cloud com o acesso atribuído ao IBMid usado anteriormente.