Gestione semplificata degli accessi con i gruppi di accesso

Organizzate gli utenti, gli ID dei servizi e i profili affidabili in gruppi di accesso per una gestione efficiente delle autorizzazioni. Assegnazione di criteri a grana fine una sola volta all'intero gruppo per implementare il privilegio minimo su scala.

È possibile creare un gruppo di accesso per organizzare un insieme di utenti, ID di servizio e profili di fiducia in un'unica entità che semplifica l'assegnazione degli accessi. È possibile assegnare un singolo criterio al gruppo invece di assegnare lo stesso accesso più volte per un singolo utente o ID servizio.

Ai gruppi di accesso sono assegnate politiche che concedono ruoli e autorizzazioni ai membri di tale gruppo. I membri di un gruppo di accesso possono includere più tipi di identità, come utenti, ID di servizio e profili affidabili. I membri ereditano i criteri, i ruoli e le autorizzazioni assegnati al gruppo di accesso e mantengono anche i ruoli assegnati individualmente.

Ad esempio, se a un utente viene assegnato il ruolo viewer sul servizio di fatturazione e viene aggiunto a un gruppo di accesso che ha il ruolo publisher sul servizio di gestione del catalogo, mantiene il ruolo viewer anche se non fa parte dei permessi del gruppo di accesso.

Per rendere l'assegnazione e la gestione dell'accesso ancora più semplice, puoi configurare i gruppi di accesso per organizzare una serie di risorse a cui vuoi che un gruppo di utenti abbia accesso. Quando il tuo gruppo di risorse è configurato, puoi assegnare una politica che fornisce l'accesso a tutte le risorse in tale gruppo invece di creare le politiche di accesso per istanze del servizio individuali nel tuo account.

Prima di iniziare

Per gestire o creare nuovi gruppi di accesso, devi disporre del seguente tipo di accesso:

  • Amministratore o redattore del servizio di gestione dell'account Gruppi di accesso IAM nell'account
  • Amministratore o editor per tutti i servizi di gestione account
  • L'utente deve essere il proprietario dell'account

Inoltre, a un amministratore o un editor può essere assegnato l'accesso per gestire un singolo gruppo creando una politica di accesso in cui la risorsa è l'ID del gruppo di accesso. Per ulteriori informazioni sulle politiche di accesso e sui ruoli per il servizio Gruppi di accesso IAM, consulta Accesso IAM.

Prima di iniziare

Prima di impostare i gruppi di accesso con Terraform, accertarsi di aver completato quanto segue:

  • Installare la CLI di Terraform e configurare il plug-in IBM Cloud Provider per Terraform. Per ulteriori informazioni, vedere il tutorial su Come iniziare con Terraform su IBM Cloud®. Il plug-in astrae le API di IBM Cloud che vengono utilizzate per completare questo compito.
  • Creare un file di configurazione di Terraform chiamato main.tf. In questo file si definiscono le risorse utilizzando il linguaggio di configurazione HashiCorp. Per ulteriori informazioni, consultare il sito Documentazione di Terraform.

Creare un gruppo di accesso nella console

È necessario un nome univoco per differenziare i gruppi di accesso nell'account. Per creare un gruppo di accesso, completa la seguente procedura:

  1. Nella console IBM Cloud®, fai clic su Gestisci > Accesso (IAM) e seleziona Gruppi di accesso.
  2. Fai clic su Crea.
  3. Inserire un nome univoco per identificare il gruppo di accesso, una descrizione opzionale e fare clic su Crea.

Quindi, continuare a configurare i gruppi aggiungendo utenti, ID servizio o profili affidabili. È possibile aggiungere utenti manualmente o creando regole dinamiche. Oppure, si può iniziare ad assegnare il gruppo di accesso e decidere chi aggiungere al gruppo di accesso in un secondo momento.

Puoi eliminare un gruppo selezionando l'opzione Rimuovi gruppo. Quando rimuovi un gruppo dall'account, rimuovi tutti gli utenti e gli ID servizio dal gruppo e tutto l'accesso assegnato al gruppo.

Creazione di un gruppo di accesso tramite la CLI

Per creare un gruppo di accesso utilizzando la CLI, puoi utilizzare il comando ibmcloud iam access-group-create.

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

È necessario un nome univoco per differenziare i gruppi di accesso nell'account.

Creare un gruppo di accesso utilizzando l'API

È possibile creare gruppi di accesso in modo programmatico chiamando l'API IBM Cloud® Identity and Access Management(IAM)Access Groups, come mostrato nella seguente richiesta di esempio. L'esempio crea un gruppo di accesso per i manager dell'account:

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

È necessario un nome univoco per differenziare i gruppi di accesso nell'account.

Creare un gruppo di accesso utilizzando Terraform

Per creare gruppi di accesso con Terraform, procedere come segue:

  1. Creare un argomento nel file main.tf. L'esempio seguente crea un gruppo di accesso utilizzando la risorsa ibm_iam_access_group, dove name è un nome unico per identificare il gruppo di accesso.

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

    È inoltre possibile specificare la descrizione del gruppo di accesso nell'opzione description. Per ulteriori informazioni, vedere i dettagli di riferimento degli argomenti nella pagina di Terraform Identity and Access Management(IAM).

Semplificate la gestione degli accessi raggruppando gli utenti e gli ID dei servizi con i moduli Terraform IBM(TIM) per i gruppi di accesso IAM.

  1. Dopo aver completato la creazione del file di configurazione, inizializzare la CLI di Terraform. Per ulteriori informazioni, vedere Inizializzazione delle directory di lavoro.

    terraform init

  2. Predisporre le risorse dal file main.tf. Per ulteriori informazioni, vedere Provisioning dell'infrastruttura con Terraform.

    1. Eseguire terraform plan per generare un piano di esecuzione di Terraform per visualizzare in anteprima le azioni proposte.

      terraform plan

    2. Eseguire terraform apply per creare le risorse definite nel piano.

      terraform apply

Assegnazione dell'accesso a un gruppo nella console

Dopo aver configurato il tuo gruppo con gli utenti e gli ID del servizio, puoi assegnare una politica di accesso comune al gruppo. Ricorda, qualsiasi politica configuri per il gruppo si applica a tutte le entità all'interno del gruppo. Ad esempio, l'assegnazione dei criteri di accesso a un gruppo di accesso delega la possibilità di concedere o revocare l'accesso agli utenti, agli ID dei servizi o ai profili affidabili agli amministratori di quel gruppo di accesso.

L'accesso dell'amministratore a tutto l'account include la possibilità di revocare l'accesso ad altri utenti con il ruolo di amministratore.

Per assegnare l'accesso a un gruppo nella console, procedere come segue:

  1. Nella console IBM Cloud, fare clic su Gestisci > Accesso (IAM) e selezionare Gruppi di accesso.

  2. Per il gruppo a cui si desidera assegnare l'accesso, selezionare l'icona Azioni Icona Azioni e fare clic su Assegna accesso.

  3. È possibile assegnare l'accesso solo alle risorse gestite dall'utente. Devi assegnare almeno un'opzione di accesso. Per tutte le opzioni di accesso che non aggiungi e configuri, viene assegnato il valore predefinito Nessun accesso. A seconda delle opzioni che sei autorizzato a gestire, puoi assegnare i seguenti tipi di accesso:

    • Un gruppo di servizi, come Tutti i servizi di Identità e accesso abilitati, Tutti i servizi di Gestione account o Tutti i servizi di Gestione account IAM.
    • Un servizio specifico

  4. Poi, è possibile limitare l'accesso a tutte le risorse o a risorse specifiche in base agli attributi delle risorse selezionate, come i tag di gestione degli accessi, la posizione o il gruppo di risorse.

  5. Seleziona tutti i ruoli da applicare. Per visualizzare le azioni mappate a ciascun ruolo, fare clic sui numeri elencati accanto a ciascun ruolo. Alcuni servizi supportano l'utilizzo di operatori avanzati per concedere l'accesso alle risorse che soddisfano specifiche convenzioni di denominazione. Per ulteriori informazioni, vedi Assegnazione dell'accesso utilizzando politiche con caratteri jolly.

  6. Cliccare sulla recensione.

  7. Fare clic su Aggiungi per aggiungere la configurazione del criterio al riepilogo dei criteri.

  8. Fai clic su Assegna.

È possibile assegnare l'accesso anche utilizzando i tag di gestione degli accessi. Per ulteriori informazioni, vedere Controllo dell'accesso alle risorse tramite tag.

Assegnazione dell'accesso a un gruppo tramite la CLI

Per creare una politica del gruppo di accesso utilizzando la CLI, puoi utilizzare il comando 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]}

Assegnare l'accesso a un gruppo utilizzando l'API

È possibile assegnare programmaticamente l'accesso a un gruppo chiamando l'API di gestione dei criteri di IBM Cloud® Identity and Access Management(IAM), come mostrato nella seguente richiesta di esempio. L'esempio assegna un ruolo al gruppo di accesso Editor per un'istanza di un servizio:

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

È possibile assegnare l'accesso a un gruppo di servizi. Per assegnare l'accesso a Tutti i servizi abilitati all'identità e all'accesso, specificare serviceType per l'attributo name e utilizzare l'attributo value service. Per assegnare l'accesso a tutti i servizi di Gestione account, specificare serviceType per l'attributo name e utilizzare l'attributo value platform_service. Per assegnare l'accesso al sottoinsieme di servizi di gestione degli account Tutti i servizi di gestione degli account IAM, specificare service_group_id per l'attributo name e utilizzare value IAM.

Assegnare l'accesso a un gruppo utilizzando Terraform

Dopo aver impostato il gruppo, utilizzare i passaggi seguenti per assegnargli l'accesso tramite Terraform.

  1. Creare un argomento nel file main.tf. Gli esempi seguenti creano un criterio IAM che concede ai membri del gruppo di accesso il ruolo di piattaforma IAM Viewer a tutti i servizi abilitati IAM usando la risorsa ibm_iam_access_group_policy. Per completare l'operazione è necessario disporre di un ID IAM esistente di un gruppo di accesso.

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

    Per ulteriori informazioni, vedere i dettagli di riferimento degli argomenti nella pagina di Terraform Identity and Access Management(IAM).

È inoltre possibile utilizzare il modulo Gruppi di accesso IAM per gestire gruppi e criteri di accesso su scala. L'esempio seguente dimostra l'utilizzo del modulo:

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

Per ulteriori informazioni sui moduli Terraform IBM, vedere Informazioni sui moduli Terraform IBM.

  1. Dopo aver completato la creazione del file di configurazione, inizializzare la CLI di Terraform. Per ulteriori informazioni, vedere Inizializzazione delle directory di lavoro.

    terraform init

  2. Predisporre le risorse dal file main.tf. Per ulteriori informazioni, vedere Provisioning dell'infrastruttura con Terraform.

    1. Eseguire terraform plan per generare un piano di esecuzione di Terraform per visualizzare in anteprima le azioni proposte.

      terraform plan

    2. Eseguire terraform apply per creare le risorse definite nel piano.

      terraform apply

Aggiunta di membri a un gruppo di accesso nella console

I membri possono essere utenti, ID di servizio e profili affidabili.

  1. Nella console IBM Cloud®, fai clic su Gestisci > Accesso (IAM) e seleziona Gruppi di accesso.

  2. Fare clic sul gruppo di accesso creato.

  3. Aggiungere membri.

    1. Fai clic su Aggiungi utenti.
    2. Fare clic su ID servizio > Aggiungi ID servizio.
    3. Fare clic su Profili attendibili > Aggiungi profili attendibili.

    Se non vedete il pulsante per aggiungere membri, forse non avete accesso. Esaminare i requisiti di accesso e contattare l'amministratore dell'account per l'accesso.

  4. Selezionare gli utenti, gli ID servizio o i profili affidabili che si desidera aggiungere al gruppo e fare clic su Aggiungi al gruppo.

I membri aggiunti al gruppo possono utilizzare il livello di accesso assegnato al gruppo.

Aggiunta di membri a un gruppo di accesso mediante l'uso della CLI

I membri possono essere utenti, ID di servizio e profili affidabili. I membri aggiunti al gruppo possono utilizzare il livello di accesso assegnato al gruppo.

  1. Ottenere gli utenti, gli ID dei servizi o i profili affidabili dell'account. Si notino i dettagli restituiti per il membro che si desidera aggiungere al gruppo di accesso.

    Ottenere tutti gli utenti:

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

    Elencare tutti gli ID del servizio:

    ibmcloud iam service-ids [--uuid]

    Ottenere tutti i profili affidabili:

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

  2. Aggiungere membri al gruppo di accesso:

    Usate il comando ibmcloud iam access-group-user-add per aggiungere utenti a un gruppo di accesso. L'esempio seguente aggiunge l'utente name@example.com al gruppo di accesso example_group utilizzando la CLI.

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

    Usare il comando ibmcloud iam access-group-service-id-add per aggiungere ID di servizio a un gruppo di accesso. L'esempio seguente aggiunge l'ID servizio example-service al gruppo di accesso example_group:

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

    Usate il comando ibmcloud iam access-group-trusted profile-add per aggiungere profili affidabili a un gruppo di accesso. L'esempio seguente aggiunge l'ID servizio PROFILE_ID al gruppo di accesso example_group:

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

Aggiunta di membri a un gruppo di accesso tramite l'API

I membri possono essere utenti, ID di servizio e profili affidabili.

  1. Elencare gli utenti, gli ID di servizio o i profili affidabili dell'account, come mostrato nel seguente esempio di richiesta. Prendere nota dell'indirizzo IBMid, dell'ID servizio o dell'ID profilo attendibile restituito per il membro che si desidera aggiungere al gruppo di accesso.

    Elenco utenti:

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

    Elencare gli ID dei servizi:

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

    Elenco dei profili affidabili:

    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. Aggiungere membri al gruppo di accesso chiamando l'API IAM Access Groups, come mostrato nel seguente esempio di richiesta.

    Il tipo di membro deve essere user, service o 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))

I membri aggiunti al gruppo possono utilizzare il livello di accesso assegnato al gruppo.

Aggiunta di membri a un gruppo di accesso utilizzando Terraform

I membri possono essere utenti, ID di servizio e profili affidabili.

  1. Creare un argomento nel file main.tf. L'esempio seguente aggiunge a un gruppo di accesso un ID servizio, un profilo fidato e un utente con l'ID 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]
}

Gestite l'appartenenza ai gruppi in modo programmatico con il modulo IAM Access Groups per il provisioning automatico degli utenti. Esplorate i moduli Terraform IBM per la gestione dei membri.

  1. Dopo aver completato la creazione del file di configurazione, inizializzare la CLI di Terraform. Per ulteriori informazioni, vedere Inizializzazione delle directory di lavoro.

    terraform init

  2. Predisporre le risorse dal file main.tf. Per ulteriori informazioni, vedere Provisioning dell'infrastruttura con Terraform.

    1. Eseguire terraform plan per generare un piano di esecuzione di Terraform per visualizzare in anteprima le azioni proposte.

      terraform plan

    2. Eseguire terraform apply per creare le risorse definite nel piano.

      terraform apply

I membri aggiunti al gruppo possono utilizzare il livello di accesso assegnato al gruppo.