Utilizzo dei digest di immagini container nei manifest di Kubernetes

Last reviewed 2023-07-21 UTC

Questo tutorial mostra agli sviluppatori e agli operatori che eseguono il deployment dei container in Kubernetes come utilizzare i digest di immagini container per identificare le immagini container. Un digest di immagini container identifica in modo univoco e immutabile un'immagine container.

Il deployment di immagini container tramite il digest delle immagini offre diversi vantaggi rispetto all'uso dei tag immagine. Per ulteriori informazioni sui digest delle immagini, consulta il documento associato sull'utilizzo dei digest delle immagini container prima di continuare questo tutorial.

L'argomento image per i container in una specifica di pod Kubernetes accetta immagini con digest. Questo argomento si applica ovunque utilizzi una specifica di un 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 digest. Di seguito è riportato un esempio di risorsa Deployment che utilizza un'immagine con un digest:

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'uso dei digest delle immagini è che non conosci il valore digest finché non hai pubblicato l'immagine in un registro. Quando crei nuove immagini, il valore del digest cambia e devi trovare un modo per aggiornare i manifest Kubernetes ogni volta che esegui il deployment.

Questo tutorial mostra come utilizzare strumenti come Skaffold, kpt, digester, kustomize, gke-deploy, e ko per usare i digest delle immagini nei tuoi manifest.

Suggerimenti

Questo documento illustra diversi modi per utilizzare le sintesi delle immagini nei deployment di 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.

Il motivo per cui gli strumenti sono complementari è che eseguono modifiche strutturate in base al modello di risorse di Kubernetes (KRM). Questo modello rende gli strumenti collegabili e ti consente di evolvere l'uso degli strumenti per creare processi e pipeline che ti consentano di eseguire il deployment delle tue app e dei tuoi servizi.

Per iniziare, ti consigliamo l'approccio più adatto agli strumenti e ai processi esistenti:

  • Skaffold può aggiungere digest ai riferimenti alle immagini. Puoi abilitare questa funzione con una piccola modifica alla configurazione. L'adozione di Skaffold offre vantaggi aggiuntivi, come l'astrazione del modo in cui strumenti diversi creano ed eseguono il deployment delle immagini container.

  • Se utilizzi lo strumento digester come webhook di ammissione mutante nei tuoi cluster Kubernetes, puoi aggiungere digest a tutti i tuoi deployment con un impatto minimo sui processi attuali per la creazione e il deployment delle immagini container. Il webhook digester semplifica inoltre l'adozione di Autorizzazione binaria, in quanto richiede solo l'aggiunta di un'etichetta a uno spazio dei nomi.

  • kpt è un'ottima opzione se ti serve uno strumento flessibile per gestire i manifest di Kubernetes. Lo strumento digester può essere utilizzato come funzione KRM lato client in una pipeline kpt.

  • Se usi già kustomize per gestire i manifest Kubernetes nei vari ambienti, ti consigliamo di sfruttare i suoi trasformatori di immagine per eseguire il deployment delle immagini per digest.

  • ko è un ottimo modo per creare e pubblicare immagini per le app Go ed è 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 il webhook 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 le tue esigenze si evolvono. Il webhook Kubernetes digester integra Skaffold abilitando deployment basati su digest per un intero cluster.

Obiettivi

  • Usa Skaffold per creare ed eseguire il push di un'immagine e per inserire il nome e il digest dell'immagine in un manifest Kubernetes.
  • Usa la funzione lato client del digester e il webhook di ammissione mutante per aggiungere digest alle immagini nei pod e nei modelli di pod Kubernetes.
  • Utilizza kpt setter per sostituire un tag immagine in un manifest Kubernetes con un digest immagine.
  • Usa kustomize per generare un manifest Kubernetes con un digest immagine.
  • Usa gke-deploy per risolvere un tag immagine in un digest in un manifest Kubernetes.
  • Usa 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 vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

  1. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  2. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  3. Attiva l'API Artifact Registry.

    Abilita l'API

  4. Nella console Google Cloud, attiva Cloud Shell.

    Attiva Cloud Shell

  5. 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].

  6. 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 esempio digest-tutorial.
    • LOCATION: una località di Artifact Registry, ad esempio us-central1.

  7. Configura l'autenticazione nella località Artifact Registry per gli strumenti dell'interfaccia a riga di comando 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 continuo e il deployment di applicazioni nei cluster Kubernetes.

Utilizza Skaffold per creare un'immagine, eseguirne il push in Artifact Registry e sostituire il valore segnaposto image in un modello manifest Kubernetes con nome, tag e digest dell'immagine di cui è stato eseguito il push:

  1. In Cloud Shell, crea e vai a una directory per archiviare i file creati in questa sezione:

    mkdir -p ~/container-image-digests-tutorial/skaffold
cd ~/container-image-digests-tutorial/skaffold

  2. Clona il repository Git Skaffold:

    git clone https://github.com/GoogleContainerTools/skaffold.git

  3. Vai alla directory dell'esempio getting-started:

    cd skaffold/examples/getting-started

  4. Controlla il tag Git che corrisponde alla tua versione di Skaffold:

    git checkout $(skaffold version)

  5. 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 nome k8s-pod.yaml.

    Per una panoramica di tutte le opzioni disponibili, consulta la documentazione di riferimento di skaffold.yaml.

  6. Visualizza il modello di manifest di 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 campo image corrisponde al valore del campo image nel file skaffold.yaml. Skaffold sostituisce questo valore segnaposto con il nome completo dell'immagine e il digest nell'output sottoposto a rendering.

  7. Crea ed 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 al registro delle immagini container specificato dal flag --default-repo.
    • I flag --interactive e --update-check sono entrambi impostati su false. Impostare questi flag su false in ambienti non interattivi, ad esempio per la creazione di pipeline, ma lasciare i valori predefiniti (true per entrambi i flag) per lo sviluppo locale.

    Se usi Cloud Deploy per il deployment su GKE, usa il file del flag --file-output come valore del flag --build-artifacts quando crei una release.

  8. Esegui il rendering del manifest Kubernetes espanso con il nome, il tag e il digest dell'immagine 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 comando skaffold build nel passaggio precedente.
    • Il flag --digest-source=none indica che Skaffold utilizza il valore digest del file fornito nel flag --build-artifacts, invece di risolvere il digest dal registro 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 del manifest visualizzato.

  9. 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 vedrai i seguenti valori:

    • TAG: il tag che Skaffold ha assegnato all'immagine.
    • DIGEST: il valore del digest dell'immagine

Utilizzo di Digester

Digester aggiunge digest alle immagini container e init nelle specifiche di pod e modelli di pod Kubernetes. Il digester sostituisce i riferimenti alle immagini container che usano i tag:

spec:
  containers:
  - image: gcr.io/google-containers/echoserver:1.10

Con riferimenti che utilizzano il digest dell'immagine:

spec:
  containers:
  - image: gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229

Il digester può essere eseguito come webhook di ammissione mutante in un cluster Kubernetes o come funzione KRM lato client con gli strumenti a riga di comando kpt o kustomize.

Utilizzo della funzione KRM del digester

  1. In Cloud Shell, crea e vai a una directory per archiviare i file creati in questa sezione:

    mkdir -p ~/container-image-digests-tutorial/digester-fn
cd ~/container-image-digests-tutorial/digester-fn

  2. Scarica il programma binario del 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

  3. Crea un manifest del pod di Kubernetes che faccia riferimento all'immagine gcr.io/google-containers/echoserver utilizzando il tag 1.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

  4. Esegui la funzione KRM del digester utilizzando kpt con i manifest nella directory corrente (.):

    kpt fn eval . --exec digester

    Quando esegui questo comando, kpt esegue un aggiornamento in loco dei manifest nella directory corrente. Se vuoi che kpt mostri il manifest aggiornato sulla console e non modifichi il file manifest, aggiungi il flag --output unwrap.

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

Utilizzo del webhook di ammissione del digester

  1. In Cloud Shell, crea e vai a una directory per archiviare i file creati in questa sezione:

    mkdir -p ~/container-image-digests-tutorial/digester-webhook
cd ~/container-image-digests-tutorial/digester-webhook

  2. Crea un cluster Kubernetes locale utilizzando kind:

    kind create cluster

    kind è uno strumento a riga di comando per eseguire cluster Kubernetes locali utilizzando Docker.

  3. Esegui il deployment del webhook 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 -

  4. Crea uno spazio dei nomi Kubernetes denominato digester-demo nel cluster di tipo:

    kubectl create namespace digester-demo

  5. Aggiungi l'etichetta digest-resolution: enabled allo spazio dei nomi digester-demo:

    kubectl label namespace digester-demo digest-resolution=enabled

    Il webhook digester aggiunge digest ai pod negli spazi dei nomi con questa etichetta.

  6. Crea un manifest del deployment di Kubernetes che faccia riferimento all'immagine gcr.io/google-containers/echoserver utilizzando il tag 1.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

  7. 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 a kubectl di restituire il nome dell'immagine alla console, seguito da un carattere di nuova riga. L'output è il seguente:

    gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229

    Questo output mostra che il webhook digester ha aggiunto il digest dell'immagine alla specifica del modello di pod nella risorsa Deployment.

  8. Elimina il cluster di tipo per liberare risorse nella sessione Cloud Shell:

    kind delete cluster

Utilizzo di kpt setter

kpt è uno strumento a riga di comando per gestire, manipolare, personalizzare e applicare i manifest delle risorse Kubernetes.

Puoi usare le funzioni KRM create-setters e apply-setters del catalogo delle funzioni kpt per aggiornare i digest delle immagini nei manifest Kubernetes quando crei nuove immagini.

  1. In Cloud Shell, crea e vai a una directory per archiviare i file creati in questa sezione:

    mkdir -p ~/container-image-digests-tutorial/kpt
cd ~/container-image-digests-tutorial/kpt

  2. Crea un pacchetto kpt nella directory corrente:

    kpt pkg init --description "Container image digest tutorial"

  3. Crea un manifest del pod di Kubernetes che faccia riferimento all'immagine gcr.io/google-containers/echoserver utilizzando il tag 1.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

  4. Utilizza kpt per creare un setter 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"

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

  6. Ottieni il valore digest dell'immagine container:

    DIGEST=$(gcloud container images describe \
    gcr.io/google-containers/echoserver:1.10 \
    --format='value(image_summary.digest)')

  7. 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 diretta del valore del campo image nel manifest.

  8. 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 di kustomize image transformer

kustomize è uno strumento a riga di comando che consente di personalizzare i manifest Kubernetes utilizzando overlay, patch e trasformatori.

Puoi utilizzare kustomize image transformer 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 immagine per l'utilizzo del 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 immagine kustomize con un digest di immagini:

  1. In Cloud Shell, crea e vai a una directory per archiviare i file creati in questa sezione:

    mkdir -p ~/container-image-digests-tutorial/kustomize
cd ~/container-image-digests-tutorial/kustomize

  2. Crea un file kustomization.yaml:

    kustomize init

  3. Crea un manifest Kubernetes con una specifica del pod che faccia riferimento all'immagine gcr.io/google-containers/echoserver utilizzando il tag 1.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

  4. Aggiungi il manifest come risorsa nel file kustomization.yaml:

    kustomize edit add resource pod.yaml

  5. Utilizza un trasformatore di immagine per aggiornare il digest dell'immagine:

    kustomize edit set image \
    gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229

  6. Visualizza il trasformatore di immagine 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

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

  8. Per eseguire kustomize transformer 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.

Uso: gke-deploy

gke-deploy è uno strumento a riga di comando che utilizzi con Google Kubernetes Engine (GKE). gke-deploy esegue il wrapping dello strumento a riga di comando kubectl e può modificare le risorse che crei seguendo le best practice consigliate di Google.

Se utilizzi i sottocomandi di 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 per sostituire il tag immagine di un digest e applicare il manifest espanso al tuo cluster GKE. Sebbene questo comando sia pratico, ha uno svantaggio: il tag immagine viene sostituito al momento del deployment. L'immagine associata al tag potrebbe essere cambiata tra il momento in cui hai deciso di eseguire il deployment e quello in cui ne hai eseguito il deployment, con conseguente deployment di un'immagine imprevista. Per i deployment di produzione, consigliamo passaggi separati per generare e applicare i manifest.

Per sostituire un tag immagine in un manifest di deployment Kubernetes con il digest immagine:

  1. In Cloud Shell, crea e vai a una directory per archiviare i file creati in questa sezione:

    mkdir -p ~/container-image-digests-tutorial/gke-deploy
cd ~/container-image-digests-tutorial/gke-deploy

  2. Installa gke-deploy:

    go install github.com/GoogleCloudPlatform/cloud-builders/gke-deploy@latest

  3. Crea un manifest del deployment di Kubernetes che faccia riferimento all'immagine gcr.io/google-containers/echoserver utilizzando il tag 1.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

  4. Genera un manifest espanso basato sul manifest deployment.yaml:

    gke-deploy prepare \
    --filename deployment.yaml \
    --image gcr.io/google-containers/echoserver:1.10 \
    --version 1.10

  5. 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 che hai utilizzato con il comando gke-deploy imposta il valore dell'etichetta app.kubernetes.io/version nel deployment e i metadati del modello di pod del manifest espanso.

    Per informazioni su come utilizzare gke-deploy con Cloud Build, consulta la documentazione di Cloud Build per gke-deploy.

Uso: ko

ko è uno strumento a riga di comando e una libreria per creare immagini container Go ed eseguirne il deployment nei 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 registro di immagini container o le carica nel daemon Docker locale.

Il sottocomando ko resolve esegue quanto segue:

  • Identifica le immagini da creare individuando i segnaposto nei campi image dei manifest Kubernetes che fornisci tramite l'argomento --filename.
  • Crea e pubblica le tue immagini.
  • Sostituisce i segnaposto del valore image con i nomi e le sintesi delle immagini create.
  • Stampa i manifest espansi.

I sottocomandi ko apply, create e run eseguono gli stessi passaggi di resolve e poi 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 di Kubernetes:

  1. In Cloud Shell, crea e vai a una directory per archiviare i file creati in questa sezione:

    mkdir -p ~/container-image-digests-tutorial/ko
cd ~/container-image-digests-tutorial/ko

  2. Scarica la lingua ko e aggiungila a PATH:

    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

  3. Crea un'app Go con il nome del modulo example.com/hello-world in una nuova directory denominata app:

    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

  4. Definisci il repository di immagini che ko utilizza per pubblicare le immagini:

    export KO_DOCKER_REPO=LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY

    Questo esempio utilizza Artifact Registry, ma puoi usare ko con un registro di immagini container diverso.

  5. Per creare e pubblicare un'immagine per la tua app, svolgi uno dei seguenti passaggi:

    • Crea e pubblica un'immagine per la tua app fornendo il percorso del pacchetto principale Go:

      ko build --base-import-paths ./cmd/ko-example

      L'argomento facoltativo --base-import-paths indica che ko utilizza il nome breve della directory del pacchetto principale come nome dell'immagine.

      ko stampa il nome e il digest dell'immagine in stdout nel seguente formato:

      LOCATION-docker.pkg.dev/PROJECT_ID/ko-example@sha256:DIGEST

      In questo output, DIGEST è il valore digest dell'immagine.

    • Utilizza ko per sostituire un segnaposto del manifest con il nome e il digest dell'immagine che crea e pubblica:

      1. Creare il manifest dei pod di Kubernetes. Il file manifest utilizza il segnaposto ko://IMPORT_PATH_OF_YOUR_MAIN_PACKAGE come valore del campo image:

        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

      2. Crea e pubblica un'immagine per la tua app e sostituisci il segnaposto del manifest con il nome e la sintesi dell'immagine:

        ko resolve --base-import-paths --filename ko-pod.yaml

        ko stampa il manifest con il nome dell'immagine e il digest in stdout:

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

  1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina le risorse

Se vuoi mantenere il progetto Google Cloud che hai utilizzato in questo tutorial, elimina le singole risorse:

  1. In Cloud Shell, elimina i file creati in questo tutorial:

    cd
rm -rf ~/container-image-digests-tutorial

  2. Elimina il repository di immagini container in Artifact Registry:

    gcloud artifacts repositories delete REPOSITORY \
    --location=LOCATION --async --quiet

Passaggi successivi