Creare un'autorizzazione nella console

Completa i seguenti passi:

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

2. Fai clic su Crea.

3. Selezionare un account di origine.

   Se il servizio di origine che deve accedere al servizio di destinazione si trova in questo account, selezionare Questo account.

   Se il servizio di origine che deve accedere al servizio di destinazione si trova in un account differente, selezionare Altro account. Quindi, immettere l'ID account del conto di origine.

4. Selezionare Instradamento log come servizio di origine. Quindi, impostare l'ambito dell'accesso su Tutte le risorse.

5. Seleziona Cloud Logs come servizio di destinazione. Quindi, impostare l'ambito dell'accesso a Tutte le risorse o a una singola istanza configurando Risorse basate su attributi selezionati > Istanza del servizio.

   Altri attributi non sono supportati per questo tipo di autorizzazione.

6. Nella sezione Accesso al servizio, selezionare Mittente per assegnare l'accesso al servizio origine che accede al servizio di destinazione.

7. Fai clic su Autorizza.

Se crei un'autorizzazione tra un servizio in un altro account e un servizio di destinazione nel tuo account corrente, devi avere accesso solo alla risorsa di destinazione. Per il conto di origine, è necessario solo il numero di conto. 

Creazione di un'autorizzazione tramite la CLI

Immetti il seguente comando per creare un'autorizzazione per il servizio IBM Cloud Logs.

ibmcloud iam authorization-policy-create logs-router logs Sender

Puoi definire l'ambito di una specifica istanza di destinazione IBM Cloud Logs utilizzando [--target-service-instance-name TARGET_SERVICE_INSTANCE_NAME | --target-service-instance-id TARGET_SERVICE_INSTANCE_ID]. Non fornire altre opzioni di ambito.

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

Creazione di un'autorizzazione utilizzando Terraform

Prima di poter creare un'autorizzazione utilizzando Terraform, assicurati di aver completato quanto segue:

• Installa la CLI Terraform e configura il plug-in Provider IBM Cloud per Terraform. Per ulteriori informazioni, vedi l'esercitazione 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.

Utilizza la seguente procedura per creare un'autorizzazione utilizzando Terraform:

1. Crea una politica di autorizzazione tra i servizi utilizzando l'argomento della risorsa ibm_iam_authorization_policy nel file main.tf.

   Il seguente esempio crea un'autorizzazione tra i servizi:

   resource "ibm_iam_authorization_policy" "policy" {
     source_service_name = "logs-router"
     target_service_name = "logs"
     roles               = ["Sender"]
     description         = "Authorization Policy"
     transaction_id     = "terraformAuthorizationPolicy"
   }
   

   La risorsa ibm_iam_authorization_policy necessita del servizio di origine, del servizio di destinazione e del ruolo. Al servizio di origine viene concesso l'accesso al servizio di destinazione e il ruolo è il livello di autorizzazione consentito dall'accesso. Facoltativamente, è possibile aggiungere una descrizione per l'autorizzazione e un ID transazione.

   • È possibile fornire un indirizzo target_resource_instance_id per l'ambito di un'istanza di destinazione IBM Cloud Logs.
   • Per ulteriori esempi, consulta la Documentazione Terraform per le risorse di autorizzazione.

È possibile usare Terraform IBM Modules (TIM) per IBM Cloud Logs per creare il criterio di autorizzazione che consenta a IBM Cloud Logs Routing di inviare i log all'istanza IBM Cloud Logs. Questo modulo può anche fornire i tenant di IBM Cloud Logs Routing per l'instradamento dei registri della piattaforma alla destinazione scelta.

2. 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
   

3. 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
      

Creare un'autorizzazione utilizzando l'API

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. L'autorizzazione definita per il servizio IBM Cloud Logs Routing richiede il ruolo Administrator per il servizio di destinazione IBM Cloud Logs.

Per autorizzare un servizio di origine a un servizio di destinazione, utilizza l'API IAM Policy Management.

Gli attributi supportati per creare una politica di autorizzazione dipendono da ciò che ogni servizio supporta. Per ulteriori informazioni sugli attributi supportati per ciascun servizio, consulta la documentazione per i servizi che stai utilizzando.

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": "logs-router"
                }
            ]
        }
    ],
    "roles": [
        {
            "role_id": "crn:v1:bluemix:public:logs::::serviceRole:Sender"
        }
    ],
    "resources": [
        {
            "attributes": [
                {
                    "name": "serviceName",
                    "value": "logs"
                },
                {
                    "name": "serviceInstance",
                    "value": "$LOGS_SERVICE_INSTANCE_CRN",
                    "operator": "stringEquals"
                }
            ]
        }
    ]
}'

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

SubjectAttribute serviceNameSubjectAttribute = new SubjectAttribute.Builder()
      .name("serviceName")
      .value("logs-router")
      .build();

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

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

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

ResourceAttribute serviceNameResourceAttribute = new ResourceAttribute.Builder()
      .name("serviceName")
      .value("logs")
      .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)
      .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: "logs-router",
      }
    ],
  },
];
const policyRoles = [
  {
    role_id: 'crn:v1:bluemix:public:logs::::serviceRole:Sender',
  },
];
const accountIdResourceAttribute = {
  name: 'accountId',
  value: exampleAccountId,
  operator: 'stringEquals',
};
const serviceNameResourceAttribute = {
  name: 'serviceName',
  value: "logs",
  operator: 'stringEquals'
};

const policyResources = [
  {
    attributes: [
      accountIdResourceAttribute,
      serviceNameResourceAttribute
    ],
  },
];
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="logs-router")
                ])
policy_roles = PolicyRole(
    role_id='crn:v1:bluemix:public:logs::::serviceRole:Sender')
account_id_resource_attribute = ResourceAttribute(
    name='accountId', value=example_account_id)
service_name_resource_attribute = ResourceAttribute(
    name='serviceName', value="logs")
policy_resources = PolicyResource(
    attributes=[account_id_resource_attribute,
                service_name_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,
    Operator: core.StringPtr("stringEquals"),
}
serviceNameSubjectAttribute := &iampolicymanagementv1.SubjectAttribute{
    Name:  core.StringPtr("serviceName"),
    Value: "logs-router",
    Operator: core.StringPtr("stringEquals"),
}
policySubjects := &iampolicymanagementv1.PolicySubject{
    Attributes: []iampolicymanagementv1.SubjectAttribute{*accountSubjectAttribute,
        *serviceNameSubjectAttribute},
}
policyRoles := &iampolicymanagementv1.PolicyRole{
    RoleID: core.StringPtr("crn:v1:bluemix:public:logs::::serviceRole:Sender"),
}
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("logs"),
    Operator: core.StringPtr("stringEquals"),
}
policyResources := &iampolicymanagementv1.PolicyResource{
    Attributes: []iampolicymanagementv1.ResourceAttribute{
        *accountIDResourceAttribute, *serviceNameResourceAttribute},
}

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