Zugriff auf Ressourcen von Container Registry gewähren

In diesem Lernprogramm erfahren Sie, wie Sie Zugriff auf Ihre Ressourcen erteilen, indem Sie IBM Cloud® Identity and Access Management (IAM) for IBM Cloud® Container Registry konfigurieren.

Alle Konten erfordern IAM-Zugriffsrichtlinien. Informationen zum Einrichten und Verwalten von IAM-Zugriffsrichtlinien finden Sie unter IAM-Zugriffsrichtlinien definieren.

Weitere Informationen zur Verwendung von IAM für die Verwaltung des Zugriffs auf Ihre Ressourcen finden Sie unter Zugriff auf Ressourcen verwalten.

Vorbereitende Schritte

Führen Sie die folgenden Tasks aus, bevor Sie beginnen:

  • Führen Sie die Anweisungen in Erste Schritte mit IBM Cloud Container Registry aus.
  • Stellen Sie sicher, dass Sie über die aktuellste Version des CLI-Plug-ins für die IBM Cloudcontainer-registry-Befehlszeilenschnittstelle (CLI) verfügen; siehe Aktualisieren des container-registry CLI-Plug-ins.
  • Stellen Sie sicher, dass Sie Zugriff auf zwei IBM Cloud-Konten haben, die Sie für dieses Tutorial verwenden können – eines für Benutzer A und eines für Benutzer B. Für jedes Konto muss eine eindeutige E-Mail-Adresse verwendet werden. Sie arbeiten in Ihrem eigenen Konto, als Benutzer A, und laden einen anderen Benutzer, Benutzer B, ein, Ihr Konto zu verwenden. Sie können entweder ein zweites IBM Cloud-Konto erstellen oder mit einem Kollegen arbeiten, der bereits ein IBM Cloud-Konto besitzt.
  • Stellen Sie sicher, dass Sie über die erforderlichen Zugriffsberechtigungen zum Hinzufügen und Entfernen von NamespacesEine Sammlung von Repositorys, die Images in einer Registry speichern. Ein Namensbereich ist einem IBM Cloud -Konto zugeordnet, das mehrere Namensbereiche enthalten kann. verfügen. Weitere Informationen finden Sie unter Zugriffsrollen für die Konfiguration von IBM Cloud Container Registry.

Benutzer berechtigen, die Registry zu konfigurieren

Fügen Sie einen zweiten Benutzer zu Ihrem Konto hinzu und geben Sie ihm die Möglichkeit, IBM Cloud Container Registry zu konfigurieren.

  1. Fügen Sie Benutzer B zum Konto von Benutzer A hinzu.

    1. Melden Sie sich beim Konto von Benutzer A an, indem Sie den folgenden Befehl ausführen.
        ibmcloud login
    ```
2. Laden Sie Benutzer B ein, mit dem folgenden Befehl auf das Konto von Benutzer A zuzugreifen. Dabei ist `<user.b@example.com>` die E-Mail-Adresse von Benutzer B.

```txt {: pre}
    ibmcloud account user-invite <user.b@example.com>
    ```
3. Rufen Sie die Konto-ID von Benutzer A ab, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    ibmcloud target
    ```
    Notieren Sie sich die Konto-ID in den runden Klammern () in der Zeile 'Konto'.

  2. Weisen Sie nach, dass Benutzer B das Konto von Benutzer A anvisieren kann, aber mit IBM Cloud Container Registry noch nichts damit anfangen kann.

    1. Melden Sie sich als Benutzer B an und führen Sie den folgenden Befehl aus, um das Konto von Benutzer A zu erreichen. Dabei ist YOUR_ACCOUNT_ID die Konto-ID von Benutzer A.
        ibmcloud login -c YOUR_ACCOUNT_ID
    ```
2. Versuchen Sie, Ihr Registry-Kontingent auf 4 GB des Datenverkehrs zu ändern, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    ibmcloud cr quota-set --traffic 4000
    ```
    Der Befehl schlägt fehl, da Benutzer B nicht die erforderlichen Zugriffsrechte hat.

  3. Weisen Sie Benutzer B die Rolle 'Manager' zu, sodass er IBM Cloud Container Registry konfigurieren kann.

    1. Melden Sie sich als Benutzer A mit dem folgenden Befehl wieder bei Ihrem Konto an.
        ibmcloud login
    ```
2. Erstellen Sie eine Richtlinie, die Benutzer B die Rolle 'Manager' zuordnet, indem Sie den folgenden Befehl ausführen.

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

  4. Vergewissern Sie sich, dass Benutzer B jetzt Kontingente im Konto von Benutzer A ändern kann.

    1. Melden Sie sich als Benutzer B an und erreichen Sie das Konto von Benutzer A, indem Sie den folgenden Befehl ausführen.
        ibmcloud login -c YOUR_ACCOUNT_ID
    ```
2. Versuchen Sie, Ihr Registry-Kontingent auf 4 GB des Datenverkehrs zu ändern, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    ibmcloud cr quota-set --traffic 4000
    ```
    Diese Aktion ist erfolgreich, weil Benutzer B über den korrekten Typ von Zugriff verfügt.

3. Ändern Sie jetzt das Kontingent zurück, indem Sie den folgenden Befehl ausführen.

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

  5. Sorgen Sie nun für eine Bereinigung.

    1. Melden Sie sich als Benutzer A mit dem folgenden Befehl wieder bei Ihrem Konto an.
        ibmcloud login
    ```
2. Listen Sie die Richtlinien für Benutzer B auf, suchen Sie mit dem folgenden Befehl nach der Richtlinie, die Sie gerade erstellt haben, und notieren Sie sich die ID.

```txt {: pre}
    ibmcloud iam user-policies <user.b@example.com>
    ```
3. Löschen Sie die Richtlinie, indem Sie den folgenden Befehl ausführen. Dabei ist `POLICY_ID` Ihre Richtlinien-ID.

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

Benutzer berechtigen, auf bestimmte Namensbereiche zuzugreifen

Erstellen Sie einige Namensbereiche mit Beispielimages und erteilen Sie Zugriff auf diese Images. Sie erstellen Richtlinien, um den einzelnen Namensbereichen unterschiedliche Rollen zuzuordnen und zu sehen, welche Auswirkungen das hat.

  1. Erstellen Sie drei neue Namensbereiche im Konto von Benutzer A. Diese Namensbereiche müssen in der gesamten Region eindeutig sein. Wählen Sie daher Ihre eigenen Namen für die Namensbereiche aus. In diesem Lernprogramm werden jedoch namespace_a, namespace_b und namespace_c beispielhaft verwendet.

    1. Melden Sie sich als Benutzer A an, indem Sie den folgenden Befehl ausführen.
        ibmcloud login
    ```
2. Erstellen Sie `namespace_a`, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    ibmcloud cr namespace-add namespace_a
    ```
    Der Namensbereich muss für alle IBM Cloud-Konten in derselben Region eindeutig sein. Namensbereiche müssen 4 bis 30 Zeichen lang sein und dürfen nur Kleinbuchstaben, Zahlen, Bindestriche (-) und Unterstreichungszeichen (_) enthalten. Namensbereiche müssen mit einem Buchstaben oder einer Zahl beginnen und enden.
    {: requirement}

    Wenn beim Versuch, einen Namensbereich hinzuzufügen, ein Problem auftritt, finden Sie weitere Informationen unter [Warum kann ich keinen Namensbereich hinzufügen?](/docs/Registry?topic=Registry-troubleshoot-add-namespace).
    {: tip}

3. Erstellen Sie `namespace_b`, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    ibmcloud cr namespace-add namespace_b
    ```
4. Erstellen Sie `namespace_c`, indem Sie den folgenden Befehl ausführen.

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

  2. Weisen Sie nach, dass Benutzer B nichts sehen kann.

    1. Melden Sie sich als Benutzer B an und erreichen Sie das Konto von Benutzer A, indem Sie den folgenden Befehl ausführen.
        ibmcloud login -c YOUR_ACCOUNT_ID
    ```
2. Versuchen Sie als Benutzer B, Namensbereiche aufzulisten, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    ibmcloud cr namespaces
    ```
    Es wird eine leere Liste zurückgegeben, da Benutzer B keinen Zugriff auf Namensbereiche hat.

  3. Erstellen Sie Richtlinien, um Benutzer B die Möglichkeit zu geben, mit den Namensbereichen zu interagieren, indem Sie den folgenden Befehl ausführen.

    1. Melden Sie sich als Benutzer A an, indem Sie den folgenden Befehl ausführen.
        ibmcloud login
    ```
2. Vergewissern Sie sich, dass mindestens drei Namensbereiche aufgelistet werden, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    ibmcloud cr namespaces
    ```
    Die drei Namensbereiche, die Sie in diesem Lernprogramm erstellt haben (`namespace_a`, `namespace_b` und `namespace_c`), werden angezeigt. Wenn diese Namespaces nicht angezeigt werden, wiederholen Sie die Anweisungen, um sie erneut zu erstellen.

3. Erstellen Sie eine Richtlinie, die Benutzer B die Rolle 'Leseberechtigter' für `namespace_b` zuordnet, indem Sie den folgenden Befehl ausführen, wobei `CLOUD_REGION` der Name Ihrer IBM Cloud-Region ist (`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
    ```
    Um die Namen der IBM Cloud-Regionen anzuzeigen, führen Sie den Befehl [`ibmcloud regions`](/docs/cli?topic=cli-ibmcloud_cli#ibmcloud_regions) aus.
    {: tip}

4. Erstellen Sie eine zweite Richtlinie, die Benutzer B die Rollen 'Leseberechtigter' und 'Schreibberechtigter' für `namespace_c` zuordnet, indem Sie den folgenden Befehl ausführen.

```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
    ```
    Mit diesem Befehl werden zwei Rollen zu derselben Ressource in derselben Richtlinie hinzugefügt.
    {: note}

  4. Übertragen Sie die Images per Push-Operation in namespace_a und namespace_b.

    1. Rufen Sie das Image hello-world ab, indem Sie den folgenden Befehl ausführen.
        docker pull hello-world
    ```
2. Kennzeichnen Sie das Image als Image für `namespace_a`, indem Sie den folgenden Befehl ausführen, wobei `REGISTRY_REGION` der Name Ihrer [IBM Cloud Container Registry-Region](/docs/Registry?topic=Registry-registry_overview#registry_regions) ist (z. B. `us-south`).

```txt {: pre}
    docker tag hello-world REGISTRY_REGION.icr.io/namespace_a/hello-world
    ```
3. Kennzeichnen Sie das Image als Image für `namespace_b`, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    docker tag hello-world REGISTRY_REGION.icr.io/namespace_b/hello-world
    ```
4. Melden Sie sich mit dem Befehl [`ibmcloud cr login`](/docs/Registry?topic=Registry-containerregcli#bx_cr_login) bei IBM Cloud Container Registry an.

```txt {: pre}
    ibmcloud cr login
    ```
    IBM Cloud Container Registry Unterstützt „ Docker “ und andere Clients. Informationen zur Anmeldung mit anderen Clients finden Sie im Abschnitt zum [interaktiven Zugriff auf Namensbereiche](/docs/Registry?topic=Registry-registry_access#registry_access_interactive).
    {: tip}

    Wenn bei dem Versuch, sich anzumelden, ein Problem auftritt, finden Sie Unterstützung unter [Warum kann ich mich nicht bei Container Registry anmelden?](/docs/Registry?topic=Registry-troubleshoot-login).
    {: tip}

5. Übertragen Sie das Image per Push-Operation an `namespace_a`, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_a/hello-world
    ```
6. Übertragen Sie das Image per Push-Operation an `namespace_b`, indem Sie den folgenden Befehl ausführen.

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

  5. Vergewissern Sie sich, dass Benutzer B mit namespace_b und namespace_c, aber nicht mit namespace_a interagieren kann.

    1. Melden Sie sich als Benutzer B an, indem Sie den folgenden Befehl ausführen.
        ibmcloud login -c YOUR_ACCOUNT_ID
    ```
2. Vergewissern Sie sich, dass Benutzer B `namespace_b` und `namespace_c` anzeigen kann, aber nicht `namespace_a`, weil Benutzer B keinen Zugriff auf `namespace_a` hat, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    ibmcloud cr namespaces
    ```
3. Listen Sie Ihre Images auf, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    ibmcloud cr images
    ```
    Das Image in `namespace_b` wird in der Liste angezeigt, das Image in `namespace_a` jedoch nicht, da Benutzer B keinen Zugriff auf `namespace_a` hat.

4. Melden Sie sich bei IBM Cloud Container Registry an, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    ibmcloud cr login
    ```
    IBM Cloud Container Registry Unterstützt „ Docker “ und andere Clients. Informationen zur Anmeldung mit anderen Clients finden Sie im Abschnitt zum [interaktiven Zugriff auf Namensbereiche](/docs/Registry?topic=Registry-registry_access#registry_access_interactive).
    {: tip}

5. Rufen Sie das Image ab, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    docker pull REGISTRY_REGION.icr.io/namespace_b/hello-world
    ```
6. Übertragen Sie das Image per Push-Operation an `namespace_b`, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_b/hello-world
    ```
    Dieser Befehl schlägt fehl, da Benutzer B in `namespace_b` nicht über die Rolle 'Schreibberechtigter' verfügt.

7. Kennzeichnen Sie das Image mit `namespace_c`, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    docker tag hello-world REGISTRY_REGION.icr.io/namespace_c/hello-world
    ```
8. Übertragen Sie das Image per Push-Operation an `namespace_c`, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_c/hello-world
    ```
    Der Befehl funktioniert, weil Benutzer B in `namespace_c` über die Rolle 'Schreibberechtigter' verfügt.

9. Führen Sie eine Pull-Operation aus `namespace_c` durch, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    docker pull REGISTRY_REGION.icr.io/namespace_c/hello-world
    ```
    Der Befehl funktioniert, weil Benutzer B in `namespace_c` über die Rolle 'Leseberechtigter' verfügt.

  6. Räumen Sie auf:

    1. Melden Sie sich wieder beim Konto von Benutzer A an, indem Sie den folgenden Befehl ausführen.
        ibmcloud login
    ```
2. Listen Sie die Richtlinien für Benutzer B auf, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    ibmcloud iam user-policies <user.b@example.com>
    ```
    Suchen Sie nach den von Ihnen erstellten Richtlinien und notieren Sie die Richtlinien-IDs.

3. Löschen Sie die von Ihnen erstellten Richtlinien, indem Sie den folgenden Befehl eingeben. Dabei ist `POLICY_ID` die Richtlinien-ID.

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

Service-ID erstellen und Zugriff auf eine Ressource erteilen

Konfigurieren Sie eine Service-ID und erteilen Sie der ID Zugriff auf Ihren IBM Cloud Container Registry-Namensbereich.

  1. Richten Sie eine Service-ID mit Zugriff auf IBM Cloud Container Registry ein und erstellen Sie dafür einen API-SchlüsselEin eindeutiger Code, der an eine API weitergegeben wird, um die aufrufende Anwendung oder den aufrufenden Benutzer zu identifizieren und um Verfolgungsdaten zu senden. Ein API-Schlüssel wird verwendet, um zu verfolgen und zu steuern, wie die API verwendet wird, um so z. B. Verwendung in böswilliger Absicht oder Missbrauch der API zu verhindern..

    1. Melden Sie sich beim Konto von Benutzer A an, indem Sie den folgenden Befehl ausführen.
        ibmcloud login
    ```
2. Erstellen Sie eine Service-ID namens `cr-roles-tutorial` mit der Beschreibung `"Created during the access control tutorial for Container Registry"`, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    ibmcloud iam service-id-create cr-roles-tutorial --description "Created during the access control tutorial for Container Registry"
    ```
3. Erstellen Sie eine Servicerichtlinie für die Service-ID, die die Rolle 'Leseberechtigter' für `namespace_a` zuordnet, indem Sie den folgenden Befehl ausführen.

```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. Erstellen Sie eine zweite Servicerichtlinie, die die Rolle 'Schreibberechtigter' für `namespace_b` zuordnet, indem Sie den folgenden Befehl ausführen.

```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. Erstellen Sie einen API-Schlüssel für die Service-ID, indem Sie den folgenden Befehl ausführen.

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

  2. Verwenden Sie Docker, um sich mit dem API-Schlüssel der Service-ID anzumelden, und interagieren Sie mit der Registry. Dabei ist API_KEY Ihr API-Schlüssel.

    1. Melden Sie sich bei IBM Cloud Container Registry an, indem Sie den folgenden Befehl ausführen.
        docker login -u iamapikey -p API_KEY REGISTRY_REGION.icr.io
    ```
    IBM Cloud Container Registry Unterstützt „ Docker “ und andere Clients. Informationen zur Anmeldung mit anderen Clients finden Sie im Abschnitt zum [Zugriff auf Namensbereiche bei der Automatisierung](/docs/Registry?topic=Registry-registry_access#registry_access_automating).
    {: tip}

2. Rufen Sie das Image ab, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    docker pull REGISTRY_REGION.icr.io/namespace_a/hello-world
    ```
3. Übertragen Sie das Image per Push-Operation an `namespace_a`, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_a/hello-world
    ```
    Dieser Befehl funktioniert nicht, da der Benutzer in `namespace_a` nicht über die Rolle 'Schreibberechtigter' verfügt.

4. Übertragen Sie das Image per Push-Operation an `namespace_b`, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    docker push REGISTRY_REGION.icr.io/namespace_b/hello-world
    ```
    Der Befehl funktioniert, weil der Benutzer in `namespace_b` über die Rolle 'Schreibberechtigter' verfügt.

  3. Räumen Sie auf:

    1. Melden Sie sich bei IBM Cloud Container Registry wieder als Benutzer A an.
        ibmcloud cr login
    ```
    IBM Cloud Container Registry Unterstützt „ Docker “ und andere Clients. Informationen zur Anmeldung mit anderen Clients finden Sie im Abschnitt zum [interaktiven Zugriff auf Namensbereiche](/docs/Registry?topic=Registry-registry_access#registry_access_interactive).
    {: tip}

2. Listen Sie Ihre Servicerichtlinien auf, indem Sie den folgenden Befehl ausführen.

```txt {: pre}
    ibmcloud iam service-policies cr-roles-tutorial
    ```
    Notieren Sie Ihre Richtlinien-IDs.

3. Löschen Sie Ihre Servicerichtlinien, indem Sie den folgenden Befehl für jede Richtlinie ausführen.

```txt {: pre}
    ibmcloud iam service-policy-delete cr-roles-tutorial POLICY_ID
    ```
4. Löschen Sie Ihre Service-ID, indem Sie den folgenden Befehl ausführen.

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

Konto bereinigen

Entfernen Sie die Ressourcen, die Sie in den vorherigen Abschnitten erstellt haben, damit Ihr Konto wieder den Zustand hat, den es zu Beginn dieses Tutorials hatte.

  1. Melden Sie sich beim Konto von Benutzer A an, indem Sie den folgenden Befehl ausführen.

    ibmcloud login

  2. Löschen Sie namespace_a, namespace_b und namespace_c, indem Sie die folgenden Befehle ausführen.

    ibmcloud cr namespace-rm namespace_a

    ibmcloud cr namespace-rm namespace_b

    ibmcloud cr namespace-rm namespace_c

  3. Entfernen Sie Benutzer B aus Ihrem Konto, indem Sie den folgenden Befehl ausführen.

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