Container Registry è deprecato e programmato per l'arresto. A partire dal 15 maggio 2024, Artifact Registry ospita le immagini per il dominio gcr.io nei progetti senza precedente utilizzo di Container Registry. Dopo il 18 marzo 2025, Container Registry verrà arrestato.

Per iniziare a gestire i container su Google Cloud, utilizza Artifact Registry. Se utilizzi Container Registry, scopri come eseguire la transizione ad Artifact Registry per gestire i container su Google Cloud.

Per ulteriori informazioni sul ritiro e sull'interruzione del servizio, consulta la pagina relativa ai ritiramenti e le note di rilascio.

Questa pagina è stata tradotta dall'API Cloud Translation.

Migrazione di container da un registry di terze parti

Se estrai alcune immagini dei container direttamente da registry di terze parti per eseguire il deployment in ambienti Google Cloud come Google Kubernetes Engine o Cloud Run, i limiti di frequenza per i tiri delle immagini o le interruzioni di terze parti possono interrompere le build e i deployment. Questa pagina descrive come identificare e copiare queste immagini in un registry in Google Cloud per una gestione consolidata e coerente delle immagini dei contenitori.

Inoltre, puoi sfruttare altre funzionalità, tra cui la protezione della catena di fornitura del software con l'analisi delle vulnerabilità e l'applicazione dei criteri di deployment con l'Autorizzazione binaria.

Scelta di un registry

Artifact Registry è il servizio consigliato per archiviare e gestire le immagini container e altri artefatti di compilazione in Google Cloud.

Se non utilizzi Container Registry, esegui la migrazione delle immagini ad Artifact Registry. Artifact Registry offre maggiore flessibilità e controllo, tra cui la memorizzazione delle immagini in una regione anziché in più regioni, un controllo dell'accesso più granulare e il supporto di altri formati di artefatti.
Se utilizzi Container Registry, puoi eseguire la transizione ad Artifact Registry.

Panoramica della migrazione

La migrazione delle immagini del container include i seguenti passaggi:

Configura i prerequisiti.
Identifica le immagini di cui eseguire la migrazione.
- Cerca nei file Dockerfile e nei manifest di deployment i riferimenti ai registry di terze parti
- Determina la frequenza di estrazione delle immagini dai registry di terze parti utilizzando Cloud Logging e BigQuery.
Copia le immagini identificate in Container Registry.
Verifica che le autorizzazioni per il registry siano configurate correttamente, in particolare se Container Registry e l'ambiente di deployment Google Cloud si trovano in progetti diversi.
Aggiorna i manifests per i tuoi deployment.
Esegui nuovamente il deployment dei carichi di lavoro.
(Facoltativo) Blocca i deployment di immagini da origini di terze parti.

Container Registry non monitora i registri di terze parti per gli aggiornamenti delle immagini che copi in Container Registry. Se vuoi incorporare una versione più recente di un'immagine nella pipeline, devi eseguirne il push in Container Registry.

Prima di iniziare

Verifica le tue autorizzazioni. Devi disporre del ruolo IAM Proprietario o Editor nei progetti in cui esegui la migrazione delle immagini in Container Registry.
Vai alla pagina del selettore dei progetti
1. Seleziona il progetto Google Cloud in cui vuoi utilizzare Container Registry
2. Nella console Google Cloud, vai a Cloud Shell
3. Individua il tuo ID progetto e impostalo in Cloud Shell. Sostituisci YOUR_PROJECT_ID con l'ID del tuo progetto.
```
gcloud config set project YOUR_PROJECT_ID
```

Esporta le seguenti variabili di ambiente:

  export PROJECT=$(gcloud config get-value project)

Abilita le API BigQuery, Container Registry e Cloud Monitoring con il seguente comando:

gcloud services enable \
containerregistry.googleapis.com \
stackdriver.googleapis.com \
logging.googleapis.com \
monitoring.googleapis.com

Verifica che sia installata la versione 1.13 o successiva di Go.
- Controlla la versione di un'installazione Go esistente con il comando:
```
go version
```
- Se devi installare o aggiornare Go, consulta la documentazione di installazione di Go.

Costi

Questa guida utilizza i seguenti componenti fatturabili di Google Cloud:

Identifica le immagini di cui eseguire la migrazione

Cerca riferimenti a registri di terze parti nei file che utilizzi per creare ed eseguire il deployment delle immagini container, quindi controlla la frequenza con cui esegui il pull delle immagini.

Identificare i riferimenti nei Dockerfile

Esegui questo passaggio in una posizione in cui sono archiviati i Dockerfile. Potrebbe essere dove il codice è stato estratto localmente o in Cloud Shell se i file sono disponibili in una VM.

Nella directory con i Dockerfile, esegui il comando:

grep -inr -H --include Dockerfile\* "FROM" . | grep -i -v -E 'docker.pkg.dev|gcr.io'

L'output è simile all'esempio seguente:

./code/build/baseimage/Dockerfile:1:FROM debian:stretch
./code/build/ubuntubase/Dockerfile:1:FROM ubuntu:latest
./code/build/pythonbase/Dockerfile:1:FROM python:3.5-buster

Questo comando cerca tutti i Dockerfile nella directory e identifica la riga "FROM". Modifica il comando in base alle tue esigenze in modo che corrisponda al modo in cui memorizzi i Dockerfile.

Identificare i riferimenti nei manifest

Esegui questo passaggio in una posizione in cui sono archiviati i manifest di GKE o Cloud Run. Potrebbe essere il luogo in cui il codice viene controllato localmente o in Cloud Shell se i file sono disponibili in una VM.

Nella directory con i manifest GKE o Cloud Run, esegui il comando:
```
grep -inr -H --include \*.yaml "image:" . | grep -i -v -E 'docker.pkg.dev|gcr.io'
```
Esempio di output:
```
./code/deploy/k8s/ubuntu16-04.yaml:63: image: busybox:1.31.1-uclibc
./code/deploy/k8s/master.yaml:26:      image: kubernetes/redis:v1
```
Questo comando esamina tutti i file YAML nella directory e identifica la riga image:. Modificala in base alle esigenze per adattarla alla modalità di archiviazione dei manifest.
Per elencare le immagini attualmente in esecuzione su un cluster, esegui il comando:
```
  kubectl get all --all-namespaces -o yaml | grep image: | grep -i -v -E 'docker.pkg.dev|gcr.io'
```
Questo comando restituisce tutti gli oggetti in esecuzione nel cluster Kubernetes attualmente selezionato e ne recupera i nomi delle immagini.

Esempio di output:
```
- image: nginx
  image: nginx:latest
    - image: nginx
    - image: nginx
```

Esegui questo comando per tutti i cluster GKE di tutti i progetti Google Cloud per una copertura totale.

Identificare la frequenza di pull da un registry di terze parti

Nei progetti che estraggono dati da registry di terze parti, utilizza le informazioni sulla frequenza di estrazione delle immagini per determinare se il tuo utilizzo è vicino o supera i limiti di frequenza applicati dal registry di terze parti.

Raccogliere i dati dei log

Crea un sink di log per esportare i dati in BigQuery. Un sink di log include una destinazione e una query che seleziona le voci di log da esportare. Puoi creare un sink eseguendo query su singoli progetti oppure utilizzare uno script per raccogliere i dati tra i progetti.

Per creare un sink per un singolo progetto:

Queste istruzioni riguardano l'interfaccia di anteprima di Log.

Vai a Esplora log
Scegli un progetto Google Cloud.

Nella scheda Query Builder, inserisci la seguente query:

  resource.type="k8s_pod"
  jsonPayload.reason="Pulling"

Modifica il filtro della cronologia da Ultima ora a Ultimi 7 giorni.
Fai clic su Esegui query.
Dopo aver verificato che i risultati vengano visualizzati correttamente, fai clic su Azioni > Crea sink.
Nell'elenco dei sink, seleziona Set di dati BigQuery e poi fai clic su Avanti.
Nel riquadro Modifica sink, svolgi i seguenti passaggi:
- Nel campo Nome destinazione, inserisci image_pull_logs.
- Nel campo Destinazione della destinazione, crea un nuovo set di dati o scegline uno di destinazione in un altro progetto.
Fai clic su Crea sink.

Per creare un sink per più progetti:

Apri Cloud Shell.

Esegui i seguenti comandi in Cloud Shell:

PROJECTS="PROJECT-LIST"
DESTINATION_PROJECT="DATASET-PROJECT"
DATASET="DATASET-NAME"

for source_project in $PROJECTS
do
  gcloud logging --project="${source_project}" sinks create image_pull_logs bigquery.googleapis.com/projects/${DESTINATION_PROJECT}/datasets/${DATASET} --log-filter='resource.type="k8s_pod" jsonPayload.reason="Pulling"'
done

dove

PROJECT-LIST è un elenco di ID progetto Google Cloud, separati da spazi. Ad esempio project1 project2 project3.
DATASET-PROJECT è il progetto in cui vuoi archiviare il set di dati.
DATASET-NAME è il nome del set di dati, ad esempio image_pull_logs.

Dopo aver creato un sink, i dati impiegano del tempo per confluire nelle tabelle BigQuery, a seconda della frequenza con cui vengono estratte le immagini.

Query per la frequenza di pull

Una volta ottenuto un campione rappresentativo dei recuperi di immagini effettuati dalle tue build, esegui una query per la frequenza di recupero.

Vai alla console BigQuery.

Esegui questa query:

SELECT
  REGEXP_EXTRACT(jsonPayload.message, r'"(.*?)"') AS imageName,
  COUNT(*) AS numberOfPulls
FROM
      `DATASET-PROJECT.DATASET-NAME.events_*`
GROUP BY
      imageName
ORDER BY
      numberOfPulls DESC

dove

DATASET-PROJECT è il progetto contenente il set di dati.
DATASET-NAME è il nome del set di dati.

L'esempio seguente mostra l'output della query. Nella colonna imageName, puoi esaminare la frequenza di estrazione delle immagini che non sono archiviate in Container Registry o Artifact Registry.

immagine

Copia le immagini in Container Registry

Dopo aver identificato le immagini dei registri di terze parti, puoi copiarle in Container Registry. Lo strumento gcrane ti aiuta con la procedura di copia.

Crea un file di testo images.txt in Cloud Shell con i nomi delle immagini che hai identificato. Ad esempio:
```
ubuntu:18.04
debian:buster
hello-world:latest
redis:buster
jupyter/tensorflow-notebook
```

Scarica gcrane.

  GO111MODULE=on go get github.com/google/go-containerregistry/cmd/gcrane

Crea uno script denominato copy_images.sh per copiare l'elenco di file.

Nota: questo script e le istruzioni in questa pagina presuppongono che tu stia copiando le immagini in gcr.io. Se vuoi utilizzare un altro host multiregionale, come eu.gcr.io, devi aggiornare di conseguenza le configurazioni e gli script di esempio.
```
#!/bin/bash

images=$(cat images.txt)

if [ -z "${GCR_PROJECT}" ]
then
    echo ERROR: GCR_PROJECT must be set before running this
    exit 1
fi

for img in ${images}
do
    gcrane cp ${img} gcr.io/${GCR_PROJECT}/${img}
done
```
Rendi eseguibile lo script:
```
  chmod +x copy_images.sh
```

Esegui lo script per copiare i file:

GCR_PROJECT=${PROJECT}
./copy_images.sh

Verificare le autorizzazioni

Per impostazione predefinita, i servizi CI/CD di Google Cloud hanno accesso a Container Registry nello stesso progetto Google Cloud.

Cloud Build può eseguire il push e il pull delle immagini
Gli ambienti di runtime come GKE, Cloud Run, l'ambiente flessibile App Engine e Compute Engine possono estrarre le immagini.

Se devi eseguire il push o il pull di immagini tra progetti o se utilizzi strumenti di terze parti nella pipeline che devono accedere a Container Registry, assicurati che le autorizzazioni siano configurate correttamente prima di aggiornare e eseguire nuovamente il deployment dei carichi di lavoro.

Per ulteriori informazioni, consulta la documentazione sul controllo dell'accesso.

Aggiorna i manifest in modo che facciano riferimento a Container Registry

Aggiorna i file Docker e i manifest in modo che facciano riferimento a Container Registry instead of the third-party registry.

L'esempio seguente mostra il manifest che fa riferimento a un registry di terze parti:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Questa versione aggiornata del manifest fa riferimento all'immagine in Container Registry:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: gcr.io/<GCR_PROJECT>/nginx:1.14.2
        ports:
        - containerPort: 80

Per un numero elevato di manifest, utilizza sed o un altro strumento in grado di gestire gli aggiornamenti in molti file di testo.

Esegui di nuovo il deployment dei carichi di lavoro

Esegui nuovamente il deployment dei carichi di lavoro con i manifest aggiornati.

Tieni traccia dei nuovi download di immagini eseguendo la seguente query nella console BigQuery:

SELECT`

FORMAT_TIMESTAMP("%D %R", timestamp) as timeOfImagePull,
REGEXP_EXTRACT(jsonPayload.message, r'"(.*?)"') AS imageName,
COUNT(*) AS numberOfPulls
FROM
  `image_pull_logs.events_*`
GROUP BY
  timeOfImagePull,
  imageName
ORDER BY
  timeOfImagePull DESC,
  numberOfPulls DESC

Tutti i nuovi estrazioni di immagini devono provenire da Container Registry e contenere la stringagcr.io.

(Facoltativo) Blocca il recupero delle immagini dai registri di terze parti

Per i cluster GKE che utilizzano Autorizzazione binaria, il criterio definito blocca automaticamente i download da origini non attendibili. Assicurati che le immagini migrate non siano bloccate dalle norme aggiungendole all'elenco delle esenzioni. Queste istruzioni descrivono come specificare un'esenzione per tutte le immagini archiviate in Container Registry all'interno del tuo progetto.

Quando aggiorni inizialmente il criterio, ti consigliamo di attivare la modalità di prova. Anziché bloccare le immagini, Autorizzazione binaria crea voci di log di controllo per consentirti di identificare le immagini in sospeso dei registri di terze parti di cui devi eseguire la migrazione a Container Registry.

Per ulteriori informazioni sulla configurazione dei criteri di deployment, consulta la documentazione di Autorizzazione binaria.

Vai alla pagina Autorizzazione binaria
Fai clic su Modifica criterio.
In Regola predefinita del progetto, attiva la modalità di prova.
In Immagini esenti dalle regole di deployment, lascia selezionata l'opzione Accetta tutte le immagini di sistema fornite da Google.
Espandi Percorsi immagine.
Aggiungi il percorso alle immagini come esenzione alla regola del progetto predefinita:
1. Nella parte inferiore dell'elenco delle immagini, fai clic su Aggiungi immagini.
2. Inserisci il percorso dell'immagine per il tuo progetto Google Cloud. Ad esempio, gcr.io/my-project/* esenta tutte le immagini del progetto my-project.
Ripeti il passaggio precedente per gli altri progetti contenenti le immagini che vuoi implementare.

Esamina gli eventi di prova in Log per i tuoi deployment. Esegui la migrazione delle immagini rimanenti che carichi regolarmente dai registry di terze parti. Una volta eseguita la migrazione di tutte le immagini, puoi modificare il criterio per disattivare la modalità di prova e bloccare le immagini provenienti da origini non attendibili.