Concessione dell'accesso tra i servizi

Utilizza IBM Cloud® Identity and Access Management (IAM) per creare o rimuovere un'autorizzazione che conceda a un servizio l'accesso a un altro servizio. Utilizza la delega di autorizzazione per creare automaticamente politiche di accesso che garantiscano l'accesso ai servizi dipendenti.

Molte delle funzionalità di IAM sono incentrate sulla gestione e sull'imposizione dell'accesso degli utenti e delle applicazioni alle risorse di IBM Cloud. Tuttavia, si possono verificare altri scenari in cui è necessario fornire a un servizio l'accesso a una risorsa di un utente in un altro servizio. Questo tipo di accesso è chiamato autorizzazione.

In un'autorizzazione, il servizio di origine è il servizio a cui viene concesso l'accesso al servizio di destinazione. I ruoli selezionati definiscono il livello di accesso al servizio di origine. Il servizio di destinazione è il servizio a cui si concede il permesso di accedere al servizio di origine in base ai ruoli assegnati. Un servizio di origine può trovarsi nello stesso account in cui viene creata l'autorizzazione o in un altro account. Il servizio di destinazione è sempre nell'account in cui è stata creata l'autorizzazione. Si può vedere se il servizio di origine si trova nell'account corrente o in un altro account visualizzando la colonna Account di origine per l'autorizzazione specifica nella pagina Autorizzazioni della console IBM Cloud®.

Autorizzazione dei servizi per i dipendenti

In alcuni casi, oltre al servizio di origine, puoi autorizzare i servizi dipendenti. Il servizio di origine che è abilitato ad accedere al servizio di destinazione dipende da un altro servizio. Al servizio dipendente deve essere assegnato l'accesso per completare il flusso di lavoro. Il diagramma seguente illustra il processo di delega dell'accesso tra servizi di origine, di destinazione e dipendenti:

S2S autorizzazioni con servizi dipendenti. — Come funzionano le autorizzazioni di S2S con i servizi dipendenti

Per ulteriori informazioni sui ruoli, vedere Ruoli di accesso al servizio.

L'esempio seguente spiega come funziona la relazione tra l'origine, la destinazione e i servizi dipendenti. Supponiamo di avere un servizio IBM Watson® che si basa su un'istanza di IBM Cloud Object Storage per memorizzare i dati. Quando si attiva un'autorizzazione tra il servizio IBM Watson e il servizio IBM® Key Protect, potrebbe essere necessario che l'istanza Object Storage acceda a una chiave nell'istanza Key Protect dell'utente. Pertanto, anche se l'autorizzazione è tra il tuo servizio IBM Watson e il servizio Key Protect, anche al servizio Object Storage viene fornito l'accesso come servizio dipendente del servizio IBM Watson. Selezionando l'opzione per abilitare le autorizzazioni per i servizi dipendenti, non hai bisogno di eseguire alcuna azione aggiuntiva poiché le politiche vengono create automaticamente per i servizi dipendenti.

I servizi dipendenti del servizio di origine potrebbero essere presenti nell'account del servizio di origine, il che significa che non puoi visualizzarli nel tuo account. Tuttavia, puoi sempre visualizzare qualsiasi politica di accesso creata dal servizio di origine per i suoi servizi dipendenti. Puoi sapere quali autorizzazioni sono state create da un utente o da un servizio di origine creato controllando la colonna Tipo per l'autorizzazione specifica nella pagina Autorizzazioni.

Creare un'autorizzazione nella console

Per creare un'autorizzazione tra i servizi, devi disporre dell'accesso al servizio di destinazione. Puoi concedere solo il livello di accesso di cui disponi come utente del servizio di destinazione. Ad esempio, se disponi dell'accesso come visualizzatore sul servizio di destinazione, puoi assegnare solo il ruolo di visualizzatore per l'autorizzazione.

Nella console IBM Cloud , fare clic su Gestisci > Accesso (IAM) e selezionare Autorizzazioni.
Fai clic su Crea.
Selezionare un conto sorgente.
- Se la sorgente che deve accedere alla destinazione è in questo account, selezionare Questo account.
- Se l'origine che deve accedere alla destinazione è in un account diverso, selezionare Un altro account. Quindi, inserire l'ID dell'account di origine.
Selezionare il servizio o i servizi a cui accedere.
- È possibile selezionare un singolo servizio e specificare se si desidera che l'origine includa tutte le risorse, le istanze solo in un determinato gruppo di risorse o solo un'istanza specifica nell'account.
- New È anche possibile selezionare Tutti i servizi abilitati a Identità e Accesso e selezionare o immettere l'ID di un gruppo di risorse.
New Inserendo un gruppo di risorse come origine, le istanze di servizio di un gruppo di risorse accedono alla risorsa di destinazione nel vostro account. Si consiglia di impostare questo livello di accesso se non si vuole dare accesso diretto a una risorsa.
Selezionare una destinazione.
Specificare se si desidera che la destinazione includa tutte le risorse o risorse specifiche. Se si scelgono risorse specifiche come destinazione, è possibile aggiungere attributi per definire ulteriormente l'accesso. Il tipo di attributi dipende dal servizio di destinazione selezionato.
(Facoltativo) Selezionare Abilita l'autorizzazione delegata dai servizi di origine e dipendenti per consentire al servizio di origine di delegare il proprio accesso a qualsiasi servizio dipendente. Questa opzione viene visualizzata solo se il servizio di origine ha servizi dipendenti. Selezionando questa opzione, le politiche vengono create automaticamente dal servizio di origine per i servizi dipendenti.
Seleziona un ruolo per assegnare l'accesso al servizio di origine che accede al servizio di destinazione.
Fai clic su Autorizza.

Se si crea un'autorizzazione tra un servizio di un altro account e un servizio di destinazione dell'account corrente, è necessario accedere solo alla risorsa di destinazione. Per il conto sorgente è sufficiente il numero di conto.

Creazione di un'autorizzazione tramite la CLI

Per autorizzare un servizio di origine ad accedere a un servizio di destinazione, eseguire il comando ibmcloud iam authorization-policy-create.

L'esempio seguente utilizza dati finti per creare un criterio in cui una specifica istanza del servizio di origine IBM Cloud Object Storage è autorizzata ad accedere a una specifica istanza del servizio di destinazione IBM Key Protect:

ibmcloud iam authorization-policy-create cloud-object-storage kms Reader --source-service-instance-id 123123 --target-service-instance-id 456456

Per ulteriori informazioni su tutti i parametri disponibili per questo comando, vedere ibmcloud iam authorization-policy-create.

Creare un'autorizzazione utilizzando Terraform

Prima di creare un'autorizzazione 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.

Per creare un'autorizzazione utilizzando Terraform, procedere come segue:

Creare un criterio di autorizzazione tra i servizi utilizzando l'argomento della risorsa ibm_iam_authorization_policy nel file main.tf.

L'esempio seguente crea un'autorizzazione tra servizi:
```
resource "ibm_iam_authorization_policy" "policy" {
source_service_name = "cloud-object-storage"
target_service_name = "kms"
roles               = ["Reader"]
description         = "Authorization Policy"
transaction_id     = "terraformAuthorizationPolicy"
}
```
La risorsa ibm_iam_authorization_policy richiede il servizio di origine, il servizio di destinazione e il ruolo. Al servizio di origine viene concesso l'accesso al servizio di destinazione e il ruolo è il livello di autorizzazione che l'accesso consente. Opzionalmente, è possibile aggiungere una descrizione dell'autorizzazione e l'ID della transazione.

Per ulteriori esempi, consultare la documentazione di Terraform per le risorse di autorizzazione.
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
```
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
```

Creare un'autorizzazione utilizzando l'API

Per autorizzare l'accesso di un servizio di origine a un servizio di destinazione, utilizzare l'API IAM Policy Management. Vedere il seguente esempio API per la creazione di un metodo di criterio con l'indirizzo type=authorization specificato.

Gli attributi supportati per la creazione di un criterio di autorizzazione dipendono da ciò che ogni servizio supporta. Per ulteriori informazioni sugli attributi supportati per ciascun servizio, consultare la documentazione dei servizi in uso.

curl --request POST \
  --url https://iam.cloud.ibm.com/v1/policies \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "type": "authorization",
    "subjects": [
        {
            "attributes": [
                {
                    "name": "accountId",
                    "value": "<account-id>"
                },
                {
                    "name": "serviceName",
                    "value": "<service-name>"
                },
                {
                    "name": "serviceInstance",
                    "value": "<instance-id>"
                }
            ]
        }
    ],
    "roles": [
        {
            "role_id": "crn:v1:bluemix:public:iam::::serviceRole:Reader"
        }
    ],
    "resources": [
        {
            "attributes": [
                {
                    "name": "accountId",
                    "value": "<account-id>"
                },
                {
                    "name": "serviceName",
                    "value": "<service-name>"
                },
                {
                    "name": "serviceInstance",
                    "value": "<instance-id>"
                },
                {
                    "name": "resourceType",
                    "value": "<resource-type>"
                },
                {
                    "name": "resource",
                    "value": "<id>"
                }
            ]
        }
    ]
}'

SubjectAttribute accountSubjectAttribute = new SubjectAttribute.Builder()
      .name("accountId")
      .value(exampleAccountId)
      .build();

SubjectAttribute serviceNameSubjectAttribute = new SubjectAttribute.Builder()
      .name("serviceName")
      .value(exampleSourceServiceName)
      .build();

SubjectAttribute serviceInstanceSubjectAttribute = new SubjectAttribute.Builder()
      .name("serviceInstance")
      .value(exampleSourceServiceInstanceId)
      .build();

PolicySubject policySubjects = new PolicySubject.Builder()
      .addAttributes(accountSubjectAttribute)
      .addAttributes(serviceNameSubjectAttribute)
      .addAttributes(serviceInstanceSubjectAttribute)
      .build();

PolicyRole policyRoles = new PolicyRole.Builder()
      .roleId("crn:v1:bluemix:public:iam::::serviceRole:Reader")
      .build();

ResourceAttribute accountIdResourceAttribute = new ResourceAttribute.Builder()
      .name("accountId")
      .value(exampleAccountId)
      .operator("stringEquals")
      .build();

ResourceAttribute serviceNameResourceAttribute = new ResourceAttribute.Builder()
      .name("serviceName")
      .value(exampleTargetServiceName)
      .operator("stringEquals")
      .build();

ResourceAttribute serviceInstanceResourceAttribute = new ResourceAttribute.Builder()
      .name("serviceInstance")
      .value(exampleTargetInstanceId)
      .operator("stringEquals")
      .build();

ResourceAttribute resourceTypeResourceAttribute = new ResourceAttribute.Builder()
      .name("resourceType")
      .value(exampleResourceType)
      .operator("stringEquals")
      .build();

ResourceAttribute resourceResourceAttribute = new ResourceAttribute.Builder()
      .name("resource")
      .value(exampleResourceId)
      .operator("stringEquals")
      .build();

PolicyResource policyResources = new PolicyResource.Builder()
      .addAttributes(accountIdResourceAttribute)
      .addAttributes(serviceNameResourceAttribute)
      .addAttributes(serviceInstanceResourceAttribute)
      .addAttributes(resourceTypeResourceAttribute)
      .addAttributes(resourceResourceAttribute)
      .build();

CreatePolicyOptions options = new CreatePolicyOptions.Builder()
      .type("authorization")
      .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: 'accountId',
        value: exampleAccounId,
      },
      {
        name: 'serviceName',
        value: exampleSourceServiceName,
      },
      {
        name: 'serviceInstance',
        value: exampleSourceServiceInstaceId,
      },
    ],
  },
];
const policyRoles = [
  {
    role_id: 'crn:v1:bluemix:public:iam::::serviceRole:Reader',
  },
];
const accountIdResourceAttribute = {
  name: 'accountId',
  value: exampleAccountId,
  operator: 'stringEquals',
};
const serviceNameResourceAttribute = {
  name: 'serviceName',
  value: exampleTargetServiceName,
  operator: 'stringEquals',
};
const serviceInstanceResourceAttribute = {
  name: 'serviceInstance',
  value: exampleTargetServiceInstanceId,
  operator: 'stringEquals',
};
const resourceTypeResourceAttribute = {
  name: 'resourceType',
  value: exampleResourceType,
  operator: 'stringEquals',
};
const resourceResourceAttribute = {
  name: 'resource',
  value: exampleResourceId,
  operator: 'stringEquals',
};

const policyResources = [
  {
    attributes: [
      accountIdResourceAttribute,
      serviceNameResourceAttribute,
      serviceInstanceResourceAttribute,
      resourceTypeResourceAttribute,
      resourceResourceAttribute,
    ],
  },
];
const params = {
  type: 'authorization',
  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='accountId', value=example_account_id),
                SubjectAttribute(name='serviceName', value=example_source_service_name),
                SubjectAttribute(name='serviceInstance', value=example_source_service_instance_id)])
policy_roles = PolicyRole(
    role_id='crn:v1:bluemix:public:iam::::serviceRole:Reader')
account_id_resource_attribute = ResourceAttribute(
    name='accountId', value=example_account_id)
service_name_resource_attribute = ResourceAttribute(
    name='serviceName', value=example_target_service_name)
service_instance_resource_attribute = ResourceAttribute(
    name='serviceInstance', value=example_target_service_instance_id)
resource_type_resource_attribute = ResourceAttribute(
    name='resourceType', value=example_resource_type)
resource_resource_attribute = ResourceAttribute(
    name='resource', value=example_resource_id)
policy_resources = PolicyResource(
    attributes=[account_id_resource_attribute,
                service_name_resource_attribute,
                service_instance_resource_attribute,
                resource_type_resource_attribute,
                resource_resource_attribute])

policy = iam_policy_management_service.create_policy(
    type='authorization',
    subjects=[policy_subjects],
    roles=[policy_roles],
    resources=[policy_resources]
).get_result()

print(json.dumps(policy, indent=2))

accountSubjectAttribute := &iampolicymanagementv1.SubjectAttribute{
    Name:  core.StringPtr("accountId"),
    Value: &exampleAccountID,
}
serviceNameSubjectAttribute := &iampolicymanagementv1.SubjectAttribute{
    Name:  core.StringPtr("serviceName"),
    Value: &exampleSourceServiceName,
}
serviceInstanceSubjectAttribute := &iampolicymanagementv1.SubjectAttribute{
    Name:  core.StringPtr("serviceInstance"),
    Value: &exampleSourceServiceInstanceId,
}
policySubjects := &iampolicymanagementv1.PolicySubject{
    Attributes: []iampolicymanagementv1.SubjectAttribute{*accountSubjectAttribute,
        *serviceNameSubjectAttribute, *serviceInstanceSubjectAttribute},
}
policyRoles := &iampolicymanagementv1.PolicyRole{
    RoleID: core.StringPtr("crn:v1:bluemix:public:iam::::serviceRole:Reader"),
}
accountIDResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
    Name:     core.StringPtr("accountId"),
    Value:    core.StringPtr(exampleAccountID),
    Operator: core.StringPtr("stringEquals"),
}
serviceNameResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
    Name:     core.StringPtr("serviceName"),
    Value:    core.StringPtr(exampleTargetServiceName),
    Operator: core.StringPtr("stringEquals"),
}
serviceInstanceResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
    Name:     core.StringPtr("serviceInstance"),
    Value:    core.StringPtr(exampleTargetServiceInstanceId),
    Operator: core.StringPtr("stringEquals"),
}
resourceTypeResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
    Name:     core.StringPtr("resourceType"),
    Value:    core.StringPtr(exampleResourceType),
    Operator: core.StringPtr("stringEquals"),
}
resourceResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
    Name:     core.StringPtr("resource"),
    Value:    core.StringPtr(exampleResourceId),
    Operator: core.StringPtr("stringEquals"),
}
policyResources := &iampolicymanagementv1.PolicyResource{
    Attributes: []iampolicymanagementv1.ResourceAttribute{
        *accountIDResourceAttribute, *serviceNameResourceAttribute,
        *serviceInstanceResourceAttribute, *resourceTypeResourceAttribute,
        *resourceResourceAttribute},
}

options := iamPolicyManagementService.NewCreatePolicyOptions(
    "authorization",
    []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))

Non tutti i servizi supportano le politiche a livello di resourceType e di singolo resource. Esempi di servizi che supportano questi attributi sono IBM Cloud Object Storage e IBM Key Protect, dove i bucket e le chiavi sono il tipo di risorsa e l'ID è elencato per specificare la risorsa specifica.

Creare autorizzazioni che utilizzino `resource-group` come parametro di riferimento `resourceType`

Per creare un'autorizzazione che utilizzi resource-group come origine o destinazione, utilizzare l'API IAM Policy Management.

`resource-group` come fonte

Vedere il seguente esempio API per Creare un metodo di criterio con resource-group specificato come origine.

{
 "type": "authorization",
    "subjects": [
        {
            "attributes": [
                {
                    "name": "resourceGroupId",
                    "value": "<rgId>"
                },
                {
                    "name": "accountId",
                    "value": "<sourceAccountId>"
                }
            ]
        }
    ],
    "roles": [
        {
            "role_id": "crn:v1:bluemix:public:iam::::role:Viewer"
        }
    ],
    "resources": [
        {
            "attributes": [
                {
                    "name": "accountId",
                    "value": "<targetAccountId>"
                },
                {
                    "name": "serviceName",
                    "value": "<targetService>"
                },
                {
                    "name": "serviceInstance",
                    "value": "<targetServiceInstance>"
                }
            ]
        }
    ]
}

`resource-group` come obiettivo

Vedere il seguente esempio API per Creare un metodo di criterio con resource-group specificato come destinazione.

{
 "type": "authorization",
    "subjects": [
        {
            "attributes": [
                {
                    "name": "accountId",
                    "value": "<sourceAccountId>"
                },
                {
                    "name": "serviceName",
                    "value": "<sourceService>"
                },
                {
                    "name": "serviceInstance",
                    "value": "<sourceServiceInstance>"
                }
            ]
        }
    ],
    "roles": [
        {
            "role_id": "crn:v1:bluemix:public:iam::::role:Viewer"
        }
    ],
    "resources": [
        {
            "attributes": [
                {
                    "name": "accountId",
                    "value": "<targetAccountId>"
                },
                {
                    "name": "resourceType",
                    "value": "resource-group"
                }
            ]
        }
    ]
}

Rimozione di un'autorizzazione nella console

Puoi rimuovere qualsiasi autorizzazione tra i servizi nell'account se ti è stato assegnato il ruolo di Amministratore sul servizio di destinazione. Se rimuovi le politiche di accesso create dal servizio di origine per i suoi servizi dipendenti, il servizio di origine non è in grado di completare il flusso di lavoro o di accedere al servizio di destinazione.

Nella console IBM Cloud , fare clic su Gestisci > Accesso (IAM) e selezionare Autorizzazioni.
Identifica la riga per l'autorizzazione che desideri rimuovere dall'account.
Fare clic sull'icona Azioni Azioni > Rimuovi.
Seleziona Rimuovi.

Se il servizio di origine viene rimosso dall'account, tutte le politiche create da tale servizio per i suoi servizi dipendenti vengono eliminate automaticamente. Allo stesso modo, se il servizio dipendente viene rimosso dall'account, vengono eliminate anche tutte le politiche di accesso delegate a tale servizio.

Rimozione di un'autorizzazione tramite la CLI

Per autorizzare un servizio di origine ad accedere a un servizio di destinazione, eseguire il comando ibmcloud iam authorization-policy-create.

Il seguente esempio elimina un criterio di autorizzazione:

ibmcloud iam authorization-policy-delete 12345678-abcd-1a2b-a1b2-1234567890ab

Per ulteriori informazioni su tutti i parametri disponibili per questo comando, vedere ibmcloud iam authorization-policy-delete.

Rimozione di un'autorizzazione tramite l'API

Per eliminare un criterio di autorizzazione, utilizzare l'API IAM Policy Management come nella seguente richiesta di esempio:

curl -X DELETE 'https://iam.cloud.ibm.com/v1/policies/$POLICY_ID' \
-H 'Authorization: Bearer $TOKEN' \
-H 'Content-Type: application/json'

DeletePolicyOptions options = new DeletePolicyOptions.Builder()
        .policyId(examplePolicyId)
        .build();

service.deletePolicy(options).execute();

const params = {
  policyId: examplePolicyId,
};

iamPolicyManagementService.deletePolicy(params)
  .then(res => {
    console.log(JSON.stringify(res, null, 2));
  })
  .catch(err => {
    console.warn(err)
  });

response = iam_policy_management_service.delete_policy(
  policy_id=example_policy_id
).get_result()

print(json.dumps(response, indent=2))

options := iamPolicyManagementService.NewDeletePolicyOptions(
  examplePolicyID,
)

response, err := iamPolicyManagementService.DeletePolicy(options)
if err != nil {
  panic(err)
}

Rimozione di un'autorizzazione tramite Terraform

Se si vuole rimuovere un'autorizzazione utilizzando Terraform, è necessario eliminare l'argomento dal file main.tf. Dopo aver eliminato l'argomento, eseguire il provisioning del file utilizzando i seguenti passaggi:

Eseguire terraform plan per generare un piano di esecuzione di Terraform per visualizzare in anteprima le azioni proposte.
```
terraform plan
```
Eseguire terraform apply per creare le risorse definite nel piano.
```
terraform apply
```

Concessione dell'accesso tra i servizi

Concessione dell'accesso tra i servizi

Autorizzazione dei servizi per i dipendenti

Creare un'autorizzazione nella console

Creazione di un'autorizzazione tramite la CLI

Creare un'autorizzazione utilizzando Terraform

Creare un'autorizzazione utilizzando l'API

Creare autorizzazioni che utilizzino resource-group come parametro di riferimento resourceType

resource-group come fonte

resource-group come obiettivo

Rimozione di un'autorizzazione nella console

Rimozione di un'autorizzazione tramite la CLI

Rimozione di un'autorizzazione tramite l'API

Rimozione di un'autorizzazione tramite Terraform

Creare autorizzazioni che utilizzino `resource-group` come parametro di riferimento `resourceType`

`resource-group` come fonte

`resource-group` come obiettivo