Questo tutorial mostra a sviluppatori e operatori che eseguono il deployment di container in Kubernetes come utilizzare i digest delle immagini container per identificarle. Un digest dell'immagine container identifica in modo univoco e immutabile un'immagine container.
Il deployment delle immagini dei container utilizzando il digest dell'immagine offre diversi vantaggi rispetto all'utilizzo dei tag immagine. Per ulteriori informazioni sui digest delle immagini, consulta il documento allegato sull'utilizzo dei digest delle immagini dei contenitori prima di continuare con questo tutorial.
L'argomento image
per i container in una specifica del pod Kubernetes accetta immagini con digest. Questo argomento si applica ovunque venga utilizzata una specifica del pod, ad esempio nella sezione template
delle risorse Deployment, StatefulSet, DaemonSet, ReplicaSet, CronJob e Job.
Per eseguire il deployment di un'immagine utilizzando il digest, utilizza il nome dell'immagine, seguito da @sha256:
e dal valore del digest. Di seguito è riportato un esempio di risorsa di Deployment che utilizza un'immagine con un digest. Un deployment è un oggetto dell'API Kubernetes che ti consente di eseguire più repliche di pod distribuite tra i nodi di un cluster.
apiVersion: apps/v1 kind: Deployment metadata: name: echo-deployment spec: selector: matchLabels: app: echo template: metadata: labels: app: echo spec: containers: - name: echoserver image: gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229 ports: - containerPort: 8080
Uno svantaggio dell'utilizzo dei digest delle immagini è che non conosci il valore del digest fino a quando non hai pubblicato l'immagine in un registry. Quando crei nuove immagini, il valore del digest cambia e devi trovare un modo per aggiornare i manifest di Kubernetes ogni volta che esegui il deployment.
Questo tutorial mostra come utilizzare strumenti come
Skaffold,
kpt,
digester,
kustomize,
gke-deploy
,
e
ko
per utilizzare i digest delle immagini nei manifest.
Consigli
Questo documento illustra diversi modi per utilizzare i digest delle immagini nei deployment Kubernetes. Gli strumenti descritti in questo documento sono complementari.
Ad esempio, puoi utilizzare l'output di una funzione kpt con kustomize per creare varianti per ambienti diversi. Skaffold può
creare immagini utilizzando ko
ed eseguirne il deployment nei tuoi cluster Kubernetes utilizzando kubectl
o kpt.
Gli strumenti sono complementari perché eseguono modifiche strutturate in base al modello di risorse Kubernetes (KRM). Questo modello rende gli strumenti collegabili e puoi evolvere il loro utilizzo per creare processi e pipeline che ti aiutino a eseguire il deployment delle tue app e dei tuoi servizi.
Per iniziare, ti consigliamo l'approccio più adatto alle tue procedure e ai tuoi strumenti esistenti:
Skaffold può aggiungere digest ai riferimenti alle immagini. Puoi attivare questa funzione con una piccola modifica alla configurazione. L'adozione di Skaffold offre vantaggi aggiuntivi, ad esempio l'astrazione del modo in cui diversi strumenti creano e distribuiscono le immagini dei container.
Utilizzando lo strumento di aggregazione come webhook di ammissione con mutazioni nei tuoi cluster Kubernetes, puoi aggiungere digest a tutti i tuoi deployment con un impatto minimo sulle tue attuali procedure di creazione e deployment delle immagini container. Il webhook del digester semplifica anche l'adozione dell'autorizzazione di tipo binario, poiché richiede solo l'aggiunta di un'etichetta a uno spazio dei nomi.
kpt è un'ottima opzione se hai bisogno di uno strumento flessibile per manipolare i manifest Kubernetes. Lo strumento di elaborazione può essere utilizzato come funzione KRM lato client in una pipeline kpt.
Se utilizzi già kustomize per gestire i manifest di Kubernetes in diversi ambienti, ti consigliamo di sfruttare i relativi trasformatori di immagini per eseguire il deployment delle immagini tramite digest.
ko
è un ottimo modo per creare e pubblicare immagini per le app Go e viene utilizzato da progetti open source come Knative, Tekton e sigstore.
Se non utilizzi nessuno degli strumenti descritti in questo documento, ti consigliamo di iniziare con Skaffold e l'webhook di Digester. Skaffold è uno strumento comune utilizzato sia dagli sviluppatori sia dai team di rilascio e si integra con gli altri strumenti descritti in questo tutorial. Puoi sfruttare queste opzioni di integrazione man mano che i tuoi requisiti si evolvono. L'webhook Kubernetes per l'estrazione di digest completa Skaffold consentendo i deployment basati su digest per un intero cluster.
Obiettivi
- Utilizza Skaffold per creare ed eseguire il push di un'immagine e per inserire il nome e il digest dell'immagine in un manifest Kubernetes.
- Utilizza la funzione lato client del digester e l'webhook di ammissione con mutazioni per aggiungere digest alle immagini nei pod e nei modelli di pod di Kubernetes.
- Utilizza i settati kpt per sostituire un tag immagine in un manifest Kubernetes con un digest dell'immagine.
- Utilizza kustomize per generare un manifest Kubernetes con un digest dell'immagine.
- Utilizza
gke-deploy
per risolvere un tag immagine in un digest in un manifest Kubernetes. - Utilizza
ko
per creare ed eseguire il push di un'immagine e per inserire il nome e il digest dell'immagine in un manifest Kubernetes.
Costi
In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:
Per generare una stima dei costi in base all'utilizzo previsto,
utilizza il Calcolatore prezzi.
Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione Pulizia.
Prima di iniziare
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the Artifact Registry API.
-
In the Google Cloud console, activate Cloud Shell.
In Cloud Shell, imposta il progetto predefinito per Google Cloud CLI:
gcloud config set project PROJECT_ID
Sostituisci
PROJECT_ID
con il tuo [ID progetto].Crea un repository di immagini container in Artifact Registry:
gcloud artifacts repositories create REPOSITORY \ --location=LOCATION \ --repository-format=docker
Sostituisci quanto segue:
REPOSITORY
: il nome che vuoi utilizzare per il repository, ad esempiodigest-tutorial
.LOCATION
: un'ubicazione di Artifact Registry, ad esempious-central1
.
Configura l'autenticazione nella posizione di Artifact Registry per gli strumenti CLI utilizzati in questo tutorial:
gcloud auth configure-docker LOCATION-docker.pkg.dev
Utilizzo di Skaffold
Skaffold è uno strumento a riga di comando per lo sviluppo e il deployment continui di applicazioni su cluster Kubernetes.
Utilizza Skaffold per creare un'immagine, eseguine il push in Artifact Registry e
sostituisci il valore del segnaposto image
in un modello manifest Kubernetes con il
nome, il tag e il digest dell'immagine di cui è stato eseguito il push:
In Cloud Shell, crea e vai a una directory per archiviare i file che crei in questa sezione:
mkdir -p ~/container-image-digests-tutorial/skaffold cd ~/container-image-digests-tutorial/skaffold
Clona il repository Git di Skaffold:
git clone https://github.com/GoogleContainerTools/skaffold.git
Vai alla directory dell'esempio
getting-started
:cd skaffold/examples/getting-started
Esegui il checkout del tag Git corrispondente alla tua versione di Skaffold:
git checkout $(skaffold version)
Visualizza il file di configurazione
skaffold.yaml
:cat skaffold.yaml
Il file è simile al seguente:
apiVersion: skaffold/v4beta6 kind: Config build: artifacts: - image: skaffold-example manifests: rawYaml: - k8s-pod.yaml
La sezione
build.artifacts
contiene il nome di un'immagine segnaposto. Skaffold cerca questo segnaposto nei file manifest di input.La sezione
manifests
indica a Skaffold di leggere un manifest di input dalla directory corrente con il nomek8s-pod.yaml
.Per una panoramica di tutte le opzioni disponibili, consulta la documentazione di riferimento di
skaffold.yaml
.Visualizza il modello manifest Kubernetes:
cat k8s-pod.yaml
Il file è il seguente:
apiVersion: v1 kind: Pod metadata: name: getting-started spec: containers: - name: getting-started image: skaffold-example
Il valore del segnaposto
skaffold-example
nel campoimage
corrisponde al valore del campoimage
nel fileskaffold.yaml
. Skaffold sostituisce questo valore segnaposto con il nome completo dell'immagine e il digest nell'output visualizzato.Crea e esegui il push dell'immagine in Artifact Registry:
skaffold build \ --default-repo=LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY \ --file-output=artifacts.json \ --interactive=false \ --push=true \ --update-check=false
Questo comando utilizza i seguenti flag:
- Il flag
--file-output
specifica il file in cui Skaffold salva le informazioni sull'immagine creata, incluso il valore digest. - Il flag
--push
indica a Skaffold di eseguire il push dell'immagine creata nel registro delle immagini container specificato dal flag--default-repo
. - I flag
--interactive
e--update-check
sono entrambi impostati sufalse
. Imposta questi flag sufalse
in ambienti non interattivi, come le pipeline di compilazione, ma lasciali con i valori predefiniti (true
per entrambi i flag) per lo sviluppo locale.
Se utilizzi Cloud Deploy per eseguire il deployment in GKE, utilizza il file del flag
--file-output
come valore del--build-artifacts
quando crei una release.- Il flag
Esegui il rendering del manifest Kubernetes espanso con il nome, il tag e il digest dell'immagine del container del passaggio precedente:
skaffold render \ --build-artifacts=artifacts.json \ --digest-source=none \ --interactive=false \ --offline=true \ --output=rendered.yaml \ --update-check=false
Questo comando utilizza i seguenti flag:
- Il flag
--build-artifacts
fa riferimento al file di output del comandoskaffold build
nel passaggio precedente. - Il flag
--digest-source=none
indica che Skaffold utilizza il valore del digest del file fornito nel flag--build-artifacts
anziché risolvere il digest dal registry delle immagini container. - Il flag
--offline=true
indica che puoi eseguire il comando senza richiedere l'accesso a un cluster Kubernetes. - Il flag
--output
specifica il file di output per il manifest visualizzato.
- Il flag
Visualizza il manifest visualizzato:
cat rendered.yaml
L'output è simile al seguente:
apiVersion: v1 kind: Pod metadata: name: getting-started spec: containers: - image: LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/skaffold-example:TAG@sha256:DIGEST name: getting-started
In questo output vengono visualizzati i seguenti valori:
TAG
: il tag assegnato da Skaffold all'immagine.DIGEST
: il valore del digest dell'immagine
Utilizzo di Digester
Digester aggiunge digest alle immagini container e init container nelle specifiche del pod e del modello di pod di Kubernetes. Digester sostituisce i riferimenti alle immagini container che utilizzano i tag:
spec:
containers:
- image: gcr.io/google-containers/echoserver:1.10
Con i riferimenti che utilizzano il digest delle immagini:
spec:
containers:
- image: gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
Digester può essere eseguito come webhook di ammissione con mutazioni in un cluster Kubernetes o come funzione KRM lato client con gli strumenti a riga di comando kpt o kustomize.
Utilizzare la funzione KRM per l'analisi di sintesi
In Cloud Shell, crea e vai a una directory per archiviare i file che crei in questa sezione:
mkdir -p ~/container-image-digests-tutorial/digester-fn cd ~/container-image-digests-tutorial/digester-fn
Scarica il programma binario di Digester:
mkdir -p ${HOME}/bin export PATH=${HOME}/bin:${PATH} DIGESTER_VERSION=$(curl -sL https://api.github.com/repos/google/k8s-digester/releases/latest | jq -r .tag_name) curl -L "https://github.com/google/k8s-digester/releases/download/${DIGESTER_VERSION}/digester_$(uname -s)_$(uname -m)" --output ${HOME}/bin/digester chmod +x ${HOME}/bin/digester
Crea un manifest del pod Kubernetes che fa riferimento all'immagine
gcr.io/google-containers/echoserver
utilizzando il tag1.10
:cat << EOF > pod.yaml apiVersion: v1 kind: Pod metadata: name: echo spec: containers: - name: echoserver image: gcr.io/google-containers/echoserver:1.10 ports: - containerPort: 8080 EOF
Esegui la funzione KRM di aggregazione utilizzando kpt con i manifest nella directory corrente (
.
):kpt fn eval . --exec digester
Quando esegui questo comando, kpt esegue un aggiornamento in situ dei manifest nella directory corrente. Se vuoi che kpt mostri il manifest aggiornato nella console e lasci invariato il file manifest, aggiungi il flag
--output unwrap
.Visualizza il manifest aggiornato:
cat pod.yaml
Il file è il seguente:
apiVersion: v1 kind: Pod metadata: name: echo spec: containers: - name: echoserver image: gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229 ports: - containerPort: 8080
Utilizzare il webhook di ammissione del digestore
In Cloud Shell, crea e vai a una directory per archiviare i file che crei in questa sezione:
mkdir -p ~/container-image-digests-tutorial/digester-webhook cd ~/container-image-digests-tutorial/digester-webhook
Crea un cluster Kubernetes locale utilizzando kind:
kind create cluster
kind è uno strumento a riga di comando per eseguire cluster Kubernetes locali utilizzando Docker.
Esegui il deployment del webhook del digester:
DIGESTER_VERSION=$(curl -sL https://api.github.com/repos/google/k8s-digester/releases/latest | jq -r .tag_name) kustomize build "https://github.com/google/k8s-digester.git/manifests?ref=${DIGESTER_VERSION}" | kubectl apply -f -
Crea uno spazio dei nomi Kubernetes denominato
digester-demo
nel tipo cluster:kubectl create namespace digester-demo
Aggiungi l'etichetta
digest-resolution: enabled
allo spazio dei nomidigester-demo
:kubectl label namespace digester-demo digest-resolution=enabled
Il webhook del digester aggiunge i digest ai pod negli spazi dei nomi con questa etichetta.
Crea un manifest di deployment Kubernetes che fa riferimento all'immagine
gcr.io/google-containers/echoserver
utilizzando il tag1.10
:cat << EOF > deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: echo-deployment spec: selector: matchLabels: app: echo template: metadata: labels: app: echo spec: containers: - name: echoserver image: gcr.io/google-containers/echoserver:1.10 ports: - containerPort: 8080 EOF
Applica il manifest nello spazio dei nomi
digester-demo
:kubectl apply --filename deployment.yaml --namespace digester-demo \ --output jsonpath='{.spec.template.spec.containers[].image}{"\n"}'
Il flag
--output
indica akubectl
di stampare il nome dell'immagine nella console, seguito da un carattere di a capo. L'output è il seguente:gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
Questo output mostra che l'webhook del digester ha aggiunto il digest dell'immagine alla specifica del modello di pod nella risorsa di deployment.
Elimina il cluster di tipo per liberare risorse nella sessione Cloud Shell:
kind delete cluster
Utilizzo degli attributi kpt
kpt è uno strumento a riga di comando per gestire, manipolare, personalizzare e applicare i manifest delle risorse Kubernetes.
Puoi utilizzare le funzioni KRM create-setters
e apply-setters
del
catalogo di funzioni kpt
per aggiornare i digest delle immagini nei manifest di Kubernetes quando crei nuove
immagini.
In Cloud Shell, crea e vai a una directory per archiviare i file che crei in questa sezione:
mkdir -p ~/container-image-digests-tutorial/kpt cd ~/container-image-digests-tutorial/kpt
Crea un pacchetto kpt nella directory corrente:
kpt pkg init --description "Container image digest tutorial"
Crea un manifest del pod Kubernetes che fa riferimento all'immagine
gcr.io/google-containers/echoserver
utilizzando il tag1.10
:cat << EOF > pod.yaml apiVersion: v1 kind: Pod metadata: name: echo spec: containers: - name: echoserver image: gcr.io/google-containers/echoserver:1.10 ports: - containerPort: 8080 EOF
Utilizza kpt per creare un settatore denominato
echoimage
per il campo manifest, dove il valore esistente ègcr.io/google-containers/echoserver:1.10
:kpt fn eval . \ --image gcr.io/kpt-fn/create-setters@sha256:0220cc87f29ff9abfa3a3b5643aa50f18d355d5e9dc9e1f518119633ddc4895c \ -- "echoimage=gcr.io/google-containers/echoserver:1.10"
Visualizza il manifest:
cat pod.yaml
Il file è il seguente:
apiVersion: v1 kind: Pod metadata: name: echo spec: containers: - name: echoserver image: gcr.io/google-containers/echoserver:1.10 # kpt-set: ${echoimage} ports: - containerPort: 8080
Ottieni il valore del digest dell'immagine container:
DIGEST=$(gcloud container images describe \ gcr.io/google-containers/echoserver:1.10 \ --format='value(image_summary.digest)')
Imposta il nuovo valore del campo:
kpt fn eval . \ --image gcr.io/kpt-fn/apply-setters@sha256:4d4295727183396f0c3c6a75d2560254c2f9041a39e95dc1e5beffeb49cc1a12 \ -- "echoimage=gcr.io/google-containers/echoserver:1.10@$DIGEST"
Quando esegui questo comando, kpt esegue una sostituzione in situ del valore del campo
image
nel manifest.Visualizza il manifest aggiornato:
cat pod.yaml
Il file è il seguente:
apiVersion: v1 kind: Pod metadata: name: echo spec: containers: - name: echoserver image: gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229 # kpt-set: ${echoimage} ports: - containerPort: 8080
Utilizzo degli strumenti di trasformazione delle immagini di kustomize
kustomize è uno strumento a riga di comando che consente di personalizzare i manifest di Kubernetes utilizzando overlay, patch e trasformatori.
Puoi utilizzare il trasformatore di immagini di kustomize per aggiornare il nome, il tag e il digest dell'immagine nel manifest esistente.
Il seguente snippet kustomization.yaml
mostra come configurare il trasformatore di immagini in modo da utilizzare il valore digest
del trasformatore per le immagini in cui il valore image
della specifica del pod corrisponde al valore name
del trasformatore:
images: - name: gcr.io/google-containers/echoserver digest: sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
Per utilizzare un trasformatore di immagini Kustomize con un digest di immagini:
In Cloud Shell, crea e vai a una directory per archiviare i file che crei in questa sezione:
mkdir -p ~/container-image-digests-tutorial/kustomize cd ~/container-image-digests-tutorial/kustomize
Crea un file
kustomization.yaml
:kustomize init
Crea un manifest Kubernetes con una specifica del pod che fa riferimento all'immagine
gcr.io/google-containers/echoserver
utilizzando il tag1.10
:cat << EOF > pod.yaml apiVersion: v1 kind: Pod metadata: name: echo spec: containers: - name: echoserver image: gcr.io/google-containers/echoserver:1.10 ports: - containerPort: 8080 EOF
Aggiungi il manifest come risorsa nel file
kustomization.yaml
:kustomize edit add resource pod.yaml
Utilizza un trasformatore di immagini per aggiornare il digest dell'immagine:
kustomize edit set image \ gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
Visualizza il trasformatore di immagini nel file
kustomization.yaml
:cat kustomization.yaml
Il file è il seguente:
apiVersion: kustomize.config.k8s.io/v1beta1 kind: Kustomization resources: - pod.yaml images: - digest: sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229 name: gcr.io/google-containers/echoserver
Visualizza il manifest risultante:
kustomize build .
L'output è il seguente:
apiVersion: v1 kind: Pod metadata: name: echo spec: containers: - image: gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229 name: echoserver ports: - containerPort: 8080
Per eseguire il trasformatore kustomize e applicare il manifest risultante a un cluster Kubernetes in un solo passaggio, puoi utilizzare il comando
kubectl apply
con il flag--kustomize
:kubectl apply --kustomize .
Se vuoi applicare l'output in un secondo momento, puoi reindirizzare l'output del comando
kustomize build
a un file.
È in uso gke-deploy
gke-deploy
è uno strumento a riga di comando che utilizzi con
Google Kubernetes Engine (GKE).
gke-deploy
racchiude lo strumento a riga di comando kubectl
e può modificare le risorse che crei seguendo le best practice consigliate da Google.
Se utilizzi i sottocomandi gke-deploy
prepare
o run
, gke-deploy
risolve i tag immagine in digest e salva i manifest espansi con i
digest delle immagini nel file output/expanded/aggregated-resources.yaml
per
impostazione predefinita.
Puoi utilizzare gke-deploy run
sia per sostituire il tag immagine con un digest sia per
applicare il manifest espanso al tuo cluster GKE. Anche se questo comando è pratico, ha un svantaggio: il tag immagine viene sostituito al momento del deployment. L'immagine associata al tag potrebbe essere cambiata nel periodo di tempo tra la decisione di eseguire il deployment e l'esecuzione stessa, con il risultato di un deployment di un'immagine inaspettata. Per i deployment in produzione, consigliamo di eseguire passaggi distinti per la generazione e l'applicazione dei manifest.
Per sostituire un tag immagine in un manifest di deployment Kubernetes con il digest dell'immagine:
In Cloud Shell, crea e vai a una directory per archiviare i file che crei in questa sezione:
mkdir -p ~/container-image-digests-tutorial/gke-deploy cd ~/container-image-digests-tutorial/gke-deploy
Installa
gke-deploy
:go install github.com/GoogleCloudPlatform/cloud-builders/gke-deploy@latest
Crea un manifest di deployment Kubernetes che fa riferimento all'immagine
gcr.io/google-containers/echoserver
utilizzando il tag1.10
:cat << EOF > deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: echo-deployment spec: selector: matchLabels: app: echo template: metadata: labels: app: echo spec: containers: - name: echoserver image: gcr.io/google-containers/echoserver:1.10 ports: - containerPort: 8080 EOF
Genera un manifest espanso in base al manifest
deployment.yaml
:gke-deploy prepare \ --filename deployment.yaml \ --image gcr.io/google-containers/echoserver:1.10 \ --version 1.10
Visualizza il manifest espanso:
cat output/expanded/aggregated-resources.yaml
L'output è il seguente:
apiVersion: apps/v1 kind: Deployment metadata: labels: app.kubernetes.io/managed-by: gcp-cloud-build-deploy app.kubernetes.io/version: "1.10" name: echo-deployment namespace: default spec: selector: matchLabels: app: echo template: metadata: labels: app: echo app.kubernetes.io/managed-by: gcp-cloud-build-deploy app.kubernetes.io/version: "1.10" spec: containers: - image: gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229 name: echoserver ports: - containerPort: 8080
Nel manifest espanso, il tag immagine viene sostituito dal digest.
L'argomento
--version
utilizzato con il comandogke-deploy
imposta il valore dell'etichettaapp.kubernetes.io/version
nel deployment e nei metadati del modello di pod del manifest espanso.Per scoprire come utilizzare
gke-deploy
con Cloud Build, consulta la documentazione di Cloud Build pergke-deploy
.
È in uso ko
ko
è uno strumento a riga di comando e una libreria per la creazione di immagini container Go
e il loro deployment in cluster Kubernetes. ko
crea immagini
senza utilizzare il daemon Docker, quindi puoi utilizzarlo in ambienti in cui
non puoi installare Docker.
Il sottocomando ko
build
crea le immagini e le pubblica in un registry di immagini container o le carica nel daemon Docker locale.
Il sottocomando ko
resolve
esegue le seguenti operazioni:
- Identifica le immagini da compilare trovando i segnaposto nei campi
image
del manifest Kubernetes che fornisci utilizzando l'argomento--filename
. - Crea e pubblica le immagini.
- Sostituisce i segnaposto dei valori
image
con i nomi e i digest delle immagini che ha creato. - Stampa i manifest espansi.
I sottocomandi ko
apply
,
create
e
run
eseguono gli stessi passaggi di resolve
, quindi eseguono kubectl apply
,
create
o run
con i manifest espansi.
Per creare un'immagine dal codice sorgente Go e aggiungere il digest dell'immagine a un manifest di deployment Kubernetes, segui questi passaggi:
In Cloud Shell, crea e vai a una directory per archiviare i file che crei in questa sezione:
mkdir -p ~/container-image-digests-tutorial/ko cd ~/container-image-digests-tutorial/ko
Scarica
ko
e aggiungilo al tuoPATH
:mkdir -p ${HOME}/bin export PATH=${HOME}/bin:${PATH} KO_VERSION=$(curl -sL https://api.github.com/repos/ko-build/ko/releases/latest | jq -r .tag_name | cut -c2-) curl -L "https://github.com/ko-build/ko/releases/download/v${KO_VERSION}/ko_${KO_VERSION}_$(uname -s)_$(uname -m).tar.gz" | tar -zxC ${HOME}/bin ko
Crea un'app Go con il nome del modulo
example.com/hello-world
in una nuova directory denominataapp
:mkdir -p app/cmd/ko-example cd app go mod init example.com/hello-world cat << EOF > cmd/ko-example/main.go package main import "fmt" func main() { fmt.Println("hello world") } EOF
Definisci il repository di immagini utilizzato da
ko
per pubblicare le immagini:export KO_DOCKER_REPO=LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY
Questo esempio utilizza Artifact Registry, ma puoi utilizzare
ko
con un altro registro di immagini container.Per creare e pubblicare un'immagine per la tua app, svolgi uno dei seguenti passaggi:
Crea e pubblica un'immagine per la tua app specificando il percorso al pacchetto principale Go:
ko build --base-import-paths ./cmd/ko-example
L'argomento facoltativo
--base-import-paths
indica cheko
utilizza il nome breve della directory del pacchetto principale come nome dell'immagine.ko
stampa il nome e il digest dell'immagine instdout
nel seguente formato:LOCATION-docker.pkg.dev/PROJECT_ID/ko-example@sha256:DIGEST
In questo output,
DIGEST
è il valore del digest dell'immagine.Utilizza
ko
per sostituire un segnaposto del manifest con il nome e il digest dell'immagine che viene creata e pubblicata:Crea un manifest del pod Kubernetes. Il manifest utilizza il segnaposto
ko://IMPORT_PATH_OF_YOUR_MAIN_PACKAGE
come valore del campoimage
:cat << EOF > ko-pod.yaml apiVersion: v1 kind: Pod metadata: name: ko-example spec: containers: - name: hello-world image: ko://example.com/hello-world/cmd/ko-example EOF
Crea e pubblica un'immagine per la tua app e sostituisci il segnaposto del file manifest con il nome e il digest dell'immagine:
ko resolve --base-import-paths --filename ko-pod.yaml
ko
stampa il manifest con il nome dell'immagine e il digest instdout
:apiVersion: v1 kind: Pod metadata: name: ko-example spec: containers: - name: hello-world image: LOCATION-docker.pkg.dev/PROJECT_ID/ko-example@sha256:DIGEST
In questo output,
DIGEST
è il valore del digest dell'immagine.
Esegui la pulizia
Il modo più semplice per eliminare la fatturazione è eliminare il progetto Google Cloud che hai creato per il tutorial. In alternativa, puoi eliminare le singole risorse.
Elimina il progetto
- In the Google Cloud console, go to the Manage resources page.
- In the project list, select the project that you want to delete, and then click Delete.
- In the dialog, type the project ID, and then click Shut down to delete the project.
Elimina le risorse
Se vuoi mantenere il progetto Google Cloud utilizzato in questo tutorial, elimina le singole risorse:
In Cloud Shell, elimina i file creati in questo tutorial:
cd rm -rf ~/container-image-digests-tutorial
Elimina il repository di immagini container in Artifact Registry:
gcloud artifacts repositories delete REPOSITORY \ --location=LOCATION --async --quiet
Passaggi successivi
- Scopri di più sui digest delle immagini container.
- Scopri di più sulla funzione KRM lato client di Digester e sull'webhook Kubernetes con mutazioni.
- Esplora la distribuzione continua in stile GitOps con Cloud Build.