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. Skaffold vous permet de configurer facilement un espace de travail de développement local, de simplifier votre boucle de développement interne et de 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 fondamentaux de Skaffold. Utilisez-le 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 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 "Site non fonctionnel". 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 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 de type Kubernetes et les sections suivantes du 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 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.

Dans cette section, vous pouvez également voir la référence à 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 similaire).

Dans cet exemple, vous pouvez voir deux superpositions pour trois cibles : dev, staging et prod. La superposition dev sera utilisée pendant le développement local, et les superpositions de préproduction et prod pour le 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. Différents contextes correspondent généralement à des environnements différents dans votre pipeline de déploiement d'applications, comme staging ou prod dans cet exemple. Cela signifie que vous pouvez facilement gérer des fichiers manifestes dont le contenu doit différer selon les environnements cibles, sans avoir à répéter la configuration récurrent.

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

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 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 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 bien démarré, le résultat suivant doit s'afficher:

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 s'exécutant dans Cloud Shell:
skaffold dev

Le processus de compilation du conteneur d'application doit s'exécuter, ce qui 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 diffère du 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 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 recompiler l'image et la redéployer sur le cluster. La modification du résultat est visible dans la fenêtre de terminal.

  1. Toujours dans le fichier « app > main.go&quot; dans le volet IDE, modifiez la ligne suivante:
time.Sleep(time.Second * 1)

pour

time.Sleep(time.Second * 10)

Là encore, vous devriez constater que l'application est recompilée et redéployée. La ligne de sortie s'affiche toutes les 10 secondes.

Apporter des modifications à la configuration Kubernetes

Vous allez maintenant modifier la configuration de Kubernetes. Une fois de plus, Skaffold se redéploie automatiquement.

  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 s'exécuter. Chacun portera 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 ne reste qu'un seul pod.

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

Couper une version

Ensuite, vous allez créer une version en compilant 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 génère l'image finale (si nécessaire) et génère les détails de la version dans le fichier artifacts.json.

Si vous souhaitez effectuer un déploiement sur vos clusters à l'aide d'un outil tel que Cloud Deploy, ce fichier contient les informations de version. Cela signifie que le ou les artefacts ne sont pas modifiables sur la route à mettre en ligne.

  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é, 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 du terminal pour arrêter la sortie Skaffold.
  2. Exécutez la commande suivante pour observer votre application opérationnelle dans le cluster:
kubectl get all --namespace staging

Vous devriez voir deux noms de pods distincts, 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é, 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 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 opérationnelle dans le cluster:
kubectl get all --namespace prod

Le résultat doit contenir des lignes semblables aux suivantes pour illustrer 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 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