Scelta di una soluzione del registro di immagini

Le immagini dei container devono essere archiviate in un registro dei container a cui il cluster possa accedere per distribuire le applicazioni all'interno del cluster. È possibile scegliere se utilizzare il registro integrato del proprio cluster Red Hat OpenShift, un registro privato con accesso limitato a utenti selezionati oppure un registro pubblico. Rivedi la seguente tabella per scegliere l'opzione migliore per il tuo caso d'uso.

Red Hat OpenShift e interna Container Registry (OCR)

Il tuo cluster è configurato con l' Red Hat OpenShift o interno Container Registry, in modo che Red Hat OpenShift possa automaticamente creare, distribuire e gestire il ciclo di vita della tua applicazione dall'interno del cluster. Le immagini sono archiviate in un dispositivo di archiviazione file classico IBM Cloud di supporto di cui viene eseguito il provisioning al momento della creazione del cluster. Se hai bisogno di ulteriore archiviazione, puoi ridimensionare il dispositivo. Casi di utilizzo:

• Red Hat OpenShift- Processo nativo di gestione del flusso di immagini, creazione delle build e distribuzione delle app a livello di singolo cluster.
• Le immagini possono essere condivise tra tutti i progetti nel cluster, con l'accesso controllato tramite i ruoli RBAC.
• Integrazione del registro interno con altri prodotti Red Hat come CloudForms per funzioni estese come la scansione delle vulnerabilità.
• Opzione per esporre il registro interno con un instradamento in modo che gli utenti possano eseguire il pull di immagini dal registro sulla rete pubblica.
• Opzione per configurare il registro interno per eseguire il pull o il push di immagini in un registro privato come IBM Cloud Container Registry.

Per ulteriori informazioni, vedi Utilizzo del registro interno.

Registro privato

I registri privati sono una buona scelta per proteggere le immagini da utenti non autorizzati. I registri privati devono essere configurati dall'amministratore del cluster per garantire che l'accesso, l'archiviazione delle quote, l'attendibilità delle immagini e altre funzioni funzionino come previsto. Per default, i tuoi Cluster Red Hat OpenShift sono integrati con il IBM Cloud Container Registry privato tramite i segreti di pull dell'immagine nel progetto default. IBM Cloud Container Registry è un registro privato a più tenant altamente disponibile per archiviare le tue immagini. Puoi anche eseguire il pull di immagini fornite da IBM dal registro icr.io globale e del software con licenza dal registro di titolarità. Con IBM Cloud Container Registry, è possibile gestire le immagini per più cluster grazie all'integrazione con IBM Cloud, IAM e la fatturazione. Vantaggi dell'utilizzo di IBM Cloud Container Registry con il registro interno:

• Memorizzazione di immagini nella cache locale per build più veloci tramite il registro interno.
• Le distribuzioni in altri progetti possono accedere al flusso di immagini, così non è necessario copiare i secret pull in ogni singolo progetto.
• Condivisione delle immagini tra più cluster senza dover eseguire il push delle immagini a più registri.
• Scansione automatica delle vulnerabilità delle immagini.
• Controllo dell'accesso tramite le politiche IBM Cloud IAM e i registri regionali separati.
• Conservazione delle immagini senza la richiesta di spazio di archiviazione nel tuo cluster o in un dispositivo di archiviazione collegato. Puoi anche impostare delle politiche per gestire la quantità di immagini per evitare che utilizzino troppo spazio.
• Infrastruttura VPC: utilizzo dell'endpoint del servizio di registro privato in modo che i cluster che utilizzano esclusivamente un endpoint del servizio cloud privato possano comunque accedere al registro.
• Configurazione dell'archiviazione e delle quote di traffico di pull dell'immagine per controllare in modo migliore la fatturazione, l'utilizzo e l'archiviazione dell'immagine.
• Esecuzione del pull del contenuto IBM con licenza dal registro di titolarità.

Per iniziare, vedi i seguenti argomenti:

• Introduzione a IBM Cloud Container Registry.
• Importazione delle immagini da IBM Cloud Container Registry nel flusso di immagini del registro interno.
• Utilizzo di IBM Cloud Container Registry.

Registro pubblico

I registri pubblici come Docker Hub consentono di condividere immagini tra team, aziende, cluster o fornitori di servizi cloud. Alcuni registri pubblici potrebbero inoltre offrire un componente di registro privato. Casi di utilizzo:

• Esecuzione del push e del pull delle immagini sulla rete pubblica.
• Test rapidi di un container su diversi provider cloud.
• Non servono funzionalità di livello aziendale come la scansione delle vulnerabilità o la gestione degli accessi.

Per ulteriori informazioni, consultare la documentazione relativa ai registri pubblici, come Quay o l’ Docker Hub.

Archiviazione delle immagini nei registri interni

Red Hat OpenShift I cluster dispongono di un registro interno predefinito. Le immagini presenti nel registro interno vengono sottoposte a backup, ma variano a seconda del fornitore dell'infrastruttura del proprio cluster Red Hat OpenShift on IBM Cloud.

Cluster classici

Il tuo cluster Red Hat OpenShift è configurato per impostazione predefinita con un registro interno che utilizza File Storage for Classic come archiviazione di backup. Quando elimini il cluster, vengono eliminati anche il registro interno e le sue immagini. Se desideri conservare le tue immagini, valuta la possibilità di utilizzare un registro privato come IBM Cloud Container Registry, di eseguire il backup delle immagini su uno spazio di archiviazione persistente come Object Storage oppure di creare un cluster separato e autonomo di registri di container (OCR) su Red Hat OpenShift. Per ulteriori informazioni, consulta la Red Hat OpenShift documentazione.

Cluster VPC

Il registro interno del tuo cluster Red Hat OpenShift esegue il backup delle tue immagini in un bucket creato automaticamente in un'istanza IBM Cloud Object Storage del tuo account. Tutti i dati archiviati nel bucket di archiviazione oggetti rimangono anche se elimini il cluster. Una volta creato il cluster, non è possibile rimuovere o scollegare il bucket IBM Cloud Object Storage dal cluster. Se si intende creare un cluster senza un registro interno basato su COS, ad esempio per gli ambienti Financial Services Cloud di IBM, è necessario omettere l'istanza COS al momento della creazione del cluster. Per ulteriori informazioni, consulta la guida " Creazione di un cluster VPC senza un bucket di Object Storage ".

Cluster Classic, VPC o Satellite

Facoltativamente, puoi scegliere di configurare il registro interno per archiviare i dati nel emptyDir del nodo di lavoro in cui viene eseguito il pod del registro interno. Tieni presente che questi dati non sono persistenti e se il pod o il nodo di lavoro viene riavviato, i dati archiviati vengono eliminati e non sono recuperabili. Potresti archiviare le immagini localmente in emptyDir per aumentare le prestazioni se crei regolarmente contenitori da immagini di grandi dimensioni.

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

Rimozione del registro immagini interno

Cloud privato virtuale

Le implementazioni dell'operatore del registro immagini sono presenti solo nei cluster gestiti dal Red Hat OpenShift on IBM Cloud Toolkit. HyperShift I cluster gestiti eseguono l'operatore del registro delle immagini nel piano di controllo.

Se non vuoi utilizzare il registro delle immagini interno, puoi completare la seguente procedura per rimuoverlo.

1. Salvare una copia delle configurazioni del registro interno.

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

2. Eseguire il seguente comando di patch per modificare lo stato di gestione del registro immagini in Removed.

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

3. Dopo aver modificato lo stato di gestione, il servizio del registro delle immagini e la distribuzione vengono rimossi dallo spazio dei nomi openshift-image-registry nel cluster. Puoi eseguire i seguenti comandi per verificare che siano stati rimossi. Notare che vengono rimossi solo il servizio e la distribuzione del Registro immagini. Il servizio e la distribuzione dell'operatore del registro immagini rimangono.

   oc get deployment -n openshift-image-registry
   

   oc get svc -n openshift-image-registry
   

Configurazione di un instradamento esterno sicuro per il registro interno

Per impostazione predefinita, il cluster di Red Hat OpenShift dispone di un registro interno accessibile tramite un servizio con un indirizzo IP interno. Se vuoi rendere disponibile il registro interno sulla rete pubblica, puoi configurare un instradamento di ricrittografia sicuro. Ad esempio, potresti configurare il registro interno del tuo cluster in modo che funga da registro pubblico per le distribuzioni in altri progetti o cluster.

Prima di cominciare:

• Conferma di avere il Ruolo di accesso del servizio Responsabile IBM Cloud IAM per il cluster.
• Assicurati che il tuo cluster disponga di connettività di rete pubblica per esporre il registro interno con un instradamento pubblico.
• Installa Docker sulla tua macchina locale.
• Accedi al tuo cluster Red Hat OpenShift.

Per utilizzare il registro interno, configura un instradamento pubblico per accedere al registro. Quindi, crea un segreto di pull dell'immagine che include le credenziali per accedere al registro in modo che le distribuzioni in altri progetti possano eseguire il pull di immagini da questo registro.

1. Dal progetto openshift-image-registry, assicurati che il servizio image-registry esista per il registro interno.

   oc get svc -n openshift-image-registry
   

   Output di esempio

   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. Crea un instradamento protetto per il servizio image-registry che utilizzi la terminazione TLS reencrypt. Con la riesecuzione della crittografia, il router termina la connessione TLS con un certificato, quindi crittografa nuovamente la connessione al registro interno con un certificato diverso. Con questo approccio, viene crittografato il percorso completo della connessione tra l'utente e il registro interno. Per utilizzare un nome di dominio personalizzato, includi l'opzione --hostname.

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

3. Richiama il nome host (HOST/PORT) e la porta (PORT) che erano stati assegnati all'instradamento image-registry.

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

   Output di esempio

   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. Modifica la route per impostare la strategia di bilanciamento del carico su " source ", in modo che lo stesso indirizzo IP del client raggiunga sempre lo stesso server, come in una configurazione di route di tipo "passthrough". Puoi impostare la strategia aggiungendo un'annotazione nella sezione metadata.annotations: haproxy.router.openshift.io/balance: source. È possibile modificare il file di configurazione dalla console dell'applicazione Red Hat OpenShift oppure dalla riga di comando eseguendo il seguente comando.

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

   Aggiungere l'annotazione.

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

5. Se le politiche di rete aziendali impediscono l'accesso dal tuo sistema locale agli endpoint pubblici tramite proxy o firewall, consenti l'accesso al dominio secondario di instradamento che crei per il registro interno nei seguenti passi.

6. Accedi al registro interno utilizzando l'instradamento come nome host.

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

7. Ora che hai effettuato l'accesso, prova ad eseguire il push di un'applicazione hello-world di esempio nel registro interno.

   1. Esegui il pull dell'immagine hello-world da DockerHub o crea un'immagine sulla tua macchina locale.

       docker pull hello-world
       ```
   1. Contrassegna l'immagine locale con il nome host del tuo registro interno, il progetto in cui vuoi distribuire l'immagine, il nome e la tag dell'immagine.
   
   ```sh {: pre}
       docker tag hello-world:latest image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud/<project>/<image_name>:<tag>
       ```
   1. Esegui il push dell'immagine nel registro interno del tuo cluster.
   
   ```sh {: pre}
       docker push image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud/<project>/<image_name>:<tag>
       ```
   4. Verificare che l'immagine sia stata aggiunta allo stream di immagini di Red Hat OpenShift.
   
   ```sh {: pre}
       oc get imagestream
       ```
       Output di esempio
   
       ```sh {: screen}
       NAME          DOCKER REPO                                                            TAGS      UPDATED
       hello-world   image-registry-openshift-image-registry.svc:5000/default/hello-world   latest    7 hours ago
       ```
   

8. Per consentire alle distribuzioni nel tuo progetto di eseguire il pull delle immagini dal registro interno, crea un segreto di pull dell'immagine nel progetto che contenga le credenziali per accedere al tuo registro interno. Quindi, aggiungi il segreto di pull dell'immagine all'account di servizio predefinito per ogni progetto.

   1. Elenca i segreti di pull dell'immagine utilizzati dall'account di servizio predefinito e prendi nota del segreto che inizia con default-dockercfg.

       oc describe sa default
       ```
       Output di esempio
   
       ```sh {: screen}
       ...
       Image pull secrets:
       all-icr-io
       default-dockercfg-mpcn4
       ...
       ```
   1. Ottieni le informazioni del segreto codificate dal campo `data` del file di configurazione.
   
   ```sh {: pre}
       oc get secret <default-dockercfg-name> -o yaml
       ```
       Output di esempio
   
       ```yaml {: screen}
       apiVersion: v1
       data:
         .dockercfg: ey...=
       ```
   1. Decodifica il valore del campo `data`.
   
   ```sh {: pre}
       echo "<ey...=>" | base64 -D
       ```
       Output di esempio
   
       ```sh {: screen}
       {"172.21.xxx.xxx:5000":{"username":"serviceaccount","password":"eyJ...
       ```
   4. Crea un nuovo segreto di pull dell'immagine per il registro interno.
   
       - `secret_name`: Assegna un nome al tuo segreto di estrazione delle immagini, ad esempio `internal-registry`.
       - `--namespace`: Accedi al progetto in cui desideri creare il segreto per il pull dell'immagine, ad esempio `default`.
       - `--docker-server`: Anziché l'indirizzo IP interno del servizio (`172.21.xxx.xxx:5000`), inserisci il nome host della route `image-registry` con la porta (`image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud:5000`).
       - `--docker-username`: Copia l' `"username"` e dal pull secret dell'immagine precedente, ad esempio `serviceaccount`.
       - `--docker-password`: Copia l' `"password"` e dal pull secret dell'immagine precedente.
       - `--docker-email`: Se ne possiedi uno, inserisci il tuo indirizzo e-mail Docker. In caso contrario, inserisci un indirizzo e-mail fittizio, ad esempio `a@b.c`. Questa e-mail è necessaria per creare un segreto Kubernetes, ma non viene utilizzata dopo la creazione.
   
   ```sh {: pre}
       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. Aggiungi il segreto di pull dell'immagine all'account di servizio predefinito del tuo progetto.
   
   ```sh {: pre}
       oc patch -n <namespace_name> serviceaccount/default --type='json' -p='[{"op":"add","path":"/imagePullSecrets/-","value":{"name":"<image_pull_secret_name>"}}]'
       ```
   6. Ripeti questi passi per ogni progetto per cui vuoi eseguire il pull di immagini dal registro interno.
   
   

Ora che hai configurato il registro interno con una rotta accessibile, puoi accedere, eseguire il push e il pull delle immagini per il registro. Per ulteriori informazioni, vedi la documentazione diRed Hat OpenShift.

Importazioni delle immagini da IBM Cloud Container Registry nel flusso di immagini del registro interno

Per impostazione predefinita, il Red Hat OpenShift on IBM Cloud cluster è configurato per estrarre le immagini dai domini IBM Cloud Container Registryicr.io privati remoti nel default progetto. È possibile importare un'immagine da IBM Cloud Container Registry nel registro interno del proprio cluster Red Hat OpenShift, contrassegnando l'immagine come flusso di immagini. Con questa configurazione, puoi distribuire le applicazioni dall'immagine utilizzando la cache locale del registro interno, che consente di sviluppare più rapidamente le tue distribuzioni di applicazioni. Inoltre, le distribuzioni in altri progetti possono fare riferimento allo stream di immagini, in modo da non dover creare credenziali segrete per il pull delle immagini da IBM Cloud Container Registry in ogni singolo progetto.

Se aggiorni l'immagine su IBM Cloud Container Registry, questa non viene importata automaticamente nel registro interno del tuo cluster Red Hat OpenShift. In alternativa, configura l'importazione periodica oppure ripeti questi passaggi per taggare l'immagine. A seconda della politica di pull dell'immagine che utilizzi nella tua distribuzione, potresti anche dover riavviare la distribuzione.

Vuoi saperne di più su come le build, i flussi di immagini e il registro interno funzionano insieme? Leggi la Red Hat OpenShift documentazione o dai un'occhiata a questo blog sulla gestione delle immagini dei container.

1. Accedi al tuo cluster Red Hat OpenShift.

2. Passa al progetto default per eseguire il pull della tua immagine nel flusso di immagini. Il progetto default è già configurato con le credenziali per accedere ai registri icr.io.

   oc project default
   

3. Elenca le immagini disponibili nel tuo IBM Cloud Container Registry. Prendi nota del repository e del tag dell'immagine che desideri importare nel registro interno del tuo cluster Red Hat OpenShift.

   ibmcloud cr images
   

4. Per eseguirne il pull dell'immagine dal tuo spazio dei nomi IBM Cloud Container Registry nel registro interno, contrassegna l'immagine come flusso di immagini. Per ulteriori informazioni, consultare la documentazione di Red Hat OpenShift o eseguire oc tag --help.

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

   • <region>.icr.io/<namespace>/<image>:<tag>: Utilizza le informazioni relative al repository e al tag che hai recuperato in precedenza per compilare i campi “ IBM Cloud Container Registry ” (regione), “namespace”, “image” e “tag name” dell’immagine che desideri scaricare.
   • default/<image>:<tag>: Inserisci le informazioni relative allo stream di immagini interno creato a partire dall'immagine con tag " IBM Cloud Container Registry ". Questo flusso di immagini va creato nel progetto " default ", che è anche il progetto in cui viene creato il flusso di immagini se non si specifica alcun progetto. I valori di <image>:<tag> corrispondono in genere a quelli recuperati in precedenza.
   • --reference-policy=local: Impostare questo valore su local in modo che una copia dell'immagine presente all'indirizzo IBM Cloud Container Registry venga importata nella cache locale del registro interno e resa disponibile ai progetti del cluster come flusso di immagini. Se non si include questo valore, lo stream di immagini rimanda a IBM Cloud Container Registry quando lo si utilizza nelle proprie distribuzioni e, di conseguenza, richiede le credenziali del progetto.
   • --scheduled: Attivare questa opzione facoltativa per configurare l'importazione periodica dell'immagine da IBM Cloud Container Registry nel registro interno. La frequenza predefinita è di 15 minuti. Per ulteriori informazioni, vedi la documentazione diRed Hat OpenShift.

5. Verifica che il tuo flusso di immagini sia stato creato.

   oc get imagestreams
   

6. Verifica che il flusso di immagini abbia eseguito correttamente il pull dell'immagine da IBM Cloud Container Registry. Nell'output, verifica che l'immagine con il tag più recente corrisponda alla tua immagine " * <region>.icr.io/<namespace>/<image>@<digest> ".

   oc describe is/<imagestream>
   

   Output di esempio

   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
   

Ora, i tuoi sviluppatori possono utilizzare il flusso di immagini in una distribuzione dell'applicazione. L'immagine viene creata correttamente dall'immagine estratta localmente nel registro interno. Non è necessario configurare un segreto per il recupero delle immagini nel progetto su IBM Cloud Container Registry, poiché lo stream delle immagini è locale al cluster.

Configurazione delle build nel registro interno per eseguire il push delle immagini a IBM Cloud Container Registry

Quando crei una build nel tuo Red Hat OpenShift on IBM Cloud cluster, puoi configurare il registro interno per trasferire l'immagine al tuo repository esterno in IBM Cloud Container Registry. Per impostazione predefinita, il segreto di pull dell'immagine nel progetto default del tuo cluster dispone solo dell'accesso in lettura per eseguire il pull delle immagini da IBM Cloud Container Registry. Per eseguire il push delle immagini, devi aggiungere un segreto con l'accesso in scrittura.

1. Accedi al tuo cluster Red Hat OpenShift.

2. Passa al progetto default.

   oc project default
   

3. Segui la procedura per configurare una chiave API IBM Cloud IAM con il ruoli di accesso al servizio Reader e Writer per eseguire il pull e il push delle immagini sui tuoi registri icr.io.

   Tieni presente che qualsiasi utente con accesso al progetto può utilizzare questo segreto per eseguire il push delle immagini al tuo registro privato. Potresti voler configurare gli strumenti di registrazione e monitoraggio in modo da poter osservare chi effettua determinate azioni nel tuo cluster.

4. Ripeti il passo precedente per ogni regione icr.io in cui vuoi eseguire il push delle immagini.

5. Aggiungi il segreto all'account del servizio di build e fai riferimento ai segreti nel file di configurazione della build. Per ulteriori informazioni, vedi la documentazione diRed Hat OpenShift.

   1. Aggiungi il segreto all'account del servizio di build collegando il segreto che hai appena creato al ruolo builder utilizzato da tutte le build nel cluster.

       oc secrets link builder <secret_name>
       ```
   1. Elenca le configurazioni di build e prendi nota di quelle a cui desideri fornire l'accesso di push e pull a IBM Cloud Container Registry.
   
   ```sh {: pre}
       oc get bc
       ```
   1. Imposta il segreto di push dell'immagine in modo che la configurazione di build utilizzi il segreto che hai appena creato con l'accesso al servizio `Writer` a IBM Cloud Container Registry.
   
   ```sh {: pre}
       oc set build-secret --push bc/<build_config_name> <secret_name>
       ```
   4. Imposta il segreto di pull dell'immagine in modo che la configurazione di build esegua il pull dal registro da cui desideri estrarre l'immagine di build iniziale. Ad esempio, puoi utilizzare il segreto che hai appena creato con l'accesso al servizio `Reader` a IBM Cloud Container Registry se l'immagine di origine si trova in un repository IBM Cloud Container Registry.
   
   ```sh {: pre}
       oc set build-secret --pull bc/<build_config_name> <secret_name>
       ```
   

6. Dopo aver aggiornato l'account del servizio di build e il file di configurazione della build per il push a IBM Cloud Container Registry, riavvia la tua build.

   oc start-build <build_name>
   

7. Recupera il nome del tuo pod di compilazione, ad esempio <build>-2-build.

   oc get pods
   

8. Controlla i log della build e nota dove è stato eseguito il push dell'immagine.

   oc logs <build_pod>
   

   Esempio di un log di invio immagini andato a buon fine.

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

9. Controlla le tue immagini nel registro privato per confermare che l'immagine è stata creata.

   ibmcloud cr image list
   

   Output di esempio

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

La tua build di Red Hat OpenShift ora può scaricare e caricare immagini da IBM Cloud Container Registry.

Utilizzo di IBM Cloud Container Registry

Per impostazione predefinita, il Red Hat OpenShift on IBM Cloud cluster è configurato per estrarre le immagini dai domini IBM Cloud Container Registryicr.io privati remoti nel default progetto. Se vuoi utilizzare le immagini archiviate in IBM Cloud Container Registry per altri progetti, puoi eseguire il pull dell'immagine al registro interno in un flusso di immagini o puoi creare i segreti di pull dell'immagine per ogni registro globale e regionale in ciascun progetto.

Per importare le immagini nel registro interno: vedi Importazioni delle immagini da IBM Cloud Container Registry nel flusso di immagini del registro interno.

Per eseguire il pull di immagini direttamente da IBM Cloud Container Registry esterno: vedi i seguenti argomenti.

• Descrizione di come autorizzare il tuo cluster ad eseguire il pull delle immagini da un registro.
• Copia del segreto all-icr-io dal progetto default al progetto da cui vuoi eseguire il pull delle immagini.
• Creazione del tuo segreto di pull dell'immagine.
• Aggiunta del segreto di pull dell'immagine alla tua configurazione di distribuzione o all'account di servizio del progetto.

Descrizione di come autorizzare il tuo cluster ad eseguire il pull delle immagini da un registro provato

Per eseguire il pull di immagini da un registro, il tuo cluster Red Hat OpenShift on IBM Cloud utilizza un tipo speciale di segreto Kubernetes, un imagePullSecret. Questo segreto di pull dell'immagine archivia le credenziali per accedere a un registro del contenitore.

Il registro del contenitore può essere:

• Uno spazio dei nomi privato nel tuo IBM Cloud Container Registry.
• Uno spazio dei nomi privato in IBM Cloud Container Registry che appartiene a un altro account IBM Cloud.
• Qualsiasi altro registro privato, ad esempio Docker.

Tuttavia, per impostazione predefinita, il cluster è configurato per recuperare le immagini esclusivamente dai namespace del proprio account su IBM Cloud Container Registry e per distribuire i container basati su tali immagini nel progetto default Red Hat OpenShift all'interno del proprio cluster. Se hai bisogno di eseguire il pull di immagini in altri progetti del cluster o da altri registri del contenitore, devi configurare i tuoi propri segreti di pull dell'immagine.

Aggiornamento dei cluster esistenti per utilizzare il segreto di pull dell'immagine della chiave API

I nuovi cluster Red Hat OpenShift on IBM Cloud memorizzano una chiave API nei segreti di pull dell'immagine per autorizzare l'accesso a IBM Cloud Container Registry. Con questi segreti di pull dell'immagine, puoi distribuire i contenitori dalle immagini che sono memorizzate nei domini del registro icr.io. Puoi aggiungere i segreti di pull dell'immagine al tuo cluster se questo non è stato creato con i segreti.

Prima di iniziare

1. Accedi al tuo cluster Red Hat OpenShift.

2. Assicurati di disporre delle seguenti autorizzazioni: ruolo di accesso della piattaforma IBM Cloud IAM Operatore o amministratore per Red Hat OpenShift on IBM Cloud. Il titolare dell'account può assegnarti il ruolo eseguendo il seguente comando.

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

3. IBM Cloud Ruolo di accesso alla piattaforma IAM Administrator per IBM Cloud Container Registry, in tutte le regioni e in tutti i gruppi di risorse. La politica non può essere limitata a una regione o a un gruppo di risorse specifici. Il titolare dell'account può assegnarti il ruolo eseguendo il seguente comando.

   Verifica che il segreto sia stato creato correttamente

   ibmcloud iam user-policy-create YOUR_USER_EMAIL --service-name container-registry --roles Administrator
   

4. Se il tuo account limita la creazione dell'ID servizio, aggiungi il ruolo Service ID creator a Identity and Access Management nella console (iam-identity nell'API o nella CLI).

5. Se il tuo account limita la creazione della chiave API, aggiungi il ruolo di creatore della chiave API utente a Identity and Access Management nella console (iam-identity nell'API o nella CLI).

Utilizzo di un "image pull secret" per accedere alle immagini presenti in registri privati esterni

Configura il tuo secret per il recupero delle immagini nel tuo cluster per distribuire container in progetti Red Hat OpenShift diversi da default, utilizzare immagini archiviate in altri account IBM Cloud oppure utilizzare immagini archiviate in registri privati esterni. Inoltre, potresti creare il tuo segreto di pull dell'immagine per applicare politiche di accesso IAM che limitano le autorizzazioni a specifici spazi dei nomi delle immagini di registro o azioni (ad esempio, push o pull).

Dopo che hai creato il segreto di pull dell'immagine, i tuoi contenitori devono utilizzare il segreto per essere autorizzati a eseguire il pull di un'immagine dal registro. Puoi aggiungere il segreto di pull delle immagini all'account del servizio per il progetto oppure fare riferimento al segreto in ciascuna distribuzione. Per le istruzioni, vedi Utilizzo del segreto di pull dell'immagine per la distribuzione dei contenitori.

Le chiavi segrete per il download delle immagini sono valide solo per i progetti Red Hat OpenShift per i quali sono state create. Ripeti questa procedura per ogni spazio dei nomi in cui vuoi distribuire i contenitori.

Prima di cominciare:

1. Configura uno spazio dei nomi in IBM Cloud Container Registry e inserisci le immagini in questo spazio dei nomi.
2. Crea un cluster.
3. Accedi al tuo cluster Red Hat OpenShift.

Per utilizzare il tuo proprio segreto di pull dell'immagine, scegli tra le seguenti opzioni:

• Copia il segreto di recupero delle immagini dal progetto predefinito " Red Hat OpenShift " agli altri progetti del tuo cluster.
• Crea nuove credenziali della chiave API IAM e archiviale in un segreto di pull dell'immagine per accedere alle immagini in altri account IBM Cloud o applicare le politiche IAM che limitano l'accesso a determinati domini di registro o spazi dei nomi.
• Crea un segreto di pull dell'immagine per accedere alle immagini in registri privati esterni.

Se nel tuo progetto hai già creato un segreto di pull dell'immagine che desideri utilizzare nella tua distribuzione, vedi Distribuzione dei contenitori utilizzando il imagePullSecret creato.

Utilizzo del segreto di pull dell'immagine per la distribuzione dei contenitori

È possibile definire un segreto per il recupero delle immagini nella distribuzione del pod oppure memorizzarlo nell'account di servizio " Kubernetes ", in modo che sia disponibile per tutte le distribuzioni che non specificano un account di servizio " Kubernetes " nel progetto.

Per pianificare l'utilizzo dei segreti per il download delle immagini nel proprio cluster, scegliere una delle seguenti opzioni.

• In riferimento al segreto di pull delle immagini nella distribuzione del tuo pod: utilizza questa opzione se non desideri concedere l'accesso al tuo registro a tutti i pod del tuo progetto per impostazione predefinita. Gli sviluppatori possono includere il segreto di pull dell'immagine in ciascuna distribuzione del pod che deve accedere al tuo registro.
• Memorizzazione della chiave segreta per il recupero delle immagini nell'account di servizio Kubernetes: utilizzare questa opzione per concedere l'accesso alle immagini presenti nel proprio registro a tutte le distribuzioni nei progetti Red Hat OpenShift selezionati. Per memorizzare un segreto di pull dell'immagine nell'account di servizio Kubernetes, utilizza la seguente procedura.

Configurazione di un cluster per eseguire il pull del software autorizzato

Puoi configurare il tuo cluster Red Hat OpenShift on IBM Cloud per eseguire il pull del software autorizzato, che è una raccolta di immagini contenitore protette fornite nei grafici Helm che IBM ti ha autorizzato a utilizzare. Il software autorizzato è archiviato in un dominio cp.icr.io IBM Cloud Container Registry speciale. Per accedere a questo dominio, devi creare un segreto di pull dell'immagine con una chiave di titolarità per il tuo cluster e aggiungere questo segreto di pull dell'immagine all'account di servizio Kubernetes di ogni progetto in cui vuoi distribuire questo software autorizzato.

Prima di iniziare: accedi al tuo cluster Red Hat OpenShift.

1. Ottieni la chiave di titolarità per la libreria del software autorizzato.

   1. Accedi al sito MyIBM.com e scorri fino alla sezione " Libreria software Container ". Fai clic su View library.
   2. Nella pagina “Accesso al software del container > Chiavi di autorizzazione ”, fare clic su “Copia chiave ”. Questa chiave autorizza l'accesso a tutto il software autorizzato nella tua libreria software del contenitore.

2. Nel progetto in cui vuoi distribuire i tuoi contenitori autorizzati, crea un segreto di pull dell'immagine in modo che tu possa accedere al registro autorizzato cp.icr.io. Utilizza la chiave di titolarità che hai richiamato in precedenza come valore --docker-password. Per ulteriori informazioni, vedi Accesso alle immagini memorizzate in altri registri privati.

   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. Aggiungi il segreto di pull dell'immagine all'account di servizio dello spazio dei nomi in modo che qualsiasi contenitore nel progetto possa utilizzare la chiave di titolarità per eseguire il pull delle immagini autorizzate. Per ulteriori informazioni, vedi Utilizzo del segreto di pull dell'immagine per la distribuzione dei contenitori.

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

4. Crea un pod nel progetto che crea un contenitore da un'immagine nel registro autorizzato.

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

5. Controlla che il tuo contenitore sia stato in grado di eseguire correttamente la creazione dall'immagine autorizzata verificando che il pod si trovi in uno stato Running.

   oc get pod <pod_name> -n <project>
   

Ti chiedi cosa fare successivamente? Puoi configurare il repository di grafici Helm entitled, dove sono archiviati i grafici Helm che incorporano software autorizzato. Se Helm è già installato nel tuo cluster, esegui helm repo add entitled https://raw.githubusercontent.com/IBM/charts/master/repo/entitled.

Aggiunta di un registro privato al segreto di pull globale

Nodi di lavoro RHEL

Nei cluster che utilizzano esclusivamente nodi di lavoro RHEL, è possibile configurare un segreto globale per il download delle immagini che ogni nodo di lavoro del cluster può utilizzare per scaricare immagini da un registro privato.

Per impostazione predefinita, il cluster di Red Hat OpenShift on IBM Cloud dispone di un segreto globale per il download delle immagini dai seguenti registri, in modo da consentire la distribuzione dei componenti predefiniti di Red Hat OpenShift.

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

Non sostituire il segreto di pull globale con un segreto di pull che non dispone delle credenziali per i registri Red Hat predefiniti. In tal caso, i componenti predefiniti di Red Hat OpenShift installati nel cluster, come ad esempio OperatorHub,, potrebbero non funzionare correttamente poiché non sono in grado di recuperare le immagini da questi registri.

Prima di cominciare:

• Scarica il pacchetto da riga di comando del processore JSON " jq ". Utilizzi jq per combinare il valore JSON del segreto di pull globale predefinito con il segreto di pull del registro privato che vuoi aggiungere.
• Accedi al tuo cluster Red Hat OpenShift.

Per aggiungere i registri privati, modifica il pull-secret globale nel progetto openshift-config.

1. Crea un valore segreto che contiene le credenziali per accedere al tuo registro privato e archivia il valore segreto decodificato in un file JSON. Quando crei il valore segreto, le credenziali vengono codificate automaticamente in base64. Utilizzando l'opzione --dry-run, nel tuo cluster viene creato solo il valore segreto e non viene creato alcun oggetto segreto. Il valore segreto decodificato viene quindi archiviato in un file JSON per essere successivamente utilizzato nel tuo segreto di pull globale.

   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>

   Obbligatorio. Il progetto Red Hat OpenShift del cluster in cui si desidera utilizzare il segreto e distribuire i container. Per visualizzare l'elenco dei progetti disponibili nel proprio cluster, eseguire il comando oc get ns``.

   <secret_name>

   Obbligatorio. Il nome che vuoi utilizzare per il tuo segreto di pull dell'immagine.

   --docker-server <registry_URL>

   Obbligatorio. L'URL del registro in cui sono memorizzate le tue immagini private.

   --docker-username <docker_username>

   Obbligatorio. Il nome utente per accedere al tuo registro privato.

   --docker-password <token_value>

   Obbligatorio. La password per accedere al tuo registro privato, ad esempio un valore token.

   --docker-email <docker-email>

   Obbligatorio. Se ne hai uno, immetti il tuo indirizzo e-mail Docker. Se non ne hai uno, inserisci un indirizzo e-mail fittizio, ad esempio a@b.c. Questa e-mail è necessaria per creare un segreto Kubernetes, ma non viene utilizzata dopo la creazione.

   --dry-run=true

   Selezionare questa opzione per creare solo il valore del segreto, senza creare né memorizzare l'oggetto segreto nel cluster.

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

   Ottieni solo il valore .dockerconfigjson dalla sezione dei dati del segreto Kubernetes.

   | base64 --decode > myregistryconfigjson

   Scarica i dati del segreto decodificato in un file myregistryconfigjson locale.

2. Richiama il valore segreto decodificato del segreto di pull globale predefinito e archivia il valore in un file dockerconfigjson.

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

3. Combina il file myregistryconfigjson del segreto di pull del registro globale scaricato con il file dockerconfigjson del segreto di pull globale predefinito.

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

4. Aggiorna il segreto di pull globale con il file combinato dockerconfigjson-merged.

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

5. Verifica che il segreto di pull globale venga aggiornato. Controlla che il tuo registro privato e ciascuno dei registri Red Hat predefiniti siano nell'output del seguente comando.

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

   Output di esempio

   {
       "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. Per applicare le modifiche alla configurazione globale, ricarica tutti i nodi di lavoro del cluster.

   1. Prendi nota dell'ID dei nodi di lavoro nel cluster.

       ibmcloud oc worker ls -c <cluster_name_or_ID>
       ```
   1. **Per i cluster classici** Ricarica ogni nodo di lavoro. Puoi ricaricare più nodi di lavoro includendo più opzioni `-w`, ma assicurati di lasciare abbastanza nodi di lavoro in esecuzione contemporaneamente per le tue applicazioni per evitare un'interruzione.
   
   ```sh {: pre}
       ibmcloud oc worker reload -c <cluster_name_or_ID> -w <workerID_1> -w <workerID_2>
       ```
   1. **Per i cluster VPC** Sostituisci ogni nodo di lavoro. Prima di iniziare, assicurati che il tuo cluster abbia un numero sufficiente di altri nodi di lavoro in modo che i tuoi pod possano essere ripianificati e continuare l'esecuzione.
   
   ```sh {: pre}
       ibmcloud oc worker replace --cluster <cluster_name_or_ID> --worker <worker_node_ID>
       ```
   
   

7. Una volta che i nodi di lavoro sono tornati in uno stato corretto, verificare che il segreto globale di pull sia stato aggiornato su un nodo di lavoro.

   1. Avvia un pod di debug per accedere a un nodo di lavoro. Utilizza l'indirizzo IP privato che hai recuperato in precedenza per l' <node_name>.

       oc debug node/<node_name>
       ```
   1. Modifica la directory root sull'host in modo da poter visualizzare i file sul nodo di lavoro.
   
   ```sh {: pre}
       chroot /host
       ```
   1. Verifica che il file di configurazione Docker abbia le credenziali del registro che corrispondono al segreto di pull globale da te impostato.
   
   ```sh {: pre}
       vi /.docker/config.json
       ```
   

Aggiornamento del segreto globale di pull

Nodi di lavoro RHCOS Nodi di lavoro RHEL

Nei cluster che utilizzano worker RHCOS o una combinazione di worker RHCOS e RHEL, è possibile completare i seguenti passaggi per aggiornare il pull secret globale nel cluster Red Hat OpenShift on IBM Cloud.

Per impostazione predefinita, il cluster di Red Hat OpenShift on IBM Cloud dispone di un segreto globale per il download delle immagini dai seguenti registri, in modo da consentire la distribuzione dei componenti predefiniti di Red Hat OpenShift.

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

Non sostituire il segreto di pull globale con un segreto di pull che non dispone delle credenziali per i registri Red Hat predefiniti. In tal caso, i componenti predefiniti di Red Hat OpenShift installati nel cluster, come ad esempio OperatorHub,, potrebbero non funzionare correttamente poiché non sono in grado di recuperare le immagini da questi registri.

1. Creare un segreto che contenga le credenziali del registro che si desidera utilizzare.

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

2. Creare un DaemonSet per applicare il segreto a tutti i nodi worker.

   ocp_release_pull_secret_image=$(oc get ds -n openshift-dns node-resolver -o jsonpath='{.spec.template.spec.containers[0].image}')
   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: ${ocp_release_pull_secret_image}
             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: ${ocp_release_pull_secret_image}
             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. Verificare che i pod siano in esecuzione.

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

Aggiornamento di una configurazione del registro personalizzato containerd IBM Cloud Kubernetes Service

Con Kubernetes versione 1.22 o successive, puoi utilizzare i file di configurazione containerd sui nodi di lavoro per configurare il pull da un registro del contenitore. Puoi utilizzare una serie di daemon per aggiornare le configurazioni su tutti i nodi in un cluster, il che impedisce la cancellazione delle configurazioni quando i nodi di lavoro vengono ricaricati o quando vengono aggiunti nuovi nodi di lavoro.

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/