Criando uma autorização no console

Deve-se ter acesso ao serviço de destino para criar uma autorização entre os serviços. É possível conceder somente o nível de acesso que você tem como um usuário do serviço de destino. Por exemplo, se você tiver acesso de visualizador no serviço de destino, poderá designar somente a função de visualizador para a autorização.

1. No console do IBM Cloud, clique em Gerenciar > Acesso (IAM) e selecione Autorizações.

2. Clique em Criar.

3. Selecione uma conta de origem.

   • Se a origem que precisa acessar o destino estiver nessa conta, selecione Esta conta.
   • Se a origem que precisa acessar o destino estiver em uma conta diferente, selecione Outra conta. Em seguida, insira o ID da conta da conta de origem.

4. Selecione o serviço ou os serviços que precisam de acesso.

   • Você pode selecionar um serviço individual e especificar se deseja que a origem inclua todos os recursos, instâncias apenas em um determinado grupo de recursos ou apenas uma instância específica na conta.
   • Novo Você também pode selecionar Todos os serviços habilitados para Identidade e Acesso e selecionar ou inserir um ID de grupo de recursos.

   Novo A inserção de um grupo de recursos como a origem dá às instâncias de serviço em um grupo de recursos acesso ao recurso de destino em sua conta. Talvez você queira configurar esse nível de acesso se não quiser dar acesso direto a um recurso.

5. Selecione um alvo.

6. Especifique se você deseja que o destino inclua todos os recursos ou recursos específicos. Se você escolher recursos específicos como alvo, poderá adicionar atributos para ampliar o escopo do acesso. O tipo de atributos depende do serviço de destino que você selecionou.

7. (Opcional) Selecione Habilitar autorização a ser delegada por serviços de origem e dependentes para permitir que o serviço de origem delegue seu acesso a quaisquer serviços dependentes. Essa opção será exibida somente se o serviço de origem tiver serviços dependentes. Ao selecionar essa opção, as políticas são criadas automaticamente pelo serviço de origem para os serviços dependentes.

8. Selecione uma função para designar acesso para o serviço de origem que acessa o serviço de destino.

9. Clique em Autorizar.

Se você criar uma autorização entre um serviço em outra conta e um serviço de destino em sua conta atual, precisará acessar somente o recurso de destino. Para a conta de origem, é necessário apenas o número da conta.

Criando uma autorização por meio da CLI

Para autorizar um serviço de origem a acessar um serviço de destino, execute o comando ibmcloud iam authorization-policy-create.

A amostra a seguir usa dados simulados para criar uma política na qual uma instância de serviço de origem específica do IBM Cloud Object Storage está autorizada a acessar uma instância de serviço de destino específica do IBM Key Protect:

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

Para obter mais informações sobre todos os parâmetros disponíveis para esse comando, consulte ibmcloud iam authorization-policy-create.

Criando uma autorização usando o Terraform

Deve-se ter acesso ao serviço de destino para criar uma autorização entre os serviços. É possível conceder somente o nível de acesso que você tem como um usuário do serviço de destino. Por exemplo, se você tiver acesso de visualizador no serviço de destino, poderá designar somente a função de visualizador para a autorização.

Antes de criar uma autorização usando o Terraform, verifique se você concluiu o seguinte:

• Instale a CLI do Terraform e configure o plug-in do provedor IBM Cloud para o Terraform. Para obter mais informações, consulte o tutorial Getting started with Terraform em IBM Cloud®. O plug-in abstrai as APIs do IBM Cloud que são usadas para concluir esta tarefa.
• Crie um arquivo de configuração do Terraform que seja denominado main.tf. Nesse arquivo, você define os recursos usando a HashiCorp Configuration Language. Para obter mais informações, consulte a documentação do Terraform.

Use as etapas a seguir para criar uma autorização usando o Terraform:

1. Crie uma política de autorização entre os serviços usando o argumento de recurso ibm_iam_authorization_policy em seu arquivo main.tf.

   O exemplo a seguir cria uma autorização entre serviços:

   resource "ibm_iam_authorization_policy" "policy" {
   source_service_name = "cloud-object-storage"
   target_service_name = "kms"
   roles               = ["Reader"]
   description         = "Authorization Policy"
   transaction_id     = "terraformAuthorizationPolicy"
   }
   

   O recurso ibm_iam_authorization_policy requer o serviço de origem, o serviço de destino e a função. O serviço de origem recebe acesso ao serviço de destino, e a função é o nível de permissão que o acesso permite. Opcionalmente, você pode adicionar uma descrição para a autorização e um ID de transação.

   Para obter mais exemplos, consulte a documentação do Terraform para recursos de autorização.

2. Depois de concluir a criação do arquivo de configuração, inicialize a CLI do Terraform. Para obter mais informações, consulte Inicialização de diretórios de trabalho.

   terraform init
   

3. Provisione os recursos do arquivo main.tf. Para obter mais informações, consulte Provisionamento de infraestrutura com o Terraform.

   1. Execute terraform plan para gerar um plano de execução do Terraform para visualizar as ações propostas.

      terraform plan
      

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

      terraform apply
      

Criando uma autorização por meio da API

Para autorizar um serviço de origem a acessar um serviço de destino, use a API de gerenciamento de política do IAM. Veja o exemplo de API a seguir para criar um método de política com o type=authorization especificado.

Os atributos suportados para criação de uma política de autorização dependem do que cada serviço suporta. Para obter mais informações sobre os atributos suportados para cada serviço, consulte a documentação para os serviços que você está usando.

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

Nem todos os serviços suportam políticas nos níveis resourceType e resource individual. Exemplos de serviços que suportam esses atributos são o IBM Cloud Object Storage e o IBM Key Protect, em que os depósitos e as chaves são o tipo de recurso e o ID é listado para especificar o recurso específico.

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

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

Removendo uma autorização no console

Se você for designado com a função de Administrador no serviço de destino, será possível remover qualquer autorização entre serviços na conta. Se você remover quaisquer políticas de acesso criadas pelo serviço de origem para seus serviços dependentes, o serviço de origem não será capaz de concluir o fluxo de trabalho ou acessar o serviço de destino.

1. No console do IBM Cloud, clique em Gerenciar > Acesso (IAM) e selecione Autorizações.
2. Identifique a linha para a autorização que você deseja remover da conta.
3. Clique no ícone Ações > Remover.
4. Selecione Remover.

Se o serviço de origem for removido da conta, quaisquer políticas criadas por esse serviço para seus serviços dependentes serão excluídas automaticamente. Da mesma forma, se o serviço dependente for removido da conta, todas as políticas de acesso delegadas a esse serviço também serão excluídas.

Removendo uma autorização por meio da CLI

Se você for designado com a função de Administrador no serviço de destino, será possível remover qualquer autorização entre serviços na conta. Se você remover quaisquer políticas de acesso criadas pelo serviço de origem para seus serviços dependentes, o serviço de origem não será capaz de concluir o fluxo de trabalho ou acessar o serviço de destino.

Para autorizar um serviço de origem a acessar um serviço de destino, execute o comando ibmcloud iam authorization-policy-create.

A amostra a seguir exclui uma política de autorização:

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

Para obter mais informações sobre todos os parâmetros disponíveis para esse comando, consulte ibmcloud iam authorization-policy-delete.

Se o serviço de origem for removido da conta, quaisquer políticas criadas por esse serviço para seus serviços dependentes serão excluídas automaticamente. Da mesma forma, se o serviço dependente for removido da conta, todas as políticas de acesso delegadas a esse serviço também serão excluídas.

Removendo uma autorização por meio da API

Se você for designado com a função de Administrador no serviço de destino, será possível remover qualquer autorização entre serviços na conta. Se você remover quaisquer políticas de acesso criadas pelo serviço de origem para seus serviços dependentes, o serviço de origem não será capaz de concluir o fluxo de trabalho ou acessar o serviço de destino.

Para excluir uma política de autorização, use a API de gerenciamento de política do IAM como na solicitação de amostra a seguir:

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

Se o serviço de origem for removido da conta, quaisquer políticas criadas por esse serviço para seus serviços dependentes serão excluídas automaticamente. Da mesma forma, se o serviço dependente for removido da conta, todas as políticas de acesso delegadas a esse serviço também serão excluídas.

Remoção de uma autorização usando o Terraform

Se quiser remover uma autorização usando o Terraform, você precisará excluir o argumento do arquivo main.tf. Depois de excluir o argumento, provisione seu arquivo usando as etapas a seguir:

1. Execute terraform plan para gerar um plano de execução do Terraform para visualizar as ações propostas.

   terraform plan
   

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

   terraform apply