Concessione dell'accesso alle risorse dell' Container Registry

Utilizza questa esercitazione per scoprire come concedere l'accesso alle tue risorse configurando IBM Cloud® Identity and Access Management (IAM) per IBM Cloud® Container Registry.

Tutti gli account richiedono politiche di accesso IAM. Per configurare e gestire le politiche di accesso IAM, consulta Definizione delle politiche di accesso IAM.

Per ulteriori informazioni su come utilizzare IAM per gestire l'accesso alle tue risorse, consulta la sezione Gestione dell'accesso alle risorse.

Prima di iniziare

Prima di iniziare, devi completare le seguenti attività:

  • Completa le istruzioni in Introduzione a IBM Cloud Container Registry.
  • Assicurati di disporre della versione più recente del plug-in dell'interfaccia a riga di comando (CLI) di container-registry per la CLI di IBM Cloud; consulta la sezione Aggiornamento del plug-in CLI di container-registry.
  • Assicurati di avere accesso a due account IBM Cloud da utilizzare per questo tutorial: uno per l'Utente A e uno per l'Utente B; ciascuno deve utilizzare un indirizzo e-mail univoco. Utilizza il tuo account, come utente A e invita un altro utente, l'utente B, ad utilizzare il tuo account. Puoi scegliere di creare un secondo account IBM Cloud, oppure di collaborare con un collega che dispone di un account IBM Cloud.
  • Assicurati di disporre delle autorizzazioni di accesso corrette per aggiungere e rimuovere spazi dei nomiUna raccolta di repository che memorizzano le immagini in un registro. Uno spazio dei nomi è associato a un account IBM Cloud , che può includere più spazi dei nomi.; consulta la sezione “Ruoli di accesso” per configurare IBM Cloud Container Registry.

Autorizza un utente a configurare il registro

Aggiungi un secondo utente al tuo account e concedi loro la capacità di configurare IBM Cloud Container Registry.

  1. Aggiungi l'utente B all'account dell'utente A.

    1. Accedi all'account dell'utente A eseguendo il seguente comando.
        ibmcloud login
    ```
2. Invita l'utente B ad accedere all'account dell'utente A eseguendo il seguente comando, dove `<user.b@example.com>` è l'indirizzo e-mail dell'utente B.

```txt {: pre}
    ibmcloud account user-invite <user.b@example.com>
    ```
3. Per ottenere l'ID account dell'utente A, esegui il seguente comando.

```txt {: pre}
    ibmcloud target
    ```
    Prendi nota dell'ID account tra parentesi ( ) nella riga Account.

  2. Dimostrare che l'utente B può selezionare come destinatario l'account dell'utente A, ma non può ancora effettuare alcuna operazione con IBM Cloud Container Registry.

    1. Accedi come Utente B e seleziona l'account dell'Utente A eseguendo il seguente comando, dove YOUR_ACCOUNT_ID è l'ID dell'account dell'Utente A.
        ibmcloud login -c YOUR_ACCOUNT_ID
    ```
2. Prova a modificare la quota del registro impostandola a 4 GB di traffico eseguendo il seguente comando.

```txt {: pre}
    ibmcloud cr quota-set --traffic 4000
    ```
    Il comando ha esito negativo perché l'utente B non dispone dell'accesso corretto.

  3. Assegna all'utente B il ruolo di amministratore, in modo che possa configurare IBM Cloud Container Registry.

    1. Accedi nuovamente al tuo account come Utente A eseguendo il seguente comando.
        ibmcloud login
    ```
2. Creare una politica che assegni il ruolo di Manager all'Utente B eseguendo il seguente comando.

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

  4. Dimostrare che l'utente B può ora modificare le quote nell'account dell'utente A.

    1. Accedi come Utente B, prendendo di mira l'account dell'Utente A, eseguendo il seguente comando.
        ibmcloud login -c YOUR_ACCOUNT_ID
    ```
2. Prova a modificare la quota del registro impostandola a 4 GB di traffico eseguendo il seguente comando.

```txt {: pre}
    ibmcloud cr quota-set --traffic 4000
    ```
    Funziona perché l'utente B ha il tipo di accesso corretto.

3. Ora ripristina la quota eseguendo il comando seguente.

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

  5. Ripulire.

    1. Accedi nuovamente al tuo account come Utente A eseguendo il seguente comando.
        ibmcloud login
    ```
2. Elenca le policy relative all'utente B, individua la policy che hai creato eseguendo il comando seguente e prendi nota dell'ID.

```txt {: pre}
    ibmcloud iam user-policies <user.b@example.com>
    ```
3. Eliminare la policy eseguendo il seguente comando, dove `POLICY_ID` corrisponde all'ID della policy.

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

Autorizza un utente ad accedere a spazi dei nomi specifici

Crea alcuni spazi dei nomi con immagini di esempio e concedi loro l'accesso. Crea le politiche per concedere ruoli diversi a ciascuno spazio dei nomi e mostrane gli effetti.

  1. Crea tre nuovi spazi dei nomi nell'account dell'utente A. Questi spazi dei nomi devono essere univoci a livello di regione, quindi scegliete voi stessi i nomi degli spazi dei nomi; in questo tutorial, tuttavia, vengono utilizzati come esempi namespace_a, namespace_b e namespace_c.

    1. Accedi come Utente A eseguendo il seguente comando.
        ibmcloud login
    ```
2. Crea un file denominato “ `namespace_a` ” eseguendo il seguente comando.

```txt {: pre}
    ibmcloud cr namespace-add namespace_a
    ```
    Lo spazio dei nomi deve essere univoco tra tutti gli account IBM Cloud nella stessa regione. Gli spazi dei nomi devono avere tra i 4 e i 30 caratteri e contenere solo lettere minuscole, numeri, trattini (-) e caratteri di sottolineatura (_). Gli spazi dei nomi devono iniziare e terminare con una lettera o un numero.
    {: requirement}

    Se hai un problema quando provi ad aggiungere uno spazio dei nomi, vedi [Perché non posso aggiungere uno spazio dei nomi?](/docs/Registry?topic=Registry-troubleshoot-add-namespace) per assistenza.
    {: tip}

3. Crea un file denominato “ `namespace_b` ” eseguendo il seguente comando.

```txt {: pre}
    ibmcloud cr namespace-add namespace_b
    ```
4. Crea un file denominato “ `namespace_c` ” eseguendo il seguente comando.

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

  2. Dimostrare che l'utente B non può vedere nulla.

    1. Accedi come Utente B, prendendo di mira l'account dell'Utente A, eseguendo il seguente comando.
        ibmcloud login -c YOUR_ACCOUNT_ID
    ```
2. Prova a elencare gli spazi dei nomi come Utente B eseguendo il comando seguente.

```txt {: pre}
    ibmcloud cr namespaces
    ```
    Restituisce un elenco vuoto perché l'utente B non ha accesso ad alcuno spazio dei nomi.

  3. Creare delle politiche per consentire all'utente B di interagire con gli spazi dei nomi eseguendo il seguente comando.

    1. Accedi all'account dell'utente A eseguendo il seguente comando.
        ibmcloud login
    ```
2. Verificare che siano elencati almeno tre spazi dei nomi eseguendo il comando seguente.

```txt {: pre}
    ibmcloud cr namespaces
    ```
    Vengono visualizzati i tre spazi dei nomi che hai creato in questa esercitazione (`namespace_a`, `namespace_b` e `namespace_c`). Se questi spazi dei nomi non sono visibili, ripetere le istruzioni per crearli nuovamente.

3. Crea una politica che conceda il ruolo Reader su `namespace_b` all'utente B immettendo il seguente comando, dove `CLOUD_REGION` è il nome della tua regione IBM Cloud, ad esempio `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
    ```
    Per visualizzare i nomi delle regioni IBM Cloud, esegui il comando [`ibmcloud regions`](/docs/cli?topic=cli-ibmcloud_cli#ibmcloud_regions).
    {: tip}

4. Creare una seconda policy che assegni i ruoli Reader e Writer su `namespace_c` all'Utente B eseguendo il comando seguente.

```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
    ```
    Questo comando aggiunge due ruoli alla stessa risorsa nella stessa politica.
    {: note}

  4. Carica le immagini su namespace_a e namespace_b.

    1. Scarica l'immagine " hello-world " eseguendo il seguente comando.
        docker pull hello-world
    ```
2. Assegna all'immagine il tag " `namespace_a` " eseguendo il seguente comando, dove `REGISTRY_REGION` è il nome della tua [regione di IBM Cloud Container Registry](/docs/Registry?topic=Registry-registry_overview#registry_regions), ad esempio `us-south`.

```txt {: pre}
    docker tag hello-world REGISTRY_REGION.icr.io/namespace_a/hello-world
    ```
3. Assegna il tag " `namespace_b` " all'immagine eseguendo il seguente comando.

```txt {: pre}
    docker tag hello-world REGISTRY_REGION.icr.io/namespace_b/hello-world
    ```
4. Accedi a IBM Cloud Container Registry eseguendo il comando [`ibmcloud cr login`](/docs/Registry?topic=Registry-containerregcli#bx_cr_login).

```txt {: pre}
    ibmcloud cr login
    ```
    IBM Cloud Container Registry supporta Docker e altri clienti. Per accedere utilizzando altri client, vedi [Accesso interattivo ai tuoi spazi dei nomi](/docs/Registry?topic=Registry-registry_access#registry_access_interactive).
    {: tip}

    Se riscontri problemi durante il login, consulta [la sezione Perché non riesco ad accedere a Container Registry?](/docs/Registry?topic=Registry-troubleshoot-login) per assistenza.
    {: tip}

5. Carica l'immagine su `namespace_a` eseguendo il seguente comando.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_a/hello-world
    ```
6. Carica l'immagine su `namespace_b` eseguendo il seguente comando.

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

  5. Dimostrare che l'utente B può interagire con namespace_b e namespace_c, ma non con namespace_a.

    1. Accedi come Utente B eseguendo il seguente comando.
        ibmcloud login -c YOUR_ACCOUNT_ID
    ```
2. Dimostrare che l'utente B può visualizzare `namespace_b` e `namespace_c`, ma non `namespace_a` poiché l'utente B non ha accesso a `namespace_a`, eseguendo il seguente comando.

```txt {: pre}
    ibmcloud cr namespaces
    ```
3. Elenca le immagini eseguendo il seguente comando.

```txt {: pre}
    ibmcloud cr images
    ```
    L'immagine in `namespace_b` viene mostrata nell'elenco, ma non quella in `namespace_a`, perché l'utente B non ha accesso a `namespace_a`.

4. Accedi a IBM Cloud Container Registry eseguendo il seguente comando.

```txt {: pre}
    ibmcloud cr login
    ```
    IBM Cloud Container Registry supporta Docker e altri clienti. Per accedere utilizzando altri client, vedi [Accesso interattivo ai tuoi spazi dei nomi](/docs/Registry?topic=Registry-registry_access#registry_access_interactive).
    {: tip}

5. Richiamare l'immagine eseguendo il seguente comando.

```txt {: pre}
    docker pull REGISTRY_REGION.icr.io/namespace_b/hello-world
    ```
6. Carica l'immagine su `namespace_b` eseguendo il seguente comando.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_b/hello-world
    ```
    Questo comando ha esito negativo perché l'utente B non ha il ruolo di Scrittore in `namespace_b`.

7. Aggiungi il tag " `namespace_c` " all'immagine eseguendo il seguente comando.

```txt {: pre}
    docker tag hello-world REGISTRY_REGION.icr.io/namespace_c/hello-world
    ```
8. Carica l'immagine su `namespace_c` eseguendo il seguente comando.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_c/hello-world
    ```
    Il comando funziona perché l'utente B ha il ruolo di Scrittore in `namespace_c`.

9. Estrai i dati da `namespace_c` eseguendo il seguente comando.

```txt {: pre}
    docker pull REGISTRY_REGION.icr.io/namespace_c/hello-world
    ```
    Il comando funziona perché l'utente B ha il ruolo di Lettore in `namespace_c`.

  6. Ripulisci:

    1. Accedi nuovamente all'account dell'utente A eseguendo il seguente comando.
        ibmcloud login
    ```
2. Elenca le politiche relative all'utente B eseguendo il seguente comando.

```txt {: pre}
    ibmcloud iam user-policies <user.b@example.com>
    ```
    Individua le politiche che hai creato e prendi nota degli ID delle politiche.

3. Eliminare le politiche create eseguendo il seguente comando, dove `POLICY_ID` è l'ID della politica.

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

Crea un ID servizio e concedi l'accesso a una risorsa

Configura un ID servizio e concedigli l'accesso al tuo spazio dei nomi IBM Cloud Container Registry.

  1. Configurare un ID di servizio con accesso a IBM Cloud Container Registry e creare una chiave APIUn codice univoco che viene passato a un'API per identificare l'applicazione o l'utente chiamante e per inviare dati di tracciamento. Una chiave API viene utilizzata per tracciare e controllare il modo in cui viene utilizzata l'API, ad esempio per impedire l'uso dannoso o improprio dell'API. corrispondente.

    1. Accedi all'account dell'utente A eseguendo il seguente comando.
        ibmcloud login
    ```
2. Crea un ID servizio denominato “ `cr-roles-tutorial` ” con la descrizione “ `"Created during the access control tutorial for Container Registry"` ” eseguendo il seguente comando.

```txt {: pre}
    ibmcloud iam service-id-create cr-roles-tutorial --description "Created during the access control tutorial for Container Registry"
    ```
3. Creare una politica di servizio per l'ID del servizio che assegni il ruolo "Reader" su `namespace_a` eseguendo il comando seguente.

```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. Creare una seconda politica di servizio che assegni il ruolo di Writer su `namespace_b` eseguendo il seguente comando.

```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. Crea una chiave API per l'ID del servizio eseguendo il comando seguente.

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

  2. Utilizza l' Docker per effettuare l'accesso con la chiave API dell'ID del servizio, dove API_KEY è la tua chiave API, e interagire con il registro.

    1. Accedi a IBM Cloud Container Registry eseguendo il seguente comando.
        docker login -u iamapikey -p API_KEY REGISTRY_REGION.icr.io
    ```
    IBM Cloud Container Registry supporta Docker e altri clienti. Per accedere utilizzando altri client, vedi [Accesso ai tuoi spazi dei nomi nell'automazione](/docs/Registry?topic=Registry-registry_access#registry_access_automating).
    {: tip}

2. Scarica l'immagine eseguendo il comando seguente.

```txt {: pre}
    docker pull REGISTRY_REGION.icr.io/namespace_a/hello-world
    ```
3. Carica la tua immagine su `namespace_a` eseguendo il seguente comando.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_a/hello-world
    ```
    Questo comando non funziona perché l'utente non ha il ruolo di Scrittore in `namespace_a`.

4. Carica la tua immagine su `namespace_b` eseguendo il seguente comando.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_b/hello-world
    ```
    Questo comando funziona perché l'utente ha il ruolo di Scrittore in `namespace_b`.

  3. Ripulisci:

    1. Accedi nuovamente al sito IBM Cloud Container Registry come Utente A.
        ibmcloud cr login
    ```
    IBM Cloud Container Registry supporta Docker e altri clienti. Per accedere utilizzando altri client, vedi [Accesso interattivo ai tuoi spazi dei nomi](/docs/Registry?topic=Registry-registry_access#registry_access_interactive).
    {: tip}

2. Elenca le politiche relative ai servizi eseguendo il comando seguente.

```txt {: pre}
    ibmcloud iam service-policies cr-roles-tutorial
    ```
    Prendi nota dei tuoi ID politica.

3. Elimina le politiche di servizio eseguendo il seguente comando per ciascuna politica.

```txt {: pre}
    ibmcloud iam service-policy-delete cr-roles-tutorial POLICY_ID
    ```
4. Elimina il tuo ID servizio eseguendo il seguente comando.

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

Pulizia del tuo account

Rimuovere le risorse create nelle sezioni precedenti, in modo che l'account torni a essere quello che era all'inizio di questa esercitazione.

  1. Accedi all'account dell'utente A eseguendo il seguente comando.

    ibmcloud login

  2. Elimina namespace_a, namespace_b e namespace_c eseguendo i seguenti comandi.

    ibmcloud cr namespace-rm namespace_a

    ibmcloud cr namespace-rm namespace_b

    ibmcloud cr namespace-rm namespace_c

  3. Rimuovi l'utente B dal tuo account eseguendo il seguente comando.

    ibmcloud account user-remove <user.b@example.com>