Débuter avec Kubernetes n'est pas toujours facile. Tout le monde n'a pas l'infrastructure nécessaire pour déployer un cluster Kubernetes complet. Kubernetes propose l'utilitaire Minikube pour un fonctionnement local. Minikube est un outil assez simple et pratique, et il existe plusieurs cours de formation sur l'utilisation de Minikube. Mais, néanmoins, on ne peut pas dire à propos de Minikube qu'en utilisant cet utilitaire, vous pouvez déployer l'environnement Kubernetes en quelques minutes.
Aujourd'hui, je veux parler du package
MicroK8s , qui, sans exagération, vous permet de déployer Kubernetes localement en quelques minutes et de démarrer le développement. Même Docker et Kubernetes préinstallés ne sont pas nécessaires, car tout compris. Dans cette leçon, vous allez envisager de déployer l'application Django dans l'environnement Kubernetes local.
En tant que source, j'ai suivi une série d'articles de
Mark Gituma qui décrivaient un travail similaire, mais uniquement avec Minikube, pas MicroK8.
Néanmoins, une exigence doit être remplie avant de commencer à travailler. Vous devez avoir installé
Snap , ce qui signifie que vous devez avoir installé Linux.
L'installation des MicroK8 est décrite dans le
manuel sur le site . Cependant, ce n'est qu'une ligne:
sudo snap install microk8s --classic
De plus, il peut être nécessaire de démarrer l'environnement:
sudo microk8s.start
Ensuite, vous devez activer l'extension. Une liste complète des extensions peut être obtenue avec la commande
microk8s.enable --help : dashboard, dns, gpu, ingress, istio, metrics-server, Registry, storage. Vous pouvez immédiatement tout activer sauf gpu et istio, car le premier d'entre eux nécessite un pilote préinstallé, et le second met essentiellement à niveau l'environnement et (personnellement, sur mon bureau faible) charge lourdement le système.
microk8s.enable dashboard dns ingress metrics-server registry storage
Comme vous pouvez maintenant le conclure à partir de la liste des extensions, vous aurez accès à de nombreux services, dont le tableau de bord et les métriques.
Créez un Dockerfile pour créer l'image:
FROM python:3-slim LABEL maintainer="mark.gituma@gmail.com" WORKDIR /app COPY requirements.txt . RUN pip install -r requirements.txt RUN django-admin startproject mysite /app EXPOSE 8000 STOPSIGNAL SIGINT ENTRYPOINT ["python", "manage.py"] CMD ["runserver", "0.0.0.0:8000"]
et le fichier avec les dépendances requirements.txt nécessaires:
celery==4.1.0 Django==2.0 kombu==4.1.0
Collectons l'image. Aucun Docker préinstallé n'est nécessaire pour cela, car Il est livré avec MicroK8:
microk8s.docker build django -t apapacy/tut-django:1.0.0
Si vous collectez l'image avec le docker installé précédemment, il peut ne pas être suffisant pour vous de simplement collecter l'image et l'envoyer au registre local, qui est également livré avec MicroK8s et fonctionne sur le port 32000:
microk8s.docker tag apapacy/tut-django:1.0.0 localhost:32000/apapacy/tut-django:1.0.0 microk8s.docker push localhost:32000/apapacy/tut-django:1.0.0
Très probablement, cette étape ne sera pas nécessaire, mais pour être complète, je l'ai souligné et en même temps, j'ai attiré votre attention sur le fait que vous disposiez d'un registre Docker local.
Le bloc de construction de base de Kubernetes est Pod (Pod), dans lequel le conteneur fonctionne (le plus souvent un mais il peut y en avoir plusieurs). Les pods peuvent être créés par différents moyens. Mais aujourd'hui, nous nous intéressons au Déploiement (Déploiement). Le déploiement décrit le modèle par lequel les pods sont créés. Le déploiement est défini à l'aide de fichiers de configuration yml. Dans la configuration de déploiement, vous spécifiez le nombre de répliques de pod et l'image à partir de laquelle ce pod et ses répliques seront collectées, ainsi que le port (port 8000 sur lequel Django de Dockerfile fonctionne - pas de magie):
apiVersion: apps/v1beta2 kind: Deployment metadata: name: django labels: app: django spec: replicas: 2 selector: matchLabels: pod: django-container template: metadata: labels: pod: django-container spec: containers: - name: django-web image: localhost:32000/apapacy/tut-django:1.0.0 ports: - containerPort: 8000
Le dépôt est chargé mercredi par l'équipe:
microk8s.kubectl apply -f config/deployment.yml
En parallèle, vous pouvez exécuter une commande qui surveillera les actions qui se produisent pendant le déploiement:
watch microk8s.kubectl get all
Vous disposez maintenant de plusieurs Pods avec des applications Django auxquelles vous n'avez pas accès. Pour que les Pods communiquent entre eux et avec le monde extérieur, il existe une autre abstraction - c'est le Service. Le service, comme le déploiement, est défini par le fichier de configuration:
kind: Service apiVersion: v1 metadata: name: django-service spec: selector: pod: django-container ports: - protocol: TCP port: 8000 # targetPort: 8001 type: ClusterIP # type: NodePort
Le sélecteur
pod: django-container détermine le déploiement qui sera pris en charge par le service (le nom du sélecteur de pod n'est pas prédéfini - c'est juste une étiquette qui doit correspondre). Le service est chargé de manière similaire au déploiement:
microk8s.kubectl apply -f config/service.yml
Après le téléchargement, le Service est accessible à l'adresse réseau interne. Si vous exécutez la commande
microk8s.kubectl get all , vous pouvez voir cette adresse:
service/django-service ClusterIP 10.152.183.156 none 8000/TCP 3h33m
En exécutant la commande curl (ou en ouvrant un navigateur) nous obtenons la page d'accueil de Django:
curl 10.152.183.156:8000
Il y a deux lignes commentées dans la configuration du Service. Si vous les décommentez, le service sera également disponible à partir d'un réseau externe via un port aléatoire dans la plage de 32000 et plus.
Afin d'obtenir une adresse permanente pour le Service, par laquelle il sera possible de contacter à partir du réseau externe, MicroK8s propose deux options: 1) entrée et 2) istio. La façon la plus simple de le faire est de pénétrer. S'il n'est pas encore activé, vous devez activer le composant d'entrée:
microk8s.enable ingress
Après cela, vous pouvez vérifier que ce composant est installé et fonctionne en exécutant la commande
microk8s.kubectl get all . Quelques entrées doivent apparaître dans la liste des applications et services avec le nom
default-http-backend . En particulier, un service fonctionnant sur le port 80 devrait apparaître:
service/default-http-backend ClusterIP 10.152.183.42 none 80/TCP 179m
Le nom default-http-backend est le nom prédéfini dans MicroK8s. C'est par ce nom que vous devez vous référer à ce service dans les configurations d'entrée.
Les configurations d'entrée ressemblent aux configurations d'un serveur Web ou d'un serveur proxy, et quelque part à l'intérieur du système, elles se trouvent. Par conséquent, des hôtes, des chemins et des ports y sont présents - tous les attributs qui sont familiers:
apiVersion: extensions/v1beta1 kind: Ingress metadata: name: tut-django annotations: nginx.ingress.kubernetes.io/rewrite-target: / spec: backend: serviceName: default-http-backend servicePort: 80 rules: - host: localhost http: paths: - path: /django backend: serviceName: django-service servicePort: 8000
La configuration d'entrée est chargée avec la commande:
microk8s.kubectl apply -f config/ingress.yml
Après quoi, la page d'accueil de Django sera disponible sur
localhost / djangoC'est tout pour aujourd'hui.
Liens utiles:
1.
github.com/apapacy/microk8s-tut2.
medium.com/@markgituma/kubernetes-local-to-production-with-django-2-docker-and-minikube-ba843d858817apapacy@gmail.com
10 février 2019