Políticas de acesso

A política de acesso do IAM que você designa aos usuários em sua conta determina as ações que um usuário pode executar dentro do contexto do serviço ou instância específica selecionada. As ações permitidas são customizadas e definidas pelo {{site.data.keyword.registryshort}} como operações que têm permissão de execução no serviço. Cada ação é mapeada para uma Função de plataforma ou serviço do IAM que você pode designar a um usuário.

As políticas permitem que o acesso seja concedido em diferentes níveis. Algumas opções incluem os seguintes níveis de acesso:

• Acesso ao serviço em sua conta
• Acesso a um recurso específico dentro do serviço
• Acesso a todos os serviços ativados para o IAM em sua conta
• Acesso aos recursos dentro de um grupo de recursos

Se você quiser restringir o acesso do usuário a um ou mais namespaces para um ID que está utilizando para automação, use um ID de serviço do IAM. Para obter mais informações sobre os IDs de serviço, consulte Criando e trabalhando com IDs de serviço.

Você pode configurar permissões para que você possa configurar o acesso a recursos dentro de um espaço de nomes no nível grupo de recursos. Para obter mais informações, consulte Permissões de usuário para trabalhar com namespaces.

Para obter mais informações sobre a ativação de políticas para o {{site.data.keyword.registryshort}}, consulte Definindo políticas de acesso do IAM.

Designar funções

Depois de definir o escopo da política de acesso do IAM, você designa uma função.

Se uma função específica e suas ações não se adequarem ao caso de uso que você deseja abordar, é possível criar uma função personalizada e selecionar as ações a serem incluídas.

Revise as tabelas a seguir que descrevem as ações que cada função permite no serviço {{site.data.keyword.registryshort}}.

• As funções de gerenciamento da plataforma permitem que os usuários realizem tarefas nos recursos do serviço no nível da plataforma; por exemplo, atribuir acesso de usuários ao serviço, criar ou excluir instâncias e vincular instâncias a aplicativos.

• Funções de acesso ao serviço habilitam os usuários acesso a {{site.data.keyword.registryshort}} e a capacidade de chamar a API {{site.data.keyword.registryshort}}.

Para obter mais informações sobre as ações exatas que são mapeadas para cada função, consulte Funções e ações do IAM para o {{site.data.keyword.registryshort}}.

Para obter mais informações sobre como atribuir funções de usuário no console do {{site.data.keyword.cloud_notm}}, consulte “Gerenciamento do acesso a recursos ”.

Restrições baseadas em contexto

{{site.data.keyword.registryshort}} também suporta restrições baseadas em contexto. É possível usar restrições baseadas em contexto para definir e impor restrições de acesso para recursos do {{site.data.keyword.cloud_notm}} com base no local de rede de solicitações de acesso. Essas restrições funcionam em conjunto com as políticas tradicionais de IAM, que se baseiam na identidade, para oferecer mais uma camada de proteção.

Para obter mais informações, consulte Protegendo recursos do {{site.data.keyword.registryshort}} com restrições baseadas em contexto.

Funções de gerenciamento de plataforma

A tabela a seguir detalha as ações que são mapeadas para funções de gerenciamento de plataforma. As funções de gerenciamento da plataforma permitem que os usuários executem tarefas em recursos de serviço no nível de plataforma, por exemplo, designar acesso de usuário para o serviço e criar ou excluir IDs de serviço.

Funções de acesso de serviço

A tabela a seguir detalha as ações que são mapeadas para as funções de acesso de serviço. As funções de acesso de serviço dão aos usuários acesso ao {{site.data.keyword.registryshort}}, assim como a capacidade de chamar a API do {{site.data.keyword.registryshort}}.

Para os comandos do {{site.data.keyword.registryshort}} a seguir, deve-se ter pelo menos uma das funções especificadas, conforme mostrado nas tabelas a seguir. Para criar uma política que permita o acesso ao {{site.data.keyword.registryshort}}, deve-se criar uma política na qual os critérios a seguir se aplicam.

• O nome do serviço é container-registry.
• A instância de serviço está vazia.
• A região é aquela à qual você deseja conceder acesso ou está vazia para dar acesso a todas as regiões.

ibmcloud iam user-policy-create USER_EMAIL --service-name container-registry --region REGION --roles ROLES

ibmcloud iam user-policy-create USER_EMAIL --service-name container-registry --region REGION --roles ROLES [--resource-type namespace --resource NAMESPACE_NAME]

Atribuição de acesso ao {{site.data.keyword.registryshort}} no console {{site.data.keyword.cloud_notm}}

Você pode usar uma das opções a seguir para atribuir acesso no console do {{site.data.keyword.cloud_notm}}:

• Políticas de acesso por usuário. É possível gerenciar políticas de acesso por usuário na página Gerenciar > Acesso (IAM) > Usuários no console do {{site.data.keyword.cloud_notm}}. Para obter mais informações sobre as etapas de atribuição de acesso ao IAM, consulte Atribuição de acesso a recursos no console.
• Grupos de acesso. Os grupos de acesso são usados para aperfeiçoar o gerenciamento de acesso, designando acesso a um grupo uma vez, em seguida, podendo incluir ou remover usuários do grupo, conforme necessário, para controlar seus acessos. Você gerencia os grupos de acesso e seus direitos de acesso na página Gerenciar > Acesso (IAM) > Grupos de acesso no console do {{site.data.keyword.cloud_notm}}. Para obter mais informações, consulte Designando acesso a um grupo no console..

Atribuição de acesso ao {{site.data.keyword.registryshort}} na interface de linha de comando (CLI)

Para obter instruções passo a passo para designar, remover e revisar o acesso, consulte Designando acesso a recursos usando a CLI. O exemplo a seguir mostra um comando para atribuir a função Manager para {{site.data.keyword.registryshort}} a um usuário, em que USER_EMAIL é o endereço de e-mail do usuário.

Use container-registry para o nome do serviço.

ibmcloud iam user-policy-create USER_EMAIL --service-name container-registry --roles Manager

Designando acesso ao {{site.data.keyword.registryshort}} usando a API

Para obter instruções passo a passo para designar, remover e revisar o acesso, consulte Designando acesso a recursos usando a API ou Criar uma política nos docs da API. Os cloud resource names (CRNs) de função na tabela a seguir são usados para designar acesso com a API.

O exemplo a seguir é para designar a função Manager ao {{site.data.keyword.registryshort}}:

Use “ container-registry ” como nome do serviço e consulte a tabela de valores de ID de função para garantir que você esteja usando o valor correto para o CRN.

curl -X POST 'https://iam.cloud.ibm.com/v1/policies' -H 'Authorization: Bearer $TOKEN' -H 'Content-Type: application/json' -d '{
  "type": "access",
  "description": "Manager role for Container Registry",
  "subjects": [
    {
      "attributes": [
        {
          "name": "iam_id",
          "value": "IBMid-123453user"
        }
      ]
    }'
  ],
  "roles":[
    {
      "role_id": "crn:v1:bluemix:public:container-registry::::serviceRole:Manager"
    }
  ],
  "resources":[
    {
      "attributes": [
        {
          "name": "accountId",
          "value": "$ACCOUNT_ID"
        },
        {
          "name": "serviceName",
          "value": "container-registry"
        }
      ]
    }
  ]
}

SubjectAttribute subjectAttribute = new SubjectAttribute.Builder()
      .name("iam_id")
      .value("IBMid-123453user")
      .build();
PolicySubject policySubjects = new PolicySubject.Builder()
      .addAttributes(subjectAttribute)
      .build();
PolicyRole policyRoles = new PolicyRole.Builder()
      .roleId("crn:v1:bluemix:public:container-registry::::serviceRole:Manager")
      .build();
ResourceAttribute accountIdResourceAttribute = new ResourceAttribute.Builder()
      .name("accountId")
      .value("ACCOUNT_ID")
      .operator("stringEquals")
      .build();
ResourceAttribute serviceNameResourceAttribute = new ResourceAttribute.Builder()
      .name("serviceName")
      .value("container-registry")
      .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: 'iam_id',
        value: 'IBMid-123453user',
      },
    ],
  },
];
const policyRoles = [
  {
    role_id: 'crn:v1:bluemix:public:container-registry::::serviceRole:Manager',
  },
];
const accountIdResourceAttribute = {
  name: 'accountId',
  value: 'ACCOUNT_ID',
  operator: 'stringEquals',
};
const serviceNameResourceAttribute = {
  name: 'serviceName',
  value: 'container-registry',
  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='iam_id', value='IBMid-123453user')])
policy_roles = PolicyRole(
  role_id='crn:v1:bluemix:public:container-registry::::serviceRole:Manager')
account_id_resource_attribute = ResourceAttribute(
  name='accountId', value='ACCOUNT_ID')
service_name_resource_attribute = ResourceAttribute(
  name='serviceName', value='container-registry')
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("iam_id"),
  Value: core.StringPtr("IBMid-123453user"),
}
policySubjects := &iampolicymanagementv1.PolicySubject{
  Attributes: []iampolicymanagementv1.SubjectAttribute{*subjectAttribute},
}
policyRoles := &iampolicymanagementv1.PolicyRole{
  RoleID: core.StringPtr("crn:v1:bluemix:public:container-registry::::serviceRole:Manager"),
}
accountIDResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
  Name:     core.StringPtr("accountId"),
  Value:    core.StringPtr("ACCOUNT_ID"),
  Operator: core.StringPtr("stringEquals"),
}
serviceNameResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
  Name:     core.StringPtr("serviceName"),
  Value:    core.StringPtr("container-registry"),
  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))

Designando acesso ao {{site.data.keyword.registryshort}} usando o Terraform

O exemplo a seguir é para designar a função Manager ao {{site.data.keyword.registryshort}}:

Use container-registry para o nome do serviço.

resource "ibm_iam_user_policy" "policy" {
  ibm_id = "test@example.com"
  roles  = ["Manager"]
  resources {
    service = "container-registry"
  }
}

Para obter mais informações, consulte ibm_iam_user_policy na documentação do Terraform.