Image-Registry-Lösung auswählen

Ihre Container-Images müssen in einer Container-Registry gespeichert werden, auf die Ihr Cluster zugreifen kann, um Anwendungen in Ihrem Cluster bereitzustellen. Sie können wahlweise die integrierte Registry Ihres Red Hat OpenShift-Clusters, eine private Registry mit Zugriffsbeschränkung auf ausgewählte Benutzer oder eine öffentliche Registry verwenden. Wählen Sie anhand der folgenden Tabelle die am besten geeignete Option für Ihren Anwendungsfall aus.

Interne Red Hat OpenShift Container Registry (OCR)

Für Ihren Cluster ist die interne Red Hat OpenShift Container Registry eingerichtet, d. h. Red Hat OpenShift kann den Anwendungslebenszyklus aus dem Cluster heraus automatisch erstellen, bereitstellen und verwalten. Images werden in einer unterstützenden, klassischen IBM Cloud-Dateispeichereinheit gespeichert, die beim Erstellen des Clusters bereitgestellt wird. Wenn Sie mehr Speicher benötigen, können Sie die Größe der Einheit ändern. Anwendungsfälle:

• Red Hat OpenShift-nativer Prozess für Image-Streaming, Erstellung und App-Bereitstellung Bereitstellungsprozess auf Clusterbasis.
• Images können für alle Projekte im Cluster gemeinsam genutzt werden. Dabei wird der Zugriff durch RBAC-Rollen gesteuert.
• Integration der internen Registry mit anderen Red Hat-Produkten wie CloudForms für erweiterte Funktionen wie Schwachstellensuche.
• (Optional) Die interne Registry kann durch eine Route zugänglich gemacht werden, damit Benutzer über das öffentliche Netz Images aus der Registry extrahieren können.
• (Optional) Die interne Registry kann für das Extrahieren von Images oder für das Übertragen von Images in eine private Registry wie IBM Cloud Container Registry eingerichtet werden.

Weitere Informationen finden Sie in Interne Registry verwenden.

Private Registry

Private Registrys sind eine gute Möglichkeit, Ihre Images vor nicht autorisiertem Zugriff zu schützen. Private Registrys müssen vom Clusteradministrator eingerichtet werden, damit sichergestellt ist, dass der Zugriff, das Speicherkontingent, Image Trust und andere Funktionen erwartungsgemäß funktionieren. Ihre Red Hat OpenShift-Cluster sind standardmäßig mit dem privaten IBM Cloud Container Registry über geheime Schlüssel für Image-Pull-Operationen im default-Projekt integriert. IBM Cloud Container Registry ist eine hoch verfügbare private Multi-Tenant-Registry zum Speichern eigener Images. Von IBM bereitgestellte Images können außerdem aus der globalen Registry icr.io extrahiert werden und lizenzierte aus der berechtigten Registry. Mit IBM Cloud Container Registry können Sie Images für mehrere Cluster mit integrierten IBM Cloud-IAM-Funktionen und Abrechnung verwalten. IBM Cloud Container Registry hat gegenüber der kombinierten Verwendung mit der internen Registry folgende Vorteile:

• Lokale Zwischenspeicherung der Images für schnellere Builds über die interne Registry
• Der Image-Stream ist für Bereitstellungen in anderen Projekten sichtbar, d. h. die geheimen Schlüssel für Pull-Operationen müssen nicht in jedes Projekt kopiert werden.
• Gemeinsame Nutzung von Images in mehreren Clustern, ohne die Images in mehrere Registrys zu übertragen
• Automatische Überprüfung der Images auf Sicherheitslücken
• Zugriffssteuerung durch IBM Cloud IAM-Richtlinien und separate regionale Registrys
• Beibehalten von Images ohne zusätzlichen Speicherplatzbedarf in Ihrem Cluster oder in einer angehängten Speichereinheit Festlegen von Richtlinien zum Verwalten der Imageanzahl, um den Speicherplatzbedarf zu begrenzen
• VPC-Infrastruktur: Verwendung des Endpunkts des privaten Registrierungsdienstes, damit auch Cluster, die nur einen Endpunkt des privaten Cloud-Dienstes verwenden, auf die Registrierung zugreifen können.
• Festlegen von Kontingenten für den Datenverkehr bei Speicher- und Image-Pull-Operationen für eine optimierte Steuerung von Speicher, Nutzung und Abrechnung
• Extrahieren lizenzierten IBM Inhalts mit einer Pull-Operation aus der Registry, für die Sie berechtigt sind.

Informationen zum Einstieg finden Sie in den folgenden Abschnitten:

• Erste Schritte mit IBM Cloud Container Registry.
• Importieren von Images aus IBM Cloud Container Registry in den Image-Stream der internen Registry.
• IBM Cloud Container Registry verwenden.

Öffentliche Registry

Öffentliche Registrys wie Docker Hub bieten die Möglichkeit zur gemeinsamen Nutzung von Images über Teams, Unternehmen, Cluster und Cloud-Provider hinweg. Einige öffentliche Registrys bieten unter Umständen auch eine private Registry-Komponente. Anwendungsfälle:

• Images im öffentlichen Netz mit Push- oder Pull-Operationen übertragen
• Schnelle Tests für Container über Cloud-Provider hinweg.
• Keine auf Unternehmen abgestimmte Funktionen wie Schwachstellensuche oder Zugriffsmanagement erforderlich.

Weitere Informationen finden Sie in der Dokumentation des öffentlichen Registers, z. B. in Quay oder Docker Hub.

Images in den internen Registrys speichern

Red Hat OpenShift-Cluster verfügen standardmäßig über eine interne Registry. Für die Images in der internen Registry werden Backups erstellt, sie variieren jedoch je nach Infrastrukturprovider Ihres Red Hat OpenShift on IBM Cloud-Clusters.

Klassische Cluster

Ihr Red Hat OpenShift-Cluster wird standardmäßig mit einer internen Registrierung eingerichtet, die File Storage for Classic als Sicherungsspeicher verwendet. Wenn Sie den Cluster löschen, werden die interne Registry und die zugehörigen Images ebenfalls gelöscht. Wenn Ihre Images dauerhaft gespeichert bleiben sollen, ziehen Sie die Verwendung einer privaten Registry z. B. IBM Cloud Container Registry, das Sichern Ihrer Images im permanenten Speicher z. B. Object Storage oder das Erstellen einer separaten eigenständigen Red Hat OpenShift Container Registry-Clusters (OCR-Cluster) in Betracht. Weitere Informationen finden Sie in der Dokumentation zuRed Hat OpenShift.

VPC-Cluster

Die interne Registrierung Ihres Red Hat OpenShift Clusters sichert Ihre Images in einem Bucket, der automatisch in einer IBM Cloud Object Storage Instanz in Ihrem Konto erstellt wird. Alle Daten, die im Object Storage-Bucket gespeichert sind, bleiben erhalten, selbst wenn Sie den Cluster löschen.

Klassische Cluster, VPC-Cluster oder Satellite-Cluster

Optional können Sie die interne Registrierung so einrichten, dass Daten im emptyDir des Arbeitsknotens gespeichert werden, auf dem der interne Registrierungs-Pod läuft. Dabei ist zu beachten, dass diese Daten nicht persistent sind. Wenn der Pod oder der Workerknoten neu gestartet wird, werden die gespeicherten Daten gelöscht und können nicht wiederhergestellt werden. Sie können die Images lokal im Verzeichnis emptyDir speichern, um die Leistung zu steigern, wenn Sie regelmäßig Container aus umfangreichen Images erstellen.

oc describe pvc -n openshift-image-registry image-registry-storage

Interne Image-Registry entfernen

Virtual Private Cloud

Die Bereitstellungen des Bildregisterbetreibers sind nur in Red Hat OpenShift on IBM Cloud Toolkit-verwalteten Clustern vorhanden. In HyperShift Clustern wird der Image-Registry-Operator in der Steuerungsebene ausgeführt.

Wenn Sie die interne Image-Registry nicht verwenden wollen, können Sie sie wie folgt entfernen.

1. Speichern Sie eine Kopie Ihrer internen Registry-Konfigurationen.

   oc get configs.imageregistry.operator.openshift.io cluster -o yaml > configs.yaml
   

2. Führen Sie den folgenden Patchbefehl aus, um den Verwaltungsstatus der Image-Registry in Removed zu ändern.

   kubectl patch configs.imageregistry.operator.openshift.io cluster -p '{"spec":{"managementState":"Removed"}}' --type='merge'
   

3. Nach dem Ändern des Managementstatus werden der Image-Registry-Service und die Bereitstellung aus dem openshift-image-registry-Namespace in Ihrem Cluster entfernt. Sie können die folgenden Befehle ausführen, um zu überprüfen, ob sie entfernt wurden. Beachten Sie, dass nur die Image-Registry-Implementierung und der Service entfernt werden. Die Bereitstellung und der Service des Image-Registry-Operators bleiben erhalten.

   oc get deployment -n openshift-image-registry
   

   oc get svc -n openshift-image-registry
   

Sichere externe Route für die interne Registry einrichten

Ihr Red Hat OpenShift-Cluster verfügt standardmäßig über eine interne Registry, die durch einen Service mit einer internen IP-Adresse zugänglich ist. Wenn Sie die interne Registry im öffentlichen Netz verfügbar machen möchten, können Sie eine sichere Route mit erneuter Verschlüsselung einrichten. Beispielsweise können Sie die interne Registry Ihres Clusters so einrichten, dass sie als öffentliche Registry für Bereitstellungen in anderen Projekten oder Clustern dient.

Vorbereitende Schritte:

• Stellen Sie sicher, dass Sie über die IAM-Service-Zugriffsrolle Manager IBM Cloud für den Cluster verfügen.
• Stellen Sie sicher, dass Ihr Cluster mit dem öffentlichen Netz verbunden ist, um die interne Registry über eine öffentliche Route zugänglich zu machen.
• Installieren Sie Docker auf Ihrer lokalen Maschine.
• Rufen Sie Ihren Red Hat OpenShift-Cluster auf.

Richten Sie für die Verwendung der internen Registry eine öffentliche Route für den Zugang zur Registry ein. Erstellen Sie anschließend einen geheimen Schlüssel zum Extrahieren von Images, der die Berechtigungsnachweise für den Zugriff auf die Registry enthält, damit Bereitstellungen in anderen Projekten Images aus dieser Registry extrahieren können.

1. Stellen Sie über das Projekt openshift-image-registry sicher, dass der Service image-registry für die interne Registry vorhanden ist.

   oc get svc -n openshift-image-registry
   

   Beispielausgabe

   NAME                      TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)                      AGE
   image-registry            ClusterIP      172.21.xxx.xxx    <none>          5000/TCP                     36d
   image-registry-operator   ClusterIP      None             <none>          60000/TCP                     36d
   

2. Erstellen Sie eine geschützte Route für den Service image-registry, die reencrypt für die TLS-Terminierung verwendet. Wenn die erneute Verschlüsselung verwendet wird, beendet der Router die TLS-Verbindung mit einem Zertifikat und verschlüsselt die Verbindung zur internen Registry dann erneut mit einem anderen Zertifikat. Bei dieser Methode wird der vollständige Pfad der Verbindung zwischen Benutzer und interner Registry verschlüsselt. Wenn Sie Ihren eigenen Domänennamen angeben möchten, fügen Sie die Option --hostname hinzu.

   oc create route reencrypt --service=image-registry -n openshift-image-registry
   

3. Rufen Sie den Hostnamen (HOST/PORT) und den PORT ab, die der Route für image-registry zugewiesen wurden.

   oc get route image-registry -n openshift-image-registry
   

   Beispielausgabe

   NAME              HOST/PORT                                                                                                  PATH      SERVICES          PORT       TERMINATION   WILDCARD
   image-registry   image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud             image-registry   5000-tcp   reencrypt     None
   

4. Bearbeiten Sie die Route, um die Lastausgleichsstrategie auf source einzustellen, damit dieselbe Client-IP-Adresse denselben Server erreicht, wie bei einer Passthrough-Routeneinrichtung. Sie können die Strategie festlegen, indem Sie eine Annotation im Abschnitt metadata.annotations hinzufügen: haproxy.router.openshift.io/balance: source. Sie können die Konfigurationsdatei über die Red Hat OpenShift-Anwendungskonsole oder über Ihre Befehlszeile bearbeiten, indem Sie den folgenden Befehl ausführen.

   oc edit route image-registry -n openshift-image-registry
   

   Fügen Sie die Annotation hinzu.

   apiVersion: route.openshift.io/v1
   kind: Route
   metadata:
   annotations:
       haproxy.router.openshift.io/balance: source
   ...
   

5. Wenn die Netzrichtlinien eines Unternehmens den Zugriff von Ihrem lokalen System auf öffentliche Endpunkte über Proxys oder Firewalls verhindern, lassen Sie den Zugriff auf die Unterdomäne der Route zu, die Sie in den folgenden Schritten für die interne Registry erstellen.

6. Melden Sie sich bei der internen Registry an und verwenden Sie dabei die Route als Hostnamen.

   docker login -u $(oc whoami) -p $(oc whoami -t) image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud
   

7. Versuchen Sie nach erfolgter Anmeldung, eine Beispielapp hello-world in die interne Registry zu übertragen.

   1. Extrahieren Sie das hello-world-Image aus DockerHub oder erstellen Sie ein Image auf Ihrer lokalen Maschine.

      docker pull hello-world
      

   2. Kennzeichnen Sie das lokale Image mit dem Hostnamen Ihrer internen Registry, dem Projekt, in dem Sie das Image bereitstellen möchten, und dem Namen und dem Tag des Images.

      docker tag hello-world:latest image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud/<project>/<image_name>:<tag>
      

   3. Übertragen Sie das Image mit einer Push-Operation in die interne Registry Ihres Clusters.

      docker push image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud/<project>/<image_name>:<tag>
      

   4. Überprüfen Sie, dass das Image zum Red Hat OpenShift-Image-Stream hinzugefügt wurde.

      oc get imagestream
      

      Beispielausgabe

      NAME          DOCKER REPO                                                            TAGS      UPDATED
      hello-world   image-registry-openshift-image-registry.svc:5000/default/hello-world   latest    7 hours ago
      

8. Damit Bereitstellungen in Ihrem Projekt Images aus der internen Registry extrahieren können, erstellen Sie einen geheimen Schlüssel für Image-Pull-Operationen in Ihrem Projekt, der die Berechtigungsnachweise zum Aufrufen Ihrer internen Registry enthält. Fügen Sie den geheimen Schlüssel für Image-Pull-Operationen zum Standardservicekonto für jedes Projekt hinzu.

   1. Listen Sie die von dem Standardservicekonto verwendeten geheimen Schlüssel für Image-Pull-Operationen auf und notieren Sie sich den geheimen Schlüssel, der mit default-dockercfg beginnt.

      oc describe sa default
      

      Beispielausgabe

      ...
      Image pull secrets:
      all-icr-io
      default-dockercfg-mpcn4
      ...
      

   2. Rufen Sie die codierten Informationen zum geheimen Schlüssel im Feld data der Konfigurationsdatei ab.

      oc get secret <default-dockercfg-name> -o yaml
      

      Beispielausgabe

      apiVersion: v1
      data:
        .dockercfg: ey...=
      

   3. Decodieren Sie den Wert des Felds data.

      echo "<ey...=>" | base64 -D
      

      Beispielausgabe

      {"172.21.xxx.xxx:5000":{"username":"serviceaccount","password":"eyJ...
      

   4. Erstellen Sie einen neuen geheimen Schlüssel für Image-Pull-Operationen für die interne Registry.

      • secret_name: Geben Sie dem geheimen Schlüssel für Image-Pull-Operationen einen Namen, z. B. internal-registry.
      • --namespace: Geben Sie den Namen des Projekts ein, in dem der geheimen Schlüssel für Image-Pull-Operationen erstellt werden soll, z. B. default.
      • --docker-server: Geben Sie anstelle der internen Service-IP-Adresse (172.21.xxx.xxx:5000) den Hostnamen der image-registry-Route mit dem Port (image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud:5000) ein.
      • --docker-username: Kopieren Sie den Wert für "username" aus dem vorherigen geheimen Schlüssel für Image-Pull-Operationen, z. B. serviceaccount.
      • --docker-password: Kopieren Sie den Wert für "password" aus dem vorherigen geheimen Schlüssel für Image-Pull-Operationen.
      • --docker-email: Geben Sie Ihre Docker-E-Mail-Adresse ein, soweit vorhanden. Wenn nicht, geben Sie eine fiktive E-Mail-Adresse ein, z. B. a@b.c. Diese E-Mail-Adresse ist erforderlich, um einen geheimen Kubernetes-Schlüssel zu erstellen, wird aber nach der Erstellung nicht weiter genutzt.

      oc create secret docker-registry internal-registry --namespace default --docker-server image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud:5000 --docker-username serviceaccount --docker-password <eyJ...> --docker-email a@b.c
      

   5. Fügen Sie den geheimen Schlüssel für Image-Pull-Operationen zum Standardservicekonto Ihres Projekts hinzu.

      oc patch -n <namespace_name> serviceaccount/default --type='json' -p='[{"op":"add","path":"/imagePullSecrets/-","value":{"name":"<image_pull_secret_name>"}}]'
      

   6. Wiederholen Sie diese Schritte für jedes Projekt, das Images aus der internen Registry extrahieren soll.

Nachdem Sie nun eine Zugangsroute für die interne Registry eingerichtet haben, können Sie sich anmelden und Images mit Push- oder Pull-Operationen in die Registry übertragen bzw. aus der Registry extrahieren. Weitere Informationen finden Sie in der Red Hat OpenShift-Dokumentation.

Images aus IBM Cloud Container Registry in den Image-Stream der internen Registry importieren

Standardmäßig ist Ihr Red Hat OpenShift on IBM Cloud-Cluster so eingerichtet, dass Images aus den privaten fernen IBM Cloud Container Registry-icr.io-Domänen in das Standardprojekt default extrahiert werden. Sie können ein Image von IBM Cloud Container Registry in die interne Registrierung Ihres Red Hat OpenShift Clusters importieren, indem Sie das Image als Image Stream markieren. Mit dieser Konfiguration können Sie Apps aus dem Image mithilfe des lokalen Caches der internen Registry bereitstellen. Dadurch können Ihre App-Bereitstellungen schneller erstellt werden. Auch können Bereitstellungen in anderen Projekten auf den Imagestream verweisen, damit Sie nicht in jedem Projekt Berechtigungsnachweise für geheime Image-Pull-Schlüssel zu IBM Cloud Container Registry erstellen müssen.

Wenn Sie Ihr Image in IBM Cloud Container Registry aktualisieren, wird das Image nicht automatisch in die interne Registry Ihres Red Hat OpenShift-Clusters übertragen. Konfigurieren Sie stattdessen den regelmäßigen Import oder wiederholen Sie diese Schritte, um das Bild zu markieren. Abhängig von der in Ihrer Bereitstellung verwendeten Image-Pull-Richtlinie, müssen Sie möglicherweise Ihre Bereitstellung erneut starten.

Sie möchten mehr über das Zusammenwirken von Builds, Image-Streams und interner Registry erfahren? Lesen Sie die Red Hat OpenShift-Dokumentationoder lesen Sie diesen Blog zur Verwaltung von Container-Images.

1. Rufen Sie Ihren Red Hat OpenShift-Cluster auf.

2. Wechseln Sie zum Projekt default, um Ihr Image in den Image-Stream zu extrahieren. Das Projekt default ist bereits mit den Berechtigungsnachweisen für den Zugriff auf die icr.io-Registrys eingerichtet.

   oc project default
   

3. Listen Sie die verfügbaren Images in Ihrer IBM Cloud Container Registry auf. Notieren Sie das Repository und den Tag des Image, das Sie per Pull-Operation in die interne Registry Ihres Red Hat OpenShift-Clusters extrahieren möchten.

   ibmcloud cr images
   

4. Markieren Sie das Image, um es aus Ihrem IBM Cloud Container Registry-Namensbereich als Imagestream in die interne Registry zu extrahieren. Weitere Informationen finden Sie in der Dokumentation Red Hat OpenShift oder führen Sie oc tag --help aus.

   oc tag <region>.icr.io/<namespace>/<image>:<tag> default/<image>:<tag> --reference-policy=local [--scheduled]
   

   • <region>.icr.io/<namespace>/<image>:<tag>: Verwenden Sie die zuvor abgerufenen Repository- und Tag-Informationen, um die IBM Cloud Container Registry Region, den Namensraum, das Bild und den Tag-Namen des Bildes zu vervollständigen, das Sie abrufen möchten.
   • default/<image>:<tag>: Geben Sie die Informationen für den internen Image-Stream ein, den Sie aus dem mit IBM Cloud Container Registry gekennzeichneten Image erstellen. Sie erstellen diesen Imagestream im default-Projekt, welches auch das Projekt ist, wo der Imagestream erstellt wird, wenn Sie kein Projekt angeben. Die Werte für <image>:<tag> stimmen normalerweise mit den Werten überein, die Sie zuvor abgerufen haben.
   • --reference-policy=local: Legen Sie diesen Wert auf local fest, damit eine Kopie des Image von IBM Cloud Container Registry in den lokalen Cache der internen Registry importiert wird und als Imagestream für die Projekte des Clusters verfügbar wird. Wenn Sie diesen Wert nicht angeben, verweist der Imagestream zurück auf IBM Cloud Container Registry, wenn Sie ihn in Ihren Bereitstellungen verwenden und erfordert daher Berechtigungsnachweise in dem Projekt.
   • --scheduled: Setzen Sie diese optionale Option, um einen regelmäßigen Import des Bildes von IBM Cloud Container Registry in die interne Registrierung einzurichten. Das Standardintervall beträgt 15 Minuten. Weitere Informationen finden Sie in der Red Hat OpenShift-Dokumentation.

5. Überprüfen Sie, ob Ihr Image-Stream erstellt wird.

   oc get imagestreams
   

6. Überprüfen Sie, dass der Image-Stream die Images erfolgreich aus IBM Cloud Container Registry extrahiert hat. Überprüfen Sie in der Ausgabe, ob das zuletzt getaggt von-Image mit Ihrem * <region>.icr.io/<namespace>/<image>@<digest>-Image übereinstimmt.

   oc describe is/<imagestream>
   

   Beispielausgabe

   NAME:            <imagestream>
   Namespace:        default
   Created:        2 days ago
   Labels:            <none>
   Annotations:        openshift.io/image.dockerRepositoryCheck=2020-03-31T09:41:36Z
   Image Repository:    image-registry.openshift-image-registry.svc:5000/default/ant1
   Image Lookup:        local=false
   Unique Images:        1
   Tags:                1
   
   latest
       tagged from <region>.icr.io/<namespace>/<image>:<tag>
   
       * <region>.icr.io/<namespace>/<image>@<digest>
           2 days ago
   

Jetzt können Ihre Entwickler den Imagstream in einer App-Bereitstellung verwenden. Das Image wird erfolgreich aus dem lokal extrahierten Image in der internen Registry erstellt. Sie müssen keinen geheimen Image-Pull-Schlüssel in dem Projekt für IBM Cloud Container Registry erstellen, denn der Imagestream ist lokal für den Cluster.

Builds in der internen Registry einrichten, um Images in IBM Cloud Container Registry zu übertragen

Wenn Sie einen Build in Ihrem Red Hat OpenShift on IBM Cloud Cluster erstellen, können Sie die interne Registrierung so einrichten, dass das Image in Ihr externes Repository in IBM Cloud Container Registry übertragen wird. Der geheime Schlüssel für Image-Pull-Operationen im Projekt default Ihres Clusters verfügt standardmäßig nur über Lesezugriff zum Extrahieren von Images aus IBM Cloud Container Registry. Zum Übertragen von Images mit Push-Operationen müssen Sie einen geheimen Schlüssel mit Schreibzugriff hinzufügen.

1. Rufen Sie Ihren Red Hat OpenShift-Cluster auf.

2. Wechseln Sie zum Projekt default.

   oc project default
   

3. Führen Sie die Schritte aus, um einen IBM Cloud IAM-API-Schlüssel mit der Servicezugriffsrolle Reader und Writer einzurichten und damit Images aus Ihren icr.io-Registrys zu extrahieren bzw. mit Push-Operation dorthin zu übertragen.

   Dabei ist zu beachten, dass jeder Benutzer mit Zugriff auf das Projekt diesen geheimen Schlüssel verwenden kann, um Images in ihre private Registry zu übertragen. Sie können bei Bedarf Tools zum Anmelden und Überwachen einrichten, um zu beobachten, welche Benutzer bestimmte Aktionen in Ihrem Cluster ausführen.

4. Wiederholen Sie den vorherigen Schritt für jede icr.io-Region, in die Sie Images übertragen möchten.

5. Fügen Sie den geheimen Schlüssel zum Buildservicekonto hinzu und verweisen Sie auf die geheimen Schlüssel in der Buildkonfigurationsdatei. Weitere Informationen finden Sie in der Red Hat OpenShift-Dokumentation.

   1. Fügen Sie den geheimen Schlüssel zum Build-Servicekonto hinzu, indem Sie auf den geheimen Schlüssel verweisen, den Sie soeben für die Rolle builder erstellt haben, die von allen Builds im Cluster verwendet wird.

      oc secrets link builder <secret_name>
      

   2. Listen Sie die Buildkonfigurationen auf und notieren Sie sich die Buildkonfigurationen, denen Sie Push- und Pull-Zugriff auf die IBM Cloud Container Registry erteilen möchten.

      oc get bc
      

   3. Legen Sie den geheimen Schlüssel für Image-Push-Operationen für die Buildkonfiguration fest, damit sie den geheimen Schlüssel verwenden, den Sie soeben mit dem Servicezugriff Writer auf die IBM Cloud Container Registry erstellt haben.

      oc set build-secret --push bc/<build_config_name> <secret_name>
      

   4. Richten Sie den geheimen Schlüssel für Image-Pull-Operationen für die Buildkonfiguration so ein, dass Images aus der Registry extrahiert, aus der das ursprüngliche Build-Image extrahiert werden soll. Sie können beispielsweise den geheimen Schlüssel verwenden, den Sie gerade mit dem Servicezugriff Reader auf die IBM Cloud Container Registry erstellt haben, wenn sich das Quellenimage in einem IBM Cloud Container Registry-Repository befindet.

      oc set build-secret --pull bc/<build_config_name> <secret_name>
      

6. Nachdem Sie das Build-Servicekonto und die Buildkonfigurationsdatei aktualisiert haben, sodass sie mit Push-Operation in die IBM Cloud Container Registry übertragen werden können, starten Sie Ihren Build erneut.

   oc start-build <build_name>
   

7. Rufen Sie den Namen Ihres Build-Pods ab, wie z. B. <build>-2-build.

   oc get pods
   

8. Überprüfen Sie die Protokolle des Builds und notieren Sie sich, wohin das Image übertragen wurde.

   oc logs <build_pod>
   

   Beispiel für ein erfolgreiches Image-Push-Protokoll

   ...
   Successfully pushed <region>.icr.io/<namespace>/<build_name>@sha256:<hash>
   Push successful
   

9. Überprüfen Sie Ihre Images in Ihrer privaten Registry, um festzustellen, ob das Image erstellt wurde.

   ibmcloud cr image list
   

   Beispielausgabe

   Repository                                Tag       Digest     Namespace     Created         Size     Security status   
   <region>.icr.io/<namespace>/<build_name>  latest    <digest>   <namespace>   2 minutes ago   182 MB   33 Issues  
   

Ihr Red Hat OpenShift-Build kann jetzt mit Pull- bzw. Push-Operationen Images in IBM Cloud Container Registry übertragen bzw. daraus extrahieren.

IBM Cloud Container Registry verwenden

Standardmäßig ist Ihr Red Hat OpenShift on IBM Cloud-Cluster so eingerichtet, dass Images aus den privaten fernen IBM Cloud Container Registry-icr.io-Domänen in das Standardprojekt default extrahiert werden. Wenn Sie Images, die in IBM Cloud Container Registry gespeichert sind, für andere Projekte verwenden möchten, können Sie entweder das Image als Image-Stream in die interne Registry extrahieren oder geheime Schlüssel für Image-Pull-Operationen für jede globale und regionale Registry in jedem Projekt erstellen.

Images in die interne Registry importieren: Weitere Informationen finden Sie in Images aus IBM Cloud Container Registry in den Image-Stream der internen Registry importieren.

Images direkt aus der externenIBM Cloud Container Registry extrahieren: Weitere Informationen finden Sie in den folgenden Abschnitten.

• Vorgehensweise beim Autorisieren Ihres Cluster zum Extrahieren von Images aus einer Registry
• Geheimen Schlüssel für all-icr-io aus dem Projekt default in das Projekt kopieren, aus dem Images extrahiert werden sollen.
• Eigenen geheimen Schlüssel für Image-Pull-Operationen erstellen.
• Hinzufügen des geheimen Schlüssels für Image-Pull-Operationen zu Ihrer Bereitstellungskonfiguration oder zum Projektservicekonto.

Informationen zur Autorisierung Ihres Clusters zum Extrahieren von Images aus einer privaten Registry

Zum Extrahieren von Images aus einer Registry verwendet Ihr Red Hat OpenShift on IBM Cloud-Custer einen speziellen Typ eines geheimen Kubernetes-Schlüssels, einen geheimen Schlüssel für Image-Pull-Operationen (imagePullSecret). In diesem geheimen Schlüssel für Image-Pull-Operationen werden die Berechtigungsnachweise für den Zugriff auf eine Container-Registry gespeichert.

Bei der Container-Registry kann es sich um Folgendes handeln:

• Ein privater Namensbereich in Ihrer eigenen Instanz von IBM Cloud Container Registry.
• Ein privater Namensbereich in IBM Cloud Container Registry, der zu einem anderen IBM Cloud-Konto gehört.
• Eine beliebige andere private Registry wie beispielsweise Docker.

Ihr Cluster ist jedoch standardmäßig so eingerichtet, dass er nur Images aus den Namensbereichen Ihres Kontos in IBM Cloud Container Registry extrahiert und Container aus diesen Images im default Red Hat OpenShift-Projekt in Ihrem Cluster bereitstellt. Wenn Sie Images in andere Projekte des Clusters oder aus anderen Container-Registrys extrahieren müssen, müssen Sie Ihre eigenen geheimen Schlüssel für Image-Pull-Operationen konfigurieren.

Vorhandene Cluster zur Verwendung von API-Schlüsseln in geheimen Schlüsseln für Image-Pull-Operationen aktualisieren

Für neue Red Hat OpenShift on IBM Cloud-Cluster wird ein API-Schlüssel in geheimen Schlüsseln für Image-Pull-Operationen, um den Zugriff auf IBM Cloud Container Registry zu autorisieren. Mit diesen geheimen Schlüsseln für Image-Pull-Operationen können Sie Container aus Images bereitstellen, die in den Registry-Domänen icr.io gespeichert sind. Sie können die geheimen Schlüssel für Image-Pull-Operationen zu Ihrem Cluster hinzufügen, wenn Ihr Cluster ohne diese geheimen Schlüssel erstellt wurde.

Vorbereitende Schritte

1. Rufen Sie Ihren Red Hat OpenShift-Cluster auf.

2. Stellen Sie sicher, dass Sie über die folgenden Berechtigungen verfügen: IBM Cloud IAM Operator or Administrator-Plattformzugriffsrolle für Red Hat OpenShift on IBM Cloud. Der Account-Besitzer kann Ihnen die Rolle mit dem folgenden Befehl zuweisen.

   ibmcloud iam user-policy-create EMAIL --service-name containers-kubernetes --roles "Administrator,Operator"
   

3. IBM Cloud IAM-Plattformzugriffsrolle Administrator für IBM Cloud Container Registry, über alle Regionen und Ressourcengruppen. Die Gültigkeit der Richtlinie kann nicht auf eine bestimmte Region oder Ressourcengruppe begrenzt werden. Der Account-Besitzer kann Ihnen die Rolle mit dem folgenden Befehl zuweisen.

   Überprüfen Sie, ob das Geheimnis erfolgreich erstellt wurde

   ibmcloud iam user-policy-create <your_user_email> --service-name container-registry --roles Administrator
   

4. Wenn Ihr Konto das Erstellen von Service-IDs einschränkt, fügen Sie die Rolle Erstellungsfunktion für Service-IDs zu Identity and Access Management in der Konsole hinzu (iam-identity in der API oder in der CLI).

5. Wenn Ihr Konto das Erstellen von API-Schlüsseln einschränkt, fügen Sie die Rolle Erstellungsfunktion für Benutzer-API-Schlüssel zu Identity and Access Management in der Konsole hinzu (iam-identity in der API oder in der CLI).

Verwendung eines Bildabrufgeheimnisses für den Zugriff auf Bilder in externen privaten Registern

Richten Sie einen eigenen geheimen Schlüssel für Image-Pull-Operationen in Ihrem Cluster ein, um Container in anderen Red Hat OpenShift-Projekten als default bereitzustellen, um Images zu verwenden, die in anderen IBM Cloud-Konten gespeichert sind, oder um Images zu verwenden die in externen privaten Registrys gespeichert sind. Weiterhin können Sie einen eigenen geheimen Schlüssel für Image-Pull-Operationen erstellen, um IAM-Zugriffsrichtlinien anzuwenden, die Berechtigungen auf bestimmte Namensbereiche für Registry-Images oder Aktionen (z. B. push oder pull) beschränken.

Nachdem Sie den geheimen Schlüssel zum Extrahieren von Images erstellt haben, müssen Ihre Container den geheimen Schlüssel verwenden, um zum Extrahieren eines Image aus der Registry berechtigt zu sein. Sie können dem Servicekonto für das Projekt den geheimen Schlüssel für Image-Pull-Operationen hinzufügen oder in jeder Bereitstellung auf den geheimen Schlüssel verweisen. Anweisungen finden Sie unter Geheimen Schlüssel für Image-Pull-Operationen zum Bereitstellen von Containern verwenden.

Geheime Schlüssel für Image-Pull-Operationen sind nur für die Red Hat OpenShift-Projekte gültig, für die sie erstellt wurden. Wiederholen Sie diese Schritte für jeden Namensbereich, in dem Sie Container bereitstellen möchten.

Vorbereitende Schritte:

1. Richten Sie einen Namensbereich in IBM Cloud Container Registry ein und übertragen Sie Images per Push-Operation an diesen Namensbereich.
2. Erstellen Sie einen Cluster.
3. Rufen Sie Ihren Red Hat OpenShift-Cluster auf.

Wählen Sie zur Verwendung Ihres eigenen geheimen Schlüssels für Image-Pull-Operationen eine der folgenden Optionen aus:

• Kopieren Sie den geheimen Schlüssel für Image-Pull-Operationen aus dem Red Hat OpenShift-Standardprojekt in andere Projekte in Ihrem Cluster.
• Erstellen Sie IAM-API-Schlüsselberechtigungsnachweise und speichern Sie sie in einem geheimen Schlüssel für Image-Pull-Operationen, um auf Images in anderen IBM Cloud-Konten zuzugreifen oder um IAM-Richtlinien zur Einschränkung des Zugriffs auf bestimmte Registry-Domänen oder Namensbereiche anzuwenden.
• Erstellen Sie einen geheimen Schlüssel für Image-Pull-Operationen, um auf Images in externen privaten Registrys zuzugreifen.

Wenn Sie bereits einen geheimen Schlüssel für Image-Pull-Operationen in Ihrem Projekt erstellt haben, den Sie in Ihrer Bereitstellung verwenden möchten, finden Sie weitere Informationen unter Container mithilfe des erstellten geheimen Schlüssels für Image-Pull-Operationen (imagePullSecret) bereitstellen.

Geheimen Schlüssel für Image-Pull-Operationen zum Bereitstellen von Containern verwenden

Sie können einen geheimen Schlüssel für die Pull-Operation von Images in Ihrer Pod-Bereitstellung definieren oder den geheimen Schlüssel für die Pull-Operation von Images in Ihrem Kubernetes-Servicekonto speichern, sodass er für alle Bereitstellungen verfügbar ist, die kein Kubernetes-Servicekonto im Projekt angeben.

Zur Planung, wie geheime Image-Pull-Schlüssel in Ihrem Cluster verwendet werden sollen, wählen Sie zwischen den folgenden Optionen.

• Verweis auf den geheimen Schlüssel für die Pull-Operation von Images in Ihrer Pod-Bereitstellung: Verwenden Sie diese Option, wenn Sie nicht allen Pods in Ihrem Projekt standardmäßig Zugriff auf Ihre Registry gewähren wollen. Entwickler können den geheimen Schlüssel für Image-Pull-Operationen in jede Podbereitstellung einbeziehen, die auf Ihre Registry zugreifen muss.
• Seichern des geheimen Schlüssels für Image-Pull-Operationen im Kubernetes Servicekonto: Verwenden Sie diese Option, um Zugriff auf Images in Ihrer Registry für alle Bereitstellungen in den ausgewählten Red Hat OpenShift-Projekten zu erteilen. Um einen geheimen Schlüssel für Image-Pull-Operationen im Kubernetes Service-Konto zu speichern, verwenden Sie die folgenden Schritte.

Cluster einrichten, mit dem Software per Pull-Operation übertragen werden kann

Sie können Ihren Red Hat OpenShift on IBM Cloud-Cluster so einrichten, dass Software, für die Sie berechtigt sind, per Pull-Operation übertragen wird. Bei der Software handelt es sich um eine Gruppe geschützter Container-Images, die in Helm-Charts gepackt sind, für deren Nutzung Sie durch IBM berechtigt wurden. Die Software, für die Sie eine Berechtigung haben, wird in der speziellen IBM Cloud Container Registry-Domäne cp.icr.io gespeichert. Um auf diese Domäne zugreifen zu können, müssen Sie einen geheimen Schlüssel für Image-Pull-Operationen mit einem Berechtigungsschlüssel für Ihren Cluster erstellen und diesen geheimen Schlüssel für Image-Pull-Operationen dem Kubernetes Servicekonto für jedes Projekt hinzufügen, in dem die Software bereitgestellt werden soll.

Vorbereitende Schritte: Greifen Sie auf Ihren Red Hat OpenShift-Cluster zu.

1. Fordern Sie den Berechtigungsschlüssel für die Bibliothek mit der Software an, für die Sie berechtigt sind.

   1. Melden Sie sich auf MyIBM.com an und blättern Sie zum Abschnitt Containersoftware-Bibliothek. Klicken Sie auf View library.
   2. Klicken Sie auf der Seite Access your container software > Entitlement keys auf Copy key. Mit diesem Schlüssel wird der Zugriff auf die gesamte Software in Ihrer Containersoftwarebibliothek autorisiert, für die Sie berechtigt sind.

2. Erstellen Sie in dem Projekt, in dem Sie die Container, für die Sie berechtigt sind, bereitstellen möchten, einen geheimen Schlüssel für Image-Pull-Operationen, damit Sie auf die Registry cp.icr.io, für die Sie berechtigt sind, zugreifen können. Verwenden Sie den Berechtigungsschlüssel, den Sie zuvor als Wert für --docker-password abgerufen haben. Weitere Informationen finden Sie unter Zugriff auf Images in anderen privaten Registrys.

   oc create secret docker-registry entitled-cp-icr-io --docker-server=cp.icr.io --docker-username=cp --docker-password=<entitlement_key> --docker-email=<docker_email> -n <project>
   

3. Fügen Sie den geheimen Schlüssel für Image-Pull-Operationen dem Servicekonto des Namensbereichs hinzu, sodass jeder Container im Projekt den Berechtigungsschlüssel zum Übertragen von Images, für die eine Berechtigung besteht, verwenden kann. Weitere Informationen finden Sie unter Geheimen Schlüssel für Image-Pull-Operationen zum Bereitstellen von Containern verwenden.

   oc patch -n <project> serviceaccount/default --type='json' -p='[{"op":"add","path":"/imagePullSecrets/-","value":{"name":"entitled-cp-icr-io"}}]'
   

4. Erstellen Sie einen Pod in dem Projekt, der einen Container aus einem Image in der Registry erstellt, für die Sie berechtigt sind.

   oc run <pod_name> --image=cp.icr.io/<image_name> -n <project> --generator=run-pod/v1
   

5. Stellen Sie sicher, dass Ihr Container erfolgreich aus dem Image, für das Sie berechtigt sind, erstellt werden konnte, indem Sie überprüfen, ob sich der Pod in einem aktiven Status (Running) befindet.

   oc get pod <pod_name> -n <project>
   

Welcher Schritt soll als Nächstes ausgeführt werden? Sie können das Helm-Chart-Repository entitled einrichten, in dem Helm-Charts gespeichert werden, die Software mit Berechtigung enthalten. Wenn Sie Helm bereits in Ihrem Cluster installiert haben, führen Sie folgenden Befehl aus: helm repo add entitled https://raw.githubusercontent.com/IBM/charts/master/repo/entitled.

Private Registry zum globalen geheimen Schlüssel für Pull-Operationen hinzufügen

RHEL-Arbeitsknoten

In Clustern, die nur RHEL-Arbeitsknoten verwenden, können Sie ein globales Image-Pull-Geheimnis einrichten, das jeder Arbeitsknoten im Cluster verwenden kann, um Images aus einer privaten Registry zu ziehen.

Standardmäßig verfügt Ihr Red Hat OpenShift on IBM Cloud-Cluster über einen globalen geheimen Schlüssel für Image-Pull-Operationen für die folgenden Registrys, damit die Red Hat OpenShift-Standardkomponenten bereitgestellt werden können.

• cloud.openshift.com
• quay.io
• registry.connect.redhat.com
• registry.redhat.io

Ersetzen Sie den geheimen Schlüssel für Image-Pull-Operationen nicht durch einen geheimen Schlüssel für Image-Pull-Operationen, der nicht über die Berechtigungsnachweise für die Standard-Registrys von Red Hat verfügt. Wenn Sie dies tun, können die Red Hat OpenShift-Standardkomponenten, die in Ihrem Cluster installiert sind, wie z. B. der OperatorHub, fehlschlagen, weil sie keine Images aus diesen Registrys extrahieren können.

Vorbereitende Schritte:

• Laden Sie das jq JSON-Prozessor-Befehlszeilenpaket herunter. jq wird verwendet, um den JSON-Wert des standardmäßigen globalen geheimen Schlüssels für Image-Pull-Operationen mit dem geheimen Schlüssel für Image-Pull-Operationen für private Registrys zu kombinieren, der hinzugefügt werden soll.
• Rufen Sie Ihren Red Hat OpenShift-Cluster auf.

Um private Registrys hinzuzufügen, bearbeiten Sie den Wert für globale geheime Schlüssel für Image-Pull-Operationen pull-secret im Projekt openshift-config.

1. Erstellen Sie einen Wert für einen geheimen Schlüssel, der die Berechtigungsnachweise enthält, um auf Ihre private Registry zuzugreifen, und speichern Sie den Wert für den decodierten geheimen Schlüssel in einer JSON-Datei. Wenn Sie den Wert für den geheimen Schlüssel erstellen, werden die Berechtigungsnachweise automatisch in Base64 codiert. Mit der Option --dry-run wird der Wert für den geheimen Schlüssel nur erstellt und es wird kein Wert für ein geheimes Objekt in Ihrem Cluster erstellt. Der Wert für den decodierten geheimen Schlüssel wird anschließend zur späteren Verwendung in Ihrem globalen geheimen Schlüssel für Pull-Operationen in einer JSON-Datei gespeichert.

   oc create secret docker-registry <secret_name> --docker-server=<registry_URL> --docker-username=<docker_username> --docker-password=<docker_password> --docker-email=<docker_email> --dry-run=true --output="jsonpath={.data.\.dockerconfigjson}" | base64 --decode > myregistryconfigjson
   

   --namespace <project>

   Erforderlich. Das Red Hat OpenShift-Projekt Ihres Clusters, in dem Sie den geheimen Schlüssel verwenden und Container bereitstellen möchten. Zum Auflisten der Projekte in Ihrem Cluster führen Sie den Befehl oc get ns aus.

   <secret_name>

   Erforderlich. Der Name, den Sie für Ihren geheimen Schlüssel für Image-Pull-Operationen verwenden wollen.

   --docker-server <registry_URL>

   Erforderlich. Die URL der Registry, in der Ihre privaten Images gespeichert sind.

   --docker-username <docker_username>

   Erforderlich. Der Benutzername für die Anmeldung bei Ihrer privaten Registry.

   --docker-password <token_value>

   Erforderlich. Das Kennwort für die Anmeldung bei Ihrer privaten Registry, z. B. ein Tokenwert.

   --docker-email <docker-email>

   Erforderlich. Falls Sie über eine Docker-E-Mail-Adresse verfügen, geben Sie diese ein. Falls Sie nicht über eine solche Adresse verfügen, geben Sie eine fiktive E-Mail-Adresse ein (z. B. a@b.c). Diese E-Mail-Adresse ist erforderlich, um einen geheimen Kubernetes-Schlüssel zu erstellen, wird aber nach der Erstellung nicht weiter genutzt.

   --dry-run=true

   Wählen Sie diese Option, um nur den geheimen Wert zu erstellen und nicht das geheime Objekt in Ihrem Cluster zu erstellen und zu speichern.

   --output="jsonpath={.data.\.dockerconfigjson}"

   Rufen Sie nur den Wert .dockerconfigjson aus dem Datenabschnitt des geheimen Kubernetes-Schlüssels ab.

   | base64 --decode > myregistryconfigjson

   Laden Sie die decodierten geheimen Daten in eine lokale Datei myregistryconfigjson herunter.

2. Rufen Sie den decodierten Wert des geheimen Schlüssels des standardmäßigen globalen geheimen Schlüssels für Pull-Operationen ab und speichern Sie ihn in einer Datei dockerconfigjson.

   oc get secret pull-secret -n openshift-config --output="jsonpath={.data.\.dockerconfigjson}" | base64 --decode > dockerconfigjson
   

3. Kombinieren Sie die heruntergeladene Datei myregistryconfigjson für geheime Schlüssel für Pull-Operationen für die private Registry mit der standardmäßigen Datei dockerconfigjson für globale geheime Schlüssel für Pull-Operationen.

   jq -s '.[0] * .[1]' dockerconfigjson myregistryconfigjson > dockerconfigjson-merged
   

4. Aktualisieren Sie den globalen geheimen Schlüssel für Pull-Operationen mit der kombinierten Datei dockerconfigjson-merged.

   oc set data secret/pull-secret -n openshift-config --from-file=.dockerconfigjson=dockerconfigjson-merged
   

5. Überprüfen Sie, ob der globale geheime Schlüssel aktualisiert wurde. Stellen Sie sicher, dass sich Ihre private Registry und jede der standardmäßigen Red Hat-Registrys in der Ausgabe des folgenden Befehls wiederfinden.

   oc get secret pull-secret -n openshift-config --output="jsonpath={.data.\.dockerconfigjson}" | base64 --decode
   

   Beispielausgabe

   {
       "auths": {
           "cloud.openshift.com": {
               "auth": "<encoded_string>",
               "email": "email@example.com"
           },
           "quay.io": {
               "auth": "<encoded_string>",
               "email": "email@example.com"
           },
           "registry.connect.redhat.com": {
               "auth": "<encoded_string>",
               "email": "email@example.com"
           },
           "registry.redhat.io": {
               "auth": "<encoded_string>",
               "email": "email@example.com"
           },
           "<private_registry>": {
               "username": "iamapikey",
               "password": "<encoded_string>",
               "email": "email@example.com",
               "auth": "<encoded_string>"
           }
       }
   }
   

6. Damit die globalen Konfigurationsänderungen aufgenommen werden, müssen Sie alle Workerknoten in Ihrem Cluster erneut laden.

   1. Notieren Sie sich die IDs der Workerknoten in Ihrem Cluster.

      ibmcloud oc worker ls -c <cluster_name_or_ID>
      

   2. Für klassische Cluster Laden Sie jeden Workerknoten erneut. Sie können mehrere Worker Nodes neu laden, indem Sie mehrere -w Optionen einbeziehen, aber stellen Sie sicher, dass genügend Worker Nodes gleichzeitig für Ihre Anwendungen laufen, um einen Ausfall zu vermeiden.

      ibmcloud oc worker reload -c <cluster_name_or_ID> -w <workerID_1> -w <workerID_2>
      

   3. Für VPC-Cluster Ersetzen Sie jeden Workerknoten. Bevor Sie beginnen, stellen Sie sicher, dass Ihr Cluster über genügend andere Workerknoten verfügt, damit Ihre Pods neu geplant und weiter ausgeführt werden können.

      ibmcloud oc worker replace --cluster <cluster_name_or_ID> --worker <worker_node_ID>
      

7. Wenn sich die Workerknoten wieder in einwandfreiem Zustand befinden, überprüfen Sie, ob der globale geheime Schlüssel für Pull-Operationen auf einem Workerknoten aktualisiert wurde.

   1. Starten Sie einen Debug-Pod, um sich bei einem Workerknoten anzumelden. Verwenden Sie die Private IP, die Sie zuvor für <node_name> abgerufen haben.

      oc debug node/<node_name>
      

   2. Ändern Sie das Stammverzeichnis in den Host, so dass Sie Dateien auf dem Workerknoten anzeigen können.

      chroot /host
      

   3. Stellen Sie sicher, dass die Docker-Konfigurationsdatei die Registry-Berechtigungsnachweise enthält, die mit dem globalen geheimen Schlüssel für Pull-Operationen übereinstimmen, den Sie festgelegt haben.

      vi /.docker/config.json
      

Aktualisierung des globalen Pull-Geheimnisses

RHCOS-Arbeiter-Knoten RHEL-Arbeitsknoten

In Clustern, die RHCOS-Worker oder eine Kombination aus RHCOS- und RHEL-Workern verwenden, können Sie die folgenden Schritte ausführen, um das globale Pull-Secret in Ihrem Red Hat OpenShift on IBM Cloud-Cluster zu aktualisieren.

Standardmäßig verfügt Ihr Red Hat OpenShift on IBM Cloud-Cluster über einen globalen geheimen Schlüssel für Image-Pull-Operationen für die folgenden Registrys, damit die Red Hat OpenShift-Standardkomponenten bereitgestellt werden können.

• cloud.openshift.com
• quay.io
• registry.connect.redhat.com
• registry.redhat.io

Ersetzen Sie den geheimen Schlüssel für Image-Pull-Operationen nicht durch einen geheimen Schlüssel für Image-Pull-Operationen, der nicht über die Berechtigungsnachweise für die Standard-Registrys von Red Hat verfügt. Wenn Sie dies tun, können die Red Hat OpenShift-Standardkomponenten, die in Ihrem Cluster installiert sind, wie z. B. der OperatorHub, fehlschlagen, weil sie keine Images aus diesen Registrys extrahieren können.

1. Erstellen Sie ein Geheimnis, das die Anmeldeinformationen für die zu verwendende Registrierung enthält.

   oc create secret docker-registry docker-auth-secret \
   --docker-server=REGISTRY \
   --docker-username=USERNAME \
   --docker-password=PASSWORD \
   --namespace kube-system
   

   Beispiel für einen create secret-Befehl

   oc create secret docker-registry docker-auth-secret \
   --docker-server=REGISTRY \
   --docker-username=cp \
   --docker-password=ENTITLEMENT-KEY \
   --namespace kube-system
   

2. Erstellen Sie ein DaemonSet, um das Geheimnis auf alle Arbeitsknoten anzuwenden.

   cat << EOF | oc create -f -
   apiVersion: apps/v1
   kind: DaemonSet
   metadata:
     name: update-docker-config
     namespace: kube-system
     labels:
       app: update-docker-config
   spec:
     selector:
       matchLabels:
         name: update-docker-config
     template:
       metadata:
         labels:
           name: update-docker-config
       spec:
         initContainers:
           - command: ["/bin/sh", "-c"]
             args:
               - >
                 echo "Checking if RHEL or RHCOS host";
                 [[ -s /docker-config/.docker/config.json  ]] && CONFIG_PATH=/docker-config/.docker || CONFIG_PATH=/docker-config/root/.docker;
                 echo "Backing up or restoring config.json";
                 [[ -s \$CONFIG_PATH/config.json ]] && cp \$CONFIG_PATH/config.json \$CONFIG_PATH/config.json.bak || cp \$CONFIG_PATH/config.json.bak \$CONFIG_PATH/config.json;
                 echo "Merging secret with config.json";
                 /host/usr/bin/jq -s '.[0] * .[1]' \$CONFIG_PATH/config.json /auth/.dockerconfigjson > \$CONFIG_PATH/config.tmp;
                 mv \$CONFIG_PATH/config.tmp \$CONFIG_PATH/config.json;
                 echo "Sending signal to reload crio config";
                 pidof crio;
                 kill -1 \$(pidof crio)
             image: icr.io/ibm/alpine:latest
             imagePullPolicy: IfNotPresent
             name: updater
             resources: {}
             securityContext:
               privileged: true
             volumeMounts:
               - name: docker-auth-secret
                 mountPath: /auth
               - name: docker
                 mountPath: /docker-config
               - name: bin
                 mountPath: /host/usr/bin
               - name: lib64
                 mountPath: /lib64
         containers:
           - resources:
               requests:
                 cpu: 0.01
             image: icr.io/ibm/alpine:latest
             name: sleepforever
             command: ["/bin/sh", "-c"]
             args:
               - >
                 while true; do
                   sleep 100000;
                 done
         hostPID: true
         volumes:
           - name: docker-auth-secret
             secret:
               secretName: docker-auth-secret
           - name: docker
             hostPath:
               path: /
           - name: bin
             hostPath:
               path: /usr/bin
           - name: lib64
             hostPath:
               path: /lib64
               hostPathType: Directory
   EOF
   

3. Überprüfen Sie, ob die Pods laufen.

   oc get daemonset -n kube-system update-docker-config
   

Containerd-Konfiguration für angepasste IBM Cloud Kubernetes Service-Registry aktualisieren

Mit Kubernetes Version 1.22 oder höher können Sie containerd-Konfigurationsdateien auf Workerknoten verwenden, um das Extrahieren aus einer Container-Registry zu konfigurieren. Sie können eine Dämongruppe verwenden, um die Konfigurationen für alle Knoten in einem Cluster zu aktualisieren. Dadurch wird verhindert, dass Konfigurationen gelöscht werden, wenn Workerknoten erneut geladen oder neue Worker hinzugefügt werden.

server = "https://docker.io"
[host."https://registry-1.docker.io"]
capabilities = ["pull", "resolve"]

apiVersion: apps/v1
kind: DaemonSet
metadata:
labels:
    name: containerd-dockerhub-registry-config
name: containerd-dockerhub-registry-config
namespace: kube-system
spec:
selector:
    matchLabels:
    name: containerd-dockerhub-registry-config
template:
    metadata:
    labels:
        name: containerd-dockerhub-registry-config
    spec:
    initContainers:
    - image: alpine:3.13.6
        name: containerd-dockerhub-registry-config
        command:
        - /bin/sh
        - -c
        - |
            #!/bin/sh
            set -uo pipefail
            cat << EOF > /etc/containerd/certs.d/docker.io/hosts.toml
            server = "https://docker.io"
            [host."https://registry-1.docker.io"]
            capabilities = ["pull", "resolve"]
            EOF
        volumeMounts:
        - mountPath: /etc/containerd/certs.d/docker.io/
        name: dockerhub-registry-config
    containers:
    - name: pause
        image: "us.icr.io/armada-master/pause:3.5"
        imagePullPolicy: IfNotPresent
    volumes:
    - name: dockerhub-registry-config
        hostPath:
        path: /etc/containerd/certs.d/docker.io/