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, simplifier votre boucle de développement interne et vous 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 fondamentaux 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 Golang simple
  • Gérer le déploiement d'applications locales avec Skaffold
  • Afficher les 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 "Impossible d'accéder au site", puis sur "Autoriser les cookies".

7b702066a2135a3d.png

3394f82132eb4fd4.png

  1. Si vous ne l'avez pas déjà 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 configuré 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 niveau supérieur, 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 de l'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 compilé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 la manière dont l'application doit être compilée. Dans ce cas, vous pouvez voir la configuration concernant le traitement des balises git, ainsi qu'une section artifacts qui définit les images de conteneur qui composent l'application.

En outre, cette section contient la référence à l'Dockerfile à utiliser pour créer les images. Skaffold est également compatible avec d'autres outils de compilation tels que Jib, Maven, Gradle, Buildpacks et Bazel cloud natifs, ainsi que les scripts personnalisés. Pour en savoir plus sur cette configuration, consultez la documentation sur la compilation Skaffold.

5. Déployer

La section deploy contient la configuration qui définit la manière dont l'application doit être déployée. Dans ce cas, vous pouvez consulter 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 courants (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 éléments 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 à l'aide de Skaffold.

6. Profils

La section profiles contient une configuration qui définit des configurations de compilation, de test et de déploiement pour différents contextes. Les différents contextes correspondent 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 différer pour différents environnements cibles, sans répéter la configuration standard.

La configuration de la section profiles peut remplacer ou corriger tous les éléments de la configuration principale (par exemple, les sections build, test ou deploy).

Par exemple, ouvrez le fichier overlays > prod > deployment.yaml. Notez que le nombre d'instances répliquées pour l'application est défini ici sur trois, remplaçant la configuration de base.

  1. Ouvrez le fichier app > main.go suivant dans le volet de l'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 de l'IDE. Ce fichier contient une séquence d'instructions permettant de créer l'image du conteneur de l'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

L'opération peut prendre plusieurs minutes. Si le cluster a démarré correctement, vous devriez obtenir la sortie suivante:

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 dans un cluster Kubernetes local exécuté dans Cloud Shell:
skaffold dev

Le processus de compilation du conteneur de l'application devrait s'exécuter (ce qui peut prendre une minute), puis la sortie 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 peut varier par rapport au résultat générique indiqué ci-dessus.

Apporter des modifications à l'application

Maintenant que l'application s'exécute dans votre cluster Kubernetes local, vous pouvez modifier le code. Skaffold se charge ensuite de recompiler et de redéployer automatiquement l'application sur le cluster.

  1. Ouvrez le fichier app > main.go dans le volet de l'IDE, puis 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 devrait reconstruire l'image et la redéployer sur le cluster. La modification de la sortie devrait être visible dans la fenêtre du terminal.

  1. Dans le fichier "app > main.go" du volet de l'IDE, modifiez la ligne:
time.Sleep(time.Second * 1)

pour

time.Sleep(time.Second * 10)

Là encore, l'application doit être recréée et redéployée, et la ligne de sortie doit s'afficher toutes les 10 secondes.

Modifier la configuration Kubernetes

Vous allez ensuite modifier la configuration Kubernetes. Skaffold redéployera alors 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 ayant un nom différent.

  1. À présent, redéfinissez la même ligne du fichier base > deployment.yaml sur:
replicas: 1

L'un des pods doit être supprimé du service, de sorte qu'il n'en reste qu'un seul.

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

Publier 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 votre application sur vos clusters, ce fichier contient les informations sur la version. Cela signifie que l'artefact ou les artefacts sont immuables sur le chemin vers la publication.

  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 lors du 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é, deux pods doivent renvoyer un résultat semblable à celui-ci:

[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 de Skaffold.
  2. Exécutez la commande suivante pour observer l'exécution de votre application dans le cluster:
kubectl get all --namespace staging

Vous devriez voir deux noms de pod distincts, car le profil staging de l'application spécifie qu'il doit y avoir deux réplicas 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 voir la sortie de trois pods semblable à celle-ci:

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

Vous devriez voir trois noms de pods distincts, car le profil prod de l'application spécifie qu'il doit y avoir trois instances répliquées 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 obtenir un résultat contenant des lignes semblables aux suivantes, qui indiquent le déploiement en production:

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

Trois pods d'application devraient également s'exécuter.

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 Understanding Skaffold et appris à configurer et à utiliser Skaffold pour le développement local et le déploiement d'applications.

Étapes suivantes :

Continuez à en apprendre davantage sur Skaffold:

Nettoyage

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