Utilizzo di digest delle immagini container nei manifest di Kubernetes

Last reviewed 2023-07-21 UTC

Questo tutorial mostra gli sviluppatori e gli operatori che eseguono il deployment dei container in Kubernetes utilizza i digest delle immagini container per identificare le immagini container. R il digest delle immagini container identifica in modo univoco e immutabile un'immagine container.

Il deployment delle immagini container utilizzando il digest delle immagini offre diversi vantaggi rispetto all'uso dei tag immagine. Per ulteriori informazioni sulle sintesi delle immagini, vedi il documento di accompagnamento utilizzando digest delle immagini container prima di continuare questo tutorial.

L'argomento image per i container in una specifica di pod Kubernetes accetta con sintesi. Questo argomento si applica ovunque utilizzi un pod ad esempio nella sezione template del deployment, StatefulSet Risorse DaemonSet, ReplicaSet, CronJob e Job.

Per eseguire il deployment di un'immagine mediante il digest, utilizza il nome dell'immagine, seguito da @sha256: e il valore del digest. Di seguito è riportato un esempio di 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'utilizzo delle sintesi delle immagini è che non conosci il valore del digest finché l'immagine non viene pubblicata in un registry. Man mano che crei nuove immagini, il valore del digest cambia e ti serve un modo per aggiornare i manifest Kubernetes ogni volta che esegui il deployment.

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

Consigli

Questo documento illustra diversi modi per utilizzare le sintesi delle immagini i deployment Kubernetes. Gli strumenti descritti in questo documento sono complementari. Ad esempio, puoi utilizzare l'output di una funzione kpt con kustomize per e creare varianti per diversi ambienti. Lo skaffold può creare immagini utilizzando ko ed eseguire il deployment delle immagini nei cluster Kubernetes utilizzando kubectl o kpt.

Il motivo per cui questi strumenti sono complementari è il fatto che modifiche strutturate in base alla Modello di risorse di Kubernetes (KRM). Questo modello rende gli strumenti collegabili in modo da consentirti di evolvere l'uso degli strumenti per creare processi e pipeline che ti aiutano a eseguire il deployment delle tue app e dei tuoi servizi.

Per iniziare, consigliamo l'approccio più adatto alle esigenze delle strumenti e processi:

  • Skaffold può aggiungere digest ai riferimenti alle immagini. Attiva questa opzione con una piccola modifica alla configurazione. L'adozione di Skaffold fornisce vantaggi aggiuntivi, come l'astrazione del modo in cui i diversi strumenti creano il deployment delle immagini container.

  • Utilizzando lo strumento digest come webhook di ammissione mutante nel tuo Kubernetes, puoi aggiungere digest a tutti i tuoi deployment con un impatto minimo sui tuoi attuali processi di creazione e deployment immagini container. Il webhook di gestione semplifica anche l'adozione Autorizzazione binaria, perché richiede solo l'aggiunta di un'etichetta a uno spazio dei nomi.

  • kpt è un'ottima opzione se ti serve uno strumento flessibile di Kubernetes. Lo strumento di digestione può essere utilizzato come client Funzione KRM in un pipeline kpt.

  • Se utilizzi già kustomize per gestire i manifest Kubernetes in ambienti cloud, ti consigliamo di sfruttare la sua capacità per il deployment delle immagini in base al digest.

  • ko è un ottimo modo per creare e pubblicare immagini per le app Go usati da progetti open source come Knative, Tekton e sigstore.

Se non utilizzi nessuno degli strumenti descritti in questo documento, ti consigliamo di: si inizia con Skaffold e il webhook di gestione. Skaffold è uno strumento comune utilizzata sia dagli sviluppatori che dai team di rilascio, e si integra con descritti in questo tutorial. Puoi sfruttare i vantaggi dell'integrazione le opzioni man mano che i requisiti si evolvono. Il webhook Kubernetes digester completa Skaffold abilitando i deployment basati su digest per un'intera in un cluster Kubernetes.

Obiettivi

  • Utilizza Skaffold per creare un'immagine ed eseguirne il push e per inserire il nome dell'immagine e digest in un manifest Kubernetes.
  • Utilizza la funzione digest lato client e il webhook di ammissione mutante da aggiungere digest alle immagini in pod e modelli di pod Kubernetes.
  • Utilizza kpt setters per sostituire un tag immagine in un manifest Kubernetes con un digest di un'immagine.
  • Usa kustomize per generare un manifest Kubernetes con un digest di immagini.
  • Utilizza gke-deploy per risolvere un tag immagine in un digest in un Kubernetes del file manifest.
  • Usa ko per creare ed eseguire il push di un'immagine, nonché per inserire il nome e digest in un manifest Kubernetes.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

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

  3. Attiva l'API Artifact Registry.

    Abilita l'API

  4. In the Google Cloud console, activate Cloud Shell.

    Activate 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 un repository attendibile, ad esempio digest-tutorial.
    • LOCATION: un Posizione Artifact Registry, ad esempio us-central1.

  7. Configura l'autenticazione nella località Artifact Registry per l'interfaccia a riga di comando usati 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 le applicazioni ai cluster Kubernetes.

Utilizzare Skaffold per creare un'immagine, eseguirne il push ad Artifact Registry e sostituisci il valore del segnaposto image in un modello manifest di Kubernetes con nome, tag e digest dell'immagine trasferita:

  1. In Cloud Shell, crea e vai a una directory in cui archiviare che crei 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 un nome immagine segnaposto. Skaffold cerca questo segnaposto nel manifest di input .

    La sezione manifests indica a Skaffold di leggere un manifest di input dal la directory attuale 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 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 segnaposto skaffold-example nel campo image corrisponde il valore del campo image nel file skaffold.yaml. Skaffold sostituisce questo valore segnaposto con il nome completo dell'immagine e il digest nel con il rendering dell'output.

  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 salva lo Skaffold informazioni sull'immagine creata, incluso il valore del digest.
    • Il flag --push indica a Skaffold di eseguire il push dell'immagine creata al Container Image Registry specificato dal flag --default-repo.
    • I flag --interactive e --update-check sono entrambi impostati su false. Imposta questi flag su false in ambienti non interattivi, come creare le pipeline, ma lasciarli come valori predefiniti (true per entrambi i flag) per lo sviluppo locale.

    Se utilizzi Cloud Deploy per il deployment su GKE, utilizza dal flag --file-output come valore dell'attributo --build-artifacts segnala quando crea una release.

  8. Esegui il rendering del manifest Kubernetes espanso con il nome, il tag e il digest di l'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 dalla skaffold build nel passaggio precedente.
    • Il flag --digest-source=none indica che Skaffold utilizza il digest del file fornito nel flag --build-artifacts, del digest del registro delle immagini container.
    • Il flag --offline=true significa che puoi eseguire il comando senza richiedono l'accesso a un cluster Kubernetes.
    • Il flag --output specifica il file di output per l'elemento del file manifest.

  9. Visualizza il manifest sottoposto a rendering:

    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'account dell'immagine.
    • DIGEST: il valore del digest dell'immagine

Utilizzo di Digest

Direttore aggiunge digest alle immagini container e di inizializzazione dei container in pod e pod Kubernetes specifiche del modello. Digester sostituisce i riferimenti alle immagini container che utilizzano :

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

Con i 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 ambiente Kubernetes o come lato client Funzione KRM con gli strumenti a riga di comando kpt o kustomize.

Utilizzo della funzione KRM digerente

  1. In Cloud Shell, crea e vai a una directory in cui archiviare che crei in questa sezione:

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

  2. Scarica il file 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 Kubernetes che fa riferimento all'immagine gcr.io/google-containers/echoserver con 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 digester utilizzando kpt con i manifest nel directory attuale (.):

    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 la console e non modificare il file manifest, aggiungi --output unwrap flag.

  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 in cui archiviare che crei in questa sezione:

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

  2. Creare un cluster Kubernetes locale utilizzando kind:

    kind create cluster

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

  3. Esegui il deployment del webhook di 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 a digester-demo spazio dei nomi:

    kubectl label namespace digester-demo digest-resolution=enabled

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

  6. Crea un manifest di deployment Kubernetes che fa riferimento all'immagine gcr.io/google-containers/echoserver con 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 inviare il nome dell'immagine al 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 digest ha aggiunto il digest immagine alla la specifica del modello di pod nella risorsa Deployment.

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

    kind delete cluster

Utilizzare kpt setter

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

Puoi utilizzare le funzioni KRM create-setters e apply-setters dalla Catalogo funzioni kpt per aggiornare le digest delle immagini nei tuoi manifest Kubernetes quando crei in formato Docker.

  1. In Cloud Shell, crea e vai a una directory in cui archiviare che crei 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 Kubernetes che fa riferimento all'immagine gcr.io/google-containers/echoserver con 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 del 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 sul posto Valore del campo image nel file 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 dei trasformatori di immagini kustomize

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

Puoi usare il comando kubestomize trasformatore di immagini per aggiornare il nome, il tag e il digest dell'immagine nel file manifest esistente.

Il seguente snippet kustomization.yaml mostra come configurare l'immagine transformer per utilizzare il valore digest di transformer per le immagini in cui il pod il valore della specifica image corrisponde al valore name del trasformatore:

images:
- name: gcr.io/google-containers/echoserver
  digest: sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229

Per usare un trasformatore di immagini kustomize con un digest di immagini, esegui la seguenti:

  1. In Cloud Shell, crea e vai a una directory in cui archiviare che crei 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 di pod che fa riferimento l'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 immagini per aggiornare il digest dell'immagine:

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

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

  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 il trasformatore kustomize e applicare il manifest risultante a un Kubernetes in un solo passaggio, puoi usare il comando kubectl apply con il flag --kustomize:

    kubectl apply --kustomize .

    Se vuoi applicare l'output in un secondo momento, puoi reindirizzarlo il comando kustomize build in un file.

Uso: gke-deploy

gke-deploy è uno strumento a riga di comando che puoi usare Google Kubernetes Engine (GKE). gke-deploy aggrega lo strumento a riga di comando kubectl e può modificare che crei seguendo le pratiche consigliate da Google.

Se utilizzi i sottocomandi gke-deploy prepare o run, gke-deploy risolve i tag immagine nei digest e salva i manifest espansi con digest dell'immagine nel file output/expanded/aggregated-resources.yaml per predefinito.

Puoi utilizzare gke-deploy run per sostituire il tag immagine con un digest e e applicare il manifest espanso al cluster GKE. Sebbene questo comando è pratico, c'è uno svantaggio: il tag immagine viene sostituito i tempi di deployment. L'immagine associata al tag potrebbe essere stata modificata nella di tempo che intercorre tra quando hai deciso di eseguire il deployment e quando ne hai eseguito il deployment, ottenendo il deployment di un'immagine imprevista. Per i deployment di produzione, consigliamo di usare i passaggi per la generazione e l'applicazione dei manifest.

Per sostituire un tag immagine in un manifest di deployment di Kubernetes con l'immagine digest, procedi nel seguente modo:

  1. In Cloud Shell, crea e vai a una directory in cui archiviare che crei 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 di deployment Kubernetes che fa riferimento all'immagine gcr.io/google-containers/echoserver con 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 file 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 file manifest espanso, il tag immagine viene sostituito dal digest.

    L'argomento --version che hai utilizzato con il comando gke-deploy imposta la valore di l'etichetta app.kubernetes.io/version nei metadati del deployment e del modello di pod del manifest espanso.

    Per scoprire 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 Vai containerizzate e il loro deployment in cluster Kubernetes. ko crea immagini senza utilizzare il daemon Docker, quindi puoi usarlo in ambienti in cui non può installare Docker.

Il sottocomando ko build crea immagini e le pubblica in un registro di immagini container oppure le carica nel tuo daemon Docker locale.

Il sottocomando ko resolve svolge le seguenti operazioni:

  • Identifica le immagini da creare individuando segnaposto in image e campi dei manifest di Kubernetes che fornisci utilizzando --filename argomento.
  • Crea e pubblica le tue immagini.
  • Sostituisce i segnaposto dei valori image con i nomi e le sintesi di le immagini che ha creato.
  • Stampa i manifest espansi.

I sottocomandi ko apply, create e run eseguire gli stessi passaggi di resolve, quindi eseguire 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, segui questi passaggi

  1. In Cloud Shell, crea e vai a una directory in cui archiviare che crei in questa sezione:

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

  2. Scarica ko e aggiungilo 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 app directory chiamata 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 Container Image Registry.

  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 al tuo Go pacchetto principale:

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

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

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

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

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

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

      1. Creare il manifest di un pod di Kubernetes. Il file manifest utilizza 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 segnaposto del file manifest con il nome dell'immagine e il digest:

        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 digest dell'immagine valore.

Esegui la pulizia

Il modo più semplice per eliminare la fatturazione è quello di eliminare il progetto Google Cloud che hai creato per il tutorial. In alternativa, puoi eliminare il singolo Google Cloud.

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