Gérer les fichiers manifestes dans Cloud Deploy

Cette page explique comment configurer Cloud Deploy pour créer le rendu de configuration pour chaque cible dans un pipeline de diffusion.

Cloud Deploy utilise Skaffold pour afficher vos fichiers manifestes Kubernetes. Le service est compatible avec le rendu des fichiers manifestes bruts et des outils de gestion des fichiers manifestes plus avancés, tels que Helm, Kustomize et kpt.

Le processus de rendu comporte deux étapes :

  1. L'outil de gestion des fichiers manifestes génère le fichier manifeste.

  2. Skaffold remplace les références d'image dans le fichier manifeste par les images que vous souhaitez déployer dans votre version.

Cette page inclut des exemples de configuration utilisant Helm et Kustomize.

Utiliser Skaffold pour générer votre configuration

Si vous ne possédez pas déjà de fichier de configuration Skaffold (skaffold.yaml), vous pouvez l'utiliser pour en générer un automatiquement, en fonction du contenu de votre dépôt.

  1. Installez Skaffold à l'aide de Google Cloud CLI :

    gcloud components install skaffold

  2. Exécutez skaffold init dans le dépôt contenant vos fichiers manifestes :

    skaffold init --skip-build

Cette commande crée un fichier skaffold.yaml dans votre dépôt. Ce fichier fait référence aux fichiers manifestes de ce dépôt. Le contenu se présente comme suit :

apiVersion: skaffold/v4beta7
kind: Config
metadata:
  name: sample-app
manifests:
  rawYaml:
    - k8s-manifests/deployment.yaml
    - k8s-manifests/rbac.yaml
    - k8s-manifests/redis.yaml
    - k8s-manifests/service.yaml

Génération de fichiers manifestes bruts

Les fichiers manifestes bruts ne sont pas gérés par un outil tel que Helm ou Kustomize. Ils n'ont donc pas besoin d'être prétraités avant d'être hydratés et déployés sur un cluster.

Par défaut, Cloud Deploy utilise skaffold render pour afficher vos fichiers manifestes Kubernetes, en remplaçant les noms d'images non taguées par les noms d'images taguées des images de conteneur que vous déployez. Ensuite, lorsque vous promouvez la version, Cloud Deploy utilise skaffold apply pour appliquer les fichiers manifestes et déployer les images sur votre cluster Google Kubernetes Engine.

Une strophe manifests d'une configuration de base se présente comme suit :

manifests:
  rawYaml:
    - PATH_TO_MANIFEST

Pour en savoir plus sur les valeurs qui peuvent être transmises ici, consultez la documentation Skaffold.

Effectuer le rendu à l'aide de Helm

Vous pouvez utiliser Cloud Deploy pour afficher vos charts Helm. Pour ce faire, vous devez inclure les détails du chart Helm dans une strophe deploy d'un profil Skaffold.

Chacune de ces définitions se présente comme suit :

apiVersion: skaffold/v4beta7
kind: Config
manifests:
  helm:
    releases:
      - name: RELEASE_NAME
        chartPath: PATH_TO_HELM_CHART

Où :

RELEASE_NAME est le nom de l'instance de graphique Helm pour cette version.

PATH_TO_HELM_CHART correspond au chemin d'accès local à un chart Helm empaqueté ou à un répertoire de chart Helm décompressé.

Vous pouvez utiliser d'autres options de configuration Helm, comme décrit dans la documentation Skaffold.

Affichage à l'aide de Kustomize

Vous pouvez utiliser Kustomize avec Cloud Deploy. Pour ce faire, vous devez pointer vers les fichiers de personnalisation à partir de la strophe deploy dans la configuration de votre profil skaffold.yaml.

Vous incluez une configuration Kustomize distincte pour chaque cible pour laquelle vous utilisez Kustomize, sous chaque profile correspondant dans votre skaffold.yaml.

Chacune de ces définitions se présente comme suit :

apiVersion: skaffold/v4beta7
kind: Config
manifests:
  kustomize:
    paths:
      - PATH_TO_KUSTOMIZE

Où :

PATH_TO_KUSTOMIZE pointe vers vos fichiers de personnalisation. La valeur par défaut est ["."].

Vous pouvez utiliser des options de configuration Kustomize supplémentaires, comme décrit dans la documentation Skaffold.

Configurer différents fichiers manifestes par cible

Chaque cible nécessite souvent une configuration légèrement différente. Par exemple, vous pouvez avoir plus de répliques dans vos déploiements de production que dans vos déploiements de préproduction.

Vous pouvez afficher un ensemble différent de fichiers manifestes pour chaque cible en fournissant chaque variante sous la forme d'un profil Skaffold différent.

Profils avec des fichiers manifestes bruts

Lorsque vous travaillez avec des fichiers manifestes bruts, vous pouvez pointer Cloud Deploy vers un autre fichier, en fonction de la cible. Vous pouvez configurer cela comme suit :

apiVersion: skaffold/v4beta7
kind: Config
profiles:
  - name: prod
    manifests:
      rawYaml:
        - prod.yaml
  - name: staging
    manifests:
      rawYaml:
        - staging.yaml

Profils avec Kustomize

Voici un exemple de skaffold.yaml comportant différents profils de préproduction et de production à l'aide de Kustomize, où chaque profil pointe vers un fichier Kustomization différent:

apiVersion: skaffold/v4beta7
kind: Config
profiles:
  - name: prod
    manifests:
      kustomize:
        paths:
          - environments/prod
  - name: staging
    manifests:
      kustomize:
        paths:
          - environments/staging

Profils référencés dans le pipeline de diffusion

Ces profils, définis dans skaffold.yaml, sont référencés dans la configuration du pipeline de livraison, par cible :

serialPipeline:
  stages:
  - targetId: staging-target
    profiles:
    - staging
  - targetId: prod-target
    profiles:
    - prod

Remplacer une image spécifique lorsque vous créez la version

Votre fichier manifeste peut utiliser un espace réservé pour le nom de l'image, que vous pouvez remplacer lorsque vous créez votre version.

Voici un exemple de fichier manifeste avec un espace réservé pour l'image :

apiVersion: v1
kind: Deployment
metadata:
  name: getting-started
  labels:
    app: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: my-app-image

Lorsque vous créez votre version, vous pouvez utiliser l'option --images= pour identifier l'image spécifique à déployer. Par exemple, la commande suivante crée une version et remplace le nom de l'espace réservé par un nom d'image qualifié par un SHA :

gcloud deploy releases create test-release-001 \
  --project=test-gke-using-deployment \
  --region=us-central1 \
  --delivery-pipeline=my-gke-demo-app-1 \
  --images=my-app-image=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa

Le fichier manifeste rendu obtenu comporte désormais une référence à l'image spécifiée au lieu de my-app-image.

Étapes suivantes