Se estrai alcune immagini container direttamente da registri di terze parti per eseguirne il deployment in ambienti Google Cloud come Google Kubernetes Engine o Cloud Run, i limiti di frequenza per il pull 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 Artifact Registry per una gestione consolidata e coerente delle immagini container.
Artifact Registry non monitora i registry di terze parti per gli aggiornamenti alle immagini copiate in Artifact Registry. Se vuoi incorporare nella pipeline una versione più recente di un'immagine, devi eseguirne il push in Artifact Registry.
Panoramica della migrazione
La migrazione delle immagini 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 eventuali riferimenti a registri di terze parti
- Determina la frequenza di pull delle immagini da registri di terze parti utilizzando Cloud Logging e BigQuery.
- Copia le immagini identificate in Artifact Registry.
- Verifica che le autorizzazioni per il registro siano configurate correttamente, in particolare se Artifact Registry e il tuo ambiente di deployment Google Cloud si trovano in progetti diversi.
- Aggiorna i manifests per i deployment.
- Esegui nuovamente il deployment dei carichi di lavoro.
Prima di iniziare
- Verifica le autorizzazioni. Devi disporre del ruolo IAM Proprietario o Editor nei progetti di cui esegui la migrazione delle immagini ad Artifact Registry.
Vai alla pagina del selettore progetti
- Seleziona il progetto Google Cloud in cui usare Artifact Registry
- Nella console Google Cloud, vai a Cloud Shell
Individua il tuo ID progetto e impostalo in Cloud Shell. Sostituisci
YOUR_PROJECT_ID
con l'ID 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, Artifact Registry e Cloud Monitoring con il seguente comando:
gcloud services enable \ artifactregistry.googleapis.com \ stackdriver.googleapis.com \ logging.googleapis.com \ monitoring.googleapis.com
Se al momento non utilizzi Artifact Registry, configura un repository per le tue immagini:
- Crea un repository
- Configura l'autenticazione per i client di terze parti che richiedono l'accesso al repository.
Verifica che Go sia installato versione 1.13 o successiva.
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 i file che utilizzi per creare ed eseguire il deployment delle immagini container per fare riferimento a registri di terze parti, quindi controlla la frequenza con cui esegui il pull delle immagini.
Identificare i riferimenti nei Dockerfile
Esegui questo passaggio in una località in cui sono archiviati i Dockerfile. Potrebbe essere il punto in cui il codice viene eseguito localmente o, se i file sono disponibili in una VM, in Cloud Shell.
Nella directory con i tuoi Dockerfile, esegui il comando:
grep -inr -H --include Dockerfile\* "FROM" . | grep -i -v -E 'docker.pkg.dev|gcr.io'
L'output è simile al seguente esempio:
./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 in tutti i Dockerfile nella directory e identifica la riga "FROM". Modifica il comando in base alle esigenze in base al modo in cui archivi i Dockerfile.
Identificare i riferimenti nei manifest
Esegui questo passaggio in una località in cui sono archiviati i manifest di GKE o Cloud Run. Potrebbe essere il punto in cui il codice viene eseguito localmente o in Cloud Shell se i file sono disponibili in una VM.
Nella directory con i manifest GKE o Cloud Run esegui questo 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 tua directory e identifica la riga image:; apporta le modifiche necessarie per gestire il modo in cui vengono archiviati i manifest.
Per elencare le immagini attualmente in esecuzione su un cluster, esegui questo 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 in tutti i progetti Google Cloud per la copertura totale.
Identificare la frequenza di pull da un registro di terze parti
Nei progetti che eseguono il pull da registri di terze parti, utilizza le informazioni sulla frequenza di pull delle immagini per determinare se l'utilizzo si avvicina o supera i limiti di frequenza applicati dal registry di terze parti.
Raccogli 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 dati su più progetti.
Per creare un sink per un singolo progetto:
Scegli un progetto Google Cloud.
Nella scheda Query Builder, inserisci la query seguente:
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, poi fai clic su Avanti.
Nel riquadro di modifica del sink, esegui i seguenti passaggi:
- Nel campo Nome sink, inserisci
image_pull_logs
. - Nel campo Destinazione sink, crea un nuovo set di dati o scegli un set di dati di destinazione in un altro progetto.
- Nel campo Nome sink, inserisci
Fai clic su Crea sink.
Per creare un sink per più progetti:
Esegui questi 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 progetti 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
.
- PROJECT-LIST è un elenco di ID progetti Google Cloud,
separati da spazi. Ad esempio
Dopo aver creato un sink, occorre del tempo prima che i dati vengano inviati alle tabelle BigQuery, a seconda della frequenza di estrazione delle immagini.
Query per frequenza di pull
Una volta ottenuto un campione rappresentativo di pull di immagini eseguite dalle tue build, esegui una query per la frequenza di pull.
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 che contiene 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 pull per le immagini non archiviate in Artifact Registry o Container Registry.
Copia immagini in Artifact Registry
Dopo aver identificato le immagini da registri di terze parti, puoi copiarle in Artifact Registry. Lo strumento gcrane semplifica la procedura di copia.
Crea un file di testo
images.txt
in Cloud Shell con i nomi delle immagini identificate. 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 il tuo elenco di file.#!/bin/bash images=$(cat images.txt) if [ -z "${AR_PROJECT}" ] then echo ERROR: AR_PROJECT must be set before running this exit 1 fi for img in ${images} do gcrane cp ${img} LOCATION-docker.pkg.dev/${AR_PROJECT}/${img} done
Sostituisci LOCATION con una regione o una più regioni del tuo repository.
Rendi eseguibile lo script:
chmod +x copy_images.sh
Esegui lo script per copiare i file:
AR_PROJECT=${PROJECT} ./copy_images.sh
Verifica autorizzazioni
Per impostazione predefinita, i servizi CI/CD di Google Cloud hanno accesso ad Artifact 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 di App Engine e Compute Engine possono eseguire il pull delle immagini.
Se devi eseguire il push o il pull di immagini su più progetti o se nella tua pipeline utilizzi strumenti di terze parti che devono accedere ad Artifact Registry, assicurati che le autorizzazioni siano configurate correttamente prima di aggiornare ed eseguire nuovamente il deployment dei carichi di lavoro.
Per ulteriori informazioni, consulta la documentazione relativa al controllo dell'accesso.
Aggiorna i manifest per fare riferimento ad Artifact Registry
Aggiorna i Dockerfile e i manifest in modo che facciano riferimento ad Artifact Registry anziché al registro di terze parti.
L'esempio seguente mostra un file manifest che fa riferimento a un registro 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 rimanda a un'immagine su us-docker.pkg.dev
.
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: us-docker.pkg.dev/<AR_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 su molti file di testo.
Esegui nuovamente il deployment dei carichi di lavoro
Esegui nuovamente il deployment dei carichi di lavoro con i manifest aggiornati.
Tieni traccia dei nuovi pull delle immagini eseguendo la seguente query nella console di 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 pull di immagini devono provenire da Artifact Registry e contenere la stringa docker.pkg.dev
.