Bereitstellung von Kubernetes auf dem Desktop in wenigen Minuten mit MicroK8s

Der Einstieg in Kubernetes ist nicht immer einfach. Nicht jeder verfügt über die erforderliche Infrastruktur, um einen vollständigen Kubernetes-Cluster bereitzustellen. Kubernetes bietet das Dienstprogramm Minikube für den lokalen Betrieb an. Minikube ist ein ziemlich einfaches und praktisches Tool, und es gibt verschiedene Schulungen zur Arbeit mit Minikube. Über Minikube kann man jedoch nicht sagen, dass Sie mit diesem Dienstprogramm die Kubernetes-Umgebung in wenigen Minuten bereitstellen können.

Heute möchte ich über das MicroK8s- Paket sprechen, mit dem Sie ohne Übertreibung Kubernetes in wenigen Minuten lokal bereitstellen und mit der Entwicklung beginnen können. Nicht einmal vorinstallierte Docker und Kubernetes sind erforderlich, wie All-Inclusive. In dieser Lektion werden Sie die Bereitstellung der Django-Anwendung in der lokalen Kubernetes-Umgebung betrachten.

Als Quelle folgte ich einer Reihe von Artikeln von Mark Gituma , in denen ähnliche Arbeiten beschrieben wurden, jedoch nur mit Minikube und nicht mit MicroK8s.

Dennoch gibt es eine Anforderung, die vor Arbeitsbeginn erfüllt sein muss. Sie müssen Snap installiert haben, was wiederum bedeutet, dass Sie Linux installiert haben müssen.

Die Installation von MicroK8s wird im Handbuch auf der Website beschrieben . Dies ist jedoch nur eine Zeile:

sudo snap install microk8s --classic 

Außerdem kann es erforderlich sein, die Umgebung zu starten:

 sudo microk8s.start 

Als nächstes müssen Sie die Erweiterung aktivieren. Eine vollständige Liste der Erweiterungen erhalten Sie mit dem Befehl microk8s.enable --help : Dashboard, microk8s.enable --help , Ingress, Istio, Metrics-Server, Registrierung, Speicher. Sie können sofort alles außer GPU und Istio aktivieren, weil Der erste erfordert einen vorinstallierten Treiber, und der zweite aktualisiert im Wesentlichen die Umgebung und lädt (persönlich auf meinem schwachen Desktop) das System stark.

 microk8s.enable dashboard dns ingress metrics-server registry storage 

Wie Sie jetzt aus der Liste der Erweiterungen schließen können, haben Sie Zugriff auf viele Dienste, einschließlich Dashboard und Metriken.

Erstellen Sie eine Docker-Datei, um das Bild zu erstellen:

 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"] 

und die Datei mit den erforderlichen Anforderungen.txt-Abhängigkeiten:

 celery==4.1.0 Django==2.0 kombu==4.1.0 

Sammeln wir das Bild. Dafür benötigen Sie keinen vorinstallierten Docker, weil Es kommt mit MicroK8s:

 microk8s.docker build django -t apapacy/tut-django:1.0.0 

Wenn Sie das Image mit dem zuvor installierten Docker erfassen, reicht es möglicherweise nicht aus, das Image einfach zu erfassen und an die lokale Registrierung zu senden, die ebenfalls mit MicroK8s geliefert wird und auf Port 32000 funktioniert:

 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 

Höchstwahrscheinlich wird dieser Schritt nicht benötigt, aber der Vollständigkeit halber habe ich darauf hingewiesen und gleichzeitig Ihre Aufmerksamkeit darauf gelenkt, dass Sie eine lokale Docker-Registrierung haben.

Der Grundbaustein von Kubernetes ist Pod (Pod), in dem der Container funktioniert (meistens einer, aber möglicherweise mehrere). Pods können auf verschiedene Weise erstellt werden. Aber heute interessieren wir uns für Deployment (Deployment). Die Bereitstellung beschreibt die Vorlage, mit der Pods erstellt werden. Die Bereitstellung wird mithilfe von XML-Konfigurationsdateien definiert. In der Bereitstellungskonfiguration geben Sie die Anzahl der Pod-Replikate und das Image an, von dem dieser Pod und seine Replikate erfasst werden, sowie den Port (Port 8000, auf dem Django von Dockerfile ausgeführt wird - keine 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 

Die Kaution wird am Mittwoch vom Team geladen:

 microk8s.kubectl apply -f config/deployment.yml 

Parallel dazu können Sie einen Befehl ausführen, der die Aktionen überwacht, die während der Bereitstellung ausgeführt werden:

 watch microk8s.kubectl get all 

Jetzt haben Sie mehrere Pods mit Django-Anwendungen, auf die Sie keinen Zugriff haben. Damit Pods miteinander und mit der Außenwelt kommunizieren können, gibt es eine andere Abstraktion - dies ist Service. Der Dienst wird wie die Bereitstellung durch die Konfigurationsdatei definiert:

 kind: Service apiVersion: v1 metadata: name: django-service spec: selector: pod: django-container ports: - protocol: TCP port: 8000 # targetPort: 8001 type: ClusterIP # type: NodePort 

Der pod: django-container Selektor bestimmt, welche Bereitstellung vom Service bedient wird (der Name des Pod-Selektors ist nicht vordefiniert - dies ist nur eine Bezeichnung, die übereinstimmen muss). Der Dienst wird ähnlich wie bei der Bereitstellung geladen:

 microk8s.kubectl apply -f config/service.yml 

Nach dem Herunterladen kann auf den Dienst unter der internen Netzwerkadresse zugegriffen werden. Wenn Sie den Befehl microk8s.kubectl get all Adresse microk8s.kubectl get all :

 service/django-service ClusterIP 10.152.183.156 none 8000/TCP 3h33m 

Durch Ausführen des Befehls curl (oder durch Öffnen eines Browsers) erhalten wir die Django-Begrüßungsseite:

 curl 10.152.183.156:8000 

In der Konfiguration des Dienstes gibt es zwei kommentierte Zeilen. Wenn Sie sie auskommentieren, ist der Dienst zusätzlich über einen zufälligen Port im Bereich von 32000 und höher über ein externes Netzwerk verfügbar.

Um eine permanente Adresse für den Dienst zu erhalten, über die über das externe Netzwerk Kontakt aufgenommen werden kann, bietet MicroK8s zwei Optionen: 1) Eingang und 2) Istio. Der einfachste Weg, dies zu tun, ist mit dem Eindringen. Wenn noch nicht aktiviert, müssen Sie die Eingangskomponente aktivieren:

 microk8s.enable ingress 

Danach können Sie überprüfen, ob diese Komponente installiert ist und funktioniert, indem Sie den Befehl microk8s.kubectl get all . In der Liste der Anwendungen und Dienste mit dem Namen default-http-backend sollten einige Einträge default-http-backend . Insbesondere sollte ein Dienst angezeigt werden, der auf Port 80 ausgeführt wird:

 service/default-http-backend ClusterIP 10.152.183.42 none 80/TCP 179m 

Der Name default-http-backend ist der in MicroK8s vordefinierte Name. Unter diesem Namen müssen Sie in Eingangskonfigurationen auf diesen Dienst verweisen.

Die Eingangskonfigurationen ähneln den Konfigurationen eines Webservers oder Proxyservers und befinden sich irgendwo im System. Daher sind in ihnen Hosts, Pfade und Ports vorhanden - alles Attribute, die bekannt sind:

 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 

Die Eingangskonfiguration wird mit dem folgenden Befehl geladen:

 microk8s.kubectl apply -f config/ingress.yml 

Danach ist die Django-Begrüßungsseite unter localhost / django verfügbar

Das ist alles für heute.

Nützliche Links:

1. github.com/apapacy/microk8s-tut
2. medium.com/@markgituma/kubernetes-local-to-production-with-django-2-docker-and-minikube-ba843d858817

apapacy@gmail.com
10. Februar 2019