Images erstellen

Sie können Ihre Images auf verschiedene Arten erstellen, einschließlich der folgenden IBM Cloud-Services.

IBM Cloud Code Engine

Code Engine unterstützt die Erstellung von Images aus einer Dockerfile und cloudnativen Buildpacks und die automatische Übertragung der Images mit Push-Operation an IBM Cloud® Container Registry. Weitere Informationen finden Sie unter Build planen.

Tekton-Pipelines

Der Continuous Delivery-Service enthält verschiedene Tekton-Tasks, die Sie in Ihren Pipelines referenzieren können, um Images zu erstellen. Weitere Informationen finden Sie unter Tekton-Pipelines.

Container aus einem vorhanden Image-Stream in der internen Registry bereitstellen

Sie können eine App aus einem vorhandenen Image-Stream bereitstellen, den Ihr Cluster-Administrator in der internen Registry Ihres Red Hat OpenShift-Clusters eingerichtet hat. Beispiel: Ihr Clusteradministrator hat den Image-Stream für den Import eines Images aus einer externen privaten Registry eingerichtet, z. B. IBM Cloud Container Registry.

Container aus einem IBM Cloud Container Registry-Image für das default Red Hat OpenShift-Projekt bereitstellen

Sie können Container aus einem von IBM bereitgestellten öffentlichen Image oder aus einem privaten Image, das in Ihrem Namensbereich IBM Cloud Container Registry-Namensbereich gespeichert ist, in Ihrem Cluster bereitstellen. Weitere Informationen dazu, wie Ihr Cluster auf Registry-Images zugreift, finden Sie unter Berechtigung des Clusters zum Extrahieren von Images aus IBM Cloud Container Registry.

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.

4. Erstellen Sie eine Bereitstellungskonfigurationsdatei namens <deployment>.yaml.

5. Definieren Sie die Bereitstellung und das zu verwendende Image aus Ihrem Projekt in IBM Cloud Container Registry.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: <deployment>
   spec:
     replicas: <number_of_replicas>
     selector:
       matchLabels:
         app: <app_name>
     template:
       metadata:
         labels:
           app: <app_name>
       spec:
         containers:
         - name: <app_name>
           image: <region>.icr.io/<project>/<image>:<tag>
   

   <deployment>

   Geben Sie Ihrer Bereitstellung einen Namen.

   <number_of_replicas>

   Geben Sie die Anzahl der Replikatpods an, die die Bereitstellung erstellt.

   app: <app_name>

   Verwenden Sie den Namen Ihrer App als Bezeichnung für den Container.

   name: <app_name>

   Geben Sie Ihrem Container einen Namen, z. B. den Namen Ihrer app-Bezeichnung.

   image: <region>.icr.io/project>/image>:tag>

   Ersetzen Sie die Image-URL-Variablen durch die Informationen für Ihr Image:

   region>: Der regionale IBM Cloud Container Registry-API-Endpunkt für die Registry-Domäne. Zum Auflisten der Domäne für die Region, in der Sie angemeldet sind, führen Sie ibmcloud cr api aus.

   namespace>: Der Registry-Namensbereich. Zum Abrufen der Informationen zu Ihrem Namensbereich führen Sie den Befehl ibmcloud cr namespace-list aus.

   image>:tag>: Das Image und des Tag, das Sie für Ihren Container verwenden wollen. Zum Auflisten der in Ihrem Registry-Namensbereich verfügbaren Images führen Sie ibmcloud cr images aus.

6. Erstellen Sie die Bereitstellung in Ihrem Cluster.

   oc apply -f <deployment>.yaml
   

Container aus einem verschlüsselten Image bereitstellen

Stellen Sie Container aus einem verschlüsselten Image unter Verwendung des Cluster-Add-ons 'Image Key Synchronizer' bereit.

In Clustern, auf denen Red Hat OpenShift 4.5 oder höher ausgeführt wird, unterstützt die Container-Laufzeitumgebung CRI-O die Verwendung verschlüsselter Container-Images. Verschlüsselte Container-Images sind OCI-Images (OCI = Open Container Initiative) mit verschlüsselten Inhaltsebenen. Anstatt ein Image für einzelne Entwickler zu schützen (z. B. indem ein Entwickler Images mithilfe geheimer Schlüssel aus einer Registry extrahiert) können Sie die Imageverschlüsselung für einen bestimmten Cluster aktivieren. Auf diese Weise können Sie sicherstellen, dass verschlüsselte Images nur in bestimmten Clustern ausgeführt werden, die über den Schlüssel zum Entschlüsseln des Images verfügen.

Wenn zum Ausführen einer App ein verschlüsseltes Image verwendet werden soll, muss der Entschlüsselungsschlüssel für das Image in der Container-Laufzeitumgebung der Workerknoten in dem Cluster freigegeben werden. Wenn Sie das Add-on 'Image Key Synchronizer' in Ihrem Cluster aktivieren, wird die Dämongruppe des Synchronisationsprogramms im Projekt image-key-synchronizer bereitgestellt. Anschließend können Sie in diesem Projekt geheime Kubernetes-Schlüssel erstellen, die die Image-Entschlüsselungsschlüssel enthalten. Das Add-on fügt die Schlüssel in einem bestimmten Verzeichnis auf den Workerknoten hinzu, damit die Container-Laufzeitumgebung die Schlüssel abrufen und zum Entschlüsseln der Container-Images verwenden kann. Beachten Sie, dass das Add-on 'Image Key Synchronizer' auch private Schlüssel unterstützt, die zuerst in einen Rootschlüssel eingeschlossen werden, der in einer IBM® Key Protect-Instanz gespeichert wird.

Vorbereitende Schritte

1. Laden Sie die CLI-Clients für die folgenden Open-Source-Tools herunter und installieren Sie sie:

   • OpenSSL, um ein RSA-Schlüsselpaar zu generieren.
   • Docker Engine CLI, um Images lokal aus einem Image-Register abzurufen.
   • Skopeo, um OCI-Container-Images zu verschlüsseln.

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

3. Optional: Wenn Sie ein öffentliches und privates Schlüsselpaar für die Imageverschlüsselung erstellen, können Sie den privaten Schlüssel direkt in einem geheimen Schlüssel angeben oder den privaten Schlüssel zuerst mithilfe eines Key Protect-Rootschlüssels oder eines Schlüsselmanagementservice (KMS) einschließen. Gehen Sie wie folgt vor, um das Wrapping für den privaten Schlüssel vorzubereiten:

   1. Installieren Sie das Key Protect-CLI-Plug-in.
   2. Erstellen Sie eine Key Protect-Serviceinstanz.
   3. Erstellen Sie einen Key Protect-Rootschlüssel.
   4. Rufen Sie die folgenden Werte für Ihre Key Protect-Instanz ab:
      • Die Serviceinstanz-ID
      • Den API-Schlüssel für die Serviceinstanz-ID
      • Die Serviceendpunkt-URL
   5. Erstellen Sie einen geheimen Kubernetes-Schlüssel mit dem Namen keyprotect-config, der die abgerufenen Werte enthält. Das Add-on 'Image Key Synchronizer' verwendet die Umgebungsvariablen aus diesem geheimen Schlüssel, um sich bei Ihrer Key Protect-Instanz zu authentifizieren.

       apiVersion: v1
       kind: Secret
       metadata:
         name: keyprotect-config
         namespace: image-key-synchronizer
       type: Opaque
       stringData:
         config.json: |
             {
                 "keyprotect-url":"<service_endpoint>",
                 "instance-id": "<service_instance_ID>",
                 "apikey": "<service_instance_ID_API_key>"
             }
       ```
   

Gehen Sie wie folgt vor, um Container bereitzustellen, die verschlüsselte Images verwenden:

1. Aktualisieren Sie das Plug-in container-service auf die neueste Version.

   ibmcloud update && ibmcloud plugin update container-service
   

2. Aktivieren Sie das Add-on 'Image Key Synchronizer'.

   ibmcloud oc cluster addon enable image-key-synchronizer -c CLUSTER_NAME_OR_ID
   

3. Stellen Sie sicher, dass das addon-image-key-synchronizer Daemon-Set im Projekt image-key-synchronizer in Ihrem Cluster erfolgreich erstellt wurde.

   oc get ds addon-image-key-synchronizer -n image-key-synchronizer
   

4. Erstellen Sie unter Verwendung von openssl ein RSA-Schlüsselpaar mit privatem und öffentlichem Schlüssel.

   openssl genrsa -out myprivatekey.pem
   openssl rsa -in myprivatekey.pem -pubout -out mypubkey.pem
   

5. Geben Sie den privaten Schlüssel direkt in einem geheimen Schlüssel an oder schließen Sie zuerst den privaten Schlüssel ein, indem Sie einen Rootschlüssel aus einem Schlüsselmanagementservice (KMS) wie Key Protect verwenden. Nachdem der geheime Schlüssel im Projekt image-key-synchronizer erstellt wurde, kopiert das Add-on 'Image Key Synchronizer' den privaten Schlüssel automatisch in das Verzeichnis /etc/crio/keys/synced auf Ihren Workerknoten.

   • Gehen Sie wie folgt vor, um den privaten Schlüssel direkt bereitzustellen: Speichern Sie den privaten Schlüssel als geheimen Kubernetes-Schlüssel im Projekt image-key-synchronizer.

       oc create -n image-key-synchronizer secret generic --type=key --from-file=myprivatekey.pem <secret_name>
       ```
   - **Gehen Sie wie folgt vor, um den privaten Schlüssel in einen Key Protect-Rootschlüssel** einzuschließen:
       1. Verschlüsseln Sie den privaten Schlüssel mit der Base64-Codierung und kopieren Sie die resultierende Ausgabe.
   
           ```sh {: pre}
           cat myprivatekey.pem | base64
           ```
       2. Verwenden Sie das Key Protect-CLI-Plug-in, um den privaten Schlüssel mit Base64-Codierung in Ihren Rootschlüssel einzuschließen. Kopieren Sie in der resultierenden Ausgabe den verschlüsselten Text des privaten Schlüssels.
   
           ```sh {: pre}
           ibmcloud kp key wrap ROOT_KEY_ID -p BASE64_ENCODED_PRIVATE_KEY
           ```
       3. Speichern Sie den privaten Schlüssel mit Wrapping als geheimen Kubernetes-Schlüssel im Projekt `image-key-synchronizer`.
   
           ```yaml {: pre}
           apiVersion: v1
           kind: Secret
           type: kp-key
           metadata:
             name: <secret_name>
             namespace: image-key-synchronizer
           stringData:
             rootkeyid: "<root_key_ID>"
             ciphertext: "<wrapped_private_key_cipertext>"
           ```
       4. Geheimen Schlüssel erstellen
   
           ```sh {: pre}
           oc apply -n image-key-synchronizer -f <secret_name>.yaml
           ```
   

6. Verwenden Sie docker, um ein OCI-Image lokal zu extrahieren. Ersetzen Sie <source_image> durch das Repository des Image und <tag> durch das Tag des Image, das Sie verwenden möchten, z. B. latest.

   docker pull <source_image>:<tag>
   

7. Verwenden Sie skopeo, um das lokale Image zu verschlüsseln. Dieser Befehl kopiert das OCI-Image, das Sie zuvor extrahiert haben, verschlüsselt es unter Verwendung Ihres öffentlichen Schlüssels und speichert das verschlüsselte Image in einer anderen lokalen Datei. Benennen Sie das verschlüsselte Image <source_image>_encrypted, um die Identifikation zu vereinfachen.

   skopeo copy --encryption-key jwe:./mypubkey.pem <source_image>:<tag> <source_image>_encrypted:<tag>
   

8. Optional: Um lokal zu überprüfen, ob das Image verschlüsselt ist, können Sie versuchen, das Image mit einem falschen Schlüssel zu entschlüsseln.

   1. Generieren Sie einen neuen privaten Schlüssel.

       openssl genrsa --out wrongkey.pem 1024
       ```
   2. Versuchen Sie, das Image mit diesem neuen Schlüssel zu entschlüsseln. Der Entschlüsselungsbefehl schlägt fehl, weil ein falscher privater Schlüssel angegeben wurde.
   
   ```sh {: pre}
       skopeo copy --decryption-key ./wrongkey.pem <source_image>_encrypted:<tag> <source_image>_decrypted:<tag>
       ```
   

9. Optional: Übertragen Sie das verschlüsselte Image per Push-Operation in IBM Cloud Container Registry, das verschlüsselte OCI-Images unterstützt.

10. Geben Sie das verschlüsselte Image in Ihrer App-Bereitstellung an. Wenn Sie beispielsweise das verschlüsselte Image mit Push-Operation an IBM Cloud Container Registry übertragen haben, können Sie dem Beispiel in Container aus einem IBM Cloud Container Registry-Image für das default Red Hat OpenShift-Projekt bereitstellen folgen. Wenn Sie die Bereitstellung in Ihrem Cluster erstellen, verwendet die Container-Laufzeitumgebung den privaten Entschlüsselungsschlüssel im Verzeichnis /etc/crio/keys/synced, um das Image zu entschlüsseln, bevor es ausgeführt wird.

11. Für alle weiteren Images, die Sie verschlüsseln möchten, können Sie entweder denselben öffentlichen Schlüssel verwenden, um die Images mit Skopeo zu verschlüsseln, oder diese Schritte wiederholen, um ein anderes Schlüsselpaar aus privatem und öffentlichem Schlüssel zu verwenden.

Wenn Sie sich später entscheiden, das Add-on zu deaktivieren, wird das addon-image-key-synchronizer Daemon-Set entfernt, das Projekt image-key-synchronizer und alle Geheimnisse, die Sie in diesem Projekt erstellt haben, bleiben jedoch erhalten, und die Container-Laufzeitumgebung kann die Geheimnisse weiterhin zum Ausführen verschlüsselter Images verwenden. Wenn auch die Schlüssel aus Ihren Workerknoten entfernt werden sollen, löschen Sie die betreffenden geheimen Schlüssel im Projekt image-key-synchronizer, bevor Sie das Add-on inaktivieren.

Eine Liste der Änderungen für jede Version des Image Key Synchronizer-Add-ons finden Sie im Änderungsprotokoll des Image Key Synchronizer-Add-ons unter IBM Cloud.

Verweis auf den geheimen Schlüssel für Image-Pull-Operationen in Ihrer Pod-Bereitstellung

Wenn der Clusteradministrator nicht den geheimen Schlüssel für Image-Pull-Operation im Kubernetes-Servicekonto gespeichert hat, können alle Bereitstellungen, die kein Servicekonto angeben, den geheimen Schlüssel für Image-Pull-Operationen nicht zum Bereitstellen von Containern verwenden. In diesem Fall kann der geheime Schlüssel für Image-Pull-Operationen in der Podbereitstellung definiert werden. Wenn Sie auf den geheimen Schlüssel für Image-Pull-Operationen in einer Pod-Bereitstellung verweisen, ist der geheime Schlüssel für Image-Pull-Operationen nur für diesen Pod gültig und kann nicht von mehreren Pods im Red Hat OpenShift-Projekt gemeinsam genutzt werden.

Vorbereitende Schritte

• Erstellen Sie einen geheimen Schlüssel für Image-Pull-Operationen, um auf Images in anderen Registrys oder in anderen Red Hat OpenShift-Projekten als default zuzugreifen.
• Rufen Sie Ihren Red Hat OpenShift-Cluster auf.

Um auf den geheimen Schlüssel für Image-Pull-Operationen in Ihrer Pod-Bereitstellung zu verweisen,

1. Erstellen Sie eine Podkonfigurationsdatei mit dem Namen mypod.yaml.

2. Definieren Sie den Pod und den geheimen Schlüssel für Image-Pull-Operationen für den Zugriff auf Images in IBM Cloud Container Registry.

   Um auf ein privates Image zuzugreifen,

   apiVersion: v1
   kind: Pod
   metadata:
     name: mypod
   spec:
     containers:
       - name: <container_name>
         image: <region>.icr.io/<namespace_name>/<image_name>:<tag>
     imagePullSecrets:
       - name: <secret_name>
   

   Um auf ein öffentliches IBM Cloud-Image zuzugreifen,

   apiVersion: v1
   kind: Pod
   metadata:
     name: mypod
   spec:
     containers:
       - name: <container_name>
         image: icr.io/<image_name>:<tag>
     imagePullSecrets:
       - name: <secret_name>
   

   container_name>

   Der Name des Containers, den Sie in Ihrem Cluster bereitstellen möchten. namespace_name>: Der Registry-Namensbereich, in dem das Image gespeichert ist. Führen Sie den Befehl ibmcloud cr namespace-list aus, um die verfügbaren Namensbereiche aufzulisten. image_name>: Der Name des zu verwendenden Image. Führen Sie den Befehl ibmcloud cr image-list aus, um die verfügbaren Images in einem IBM Cloud-Konto aufzulisten. tag>: Die Version des Image, die Sie verwenden möchten. Wenn kein Tag angegeben ist, wird standardmäßig das Image mit dem Tag Aktuellstes verwendet. <secret_name>: Der Name des geheimen Schlüssels für Image-Pull-Operationen, den Sie zuvor erstellt haben.

3. Speichern Sie Ihre Änderungen.

4. Erstellen Sie die Bereitstellung in Ihrem Cluster.

   oc apply -f mypod.yaml
   

Images mit Push-Operation in IBM Cloud Container Registry übertragen

Nach dem Einrichten einer Image-Registry mit IBM Cloud Container Registry durch den Clusteradministrator können Sie Docker-Images sicher speichern und mit anderen Benutzern gemeinsam nutzen, indem Sie Images zu Ihrem Namensbereich hinzufügen.

Sie können beispielsweise ein Image mit einer Pull-Operation aus einer privaten oder öffentlichen Registryquelle extrahieren und es anschließend für die spätere Verwendung in IBM Cloud Container Registry mit einem entsprechenden Tag kennzeichnen. Sie können beispielsweise auch ein Docker-Image mit einer Push-Operation in Ihren Namensbereich übertragen, damit andere Benutzer auf das Image zugreifen können. Lesen Sie als Einstieg zu diesem Thema den Abschnitt Images zum Namensbereich hinzufügen.

Sicherheit von Images in IBM Cloud Container Registry mit Vulnerability Advisor verwalten

Vulnerability Advisor überprüft den Sicherheitsstatus von Container-Images, die von IBM oder anderen Anbietern bereitgestellt oder zum IBM Cloud Container Registry-Namensbereich Ihrer Organisation hinzugefügt werden.

Images, die zu einem Namensbereich hinzugefügt werden, werden automatisch von Vulnerability Advisor auf Sicherheitsprobleme und Sicherheitslücken überprüft. Werden Sicherheitsprobleme ermittelt, werden Anleitungen bereitgestellt, die das Beheben der gemeldeten Probleme erleichtern. Lesen Sie als Einstieg zu diesem Thema den Abschnitt Sicherheit von Images mit Vulnerability Advisor verwalten.

Vertrauenswürdige Inhalte für Container-Images konfigurieren

Sie können Container aus vertrauenswürdigen Images erstellen, die signiert und in IBM Cloud Container Registry gespeichert sind, und Bereitstellungen aus nicht signierten oder gefährdeten Images verhindern.

1. Images für vertrauenswürdige Inhalte signieren. Nachdem Sie eine Vertrauensbeziehung für Ihre Images konfiguriert haben, können Sie vertrauenswürdige Inhalte und Unterzeichner, die Images per Push-Operation in Ihre Registry übertragen können, verwalten.
2. Um eine Richtlinie umzusetzen, durch die nur signierte Images zum Erstellen von Containern in Ihrem Cluster verwendet werden können, installieren Sie das Open-Source-Projekt Portieris.
3. Clusterbenutzer können Apps, die aus vertrauenswürdigen Images erstellt werden, bereitstellen.
   1. Bereitstellung im Kubernetes-Namensbereich default durchführen.
   2. Bereitstellung in anderem Kubernetes-Namensbereich oder aus anderen IBM Cloud-Regionen oder -Konten durchführen.

Durchsetzung von Imagesicherheit in Ihrem Cluster aktivieren

Wenn Sie die Durchsetzung von Imagesicherheit in Ihrem Cluster aktivieren, installieren Sie das Open-Source-Kubernetes-Projekt Portieris. Anschließend können Sie Imagerichtlinien erstellen, um zu verhindern, dass Pods, die die Richtlinien nicht erfüllen, wie z. B. nicht signierte Images, in Ihrem Cluster ausgeführt werden.

Weitere Informationen finden Sie in der Dokumentation zu Portieris.

Mutatierte Images: Standardmäßig verwendet Portieris den Zugangscontroller MutatingAdmissionWebhook, um Ihr Image so zu mutieren, dass es mithilfe eines Auszugs anstelle eines Tags auf das Image verweist. Möglicherweise verfügen Sie jedoch über eine Bereitstellungstechnologie, die ein mutiertes Image ablehnt. In diesem Fall können Sie die Option Image-Mutation und die entsprechende Richtlinie verwenden, um das Standardverhalten zu ändern.