Revue Skaffold pour le développement de Kubernetes

Il y a un an et demi, le 5 mars 2018, Google a publié la première version alpha de son projet Open Source pour CI / CD appelé Skaffold , dont l'objectif était de créer un «développement simple et reproductible pour Kubernetes» afin que les développeurs puissent se concentrer spécifiquement sur le développement, et pas sur l'administration. Qu'est-ce qui pourrait intéresser Skaffold? En fin de compte, il a quelques atouts dans sa manche, grâce auxquels il peut devenir un outil puissant pour un développeur, et peut-être un ingénieur d'exploitation. Nous prendrons connaissance du projet et de ses capacités.

NB : Au fait, nous avons déjà parlé brièvement de Skaffold dans notre aperçu général des outils pour les développeurs dont la vie est liée à Kubernetes.

Théorie Objectif et fonctionnalités

Donc, d'une manière générale, Skaffold résout le problème de l'automatisation du cycle CI / CD (aux étapes de la construction, de la transmission, du déploiement), en offrant au développeur un retour d'information rapide, c'est-à-dire la possibilité d'obtenir rapidement le résultat des prochaines modifications de code - sous la forme d'une application mise à jour exécutée dans le cluster Kubernetes. Et il peut fonctionner dans différents contours (développement, stade, production ...), pour lesquels Skaffold aide à décrire les pipelines appropriés pour le déploiement.

Le code source de Skaffold est écrit en Go et est distribué sous la licence gratuite Apache 2.0 ( GitHub ).

Considérez les principales fonctions et caractéristiques. Les premiers comprennent les éléments suivants:

• Skaffold propose des outils pour créer des pipelines CI / CD.
• Vous permet de surveiller les modifications du code source en arrière-plan et de démarrer le processus automatisé de création de code dans des images de conteneur, de publication de ces images dans le Docker Registry et de les déployer sur le cluster Kubernetes.
• Synchronise les fichiers du référentiel avec le répertoire de travail du conteneur.
• Teste automatiquement à l'aide de container-structure-test.
• Transmet les ports.
• Lit les journaux de l'application en cours d'exécution dans le conteneur.
• Aide au débogage d'applications écrites en Java, Node.js, Python, Go.

Maintenant sur les fonctionnalités:

• Skaffold lui-même n'a pas de composants côté cluster . Autrement dit, vous n'avez pas besoin de configurer en plus Kubernetes pour utiliser cet utilitaire.
• Différents pipelines pour votre application . Besoin de déployer le code dans le minikube local pendant que vous développez, puis sur scène ou en production? Pour ce faire, des profils et des configurations utilisateur, des variables d'environnement et des indicateurs sont fournis, qui vous permettent de décrire différents pipelines pour une application.
• CLI Uniquement utilitaire et configurations de console en YAML. Sur le réseau, vous pouvez trouver des références à des tentatives de création d'une interface graphique expérimentale , mais pour le moment, cela signifie probablement que quelqu'un en a besoin, mais pas vraiment.
• Modularité . Skaffold n'est pas une moissonneuse-batteuse indépendante, mais cherche à utiliser des modules distincts ou des solutions existantes pour des tâches spécifiques.

Illustration de ce dernier:

• Au stade de l'assemblage, vous pouvez utiliser:
  • docker build localement, dans un cluster utilisant kaniko ou dans Google Cloud Build;
  • Bazel localement;
  • Jib Maven et Jib Gradle localement ou sur Google Cloud Build;
  • les scripts de construction personnalisés s'exécutent localement. Si vous devez exécuter une autre solution (plus flexible / familière / ...) pour l'assembly, elle est décrite dans le script afin que Skaffold l'exécute ( exemple de la documentation ). Cela vous permet d'utiliser n'importe quel collecteur pouvant être appelé à l'aide d'un script;
• Au stade du test, le test de structure de conteneur déjà mentionné est pris en charge;
• Pour le déploiement sont fournis:
  • Kubectl;
  • Helm;
  • kustomize.

Grâce à cela, Skaffold peut être appelé une sorte de framework pour la construction de CI / CD . Voici un exemple de workflow lors de son utilisation (à partir de la documentation du projet):



À quoi ressemble le travail de Skaffold en général?

1. L'utilitaire surveille les modifications dans le répertoire source. Si des modifications sont apportées aux fichiers, elles sont synchronisées avec le module d'application dans le cluster Kubernetes. Si possible, sans remonter l'image. Sinon, une nouvelle image va.
2. L'image assemblée est vérifiée à l'aide de container-structure-test, étiquetée et envoyée au Docker Registry.
3. Après cela, l'image est déployée - elle est déployée dans un cluster Kubernetes.
4. Si le lancement a été initialisé à l'aide de la commande skaffold dev , nous commençons à recevoir des journaux de l'application et Skaffold s'attend à des modifications pour répéter à nouveau toutes les étapes.

Illustration des jalons de l'échafaudage

Pratique. Essayer Skaffold

Pour démontrer l'utilisation de Skaffold, je vais prendre un exemple du référentiel GitHub du projet . Au fait, vous y trouverez de nombreux autres exemples qui prennent en compte diverses spécificités. Toutes les actions seront effectuées localement dans Minikube. L'installation est simple et prend quelques minutes, et kubectl est requis pour commencer.

Installez Skaffold:

 curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64 chmod +x skaffold sudo mv skaffold /usr/local/bin skaffold version v0.37.1 

Clonons le référentiel Skaffold avec les exemples nécessaires:

 git clone https://github.com/GoogleContainerTools/skaffold cd skaffold/examples/microservices 

J'ai choisi un exemple avec deux pods, chacun contenant une petite application sur Go. Une application est le frontend (leeroy-web), une demande de redirection vers la deuxième application est le backend (leeroy-app). Voyons à quoi ça ressemble:

 ~/skaffold/examples/microservices # tree . ├── leeroy-app │ ├── app.go │ ├── Dockerfile │ └── kubernetes │ └── deployment.yaml ├── leeroy-web │ ├── Dockerfile │ ├── kubernetes │ │ └── deployment.yaml │ └── web.go ├── README.adoc └── skaffold.yaml 4 directories, 8 files 

leeroy-app et leeroy-web contiennent du code Go et de simples Dockerfiles pour construire ce code localement:

 ~/skaffold/examples/microservices # cat leeroy-app/Dockerfile FROM golang:1.12.9-alpine3.10 as builder COPY app.go . RUN go build -o /app . FROM alpine:3.10 CMD ["./app"] COPY --from=builder /app . 

Je ne donnerai pas le code de l'application - il suffit de savoir que leeroy-web accepte les requêtes et les leeroy-app procuration à leeroy-app . Par conséquent, dans les fichiers Deployment.yaml , il n'y a de service que pour l' app (pour le routage interne). Le port du pod web nous sera jeté pour un accès rapide à l'application.

A quoi ressemble skaffold.yaml :

 ~/skaffold/examples/microservices # cat skaffold.yaml apiVersion: skaffold/v1beta13 kind: Config build: artifacts: - image: leeroy-web context: ./leeroy-web/ - image: leeroy-app context: ./leeroy-app/ deploy: kubectl: manifests: - ./leeroy-web/kubernetes/* - ./leeroy-app/kubernetes/* portForward: - resourceType: deployment resourceName: leeroy-web port: 8080 localPort: 9000 

Toutes les étapes mentionnées ci-dessus sont décrites ici. En plus de cette configuration, il existe également un fichier avec des paramètres globaux - ~/.skaffold/config . Il peut être modifié manuellement ou via la CLI - par exemple, comme ceci:

 skaffold config set --global local-cluster true 

Cette commande définit la variable globale du local-cluster sur true , après quoi Skaffold ne tentera pas de «pousser» les images dans le registre distant. Si vous développez localement, vous pouvez également utiliser cette commande pour ajouter des images localement.

Retour à skaffold.yaml :

• Au stade de la build , nous indiquons que vous devez collecter et enregistrer l'image localement. Après le premier assemblage, nous verrons ce qui suit:
  
  

   // .. Minikube      , //   ,    # minikube ssh $ docker images REPOSITORY TAG IMAGE ID CREATED SIZE leeroy-app 7d55a50803590b2ff62e47e6f240723451f3ef6f8c89aeb83b34e661aa287d2e 7d55a5080359 4 hours ago 13MB leeroy-app v0.37.1-171-g0270a0c-dirty 7d55a5080359 4 hours ago 13MB leeroy-web 5063bfb29d984db1ff70661f17d6efcc5537f2bbe6aa6907004ad1ab38879681 5063bfb29d98 5 hours ago 13.1MB leeroy-web v0.37.1-171-g0270a0c-dirty 5063bfb29d98 5 hours ago 13.1MB 

  
  Comme vous pouvez le voir, Skaffold a indépendamment testé les images. Soit dit en passant, plusieurs politiques de marquage sont prises en charge.
• Ce qui suit est spécifié dans le context: ./leeroy-app/ configuration context: ./leeroy-app/ , i.e. Le contexte dans lequel l'image est assemblée est spécifié.
• Au stade du déploiement, il est déterminé que nous utiliserons kubectl et un masque pour les manifestes souhaités.
• PortForward : similaire à la façon dont nous transmettons habituellement les ports à l'aide de kubectl port-forward , nous donnons à Skaffold des instructions pour appeler cette commande. Dans ce cas, le port local 9000 est transféré vers 8080 dans Déploiement avec le nom leeroy-web .

Il est temps de commencer le développement de skaffold dev : l'équipe créera une «boucle de rétroaction» continue, c'est-à-dire non seulement recueille tout et installe dans un cluster, mais indique également le statut des pods en ce moment, surveillera les modifications et mettra à jour le statut des pods.

Voici le résultat de l'exécution de skaffold dev --port-forward lors du remontage:



Premièrement, il est clair que le cache est utilisé. Ensuite - l'application est assemblée, déployée, les ports sont transférés. Étant donné que --port-forward est spécifié, Skaffold a transféré le port sur le web , comme demandé, mais il a transféré l' app à sa discrétion (il a choisi la plus proche gratuite). Après cela, nous obtenons les premiers journaux des applications.

Vérifiez les performances?

 ~/skaffold/examples/microservices # kubectl get po NAME READY STATUS RESTARTS AGE leeroy-app-6998dfcc95-2nxvf 1/1 Running 0 103s leeroy-web-69f7d47c9d-5ff77 1/1 Running 0 103s ~/skaffold/examples/microservices # curl localhost:9000 leeroooooy app!!! 

Modifiez le leeroy-app/app.go - cela prend quelques secondes ... et:

 ~/skaffold/examples/microservices # kubectl get po NAME READY STATUS RESTARTS AGE leeroy-app-ffd79d986-l6nwp 1/1 Running 0 11s leeroy-web-69f7d47c9d-5ff77 1/1 Running 0 4m59s ~/skaffold/examples/microservices # curl localhost:9000 leeroooooy Habr!!! 

En même temps, Skaffold lui-même a apporté à la console la même chose qu'auparavant, à l'exception d'un point: il n'a déployé que l' leeroy-app , et pas tout à la fois.

Plus de pratique

Il convient de mentionner que lors de la création d'un nouveau projet, les configurations pour Skaffold peuvent être amorcées à l'aide de la commande init , ce qui est très pratique. De plus, vous pouvez écrire plusieurs configurations: développez sur la configuration par défaut, puis run à l'étape avec la commande run (le même processus que dev , ne suit tout simplement pas les modifications), en utilisant une configuration différente.

Katacoda a un tutoriel avec un exemple encore plus simple. Mais il propose un bac à sable prêt à l'emploi avec Kubernetes, l'application et Skaffold. Une excellente option si vous êtes intéressé à essayer vous-même les bases.

Un cas d'utilisation possible pour Skaffold est de mener le développement sur un cluster distant. Tout le monde n'est pas à l'aise d'exécuter Minikube sur son propre matériel, puis de déployer l'application et d'attendre son bon fonctionnement ... Dans ce cas, Skaffold résout parfaitement la tâche, ce que, par exemple, les ingénieurs de Reddit peuvent confirmer, comme nous l'avons déjà écrit dans notre blog.

Et dans cette publication de Weaveworks, vous pouvez trouver un exemple de création d'un pipeline pour la production.

Conclusion

Skaffold est un outil pratique pour la construction de pipelines qui impliquent le déploiement d'applications sur Kubernetes et sont principalement axés sur les besoins de développement. Avec lui, il est assez simple de créer un pipeline «court» qui prend en compte les besoins de base du développeur, mais si vous le souhaitez, vous pouvez organiser des processus plus ambitieux. L'un des exemples illustratifs d'utilisation de Skaffold dans les processus CI / CD est un projet de test de 10 microservices qui utilise les capacités de Kubernetes, gRPC, Istio et OpenCensus Tracing.

Skaffold a déjà reçu près de 8000 étoiles sur GitHub, est développé par Google et fait partie de GoogleContainerTools - en général, pour le moment, il y a tout lieu de croire que le projet se développera avec bonheur pour toujours.

PS

Lisez aussi dans notre blog:

• « Outils pour les développeurs d'applications fonctionnant sur Kubernetes »;
• « Werf est notre outil CI / CD à Kubernetes (revue et rapport vidéo) »;
• " Garden v0.10.0: Votre ordinateur portable n'a pas besoin de Kubernetes ";
• " Trucs et astuces Kubernetes: sur le développement local et la téléprésence ."