Configurazione di un registro di immagini

Scelta di una soluzione del registro di immagini

Le immagini dei container devono essere archiviate in un registro container accessibile dal cluster per poter distribuire le app nel cluster. È possibile scegliere di utilizzare il registro integrato del proprio Red Hat OpenShift cluster, un registro privato con accesso limitato a utenti selezionati o un registro pubblico. Rivedi la seguente tabella per scegliere l'opzione migliore per il tuo caso d'uso.

Interno Red Hat OpenShiftContainer Registry (OCR)

Il cluster è configurato con l'interno in Red Hat OpenShiftContainer Registry modo che Red Hat OpenShift possa automaticamente creare, distribuire e gestire il ciclo di vita dell'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- flusso di immagini native, processo di compilazione e distribuzione delle app su base 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 con l'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 vedere il flusso di immagini, quindi non è necessario copiare i segreti pull in ogni 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 solo 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 sono un modo per 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 rapido di un container su diversi fornitori di servizi cloud.
• Non sono necessarie funzionalità di livello aziendale come la scansione delle vulnerabilità o la gestione degli accessi.

Per ulteriori informazioni, consultare la documentazione del registro pubblico, come Quay o Docker Hub.

Memorizzazione delle immagini nei registri interni

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

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, eseguire il backup delle immagini su un archivio permanente come Object Storage, oppure creare un cluster separato e autonomo Red Hat OpenShift di registri container (OCR). Per ulteriori informazioni, consulta la Red Hat OpenShift documentazione.

Cluster VPC

Il registro interno del tuo Red Hat OpenShift cluster esegue il backup delle tue immagini in un bucket creato automaticamente in IBM Cloud Object Storage un'istanza nel tuo account. Tutti i dati archiviati nel bucket di archiviazione oggetti rimangono anche se elimini il cluster.

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 Red Hat OpenShift cluster dispone di un registro interno disponibile 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 fornire il proprio nome di dominio personalizzato, includere --hostname l'opzione.

   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 il percorso per impostare la strategia di bilanciamento del carico in source modo che lo stesso indirizzo IP client raggiunga lo stesso server, come in una configurazione di percorso 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 Red Hat OpenShift dell'applicazione o 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
      

   2. 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.

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

   3. Esegui il push dell'immagine nel registro interno del tuo cluster.

      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 al flusso Red Hat OpenShift di immagini.

      oc get imagestream
      

      Output di esempio

      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

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

   2. Ottieni le informazioni del segreto codificate dal campo data del file di configurazione.

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

      Output di esempio

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

   3. Decodifica il valore del campo data.

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

      Output di esempio

      {"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 dell'immagine, ad esempio internal-registry.
      • --namespace: Inserisci il progetto in cui creare il segreto di pull dell'immagine, ad esempio default.
      • --docker-server: Invece dell'indirizzo IP del servizio interno (172.21.xxx.xxx:5000), inserisci il nome host della image-registry rotta con la porta (image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud:5000).
      • --docker-username: Copia il "username" dal segreto pull dell'immagine precedente, ad esempio serviceaccount.
      • --docker-password: Copia il "password" dal segreto pull dell'immagine precedente.
      • --docker-email: Se ne hai uno, inserisci il tuo Docker indirizzo e-mail. Se non lo fai, 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.

      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.

      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 Red Hat OpenShift cluster 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 al flusso di immagini, in modo da non dover creare credenziali segrete per il pull IBM Cloud Container Registry delle immagini in ogni progetto.

Se aggiorni la tua immagine in IBM Cloud Container Registry, l'immagine non viene inserita automaticamente nel registro interno del tuo Red Hat OpenShift cluster. Configura invece l'importazione periodica o 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 inserire nel registro interno del tuo Red Hat OpenShift cluster.

   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 recuperate in precedenza per completare la IBM Cloud Container Registry regione, lo spazio dei nomi, l'immagine e il nome del tag dell'immagine che desideri scaricare.
   • default/<image>:<tag>: Inserisci le informazioni relative al flusso di immagini interno creato dall'immagine IBM Cloud Container Registry con tag. Questo flusso di immagini viene creato nel default progetto, che è anche il progetto in cui viene creato il flusso di immagini se non si specifica un progetto. I valori per <image>:<tag> corrispondono in genere ai valori recuperati in precedenza.
   • --reference-policy=local: Impostare questo valore su local in modo che una copia dell'immagine da 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 includi questo valore, il flusso di immagini fa riferimento a IBM Cloud Container Registry quando lo utilizzi nelle tue distribuzioni e richiede quindi credenziali nel progetto.
   • --scheduled: Impostare 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 'ultimo tag dell'immagine corrisponda alla tua * <region>.icr.io/<namespace>/<image>@<digest> immagine.

   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 impostare un segreto di pull dell'immagine nel progetto, IBM Cloud Container Registry poiché il flusso di 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>
      

   2. 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.

      oc get bc
      

   3. 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.

      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.

      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. Ottieni 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 riuscito.

   ...
   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 Red Hat OpenShift build ora può estrarre immagini da e inviare immagini a 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 estrarre immagini solo dagli spazi dei nomi del tuo account in IBM Cloud Container Registry e distribuire container da queste immagini al defaultRed Hat OpenShift progetto nel tuo 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 proprietario 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 tutti i gruppi di risorse. La politica non può essere limitata a una regione o a un gruppo di risorse specifici. Il proprietario 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 segreto di recupero immagini per accedere alle immagini nei registri privati esterni

Configura il tuo segreto di recupero immagini nel tuo cluster per distribuire container in Red Hat OpenShift progetti diversi da default, utilizzare immagini archiviate in altri IBM Cloud account o 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.

I segreti di pull delle immagini sono validi solo per i Red Hat OpenShift progetti per cui sono stati creati. 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 estrazione delle immagini dal progetto Red Hat OpenShift predefinito ad altri progetti nel 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 di pull dell'immagine nella distribuzione del pod o memorizzare il segreto di pull dell'immagine nell'account Kubernetes di servizio in modo che sia disponibile per tutte le distribuzioni che non specificano un account Kubernetes di servizio nel progetto.

Per pianificare l'utilizzo dei segreti di recupero delle immagini nel cluster, scegliere tra le seguenti opzioni.

• Riferimento al segreto di pull dell'immagine nella distribuzione del pod: utilizzare questa opzione se non si desidera concedere l'accesso al proprio registro a tutti i pod del 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.
• Archiviazione del segreto di pull dell'immagine nell'account Kubernetes di servizio: utilizzare questa opzione per concedere l'accesso alle immagini nel proprio registro per 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 a MyIBM.com e scorri fino alla sezione Libreria software Container. Fai clic su View library.
   2. Dalla pagina Access your container software > Entitlement keys, fai clic su Copy key. 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 solo nodi worker RHEL, è possibile impostare un segreto di pull dell'immagine globale che ogni nodo worker nel cluster può utilizzare per estrarre immagini da un registro privato.

Per impostazione predefinita, il Red Hat OpenShift on IBM Cloud cluster dispone di un segreto di pull dell'immagine globale per i seguenti registri, in modo che i Red Hat OpenShift componenti predefiniti possano essere distribuiti.

• 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 Red Hat OpenShift predefiniti installati nel cluster, come ad esempio il OperatorHub,, potrebbero non funzionare correttamente poiché non sono in grado di recuperare le immagini da questi registri.

Prima di cominciare:

• Scarica il pacchetto della riga di jq comando del processore JSON. 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 Red Hat OpenShift progetto del cluster in cui desideri utilizzare il segreto e distribuire i container. Per elencare i progetti disponibili nel tuo cluster, esegui 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

   Includi questa opzione per creare solo il valore segreto, senza creare e archiviare l'oggetto segreto nel tuo 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, ricaricare tutti i nodi di lavoro nel cluster.

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

      ibmcloud oc worker ls -c <cluster_name_or_ID>
      

   2. 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.

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

   3. 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.

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

7. Dopo che i nodi worker sono tornati in uno stato integro, verificare che il segreto pull globale sia stato aggiornato su un nodo worker.

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

      oc debug node/<node_name>
      

   2. Modifica la directory root sull'host in modo da poter visualizzare i file sul nodo di lavoro.

      chroot /host
      

   3. Verifica che il file di configurazione Docker abbia le credenziali del registro che corrispondono al segreto di pull globale da te impostato.

      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 Red Hat OpenShift on IBM Cloud cluster dispone di un segreto di pull dell'immagine globale per i seguenti registri, in modo che i Red Hat OpenShift componenti predefiniti possano essere distribuiti.

• 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 Red Hat OpenShift predefiniti installati nel cluster, come ad esempio il 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.

   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. 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/