Utiliser des condensés d'image de conteneur dans les fichiers manifestes Kubernetes

Ce tutoriel montre aux développeurs et aux opérateurs qui déploient des conteneurs dans Kubernetes comment utiliser des condensés d'image de conteneur pour identifier les images de conteneurs. Un condensé d'image de conteneur permet d'identifier de manière unique et immuable une image de conteneur.

Le déploiement d'images de conteneurs à l'aide d'un condensé d'image offre plusieurs avantages par rapport aux tags d'image. Pour plus d'informations sur les condensés d'images, consultez le document d'accompagnement sur l'utilisation des condensés d'images de conteneurs avant de poursuivre ce tutoriel.

L'argument image pour les conteneurs dans une spécification de pod Kubernetes accepte les images avec des condensés. Cet argument s'applique partout où vous utilisez une spécification de pod, par exemple dans la section template des ressources Deployment, StatefulSet, DaemonSet, ReplicaSet, CronJob et Job.

Pour déployer une image à l'aide du condensé, utilisez le nom de l'image, suivi de @sha256: et de la valeur du condensé. Voici un exemple de ressource Deployment qui utilise une image avec un condensé. Un déploiement est un objet de l'API Kubernetes qui vous permet d'exécuter plusieurs instances dupliquées de pods répartis entre les nœuds d'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

L'un des inconvénients de l'utilisation de condensés d'images est de ne pas connaître la valeur du condensé tant que vous n'avez pas publié votre image dans un registre. Lorsque vous créez des images, la valeur du condensé change et vous avez besoin d'un moyen de mettre à jour vos fichiers manifestes Kubernetes à chaque déploiement.

Ce tutoriel explique comment utiliser des outils tels que Skaffold, kpt, digester, kustomize, gke-deploy et ko pour utiliser des condensés d'image dans vos fichiers manifestes.

Recommandations

Ce document décrit plusieurs manières d'utiliser les condensés d'images dans des déploiements Kubernetes. Les outils décrits dans ce document sont complémentaires. Par exemple, vous pouvez utiliser le résultat d'une fonction kpt avec kustomize afin de créer des variantes pour différents environnements. Skaffold peut créer des images à l'aide de ko et les déployer sur vos clusters Kubernetes à l'aide de kubectl ou de kpt.

Les outils sont complémentaires parce qu'ils effectuent des modifications structurées basées sur le modèle de ressource Kubernetes (KRM). Ce modèle rend les outils connectables, et vous pouvez adapter votre utilisation des outils pour créer des processus et des pipelines qui vous aident à déployer vos applications et services.

Pour commencer, nous vous recommandons de choisir l'approche qui fonctionne le mieux avec vos outils et processus existants :

  • Skaffold peut ajouter des condensés aux références d'images. Vous activez cette fonction avec une petite modification de configuration. L'adoption de Skaffold offre des avantages supplémentaires, tels que l'abstraction de la manière dont différents outils créent et déploient des images de conteneurs.

  • En utilisant l'outil de condensé comme webhook d'admission de mutation dans vos clusters Kubernetes, vous pouvez ajouter des condensés à tous vos déploiements avec un impact minimal sur vos processus actuels de création et de déploiement d'images de conteneurs. Le webhook de condensé simplifie également l'adoption de l'autorisation binaire, car il ne nécessite qu'un libellé à ajouter à un espace de noms.

  • kpt est une excellente option si vous avez besoin d'un outil flexible pour manipuler des fichiers manifestes Kubernetes. L'outil digester peut être utilisé en tant que fonction KRM côté client dans un pipeline kpt.

  • Si vous utilisez déjà Kustomize pour gérer les fichiers manifestes Kubernetes dans différents environnements, nous vous recommandons d'exploiter ses transformateurs d'images pour déployer des images par condensé.

  • ko est un excellent moyen de créer et de publier des images pour les applications Go. Il est utilisé par des projets Open Source tels que Knative, Tekton et sigstore.

Si vous n'utilisez aucun des outils décrits dans ce document, nous vous recommandons de commencer par Skaffold et le webhook de condensé. Skaffold est un outil courant utilisé par les équipes de développement et de publication. Il s'intègre aux autres outils décrits dans ce tutoriel. Vous pouvez utiliser ces options d'intégration à mesure que vos besoins évoluent. Le webhook de Kubernetes de condensé est destiné à compléter Skaffold en activant les déploiements par condensé pour l'ensemble d'un cluster.

Utiliser Skaffold

Skaffold est un outil de ligne de commande permettant le développement et le déploiement continus d'applications sur des clusters Kubernetes.

Utilisez Skaffold pour créer une image, transférer l'image vers Artifact Registry et remplacer la valeur de l'espace réservé image dans un modèle de fichier manifeste Kubernetes par le nom et le condensé de l'image transférée :

  1. Dans Cloud Shell, créez et accédez à un répertoire pour stocker les fichiers que vous créez dans cette section :

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

  2. Clonez le dépôt Git Skaffold :

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

  3. Accédez au répertoire de l'exemple getting-started :

    cd skaffold/examples/getting-started

  4. Vérifiez le tag Git qui correspond à votre version de Skaffold :

    git checkout $(skaffold version)

  5. Affichez le fichier de configuration skaffold.yaml :

    cat skaffold.yaml

    Le fichier se présente comme suit:

    apiVersion: skaffold/v4beta6
kind: Config
build:
  artifacts:
  - image: skaffold-example
manifests:
  rawYaml:
  - k8s-pod.yaml

    La section build.artifacts contient un nom d'image pour l'espace réservé. Skaffold recherche cet espace réservé dans les fichiers manifestes d'entrée.

    La section manifests indique à Skaffold de lire un fichier manifeste d'entrée du répertoire actuel nommé k8s-pod.yaml.

    Pour en savoir plus sur toutes les options disponibles, consultez la documentation de référence skaffold.yaml.

  6. Affichez le modèle de fichier manifeste Kubernetes :

    cat k8s-pod.yaml

    Le fichier est le suivant :

    apiVersion: v1
kind: Pod
metadata:
  name: getting-started
spec:
  containers:
  - name: getting-started
    image: skaffold-example

    La valeur de l'espace réservé skaffold-example du champ image correspond à la valeur du champ image du fichier skaffold.yaml. Skaffold remplace la valeur de cet espace réservé par le nom complet de l'image et le condensé dans le résultat affiché.

  7. Créez et transférez l'image vers Artifact Registry :

    skaffold build \
    --default-repo=LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY \
    --file-output=artifacts.json \
    --interactive=false \
    --push=true \
    --update-check=false

    Cette commande utilise les options suivantes :

    • L'option --file-output spécifie le fichier dans lequel Skaffold enregistre les informations sur l'image compilée, y compris la valeur de condensé.
    • L'option --push indique à Skaffold de transférer l'image compilée vers le registre d'images de conteneur spécifié par l'option --default-repo.
    • Les options --interactive et --update-check sont toutes deux définies sur false. Définissez ces options sur false dans des environnements non interactifs, tels que des pipelines de compilation, mais conservez leurs valeurs par défaut (true pour les deux options) pour le développement local.

    Si vous déployez avec GKE à l'aide de Cloud Deploy, utilisez le fichier de l'option --file-output comme valeur de l'option --build-artifacts lorsque vous créez une version.

  8. Affichez le fichier manifeste Kubernetes développé avec le nom, le tag et le condensé de l'image de conteneur de l'étape précédente :

    skaffold render \
    --build-artifacts=artifacts.json \
    --digest-source=none \
    --interactive=false \
    --offline=true \
    --output=rendered.yaml \
    --update-check=false

    Cette commande utilise les options suivantes :

    • L'option --build-artifacts référence le fichier de sortie de la commande skaffold build à l'étape précédente.
    • L'option --digest-source=none signifie que Skaffold utilise la valeur de condensé du fichier fourni dans l'option --build-artifacts au lieu de résoudre le condensé à partir du registre d'images de conteneurs.
    • L'argument --offline=true signifie que vous pouvez exécuter la commande sans exiger l'accès à un cluster Kubernetes.
    • L'option --output spécifie le fichier de sortie du fichier manifeste rendu.

  9. Affichez le fichier manifeste rendu :

    cat rendered.yaml

    Le résultat se présente comme suit :

    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

    Dans ce résultat, les valeurs suivantes s'affichent :

    • TAG : tag que Skaffold a attribué à l'image.
    • DIGEST : valeur du condensé de l'image

Utiliser le condensé

Digester ajoute des condensés aux images de conteneurs et d'initialisation du conteneur dans les spécifications du modèle de pod et de pod Kubernetes. Digester remplace les références d'image de conteneur qui utilisent des tags:

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

Avec des références utilisant le condensé de l'image:

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

Digester peut être exécuté en tant que webhook d'admission de mutation dans un cluster Kubernetes ou en tant que fonction KRM côté client avec les outils de ligne de commande kpt ou kustomize.

Utiliser la fonction KRM du condensé

  1. Dans Cloud Shell, créez et accédez à un répertoire pour stocker les fichiers que vous créez dans cette section :

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

  2. Téléchargez le binaire du condensé:

    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. Créez un fichier manifeste de pod Kubernetes qui référence l'image gcr.io/google-containers/echoserver à l'aide du 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. Exécutez la fonction KRM du condensé en utilisant kpt avec les fichiers manifestes du répertoire actuel (.):

    kpt fn eval . --exec digester

    Lorsque vous exécutez cette commande, kpt effectue une mise à jour sur place des fichiers manifestes dans le répertoire actuel. Si vous souhaitez que kpt affiche le fichier manifeste mis à jour sur la console et ne pas modifier le fichier manifeste, ajoutez l'option --output unwrap.

  5. Affichez le fichier manifeste mis à jour:

    cat pod.yaml

    Le fichier est le suivant :

    apiVersion: v1
kind: Pod
metadata:
  name: echo
spec:
  containers:
    - name: echoserver
      image: gcr.io/google-containers/echoserver:1.10@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
      ports:
        - containerPort: 8080

Utiliser le webhook d'admission du condensé

  1. Dans Cloud Shell, créez et accédez à un répertoire pour stocker les fichiers que vous créez dans cette section :

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

  2. Créez un cluster Kubernetes local à l'aide de kind :

    kind create cluster

    kind est un outil de ligne de commande qui permet d'exécuter des clusters Kubernetes locaux à l'aide de Docker.

  3. Déployez le webhook de condensé:

    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. Créez un espace de noms Kubernetes nommé digester-demo dans le cluster Kind :

    kubectl create namespace digester-demo

  5. Ajoutez le libellé digest-resolution: enabled à l'espace de noms digester-demo:

    kubectl label namespace digester-demo digest-resolution=enabled

    Le webhook de condensé ajoute des condensés aux pods dans les espaces de noms portant ce libellé.

  6. Créez un fichier manifeste de déploiement Kubernetes qui référence l'image gcr.io/google-containers/echoserver à l'aide du 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. Appliquez le fichier manifeste dans l'espace de noms digester-demo:

    kubectl apply --filename deployment.yaml --namespace digester-demo \
    --output jsonpath='{.spec.template.spec.containers[].image}{"\n"}'

    L'option --output demande à kubectl de générer le nom de l'image dans la console, suivi d'un caractère de nouvelle ligne. Le résultat est le suivant :

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

    Ce résultat indique que le webhook de condensé a ajouté le condensé d'image à la spécification de modèle de pod dans la ressource de déploiement.

  8. Supprimez le cluster kind pour libérer des ressources dans votre session Cloud Shell:

    kind delete cluster

Utiliser la méthode kpt setters

kpt est un outil de ligne de commande permettant de gérer, manipuler, personnaliser et appliquer des fichiers manifestes de ressources Kubernetes.

Vous pouvez utiliser les fonctions KRM create-setters et apply-setters du catalogue des fonctions Kpt pour mettre à jour les condensés d'images dans vos fichiers manifestes Kubernetes lorsque vous créez de nouvelles images.

  1. Dans Cloud Shell, créez et accédez à un répertoire pour stocker les fichiers que vous créez dans cette section :

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

  2. Créez un package kpt dans le répertoire actuel:

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

  3. Créez un fichier manifeste de pod Kubernetes qui référence l'image gcr.io/google-containers/echoserver à l'aide du 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. Utilisez kpt pour créer un setter nommé echoimage pour le champ "manifest", où la valeur existante est 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. Affichez le fichier manifeste :

    cat pod.yaml

    Le fichier est le suivant :

    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. Obtenez la valeur du condensé de l'image de conteneur:

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

  7. Définissez la nouvelle valeur de champ :

    kpt fn eval . \
    --image gcr.io/kpt-fn/apply-setters@sha256:4d4295727183396f0c3c6a75d2560254c2f9041a39e95dc1e5beffeb49cc1a12 \
    -- "echoimage=gcr.io/google-containers/echoserver:1.10@$DIGEST"

    Lorsque vous exécutez cette commande, kpt effectue un remplacement sur place de la valeur du champ image dans le fichier manifeste.

  8. Affichez le fichier manifeste mis à jour:

    cat pod.yaml

    Le fichier est le suivant :

    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

Utiliser les transformateurs d'images Kustomize

kustomize est un outil de ligne de commande qui vous permet de personnaliser les fichiers manifestes Kubernetes à l'aide de superpositions, de correctifs et de transformateurs.

Vous pouvez utiliser le transformateur d'images kustomize pour mettre à jour le nom, le tag et le condensé de l'image dans votre fichier manifeste existant.

L'extrait de code kustomization.yaml suivant montre comment configurer le transformateur d'image pour utiliser la valeur de transformateur digest des images dont la valeur de spécification du pod image correspond à la valeur name du transformateur :

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

Pour utiliser un transformateur d'image kustomize avec un condensé d'image, procédez comme suit :

  1. Dans Cloud Shell, créez et accédez à un répertoire pour stocker les fichiers que vous créez dans cette section :

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

  2. Créez un fichier kustomization.yaml :

    kustomize init

  3. Créez un fichier manifeste Kubernetes avec une spécification de pod faisant référence à l'image gcr.io/google-containers/echoserver à l'aide du 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. Ajoutez le fichier manifeste en tant que ressource dans le fichier kustomization.yaml :

    kustomize edit add resource pod.yaml

  5. Utilisez un transformateur d'image pour mettre à jour le condensé de l'image :

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

  6. Affichez le transformateur de l'image dans le fichier kustomization.yaml :

    cat kustomization.yaml

    Le fichier est le suivant :

    apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
- pod.yaml
images:
- digest: sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
  name: gcr.io/google-containers/echoserver

  7. Affichez le fichier manifeste obtenu :

    kustomize build .

    Le résultat est le suivant :

    apiVersion: v1
kind: Pod
metadata:
  name: echo
spec:
  containers:
  - image: gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
    name: echoserver
    ports:
    - containerPort: 8080

  8. Pour exécuter le transformateur Kustomize et appliquer le fichier manifeste obtenu à un cluster Kubernetes en une seule étape, vous pouvez utiliser la commande kubectl apply avec l'option --kustomize :

    kubectl apply --kustomize .

    Si vous souhaitez appliquer le résultat ultérieurement, vous pouvez rediriger le résultat de la commande kustomize build vers un fichier.

Utiliser un fichier de cookie (gke-deploy)

gke-deploy est un outil de ligne de commande que vous utilisez avec Google Kubernetes Engine (GKE). gke-deploy encapsule l'outil de ligne de commande kubectl et peut modifier les ressources que vous créez en suivant les pratiques recommandées par Google.

Si vous utilisez les sous-commandes gke-deploy prepare ou run, gke-deploy convertit vos tags d'image en condensés et enregistre les fichiers manifestes étendus avec les condensés d'image dans le fichier output/expanded/aggregated-resources.yaml par défaut.

Vous pouvez utiliser gke-deploy run pour remplacer le tag d'image d'un condensé et appliquer le fichier manifeste développé à votre cluster GKE. Bien que cette commande soit pratique, il existe un inconvénient : le tag d'image est remplacé au moment du déploiement. L'image associée au tag peut avoir changé entre le moment où vous avez décidé de la déployer et lors de son déploiement, ce qui entraîne le déploiement d'une image inattendue. Pour les déploiements de production, nous recommandons de suivre des étapes distinctes pour générer et appliquer les fichiers manifestes.

Pour remplacer un tag d'image dans un fichier manifeste de déploiement Kubernetes par le condensé d'image, procédez comme suit :

  1. Dans Cloud Shell, créez et accédez à un répertoire pour stocker les fichiers que vous créez dans cette section :

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

  2. Installez gke-deploy :

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

  3. Créez un fichier manifeste de déploiement Kubernetes qui référence l'image gcr.io/google-containers/echoserver à l'aide du 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. Générez un fichier manifeste développé basé sur le fichier manifeste deployment.yaml:

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

  5. Affichez le fichier manifeste développé :

    cat output/expanded/aggregated-resources.yaml

    Le résultat est le suivant :

    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

    Dans le fichier manifeste développé, le tag d'image est remplacé par le condensé.

    L'argument --version que vous avez utilisé avec la commande gke-deploy définit la valeur de l'étiquette app.kubernetes.io/version dans le déploiement et dans les métadonnées du modèle de pod du fichier manifeste développé.

    Pour apprendre à utiliser gke-deploy avec Cloud Build, consultez la documentation Cloud Build pour gke-deploy.

Utiliser un fichier de cookie (ko)

ko est un outil de ligne de commande et une bibliothèque permettant de créer des images de conteneurs Go et de les déployer sur des clusters Kubernetes. ko crée des images sans utiliser le daemon Docker. Vous pouvez donc l'utiliser dans des environnements où vous ne pouvez pas installer Docker.

La sous-commande ko build crée des images et les publie dans un registre d'images de conteneurs ou les charge dans votre daemon Docker local.

La sous-commande ko resolve effectue les opérations suivantes :

  • Identifie les images à créer en recherchant des espaces réservés dans les champs image des fichiers manifestes Kubernetes que vous fournissez à l'aide de l'argument --filename.
  • Crée et publie vos images.
  • Remplace les espaces réservés de la valeur image par les noms et les condensés des images qu'elle a créées.
  • Affiche les fichiers manifestes développés.

Les sous-commandes ko apply, create et run effectuent les mêmes étapes que resolve, puis exécutent kubectl apply, create ou run avec les fichiers manifestes développés.

Pour créer une image à partir d'un code source Go, puis ajouter le condensé de l'image à un fichier manifeste de déploiement Kubernetes, procédez comme suit :

  1. Dans Cloud Shell, créez et accédez à un répertoire pour stocker les fichiers que vous créez dans cette section :

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

  2. Téléchargez ko et ajoutez-le à votre 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. Créez une application Go avec le nom de module example.com/hello-world dans un nouveau répertoire nommé 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. Définissez le dépôt d'images utilisé par ko pour publier des images :

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

    Cet exemple utilise Artifact Registry, mais vous pouvez utiliser ko avec un autre registre d'images de conteneurs.

  5. Pour créer et publier une image pour votre application, effectuez l'une des opérations suivantes :

    • Créez et publiez une image pour votre application en indiquant le chemin d'accès à votre package principal Go :

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

      L'argument facultatif --base-import-paths signifie que ko utilise le nom court du répertoire du package principal comme nom de l'image.

      ko renvoie le nom et le condensé de l'image à stdout au format suivant :

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

      Dans ce résultat, DIGEST correspond à la valeur du condensé de l'image.

    • Utilisez ko pour remplacer un espace réservé du fichier manifeste par le nom et le condensé de l'image créée et publiée :

      1. Créez un fichier manifeste de pod Kubernetes. Le fichier manifeste utilise l'espace réservé ko://IMPORT_PATH_OF_YOUR_MAIN_PACKAGE comme valeur du champ 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. Créez et publiez une image pour votre application, et remplacez l'espace réservé du fichier manifeste par le nom et le condensé de l'image :

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

        ko renvoie le fichier manifeste avec le nom et le condensé de l'image dans 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

        Dans ce résultat, DIGEST correspond à la valeur du condensé de l'image.