Assegnazione dell'accesso ai cataloghi

In quanto proprietario dell'account, assegni agli utenti l'accesso di gestione del catalogo specifico in base a quali attività stanno eseguendo. Per semplificare il processo di assegnazione dell'accesso, puoi utilizzare i gruppi di accesso per organizzare una serie di utenti in una singola entità. In questo modo, è possibile assegnare una singola politica al gruppo una sola volta e quindi aggiungere o rimuovere gli utenti dal gruppo in base alle necessità.

Per ulteriori dettagli, vedi Gestione dell'accesso in IBM Cloud.

Configurazione dei tuoi gruppi di accesso nella console

Consulta le seguenti sezioni per dettagli sulla creazione dei tuoi gruppi di accesso e sull'assegnazione a ciascuno di essi di politiche IAM specifiche.

Accesso come amministratore nella console

L'accesso di amministratore è richiesto per l'impostazione dei filtri a livello di account nel catalogo IBM Cloud.

Esegui l'accesso al tuo account IBM Cloud.
Vai a Manage > Access (IAM) > Access groups nella console IBM Cloud.
Fai clic su Crea.
Immettere private-catalog-admins come nome del gruppo e fare clic su Crea.
Fare clic su Accesso > Assegnazione dell'accesso.
Selezionare Gestione catalogo dall'elenco dei servizi.
Selezionare il catalogo a cui gli utenti devono accedere.
Nella sezione Accesso alla piattaforma, selezionare il ruolo Amministratore.
Fai clic su Aggiungi > Assegna.

Accesso all'editor nella console

L'accesso di editor è richiesto per la creazione di cataloghi privati, l'impostazione di filtri a livello di catalogo privato, l'aggiunta del software al proprio catalogo privato e l'aggiornamento, l'obsolescenza e il ripristino del software.

Vai a Access groups e fai clic su Create.
Immettere private-catalog-editors come nome del gruppo e fare clic su Crea.
Fare clic su Accesso > Assegnazione dell'accesso.
Selezionare Gestione catalogo dall'elenco dei servizi.
Selezionare il catalogo a cui gli utenti devono accedere.
Nella sezione di accesso alla piattaforma, selezionare il ruolo Editor.
Fai clic su Aggiungi.
Selezionare Kubernetes Service dall'elenco dei servizi.
Seleziona il tuo cluster e quindi i ruoli Amministratore e Gestore.
Fai clic su Aggiungi.
Selezionare Schematics dall'elenco dei servizi.
Selezionare il ruolo di Manager.
Fai clic su Aggiungi > Assegna.

Accesso al visualizzatore nella console

L'accesso al Visualizzatore è richiesto per visualizzare i cataloghi privati, il catalogo IBM Cloud filtrato e le impostazioni del filtro.

Vai a Access groups e fai clic su Create.
Immettere private-catalog-viewers come nome del gruppo e fare clic su Crea.
Fare clic su Accesso > Assegnazione dell'accesso.
Selezionare Gestione catalogo dall'elenco dei servizi.
Selezionare il catalogo a cui gli utenti devono accedere.
Nella sezione Accesso alla piattaforma, selezionare il ruolo Visualizzatore.
Fai clic su Aggiungi > Assegna.

Devi anche avere l'accesso di visualizzatore sul gruppo di risorse a cui è assegnato il catalogo privato. Puoi assegnare il tuo Catalogo privato a un gruppo di risorse quando completi la procedura per creare il catalogo privato. Per ulteriori informazioni, vedi Personalizzazione del Catalogo IBM Cloud per tutti gli utenti dell'account.

Per assegnare l'accesso visualizzatore al tuo gruppo di risorse del catalogo privato, utilizza la seguente procedura:

Andare a Utenti e selezionare l'utente.
Selezionare Accesso > Assegna accesso.
Selezionare Tutti i servizi abilitati all'accesso e all'identità dall'elenco di servizi.
Definire l'ambito dell'accesso a Risorse specifiche in base agli attributi selezionati e selezionare il gruppo di risorse dei cataloghi privati.
Per l'accesso alla piattaforma, selezionare il ruolo Visualizzatore.
Fai clic su Aggiungi > Assegna.

Aggiungi gli utenti ai tuoi gruppi di accesso nella console

Dopo aver configurato i tuoi gruppi di accesso, completa la seguente procedura per aggiungere gli utenti ai gruppi:

Vai a Utenti e fai clic su Invita utenti.
Specifica gli indirizzi e-mail degli utenti. Se inviti più di un utente con un singolo invito, a tutti viene assegnato lo stesso accesso.
Seleziona uno dei tre gruppi di accesso che hai precedentemente creato e fai clic su Aggiungi > Invita.
Ripetere la procedura per aggiungere utenti agli altri gruppi di accesso.

In alternativa, puoi concedere l'accesso agli utenti aggiungendo profili attendibili ai tuoi gruppi di accesso. Per ulteriori informazioni, consultare What rende una buona strategia di profili attendibili? e Creazione di profili attendibili.

Impostazione dei gruppi di accesso tramite la CLI

Per assegnare l'accesso, eseguire il comando ibmcloud iam user-policy-create.

Accesso dell'amministratore tramite CLI

Eseguire il seguente comando per assegnare l'accesso di amministratore:

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

Accesso all'editor tramite CLI

Immettere il seguente comando per assegnare l'accesso editor:

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

Accesso al visualizzatore tramite CLI

Eseguire il seguente comando per impostare l'accesso del visualizzatore:

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

Aggiungi gli utenti ai tuoi gruppi di accesso utilizzando la CLI

Per aggiungere utenti a un gruppo di accessi utilizzando la CLI, esegui il comando ibmcloud iam access-group-user-add.

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

Ad esempio, il seguente comando aggiunge l'utente name@example.com al gruppo di accesso example_group.

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

Impostazione dei gruppi di accesso tramite l'API

Per assegnare l'accesso, richiama l'API IAM Policy Management come mostrato nel seguente esempio. Sostituisci role_id vaiable con il ruolo che vuoi assegnare: Viewer, Editor o 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))

Impostazione della risposta prevista di accesso

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

Aggiungi gli utenti ai tuoi gruppi di accesso utilizzando l'API

Per aggiungere utenti a un gruppo di accesso utilizzando l'API, richiama l'API IAM Access Groups come mostrato nel seguente esempio.

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

Aggiunta della risposta prevista degli utenti

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

Aggiungi gli utenti ai tuoi gruppi di accesso utilizzando Terraform

Prima di poter aggiungere gli utenti ai tuoi gruppi di accesso utilizzando Terraform, assicurati di aver completato quanto segue:

Installa la CLI Terraform e configurare il plug-in del provider IBM Cloud per Terraform. Per ulteriori informazioni, vedi l'esercitazione per Introduzione a Terraform su IBM Cloud®. Il plug-in astrae le API IBM Cloud utilizzate per completare questa attività.
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, vedi la documentazione Terraform.

Per aggiungere utenti ai gruppi di accesso, procedere come segue:

Nel file di configurazione Terraform, trova il codice Terraform che hai utilizzato per creare il gruppo di accesso e prendi nota del access_group_id assegnato al tuo gruppo di accesso.
Aggiungere un membro al gruppo di accesso.
```
resource "ibm_iam_access_group_members" "accgroupmem" {
access_group_id = ibm_iam_access_group.accgroup.id
ibm_ids = ["test@in.ibm.com"]
}
```
Per ulteriori informazioni, vedi i dettagli di riferimento dell'argomento nella pagina Terraform Identity and Access Management(IAM).

È inoltre possibile utilizzare il modulo IAM Access Group di Terraform IBM Modules(TIM) per gestire l'appartenenza ai gruppi di accesso insieme alle policy in una configurazione coerente e riutilizzabile.
Dopo aver terminato la creazione del file di configurazione, inizializza la CLI Terraform. Per ulteriori informazioni, consultare la sezione Inizializzazione delle directory di lavoro.
```
terraform init
```
Eseguire il provisioning delle risorse dal file main.tf. Per ulteriori informazioni, vedi Provisioning dell'infrastruttura con Terraform.
1. Eseguire terraform plan per generare un piano di esecuzione Terraform per visualizzare in anteprima le azioni proposte.
```
terraform plan
```
2. Eseguire terraform apply per creare le risorse definite nel piano.
```
terraform apply
```