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

Autopilot Standard

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.

Objectifs

• Utilisez Skaffold pour créer et transférer une image, et insérer le nom de l'image et le condensé dans un fichier manifeste Kubernetes.
• Utilisez la fonction de condensé côté client et le webhook d'admission de mutation pour ajouter des condensés aux images dans les pods Kubernetes et les modèles de pods.
• Utilisez des setters kpt pour remplacer un tag d'image dans un fichier manifeste Kubernetes par un condensé d'image.
• Utilisez Kustomize pour générer un fichier manifeste Kubernetes avec un condensé d'images.
• Utilisez la fonction gke-deploy pour convertir un tag d'image en un condensé dans un fichier manifeste Kubernetes.
• Utilisez ko pour créer et transférer une image, et insérer le nom de l'image et le condensé dans un fichier manifeste Kubernetes.

Coûts

Dans ce document, vous utilisez les composants facturables de Google Cloudsuivants :

• Artifact Registry

Vous pouvez obtenir une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai sans frais.

Une fois que vous avez terminé les tâches décrites dans ce document, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

2. Verify that billing is enabled for your Google Cloud project.

3. Enable the Artifact Registry API.

   Roles required to enable APIs

   To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

   Enable the API

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

   Activate Cloud Shell

5. Dans Cloud Shell, définissez le projet par défaut pour Google Cloud CLI :

   gcloud config set project PROJECT_ID
   

   Remplacez PROJECT_ID par l'ID de votre projet.

6. Créez un dépôt d'images de conteneurs dans Artifact Registry :

   gcloud artifacts repositories create REPOSITORY \
       --location=LOCATION \
       --repository-format=docker
   

   Remplacez les éléments suivants :

   • REPOSITORY : nom que vous souhaitez utiliser pour votre dépôt, par exemple digest-tutorial.
   • LOCATION : emplacement Artifact Registry, par exemple us-central1.

7. Configurez l'authentification sur l'emplacement Artifact Registry pour les outils CLI utilisés dans ce tutoriel :

   gcloud auth configure-docker LOCATION-docker.pkg.dev
   

   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.

        Remarque : Tout autre résultat ko est transmis à stderr. Si vous souhaitez capturer le nom et le condensé de l'image, vous pouvez capturer stdout dans une variable d'environnement :

        IMAGE_AND_DIGEST=$(ko build --base-import-paths ./cmd/ko-example)
        

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

   Effectuer un nettoyage

   Le moyen le plus simple d'empêcher la facturation est de supprimer le Google Cloud projet que vous avez créé pour ce tutoriel. Vous pouvez également supprimer les différentes ressources.

   Supprimer le projet

   Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :
   • Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
   • Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.
   1. In the Google Cloud console, go to the Manage resources page.

      Go to Manage resources

   2. In the project list, select the project that you want to delete, and then click Delete.
   3. In the dialog, type the project ID, and then click Shut down to delete the project.

   Supprimer les ressources

   Si vous souhaitez conserver le projet Google Cloud que vous avez utilisé dans ce tutoriel, supprimez les différentes ressources :

   1. Dans Cloud Shell, supprimez les fichiers que vous avez créés dans ce tutoriel :

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

   2. Supprimez le dépôt d'images de conteneurs dans Artifact Registry :

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

   Étapes suivantes

   • Documentez-vous sur les condensés d'image de conteneur.
   • En savoir plus sur la fonction KRM côté client de condensé et le webhook de mutation Kubernetes
   • Apprenez-en davantage sur la livraison continue de type GitOps avec Cloud Build