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 :
Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.
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
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Vérifiez que la facturation est activée pour votre projet Google Cloud.
-
Activez l'API Artifact Registry
-
In the Google Cloud console, activate Cloud Shell.
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.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 exempledigest-tutorial
.LOCATION
: emplacement Artifact Registry, par exempleus-central1
.
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 :
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
Clonez le dépôt Git Skaffold :
git clone https://github.com/GoogleContainerTools/skaffold.git
Accédez au répertoire de l'exemple
getting-started
:cd skaffold/examples/getting-started
Vérifiez le tag Git qui correspond à votre version de Skaffold :
git checkout $(skaffold version)
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
.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 champimage
correspond à la valeur du champimage
du fichierskaffold.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é.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 surfalse
. Définissez ces options surfalse
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.- L'option
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 commandeskaffold 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.
- L'option
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é
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
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
Créez un fichier manifeste de pod Kubernetes qui référence l'image
gcr.io/google-containers/echoserver
à l'aide du tag1.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
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
.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é
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
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.
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 -
Créez un espace de noms Kubernetes nommé
digester-demo
dans le cluster Kind :kubectl create namespace digester-demo
Ajoutez le libellé
digest-resolution: enabled
à l'espace de nomsdigester-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é.
Créez un fichier manifeste de déploiement Kubernetes qui référence l'image
gcr.io/google-containers/echoserver
à l'aide du tag1.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
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.
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.
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
Créez un package kpt dans le répertoire actuel:
kpt pkg init --description "Container image digest tutorial"
Créez un fichier manifeste de pod Kubernetes qui référence l'image
gcr.io/google-containers/echoserver
à l'aide du tag1.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
Utilisez kpt pour créer un setter nommé
echoimage
pour le champ "manifest", où la valeur existante estgcr.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"
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
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)')
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.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 :
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
Créez un fichier
kustomization.yaml
:kustomize init
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 tag1.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
Ajoutez le fichier manifeste en tant que ressource dans le fichier
kustomization.yaml
:kustomize edit add resource pod.yaml
Utilisez un transformateur d'image pour mettre à jour le condensé de l'image :
kustomize edit set image \ gcr.io/google-containers/echoserver@sha256:cb5c1bddd1b5665e1867a7fa1b5fa843a47ee433bbb75d4293888b71def53229
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
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
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 :
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
Installez
gke-deploy
:go install github.com/GoogleCloudPlatform/cloud-builders/gke-deploy@latest
Créez un fichier manifeste de déploiement Kubernetes qui référence l'image
gcr.io/google-containers/echoserver
à l'aide du tag1.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
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
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 commandegke-deploy
définit la valeur de l'étiquetteapp.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 pourgke-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 :
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
Téléchargez
ko
et ajoutez-le à votrePATH
: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
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
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.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 queko
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 :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 champimage
: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
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 dansstdout
: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
- Dans la console Google Cloud, accédez à la page Gérer les ressources.
- Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
- Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.
Supprimer les ressources
Si vous souhaitez conserver le projet Google Cloud que vous avez utilisé dans ce tutoriel, supprimez les différentes ressources :
Dans Cloud Shell, supprimez les fichiers que vous avez créés dans ce tutoriel :
cd rm -rf ~/container-image-digests-tutorial
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