Concessão de acesso aos recursos d {{site.data.keyword.registryshort}}

Use este tutorial para descobrir como conceder acesso a seus recursos configurando o {{site.data.keyword.iamlong}} (IAM) para {{site.data.keyword.registrylong}}.

Todas as contas requerem políticas de acesso ao IAM. Para configurar e gerenciar políticas de acesso do IAM, consulte Definindo políticas de acesso do IAM.

Para obter mais informações sobre como usar o IAM para gerenciar o acesso aos seus recursos, consulte Gerenciando o acesso a recursos.

Antes de Iniciar

Antes de iniciar, você deve concluir as seguintes tarefas:

Conclua as instruções em Introdução ao {{site.data.keyword.registrylong_notm}}.
Certifique-se de ter a versão mais recente do plug-in da interface de linha de comando (CLI) do container-registry para a CLI do {{site.data.keyword.cloud_notm}}; consulte Atualização do plug-in da CLI do container-registry.
Certifique-se de ter acesso a duas contas do {{site.data.keyword.cloud_notm}} que possam ser usadas neste tutorial: uma para o Usuário A e outra para o Usuário B. Cada uma delas deve utilizar um endereço de e-mail exclusivo. Você trabalha em sua própria conta, Usuário A, e convida outro usuário, Usuário B, para usar sua conta. É possível optar por criar uma segunda conta {{site.data.keyword.cloud_notm}} ou trabalhar com um colega que tenha uma conta {{site.data.keyword.cloud_notm}}.
Certifique-se de que possui as permissões de acesso corretas para adicionar e remover namespaces; consulte Funções de acesso para configurar o {{site.data.keyword.registrylong_notm}}.

Autorizar um usuário a configurar o registro

Inclua um segundo usuário em sua conta e conceda a eles a capacidade de configurar o {{site.data.keyword.registrylong_notm}}.

Inclua o Usuário B na conta do Usuário A.

Efetue login na conta do Usuário A, executando o comando a seguir.

    ibmcloud login
    ```
2. Convide o Usuário B para acessar a conta do Usuário A executando o seguinte comando, em que `<user.b@example.com>` é o endereço de e-mail do Usuário B.

```txt {: pre}
    ibmcloud account user-invite <user.b@example.com>
    ```
3. Obtenha o ID da conta do Usuário A, executando o comando a seguir.

```txt {: pre}
    ibmcloud target
    ```
    Anote o ID da conta que está entre parênteses () na linha Conta.

Demonstre que o Usuário B pode selecionar a conta do Usuário A como alvo, mas ainda não pode realizar nenhuma ação com {{site.data.keyword.registrylong_notm}}.
1. Efetue login como Usuário B e use a conta do Usuário A executando o comando a seguir, em que YOUR_ACCOUNT_ID é o ID da conta do Usuário A.
```
    ibmcloud login -c YOUR_ACCOUNT_ID
    ```
2. Tente editar a sua cota de registro para 4 GB de tráfego, executando o comando a seguir.

```txt {: pre}
    ibmcloud cr quota-set --traffic 4000
    ```
    O comando falha porque o Usuário B não tem o acesso correto.
```

Conceda ao Usuário B a função de Gerenciador para que ele possa configurar o {{site.data.keyword.registrylong_notm}}.

Efetue login novamente em sua conta como você mesmo, Usuário A, executando o comando a seguir.

    ibmcloud login
    ```
2. Crie uma política que conceda a função de Gerenciador ao Usuário B, executando o comando a seguir.

```txt {: pre}
    ibmcloud iam user-policy-create USER.B@EXAMPLE.COM --service-name container-registry --roles Manager
    ```

Prove que o Usuário B agora pode mudar cotas na conta do Usuário A.

Efetue login como Usuário B, tendo como destino a conta do Usuário A, executando o comando a seguir.

    ibmcloud login -c YOUR_ACCOUNT_ID
    ```
2. Tente editar a sua cota de registro para 4 GB de tráfego, executando o comando a seguir.

```txt {: pre}
    ibmcloud cr quota-set --traffic 4000
    ```
    Funciona porque o Usuário B tem o tipo correto de acesso.

3. Agora mude a cota de volta, executando o comando a seguir.

```txt {: pre}
    ibmcloud cr quota-set --traffic 5120
    ```

Limpe.

Efetue login novamente em sua conta como você mesmo, Usuário A, executando o comando a seguir.

    ibmcloud login
    ```
2. Liste as políticas para o Usuário B, localize a política que você criou, executando o comando a seguir e anote o ID.

```txt {: pre}
    ibmcloud iam user-policies <user.b@example.com>
    ```
3. Exclua a política executando o comando a seguir, em que `POLICY_ID` é o seu ID de política.

```txt {: pre}
    ibmcloud iam user-policy-delete <user.b@example.com> POLICY_ID
    ```

Autorizar um usuário a acessar namespaces específicos

Crie alguns namespaces com imagens de amostra e conceda acesso a eles. Você cria políticas para conceder funções diferentes a cada namespace e mostra o efeito que isso tem.

Crie três novos namespaces na conta do Usuário A. Esses namespaces devem ser exclusivos em toda a região. Portanto, escolha os seus próprios nomes de namespace, mas este tutorial usa namespace_a, namespace_b e namespace_c como exemplos.

Efetue login como Usuário A, executando o comando a seguir.

    ibmcloud login
    ```
2. Crie `namespace_a`, executando o comando a seguir.

```txt {: pre}
    ibmcloud cr namespace-add namespace_a
    ```
    O namespace deve ser exclusivo em todas as contas do {{site.data.keyword.cloud_notm}} na mesma região. Os namespaces devem ter de 4 a 30 caracteres e conter apenas letras minúsculas, números, hífens (-) e sublinhados (_). Os namespaces devem iniciar e terminar com uma letra ou número.
    {: requirement}

    Se você tiver um problema ao tentar adicionar um espaço de nomes, veja [Por que eu não posso adicionar um namespace?](/docs/Registry?topic=Registry-troubleshoot-add-namespace) para assistência.
    {: tip}

3. Crie `namespace_b`, executando o comando a seguir.

```txt {: pre}
    ibmcloud cr namespace-add namespace_b
    ```
4. Crie `namespace_c`, executando o comando a seguir.

```txt {: pre}
    ibmcloud cr namespace-add namespace_c
    ```

Demonstre que o Usuário B não consegue ver nada.

Efetue login como Usuário B, tendo como destino a conta do Usuário A, executando o comando a seguir.

    ibmcloud login -c YOUR_ACCOUNT_ID
    ```
2. Tente listar os namespaces como Usuário B, executando o comando a seguir.

```txt {: pre}
    ibmcloud cr namespaces
    ```
    Ele retorna uma lista vazia porque o Usuário B não tem acesso a nenhum namespace.

Crie políticas para conceder ao Usuário B a capacidade de interagir com os namespaces, executando o comando a seguir.

Efetue login como a conta do Usuário A, executando o comando a seguir.

    ibmcloud login
    ```
2. Verifique se pelo menos três namespaces estão listados, executando o comando a seguir.

```txt {: pre}
    ibmcloud cr namespaces
    ```
    Os três namespaces que você criou neste tutorial (`namespace_a`, `namespace_b` e `namespace_c`) são exibidos. Se você não encontrar esses namespaces, repita as instruções para criá-los novamente.

3. Crie uma política que conceda a função de Leitor em `namespace_b` ao Usuário B, executando o comando a seguir, em que `CLOUD_REGION` é o nome de sua região do {{site.data.keyword.cloud_notm}}, por exemplo `us-south`.

```txt {: pre}
    ibmcloud iam user-policy-create USER.B@EXAMPLE.COM --service-name container-registry --region CLOUD_REGION --resource-type namespace --resource namespace_b --roles Reader
    ```
    Para ver os nomes das regiões do {{site.data.keyword.cloud_notm}}, execute o comando [`ibmcloud regions`](/docs/cli?topic=cli-ibmcloud_cli#ibmcloud_regions).
    {: tip}

4. Crie uma segunda política que conceda as funções de Leitor e Gravador no `namespace_c` para o Usuário B, executando o comando a seguir.

```txt {: pre}
    ibmcloud iam user-policy-create USER.B@EXAMPLE.COM --service-name container-registry --region CLOUD_REGION --resource-type namespace --resource namespace_c --roles Reader,Writer
    ```
    Esse comando inclui duas funções no mesmo recurso na mesma política.
    {: note}

Envie por push imagens para o namespace_a e o namespace_b.

Extraia a imagem de hello-world executando o comando a seguir.

    docker pull hello-world
    ```
2. Identifique com tag a imagem para `namespace_a` executando o comando a seguir, em que `REGISTRY_REGION` é o nome da sua região do [{{site.data.keyword.registrylong_notm}}](/docs/Registry?topic=Registry-registry_overview#registry_regions), por exemplo `us-south`.

```txt {: pre}
    docker tag hello-world REGISTRY_REGION.icr.io/namespace_a/hello-world
    ```
3. Identifique a imagem para o `namespace_b`, executando o comando a seguir.

```txt {: pre}
    docker tag hello-world REGISTRY_REGION.icr.io/namespace_b/hello-world
    ```
4. Efetue login no {{site.data.keyword.registrylong_notm}} executando o comando [`ibmcloud cr login`](/docs/Registry?topic=Registry-containerregcli#bx_cr_login).

```txt {: pre}
    ibmcloud cr login
    ```
    {{site.data.keyword.registrylong_notm}} suporta Docker e outros clientes. Para efetuar login usando outros clientes, consulte [Como acessar seus namespaces de forma interativa](/docs/Registry?topic=Registry-registry_access#registry_access_interactive).
    {: tip}

    Se você tiver um problema ao tentar efetuar login, consulte [Por que eu não posso efetuar login no {{site.data.keyword.registryshort_notm}}?](/docs/Registry?topic=Registry-troubleshoot-login) para obter assistência.
    {: tip}

5. Envie por push a imagem para o `namespace_a`, executando o comando a seguir.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_a/hello-world
    ```
6. Envie por push a imagem para o `namespace_b`, executando o comando a seguir.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_b/hello-world
    ```

Prove que o Usuário B pode interagir com namespace_b e namespace_c, mas não com namespace_a.

Efetue login como Usuário B, executando o comando a seguir.

    ibmcloud login -c YOUR_ACCOUNT_ID
    ```
2. Mostre que o Usuário B pode ver `namespace_b` e `namespace_c`, mas não `namespace_a` porque o Usuário B não tem acesso a `namespace_a`, executando o comando a seguir.

```txt {: pre}
    ibmcloud cr namespaces
    ```
3. Liste as suas imagens, executando o comando a seguir.

```txt {: pre}
    ibmcloud cr images
    ```
    A imagem em `namespace_b` é mostrada na lista, mas a imagem em `namespace_a` não, porque o Usuário B não tem acesso a `namespace_a`.

4. Efetue login no {{site.data.keyword.registrylong_notm}}, executando o comando a seguir.

```txt {: pre}
    ibmcloud cr login
    ```
    {{site.data.keyword.registrylong_notm}} suporta Docker e outros clientes. Para efetuar login usando outros clientes, consulte [Como acessar seus namespaces de forma interativa](/docs/Registry?topic=Registry-registry_access#registry_access_interactive).
    {: tip}

5. Extraia a imagem executando o comando a seguir.

```txt {: pre}
    docker pull REGISTRY_REGION.icr.io/namespace_b/hello-world
    ```
6. Envie por push a imagem para o `namespace_b`, executando o comando a seguir.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_b/hello-world
    ```
    Esse comando falha porque o Usuário B não tem a função de Gravador em `namespace_b`.

7. Identifique a imagem com `namespace_c`, executando o comando a seguir.

```txt {: pre}
    docker tag hello-world REGISTRY_REGION.icr.io/namespace_c/hello-world
    ```
8. Envie por push a imagem para o `namespace_c`, executando o comando a seguir.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_c/hello-world
    ```
    O comando funciona porque o Usuário B possui a função de Gravador em `namespace_c`.

9. Extraia de `namespace_c` executando o comando a seguir.

```txt {: pre}
    docker pull REGISTRY_REGION.icr.io/namespace_c/hello-world
    ```
    O comando funciona porque o Usuário B possui a função de Leitor em `namespace_c`.

Limpeza:

Efetue login novamente na conta do Usuário A, executando o comando a seguir.

    ibmcloud login
    ```
2. Liste as políticas para o Usuário B, executando o comando a seguir.

```txt {: pre}
    ibmcloud iam user-policies <user.b@example.com>
    ```
    Localize as políticas que você criou e anote os IDs de política.

3. Exclua as políticas que você criou executando o seguinte comando, em que `POLICY_ID` é o ID de política.

```txt {: pre}
    ibmcloud iam user-policy-delete <user.b@example.com> POLICY_ID
    ```

Criar um ID de serviço e conceder acesso a um recurso

Configure um ID de serviço e conceda a ele acesso ao seu namespace do {{site.data.keyword.registrylong_notm}}.

Configure um ID de serviço com acesso a {{site.data.keyword.registrylong_notm}} e crie uma chave de API para ele.

Efetue login na conta do Usuário A, executando o comando a seguir.

    ibmcloud login
    ```
2. Crie um ID de serviço denominado `cr-roles-tutorial` com a descrição `"Created during the access control tutorial for Container Registry"`, executando o comando a seguir.

```txt {: pre}
    ibmcloud iam service-id-create cr-roles-tutorial --description "Created during the access control tutorial for Container Registry"
    ```
3. Crie uma política de serviço para o ID de serviço que conceda a função de Leitor em `namespace_a`, executando o comando a seguir.

```txt {: pre}
    ibmcloud iam service-policy-create cr-roles-tutorial --service-name container-registry --region CLOUD_REGION --resource-type namespace --resource namespace_a --roles Reader
    ```
4. Crie uma segunda política de serviço que conceda a função de Gravador em `namespace_b`, executando o comando a seguir.

```txt {: pre}
    ibmcloud iam service-policy-create cr-roles-tutorial --service-name container-registry --region CLOUD_REGION --resource-type namespace --resource namespace_b --roles Writer
    ```
5. Crie uma chave de API para o ID de serviço, executando o comando a seguir.

```txt {: pre}
    ibmcloud iam service-api-key-create cr-roles-tutorial-apikey cr-roles-tutorial
    ```

Use o Docker para efetuar login com a chave de API do ID de serviço, em que API_KEY é a sua chave de API, e interaja com o registro.

Efetue login no {{site.data.keyword.registrylong_notm}}, executando o comando a seguir.

    docker login -u iamapikey -p API_KEY REGISTRY_REGION.icr.io
    ```
    {{site.data.keyword.registrylong_notm}} suporta Docker e outros clientes. Para efetuar login usando outros clientes, consulte [Como acessar seus namespaces na automação](/docs/Registry?topic=Registry-registry_access#registry_access_automating).
    {: tip}

2. Extraia sua imagem executando o comando a seguir.

```txt {: pre}
    docker pull REGISTRY_REGION.icr.io/namespace_a/hello-world
    ```
3. Envie por push a sua imagem para o `namespace_a`, executando o comando a seguir.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_a/hello-world
    ```
    Esse comando não funciona porque o usuário não tem a função de Gravador em `namespace_a`.

4. Envie por push a sua imagem para o `namespace_b`, executando o comando a seguir.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_b/hello-world
    ```
    Esse comando funciona porque o usuário possui a função de Gravador em `namespace_b`.

Limpeza:

Efetue login novamente no {{site.data.keyword.registrylong_notm}} como Usuário A.

    ibmcloud cr login
    ```
    {{site.data.keyword.registrylong_notm}} suporta Docker e outros clientes. Para efetuar login usando outros clientes, consulte [Como acessar seus namespaces de forma interativa](/docs/Registry?topic=Registry-registry_access#registry_access_interactive).
    {: tip}

2. Liste as suas políticas de serviço, executando o comando a seguir.

```txt {: pre}
    ibmcloud iam service-policies cr-roles-tutorial
    ```
    Anote seus IDs de Política.

3. Exclua as suas políticas de serviço, executando o comando a seguir para cada política.

```txt {: pre}
    ibmcloud iam service-policy-delete cr-roles-tutorial POLICY_ID
    ```
4. Exclua o seu ID de serviço, executando o comando a seguir.

```txt {: pre}
    ibmcloud iam service-id-delete cr-roles-tutorial
    ```

Limpando sua conta

Remova os recursos que você criou nas seções anteriores para que sua conta volte ao estado em que se encontrava no início deste tutorial.

Efetue login na conta do Usuário A, executando o comando a seguir.
```
ibmcloud login
```

Exclua namespace_a, namespace_b e namespace_c, executando os comandos a seguir.

ibmcloud cr namespace-rm namespace_a

ibmcloud cr namespace-rm namespace_b

ibmcloud cr namespace-rm namespace_c

Remova o Usuário B de sua conta, executando o comando a seguir.
```
ibmcloud account user-remove <user.b@example.com>
```