Comprendre Skaffold

1. Objectifs

Skaffold est un outil qui gère le workflow de création, de transfert et de déploiement de votre application. Vous pouvez utiliser Skaffold pour configurer facilement un espace de travail de développement local, rationaliser votre boucle de développement interne et l'intégrer à d'autres outils tels que Kustomize et Helm pour vous aider à gérer vos fichiers manifestes Kubernetes.

Dans ce tutoriel, vous allez découvrir certains concepts de base de Skaffold, l'utiliser pour automatiser votre boucle de développement interne, puis déployer une application.

Vous découvrirez comment :

  • Configurer et activer Skaffold pour le développement local
  • Créer et exécuter une application Go simple
  • Gérer le déploiement d'applications locales avec Skaffold
  • Générer des fichiers manifestes et déployer votre application

2. Avant de commencer

Préparer votre espace de travail

  1. Ouvrez l'éditeur Cloud Shell en accédant à l'URL suivante :
https://shell.cloud.google.com

Autorisez les cookies tiers. Cliquez sur "Le site ne fonctionne pas", puis sur "Autoriser les cookies".

7b702066a2135a3d.png

3394f82132eb4fd4.png

  1. Si vous ne l'avez pas encore fait, clonez la source de l'application dans la fenêtre de terminal à l'aide de la commande suivante :
git clone https://github.com/GoogleCloudPlatform/software-delivery-workshop.git
  1. Accédez au répertoire du dépôt cloné :
cd software-delivery-workshop/labs/understanding-skaffold/getting-started
  1. Définissez votre espace de travail Cloud Shell sur le répertoire actuel en exécutant la commande suivante :
cloudshell workspace .

Préparer votre projet

  1. Assurez-vous que votre projet Google Cloud est correctement défini en exécutant la commande suivante :
gcloud config set project {{project-id}}

3. Premiers pas avec Skaffold

  1. Exécutez la commande suivante pour créer le fichier de configuration Skaffold de premier niveau, skaffold.yaml :
cat <<EOF > skaffold.yaml
apiVersion: skaffold/v2beta21
kind: Config
metadata:
  name: getting-started-kustomize
build:
  tagPolicy:
    gitCommit:
      ignoreChanges: true
  artifacts:
  - image: skaffold-kustomize
    context: app
    docker:
      dockerfile: Dockerfile
deploy:
  kustomize:
    paths:
    - overlays/dev
profiles:
- name: staging
  deploy:
    kustomize:
      paths:
      - overlays/staging
- name: prod
  deploy:
    kustomize:
      paths:
      - overlays/prod
EOF
  1. Ouvrez le fichier skaffold.yaml dans le volet IDE. Il s'agit du fichier de configuration de premier niveau qui définit le pipeline Skaffold.

Notez le format YAML semblable à celui de Kubernetes et les sections suivantes dans le fichier YAML :

  • build
  • deploy
  • profiles

Ces sections définissent la manière dont l'application doit être créée et déployée, ainsi que les profils pour chaque cible de déploiement.

Pour en savoir plus sur la liste complète des étapes Skaffold, consultez la documentation sur les étapes du pipeline Skaffold.

4. Build

La section build contient la configuration qui définit comment l'application doit être créée. Dans ce cas, vous pouvez voir la configuration de la gestion des tags git, ainsi qu'une section artifacts qui définit les images de conteneurs composant l'application.

Dans cette section, vous pouvez également voir la référence au Dockerfile à utiliser pour créer les images. Skaffold est également compatible avec d'autres outils de compilation tels que Jib, Maven, Gradle, Buildpacks natif au cloud, Bazel et les scripts personnalisés. Pour en savoir plus sur cette configuration, consultez la documentation sur Skaffold Build.

5. Déployer

La section deploy contient la configuration qui définit comment l'application doit être déployée. Dans ce cas, vous pouvez voir un exemple de déploiement par défaut qui configure Skaffold pour utiliser l'outil Kustomize.

L'outil Kustomize permet de générer des fichiers manifestes Kubernetes en combinant un ensemble de fichiers YAML de composants communs (dans le répertoire base) avec une ou plusieurs "superpositions" qui correspondent généralement à une ou plusieurs cibles de déploiement (généralement dev, test, staging et production, ou des noms similaires).

Dans cet exemple, vous pouvez voir deux superpositions pour trois cibles : dev, staging et prod. La superposition dev sera utilisée lors du développement local, et les superpositions staging et prod lors du déploiement avec Skaffold.

6. Profils

La section profiles contient une configuration qui définit les configurations de compilation, de test et de déploiement pour différents contextes. Les différents contextes sont généralement différents environnements dans le pipeline de déploiement de votre application, comme staging ou prod dans cet exemple. Cela signifie que vous pouvez facilement gérer les fichiers manifestes dont le contenu doit être différent pour différents environnements cibles, sans répéter la configuration standard.

La configuration de la section profiles peut remplacer ou corriger n'importe quel élément de la configuration principale (par exemple, les sections build, test ou deploy).

Pour illustrer cela, ouvrez le fichier overlays > prod > deployment.yaml. Notez que le nombre d'instances répliquées pour l'application est configuré ici sur trois, ce qui remplace la configuration de base.

  1. Ouvrez le fichier app > main.go dans le volet IDE. Il s'agit d'une application Golang simple qui écrit une chaîne dans stdout toutes les secondes.
  2. Notez que l'application affiche également le nom du pod Kubernetes dans lequel elle s'exécute.

Afficher le fichier Dockerfile

  1. Ouvrez le fichier app > Dockerfile dans le volet IDE. Ce fichier contient une séquence de directives permettant de créer l'image de conteneur d'application pour le fichier main.go. Il est référencé dans le fichier skaffold.yaml de premier niveau.

7. Développer avec Skaffold

Configurer votre environnement Kubernetes

  1. Exécutez la commande suivante pour vous assurer que votre cluster Kubernetes local est en cours d'exécution et configuré :
minikube start

Cette opération peut prendre plusieurs minutes. Si le cluster a démarré correctement, vous devriez obtenir le résultat suivant :

Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default
  1. Exécutez la commande suivante pour créer des espaces de noms Kubernetes pour dev, staging et prod :
kubectl apply -f namespaces.yaml

Vous devriez obtenir le résultat suivant :

namespace/dev created
namespace/staging created
namespace/prod created

Utiliser Skaffold pour le développement local

  1. Exécutez la commande suivante pour créer l'application et la déployer sur un cluster Kubernetes local exécuté dans Cloud Shell :
skaffold dev

Le processus de compilation du conteneur d'application devrait s'exécuter (cela peut prendre une minute), puis le résultat de l'application devrait se répéter toutes les secondes :

[skaffold-kustomize] Hello world from pod skaffold-kustomize-dev-xxxxxxxxx-xxxxx

Notez que le nom exact du pod sera différent de celui générique indiqué ci-dessus.

Modifier l'application

Maintenant que l'application s'exécute dans votre cluster Kubernetes local, vous pouvez modifier le code. Skaffold reconstruira et redéploiera automatiquement l'application sur le cluster.

  1. Ouvrez le fichier app > main.go dans le volet IDE et modifiez la chaîne de sortie :
"Hello world from pod %s!\n"

par :

"Hello Skaffold world from pod %s!\n"

Une fois la modification effectuée, Skaffold doit reconstruire l'image et la redéployer sur le cluster. La modification de la sortie doit être visible dans la fenêtre du terminal.

  1. Maintenant, toujours dans le fichier "app > main.go" du volet IDE, modifiez la ligne :
time.Sleep(time.Second * 1)

pour

time.Sleep(time.Second * 10)

Là encore, l'application doit être reconstruite et redéployée, avec une ligne de résultat qui s'affiche toutes les 10 secondes.

Modifier la configuration Kubernetes

Ensuite, vous apporterez une modification à la configuration Kubernetes, et Skaffold redéploiera automatiquement l'application.

  1. Ouvrez le fichier base > deployment.yaml dans l'IDE et modifiez la ligne :
replicas: 1

pour

replicas: 2

Une fois l'application redéployée, vous devriez voir deux pods en cours d'exécution, chacun avec un nom différent.

  1. À présent, remplacez la même ligne dans le fichier base > deployment.yaml par :
replicas: 1

Vous devriez voir l'un des pods retiré du service, de sorte qu'il n'en reste qu'un.

  1. Enfin, appuyez sur Ctrl-C dans la fenêtre du terminal pour arrêter le développement local Skaffold.

Créer une version

Vous allez ensuite créer une version en créant une image de version et en la déployant sur un cluster.

  1. Exécutez la commande suivante pour créer la version :
skaffold build --file-output artifacts.json

Cette commande crée l'image finale (si nécessaire) et génère les détails de la version dans le fichier artifacts.json.

Si vous souhaitez utiliser un outil tel que Cloud Deploy pour déployer des applications sur vos clusters, ce fichier contient les informations sur la version. Cela signifie que les artefacts sont immuables sur le chemin vers la diffusion en direct.

  1. Exécutez la commande suivante pour afficher le contenu du fichier artifacts.json :
cat artifacts.json | jq

Notez que le fichier contient la référence à l'image qui sera utilisée dans le déploiement final.

Déployer en préproduction

  1. Exécutez la commande suivante pour déployer la version à l'aide du profil staging :
skaffold deploy --profile staging --build-artifacts artifacts.json --tail

Une fois le déploiement terminé, le résultat de deux pods doit s'afficher, comme suit :

[skaffold-kustomize] Hello world from pod skaffold-kustomize-staging-xxxxxxxxxx-xxxxx!
  1. Appuyez sur Ctrl+C dans la fenêtre de terminal pour arrêter la sortie Skaffold.
  2. Exécutez la commande suivante pour observer votre application en cours d'exécution dans le cluster :
kubectl get all --namespace staging

Deux noms de pods distincts devraient s'afficher, car le profil staging de l'application indique qu'il doit y avoir deux répliques dans le déploiement.

Déployer en production

  1. Exécutez maintenant la commande suivante pour déployer la version à l'aide du profil prod :
skaffold deploy --profile prod --build-artifacts artifacts.json --tail

Une fois le déploiement terminé, vous devriez obtenir un résultat semblable à celui-ci pour trois pods :

[skaffold-kustomize] Hello world from pod skaffold-kustomize-prod-xxxxxxxxxx-xxxxx!
  1. Appuyez sur Ctrl+C dans la fenêtre de terminal pour arrêter la sortie Skaffold.

Vous devriez voir trois noms de pods distincts, car le profil prod de l'application indique qu'il devrait y avoir trois réplicas dans le déploiement.

  1. Exécutez la commande suivante pour observer votre application en cours d'exécution dans le cluster :
kubectl get all --namespace prod

Vous devriez voir un résultat contenant des lignes semblables à celles ci-dessous, qui indiquent le déploiement de production :

NAME                                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/skaffold-kustomize-prod   3/3     3            3           16m

Vous devriez également voir trois pods d'application en cours d'exécution.

NAME                                           READY   STATUS    RESTARTS   AGE
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m

8. Félicitations !

Félicitations ! Vous avez terminé l'atelier de programmation Understanding Skaffold et appris à configurer et à utiliser Skaffold pour le développement local et le déploiement d'applications.

Étapes suivantes :

Pour en savoir plus sur Skaffold :

Nettoyage

  1. Exécutez la commande suivante pour arrêter le cluster local :
minikube delete