Premiers pas avec Skaffold dans Cloud Deploy

Ce document explique comment commencer à utiliser Skaffold dans Cloud Deploy, y compris les éléments suivants :

Configurer Skaffold pour l'utiliser avec un pipeline de déploiement Cloud Deploy
Utiliser Skaffold et Cloud Deploy avec des outils de rendu tiers, tels que Helm et Kustomize
(Facultatif) Utiliser Skaffold pour le développement local
(Facultatif) Utiliser Skaffold pour l'intégration et le déploiement continus (CI/CD)

Pourquoi utiliser Skaffold ?

Vous souhaitez savoir pourquoi Cloud Deploy utilise Skaffold et pourquoi vous devez gérer une configuration Skaffold ? Lisez la suite.

Je suis expérimenté en CI/CD, mais je n'utilise pas Skaffold actuellement

Skaffold est un outil de ligne de commande Open Source qui permet d'améliorer la productivité des développeurs. Il orchestre le développement continu, l'intégration continue (CI) et la livraison continue (CD).

Skaffold fournit une configuration portable et déclarative, à l'aide d'une architecture connectable, qui vous permet d'utiliser différents outils pour la phase de rendu.

Lorsqu'une version est créée, Cloud Deploy appelle Skaffold pour afficher vos fichiers manifestes. Au moment du déploiement, Cloud Deploy appelle à nouveau Skaffold pour appliquer ces fichiers manifestes afin de déployer votre application sur chaque cible de votre progression. Après le déploiement, Skaffold effectue des vérifications de l'état pour surveiller l'environnement d'exécution cible et s'assurer que le déploiement a réussi.

Skaffold pour le développement continu

Lorsque vous utilisez Skaffold pour le développement continu, les images sont créées, testées et déployées sur un cluster (ou Minikube) à mesure que vous modifiez votre code. Les extensions d'IDE Cloud Code pour VS Code et Cloud Code pour IntelliJ intègrent Skaffold aux IDE Visual Studio Code et JetBrains pour le développement continu.

Skaffold pour la livraison continue

Vous pouvez également utiliser Skaffold pour la livraison continue, avec des étapes de compilation, de déploiement, de rendu et d'application. Cloud Deploy utilise les fonctionnalités render and apply de Skaffold. Pour utiliser Cloud Deploy, vous devez disposer au moins d'un fichier de configuration skaffold.yaml valide.

Skaffold vous permet également de vous intégrer à des outils tiers de gestion des fichiers manifestes, tels que Helm et Kustomize. Utiliser Skaffold de cette manière vous permet d'utiliser les fonctionnalités de ces outils pour afficher les manifestes. kubectl reste le déployeur de ces fichiers manifestes.

Je n'ai jamais déployé d'application sur Kubernetes

Avec Skaffold, vous pouvez configurer un ensemble de base de fichiers manifestes pour tous vos déploiements. Vous pouvez ensuite utiliser le moteur de rendu de Skaffold, via Cloud Deploy, pour afficher, puis déployer, chaque fichier manifeste spécifique au déploiement à partir de l'un de ces fichiers manifestes de base.

En savoir plus sur la gestion des fichiers manifestes, y compris des exemples d'utilisation de Skaffold et Cloud Deploy avec des outils courants de modélisation des fichiers manifestes, tels que Helm et Kustomize.

Quels sont les éléments nécessaires au bon fonctionnement de Cloud Deploy ?

Pour utiliser un pipeline de déploiement Cloud Deploy de base, le fichier de configuration skaffold.yaml doit au moins contenir la configuration suivante :

Informations d'en-tête dont toutes les configurations skaffold.yaml ont besoin :
```
apiVersion: skaffold/v4beta7
kind: Config
```
Une strophe manifests pour GKE, les clusters GKE associés ou Cloud Run listant tous les fichiers manifestes Kubernetes bruts (sauf si vous utilisez un outil de gestion des fichiers manifestes, tel que Helm ou Kustomize).

Voici un exemple utilisant un fichier manifeste Kubernetes brut :
```
manifests:
  rawYaml:
  - deployment.yaml
```
Si vous prévoyez d'utiliser un moteur de rendu (comme Helm ou Kustomize) pour afficher les fichiers manifestes, consultez Ajouter la compatibilité Helm à votre fichier skaffold.yaml et Ajouter la compatibilité Kustomize à votre fichier skaffold.yaml pour savoir comment configurer Skaffold afin d'utiliser ces outils.

Pour obtenir des exemples Helm et Kustomize, consultez Gérer les fichiers manifestes.
Une strophe deploy, avec deploy.kubectl pour le déploiement sur GKE ou sur des clusters GKE associés, ou deploy.cloudrun pour le déploiement sur Cloud Run.

Pour les clusters GKE et associés à GKE :
```
deploy:
  kubectl: {}
```
La section "deploy" déploie les fichiers manifestes de l'application fournis dans la section "manifests".

Pour les cibles Cloud Run :
```
deploy:
  cloudrun: {}
```
La section "deploy" déploie les fichiers manifestes d'application fournis dans la section "manifests".

Si vous utilisez des cibles personnalisées, votre skaffold.yaml doit comporter l'en-tête (apiVersion et kind:), ainsi que les actions personnalisées que la cible personnalisée utilisera si le type de cible personnalisée ne fait pas déjà référence à une configuration Skaffold à distance.

Créez un fichier `skaffold.yaml`.

Cloud Deploy utilise Skaffold pour générer et déployer vos applications.

Pour chaque version, vous devez fournir au moins un fichier skaffold.yaml qui identifie les fichiers manifestes à utiliser. Consultez la section précédente pour savoir ce que vous devez inclure dans ce fichier.

Générez votre `skaffold.yaml` avec Cloud Deploy.

Si vous ne disposez pas de fichier skaffold.yaml, mais que vous avez un fichier manifeste Kubernetes ou un fichier de définition de service Cloud Run, Cloud Deploy peut générer un fichier skaffold.yaml pour vous.

Le fichier Skaffold généré sera disponible dans le répertoire de préproduction de la source Cloud Storage une fois la version publiée.

La commande suivante inclut l'option --from-k8s-manifest, qui transmet le fichier manifeste Kubernetes. Cloud Deploy utilise les informations du fichier manifeste pour générer le skaffold.yaml, qui est ensuite utilisé pour la version.

gcloud deploy releases create  RELEASE_NAME --delivery-pipeline=PIPELINE_NAME --from-k8s-manifest=MANIFEST --region=REGION

Pour générer le skaffold.yaml à partir d'un fichier YAML de service Cloud Run, utilisez la même commande, mais avec --from-run-manifest au lieu de --from-k8s-manifest.

L'utilisation de l'une de ces options avec l'option --skaffold-file ou --source génère une erreur.

Utiliser le fichier `skaffold.yaml` généré

Le skaffold.yaml généré est adapté à l'intégration, à l'apprentissage et à la démonstration de Cloud Deploy. Une fois que vous êtes familiarisé avec Cloud Deploy et pour les charges de travail de production, vous pouvez souhaiter une configuration Skaffold qui différencie vos cibles (à l'aide des profils Skaffold).

Lorsque vous utilisez le fichier skaffold.yaml généré comme point de départ pour créer votre propre configuration Skaffold différenciée, veillez à utiliser le fichier dans l'archive de la source de rendu, et non le fichier rendu. La source de rendu peut être téléchargée depuis l'onglet Artefacts de la page Détails de la version.

Ce skaffold.yaml généré est inclus dans la source de rendu stockée dans un bucket Cloud Storage.

Pour afficher ce fichier, téléchargez le fichier .tar.gz et extrayez-le.
Le skaffold.yaml rendu est disponible dans Artefacts cibles.

Dans la section Artefacts cibles, cliquez sur Afficher les artefacts.

Utiliser Skaffold pour le développement local

L'un des points forts de Skaffold est que vous pouvez l'utiliser pour le développement local et pour la CI/CD. En mode dev, Skaffold surveille vos fichiers sources. Lorsqu'il détecte une modification, il recompense les images, effectue de nouveaux tests et redéploie les conteneurs sur un cluster minikube (par exemple) sur votre ordinateur local.

Lorsque vous utilisez Skaffold de cette manière, vous pouvez utiliser les mêmes commandes localement que pour le déploiement à distance.

Si vous utilisez Skaffold pour le développement local, vous pouvez définir des profils Skaffold distincts pour vos cibles et une strophe de déploiement par défaut pour le développement local.

Lorsque vous arrêtez le mode dev, Skaffold nettoie les artefacts déployés à partir du cluster.

Utiliser Skaffold pour la CI/CD

En plus d'utiliser Skaffold pour la compilation et le déploiement continus en local, vous pouvez l'utiliser pour la CI/CD. Cloud Deploy utilise les fonctionnalités CI/CD de Skaffold pour afficher et appliquer vos fichiers manifestes, et déployer votre application sur les cibles que vous avez définies, en fonction des images de conteneur créées à l'aide d'un outil CI tel que Cloud Build et d'un registre d'images tel que Artifact Registry.

Afficher, déployer et appliquer

Skaffold sépare le processus de rendu du fichier manifeste du déploiement. Cloud Deploy appelle skaffold render pour afficher les fichiers manifestes et skaffold apply pour les appliquer à la cible.

Cette séparation entre le rendu et l'application vous permet de capturer l'état déclaratif complet de votre application dans la configuration, afin qu'il puisse être appliqué de manière sécurisée et répétable (par exemple, pour les rollbacks). Cette technique facilite également les approbations. Étant donné que les fichiers manifestes sont affichés pour toutes les cibles avant le premier déploiement, vous pouvez voir le code YAML affiché qui sera appliqué à chaque cible.

Cloud Deploy n'accepte pas l'utilisation d'autres outils de déploiement pour déployer votre application. Toutefois, vous pouvez utiliser des outils tels que Helm ou Kustomize pour le rendu.

Pour en savoir plus sur la façon dont Cloud Deploy déploie des applications à l'aide de kubectl en tant que déployeur, consultez Architecture du service Cloud Deploy.

À propos des profils Skaffold

Vous pouvez créer des profils Skaffold distincts, identifiés dans skaffold.yaml, dans une strophe profiles:.

Lorsque vous utilisez des profils Skaffold avec Cloud Deploy, vous pouvez créer des profils distincts pour tout ou partie de vos cibles. Par exemple, différents profils pour dev, staging et prod.

Les profils ne sont pas nécessaires pour utiliser Skaffold dans Cloud Deploy, mais ils sont utiles pour définir des personnalisations de fichier manifeste entre vos cibles, par exemple en utilisant différents fichiers kustomization.yaml Kustomize par cible.

Ajouter la compatibilité Kustomize à votre `skaffold.yaml`

Pour intégrer votre configuration Kustomize à votre configuration Cloud Deploy/Skaffold, procédez comme suit :

Incluez un fichier kustomization.yaml dans vos fichiers de configuration.

Vous pouvez stocker vos fichiers de configuration dans un répertoire local ou dans un bucket Cloud Storage.

Dans votre fichier skaffold.yaml, créez une strophe deploy pour chaque profil.

Vous pouvez également avoir une strophe deploy en dehors de tout profil défini, si vous n'utilisez pas de profils ou pour une configuration de déploiement par défaut non liée à un profil.

Voici un exemple de configuration Skaffold qui montre les strophes deploy par profil et utilise un exemple d'application fictive appelée my-app :

apiVersion: skaffold/v4beta7
kind: Config
build:
  artifacts:
    - image: my-app-web-profiles
      context: my-app-web-profiles
    - image: my-app-application-profiles
      context: my-app-application-profiles
  googleCloudBuild:
    projectId: ${PROJECT_ID}
profiles:
- name: local
  manifests:
    kustomize:
      paths:
        - my-app-application-profiles/kubernetes/local
- name: test
  manifests:
    kustomize:
      paths:
        - my-app-application-profiles/kubernetes/test
- name: staging
  manifests:
    kustomize:
      paths:
        - my-app-application-profiles/kubernetes/staging
- name: prod
  manifests:
    kustomize:
      paths:
        - my-app-application-profiles/kubernetes/prod
deploy:
  kubectl: {}

La configuration Skaffold présentée ici comporte des profils distincts pour les cibles test, staging et prod. Il affiche également un profil pour le développement en local. Dans chaque profil, il existe une strophe deploy.kustomize avec un chemin d'accès qui pointe vers l'emplacement de la personnalisation à utiliser pour cette cible.

Ajouter la prise en charge de Helm à votre `skaffold.yaml`

Vous pouvez utiliser Helm pour afficher vos fichiers manifestes. Cloud Deploy n'utilise pas Helm pour déployer vos applications et n'accepte que kubectl comme outil de déploiement.

Pour utiliser Helm, vous avez besoin de votre ou vos charts Helm, stockés à n'importe quel emplacement auquel vous pouvez faire référence depuis votre skaffold.yaml. Cet emplacement peut se trouver dans un système de fichiers, un dépôt (éventuellement avec votre fichier skaffold.yaml) ou un dépôt Open Container Initiative (OCI).

Pour utiliser un graphique Helm, ajoutez un stanza helm à votre fichier skaffold.yaml.

apiVersion: skaffold/v4beta7
kind: Config
build:
  artifacts:
  - image: skaffold-helm-image
manifests:
  helm:
    releases:
    - name: skaffold-helm-image
      chartPath: charts
deploy:
  kubectl: {}

La référence skaffold.yaml indique ce qui est requis dans cette strophe helm.

Fonctionnalités Skaffold non compatibles

Les fonctionnalités Skaffold suivantes ne peuvent pas être utilisées dans Cloud Deploy :

Hooks de cycle de vie
Modules Skaffold dynamiques

L'utilisation de --module= pour sélectionner des modules spécifiques pour build, render, apply, etc., n'est pas prise en charge. Les modules statiques sont acceptés.
Dans Helm, la possibilité de créer un espace de noms s'il n'en existe pas.

Étapes suivantes

Consultez le site Skaffold pour découvrir son fonctionnement et ce qu'il peut faire pour vous.
Entraînez-vous à utiliser Cloud Deploy avec des profils Kustomize et Skaffold.
Découvrez comment Cloud Deploy sélectionne les versions d'outils à utiliser et comment déterminer les versions en cours d'utilisation.
Découvrez comment utiliser les profils Skaffold avec des outils avancés de gestion des fichiers manifestes tels que Helm, Kustomize et kpt.