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

Last reviewed 2023-07-21 UTC

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

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 suivants de Google Cloud :

• Artifact Registry

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

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. 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.

   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. Make sure that billing is enabled for your Google Cloud project.

3. Enable the Artifact Registry API.

   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'éviter la facturation consiste à supprimer le projet Google Cloud que vous avez créé pour le 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