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 l'utiliser pour configurer facilement un espace de travail de développement local, simplifier 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 Golang simple
  • Gérer le déploiement d'une application locale 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 ce n'est 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 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 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 comment 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 documentation.

4. Créer

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 qui composent 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 cloud natifs, Bazel et 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 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 à l'aide de Skaffold.

6. Profils

La section profiles contient la 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 des environnements différents dans votre pipeline de déploiement d'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 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é sur trois, ce qui remplace la configuration de base.

  1. Ouvrez le fichier suivant app > main.go 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 génère é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 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

L'opération peut prendre plusieurs minutes. Le résultat suivant doit s'afficher si le cluster a démarré correctement :

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 création du conteneur d'application doit s'exécuter (cela peut prendre une minute), puis le résultat de l'application doit 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 varie 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 recréera et redéploiera automatiquement l'application dans le cluster.

  1. Ouvrez le fichier app > main.go dans le volet de l'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 recréer l'image et la redéployer dans le cluster. La modification du résultat doit être visible dans la fenêtre de terminal.

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

par

time.Sleep(time.Second * 10)

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

Apporter des modifications à la configuration Kubernetes

Vous allez maintenant modifier la configuration Kubernetes. Skaffold redéploiera automatiquement l'application.

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

par

replicas: 2

Une fois l'application redéployée, deux pods doivent s'exécuter. Ils auront chacun un nom différent.

  1. Maintenant, remplacez la même ligne dans le fichier base > deployment.yaml par :
replicas: 1

L'un des pods doit être supprimé du service. Il n'en restera donc qu'un seul.

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

Créer une version

Vous allez maintenant 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 effectuer un déploiement sur vos clusters, ce fichier contient les informations de la version. Cela signifie que les artefacts sont immuables sur la route vers la mise en production.

  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 doivent s'afficher, car le profil staging de l'application spécifie qu'il doit y avoir deux instances répliquées 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é, le résultat de trois pods doit s'afficher, comme suit :

[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.

Trois noms de pods distincts doivent s'afficher, 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

Le résultat doit contenir des lignes semblables à celles qui suivent, qui affichent 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 doivent également être 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 Understanding Skaffold et appris à configurer et à utiliser Skaffold pour le développement local et le déploiement d'applications.

Étapes suivantes :

Pour aller plus loin dans votre apprentissage de Skaffold :

Nettoyage

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