Kubernetes semble être axé sur le déploiement de conteneurs sur un nuage de clusters. Ce qu'il ne semble pas toucher, ce sont les environnements de développement et de mise en scène (ou autre).

Pendant le développement, vous voulez être aussi proche que possible de l'environnement de production avec quelques changements importants:

• Déployé localement (ou du moins quelque part où vous et vous seul pouvez accéder )
• Utilisez le dernier code source lors de l'actualisation de la page (en supposant qu'il s'agit d'un site Web; idéalement, l'actualisation automatique de la page sur la sauvegarde du fichier local, ce qui peut être fait si vous montez le code source et utilisez des éléments comme Yeoman ).

De même, on peut souhaiter qu'un environnement non public fasse une intégration continue .

Kubernetes prend-il en charge ce type d'environnement de développement ou est-ce quelque chose qu'il faut construire, en espérant que pendant la production, cela fonctionnera toujours?

Mise à jour (15/07/2016)

Avec la sortie de Kubernetes 1.3, Minikube est désormais le moyen recommandé d'exécuter Kubernetes sur votre machine locale pour le développement.

Vous pouvez exécuter Kubernetes localement via Docker . Une fois que vous avez un nœud en cours d'exécution, vous pouvez lancer un pod qui a un serveur Web simple et monte un volume à partir de votre machine hôte. Lorsque vous frappez le serveur Web, il lira à partir du volume et si vous avez modifié le fichier sur votre disque local, il peut servir la dernière version.

Nous travaillons sur un outil pour ce faire. L'idée de base est que vous avez un cluster Kubernetes distant, en fait un environnement intermédiaire, puis vous exécutez le code localement et il est envoyé par proxy au cluster distant. Vous obtenez un accès réseau transparent, des variables d'environnement copiées, un accès aux volumes ... aussi proche que possible de l'environnement distant, mais avec votre code s'exécutant localement et sous votre contrôle total.

Vous pouvez donc faire du développement en direct, par exemple. Docs sur http://telepresence.io

Le genre de «rechargement à chaud» est quelque chose que nous avons l'intention d'ajouter, mais ce n'est pas aussi facile qu'il pourrait l'être aujourd'hui. Cependant, si vous vous sentez aventureux, vous pouvez utiliser rsync avec docker exec, kubectl exec ou osc exec (tous font la même chose à peu près) pour synchroniser un répertoire local dans un conteneur chaque fois qu'il change. Vous pouvez utiliser rsync avec kubectl ou osc exec comme ceci:

# rsync using osc as netcat
$ rsync -av -e 'osc exec -ip test -- /bin/bash' mylocalfolder/ /tmp/remote/folder

Un autre excellent point de départ est cette configuration Vagrant , en particulier. si votre système d'exploitation hôte est Windows. Les avantages évidents étant

• installation rapide et sans douleur
• facile à détruire / recréer la machine
• limite implicite des ressources
• possibilité de tester la mise à l'échelle horizontale en créant plusieurs nœuds

Les inconvénients - vous avez besoin de beaucoup de RAM, et VirtualBox est VirtualBox ... pour le meilleur ou pour le pire.

Le mappage des fichiers via NFS constitue un avantage / inconvénient mixte. Dans notre configuration, nous avons créé deux ensembles de définitions RC - un qui télécharge simplement une image docker de nos serveurs d'applications; l'autre avec 7 lignes supplémentaires qui configurent le mappage de fichiers depuis HostOS -> Vagrant -> VirtualBox -> CoreOS -> Kubernetes pod; écrasant le code source de l'image Docker.

L'inconvénient de cela est le cache de fichiers NFS - avec lui, c'est problématique, sans lui, il est très lent. Même le réglage mount_options: 'nolock,vers=3,udp,noac'ne résout pas complètement les problèmes de mise en cache, mais cela fonctionne la plupart du temps. Certaines tâches Gulp exécutées dans un conteneur peuvent prendre 5 minutes alors qu'elles prennent 8 secondes sur le système d'exploitation hôte. Un bon compromis semble être mount_options: 'nolock,vers=3,udp,ac,hard,noatime,nodiratime,acregmin=2,acdirmin=5,acregmax=15,acdirmax=15'.

En ce qui concerne le rechargement automatique du code, c'est spécifique au langage, mais nous sommes satisfaits du serveur de développement de Django pour Python et de Nodemon pour Node.js. Pour les projets frontaux, vous pouvez bien sûr faire beaucoup avec quelque chose comme gulp + browserSync + watch, mais pour de nombreux développeurs, il n'est pas difficile de servir à partir d'Apache et de faire simplement une actualisation matérielle traditionnelle.

Nous conservons 4 ensembles de fichiers yaml pour Kubernetes. Dev, "devstable", stage, prod. Les différences entre ceux-ci sont

• variables d'environnement définissant explicitement l'environnement (dev / stage / prod)
• nombre de répliques
• devstable, stage, prod utilise des images docker
• dev utilise des images docker et mappe le dossier NFS avec le code source dessus.

Il est très utile de créer beaucoup d'alias bash et de la saisie semi-automatique - je peux simplement taper rec userset ça fera l'affaire kubectl delete -f ... ; kubectl create -f .... Si je veux que l'ensemble de la configuration démarre, je tape recfoet il recrée une douzaine de services, en extrayant les dernières images du docker, en important le dernier db dump de Staging env et en nettoyant les anciens fichiers Docker pour économiser de l'espace.

Je viens de commencer avec Skaffold

Il est vraiment utile d'appliquer automatiquement les modifications du code à un cluster local.

Pour déployer un cluster local, le meilleur moyen est Minikube ou simplement Docker pour Mac et Windows, les deux incluent une interface Kubernetes.

Voir https://github.com/kubernetes/kubernetes/issues/12278 pour savoir comment monter un volume à partir de la machine hôte, l'équivalent de:

docker run -v hostPath:ContainerPath

Avoir une belle boucle de rétroaction sur le développement local est un sujet de développement rapide dans l'écosystème Kubernetes.

Pour briser cette question, il y a quelques outils qui, à mon avis, soutiennent bien cet objectif.

Docker pour Mac Kubernetes

Docker pour Mac Kubernetes ( Docker Desktop est le nom générique de plusieurs plates-formes) offre une excellente option pour le développement local. Pour la virtualisation, il utilise HyperKit qui est construit sur le framework Hypervisor natif dans macOS au lieu de VirtualBox.

La fonctionnalité Kubernetes a été publiée pour la première fois en version bêta sur le canal de périphérie en janvier 2018 et a parcouru un long chemin depuis, devenant un Kubernetes certifié en avril 2018 et passant au canal stable en juillet 2018 .

D'après mon expérience, il est beaucoup plus facile de travailler avec que Minikube, en particulier sur macOS, et en particulier lorsqu'il s'agit de problèmes tels que RBAC, Helm, hyperviseur, registre privé, etc.

Barre

En ce qui concerne la distribution de votre code et l'extraction des mises à jour localement, Helm est l'une des options les plus populaires. Vous pouvez publier vos applications via CI / CD sous forme de graphiques Helm (ainsi que les images Docker sous-jacentes auxquelles elles font référence). Ensuite, vous pouvez extraire ces graphiques de votre registre de graphiques Helm localement et les mettre à niveau sur votre cluster local.

Brouillon Azure

Vous pouvez également utiliser un outil tel qu'Azure Draft pour effectuer des déploiements locaux simples et générer des graphiques Helm de base à partir de modèles de langage courants, un peu comme des buildpacks, pour automatiser cette pièce du puzzle.

Skaffold

Skaffold est comme Azure Draft mais plus mature, beaucoup plus large et fabriqué par Google. Il a une architecture très enfichable. Je pense qu'à l'avenir, plus de personnes l'utiliseront pour le développement d'applications locales pour Kubernetes.

Si vous avez utilisé React, je pense à Skaffold comme " Create React App for Kubernetes".

Kompose ou Compose sur Kubernetes

Docker Compose , bien que non lié à Kubernetes, est une alternative que certaines entreprises utilisent pour fournir un environnement de développement local simple, facile et portable, analogue à l'environnement Kubernetes qu'elles exécutent en production. Cependant, emprunter cette voie signifie diviser vos configurations de production et de développement local.

Kompose est un convertisseur Docker Compose vers Kubernetes. Cela pourrait être un chemin utile pour quelqu'un qui exécute déjà ses applications en tant que collections de conteneurs localement.

Compose on Kubernetes est une offre récemment ouverte (décembre 2018) de Docker qui permet de déployer des fichiers Docker Compose directement sur un cluster Kubernetes via un contrôleur personnalisé.

Kubespary est utile pour la mise en place de clusters locaux. La plupart du temps, j'ai utilisé un cluster basé sur un vagabond sur une machine locale.

Configuration de Kubespray Vous pouvez modifier ces variables pour avoir la version Kubernetes souhaitée.

L'inconvénient de l'utilisation minkubeest qu'elle génère une autre machine virtuelle sur votre machine. De plus, avec la dernière minikubeversion, il faut au minimum avoir 2 CPU et 2 Go de RAM de votre système, ce qui le rend assez lourd si vous n'avez pas le système avec suffisamment de ressources.

C'est la raison pour laquelle je suis passé au microk8sdéveloppement sur kubernetes et je l'adore. microk8sprend en charge le DNS, le stockage local, le tableau de bord, l'istio, l'entrée et bien d'autres, tout ce dont vous avez besoin pour tester vos microservices.

Il est conçu pour être une installation Kubernetes en amont rapide et légère isolée de votre environnement local. Cet isolement est obtenu en regroupant tous les binaires pour Kubernetes, Docker.io, iptables et CNI dans un seul package snap.

Un cluster Kubernetes à nœud unique peut être installé en une minute avec une seule commande:

snap install microk8s --classic

Assurez-vous que votre système ne dispose d'aucun service docker ou kubelet en cours d'exécution. Microk8sinstallera automatiquement tous les services requis.

Veuillez consulter le lien suivant pour activer d'autres modules complémentaires dans microk8s.

https://github.com/ubuntu/microk8s

Vous pouvez vérifier l'état en utilisant:

velotio@velotio-ThinkPad-E470:~/PycharmProjects/k8sClient$ microk8s.status
microk8s is running
addons:
ingress: disabled
dns: disabled
metrics-server: disabled
istio: disabled
gpu: disabled
storage: disabled
dashboard: disabled
registry: disabled

Jetez un œil à https://github.com/okteto/okteto et Okteto Cloud . La proposition de valeur est d'avoir l'expérience de développement classique que de travailler localement, avant docker, où vous pouvez avoir des recharges à chaud, des builds incrémentiels, des débogueurs ... mais toutes vos modifications locales sont immédiatement synchronisées sur un conteneur distant. Les conteneurs distants vous donnent accès à la vitesse du cloud, permettent un nouveau niveau de collaboration et intègrent le développement dans un environnement de production. En outre, il élimine le fardeau des installations locales.

Comme spécifié précédemment par Robert, minikube est la voie à suivre.

Voici un guide rapide pour démarrer avec minikube. Les étapes générales sont:

• Installer minikube

• Créer un cluster de minikube (dans une machine virtuelle qui peut être VirtualBox ou Docker pour Mac ou HyperV dans le cas de Windows)

• Créer une image Docker de votre fichier d'application (à l'aide de Dockerfile)

• Exécutez l'image en créant un déploiement

• Créez un service qui expose votre application afin que vous puissiez y accéder.

Voici comment j'ai fait une configuration locale pour Kubernetes dans Windows 10: -

• Utiliser Docker Desktop

• Activez Kubernetes dans l'option des paramètres de Docker Desktop

• Dans Docker Desktop, la ressource par défaut allouée à la mémoire est de 2 Go, donc pour utiliser Kubernetes avec Docker Desktop, augmentez la mémoire.

• Installez kubectl en tant que client pour parler au cluster Kubernetes

• Exécutez la commande kubectl config get-contextts pour obtenir le cluster disponible

• Exécutez la commande kubectl config use-context docker-desktop pour utiliser le bureau docker

• Créez une image docker de votre application

• Ecrire un fichier YAML (méthode descriptive pour créer votre déploiement dans Kubernetes) pointant vers l'image créée dans le cluster de l'étape ci-dessus

• Exposez un service de type node port pour chacun de vos déploiements pour le rendre disponible au monde extérieur