Wie man eine mehrschichtige Anwendung mit Kubernetes einsetzt

Eine mehrschichtige Anwendung ist eine Anwendung, die auf mehr als eine Schicht verteilt ist. Sie trennt die operativen Schichten logisch voneinander. Die Anzahl der Schichten variiert je nach Geschäfts- und Anwendungsanforderungen. In diesem Artikel sehen wir eine Anwendung, die in 2 Schichten, Backend- und Frontend-Schicht, unterteilt ist. Wir werden MongoDB als Backend zum Speichern von Daten und Python Flask als Frontend-Webserver verwenden. Wir werden diese beiden Anwendungen unter Verwendung von Implementierungen in Kubernetes einsetzen und über Dienste verfügen, um Anfragen an sie weiterzuleiten.

Vorraussetzungen

  1. Kubernetes Cluster mit mindestens 1 Worker-Knoten.
    Wenn Sie lernen möchten, wie man einen Kubernetes Cluster erstellt, klicken Sie hier. Dieses Handbuch hilft Ihnen, einen Kubernetes-Cluster mit 1 Master- und 2 Worker-Knoten auf AWS Ubuntu 18.04 EC2-Instanzen zu erstellen.
  2. Grundlegendes Verständnis von Implementierungen und Diensten.
    Siehe Implementierungenund Dienste, um ein grundlegendes Verständniszu erhalten.

Was werden wir tun?

  1. Bereitstellen einer mehrschichtigen Anwendung

Bereitstellen einer mehrschichtigen Anwendung

Erstellen Sie eine neue Datei mit dem Namen „test-db-deployment.yaml“ mit folgendem Inhalt. Dadurch wird ein Deployment von MongoDB definiert, das als Datenbank, als Backend-Layer, fungiert.

vim test-db-b-bereitstellung.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-db
spec:
  selector:
    matchLabels:
      appdb: testdb
  replicas: 1
  template:
    metadata:
      labels:
        appdb: testdb
    spec:
      containers:
      - name: test-db
        image: mongo:3.3
        env:
        - name: MONGODB_DATABASE
          value: testdata
        ports:
        - containerPort: 27017

Datei test-db-deployment.yaml

Erstellen Sie jetzt einen Dienst, der Anfragen an die MongoDB von unserer Frontend-Anwendung aus bedient. Dieser Dienst wird auf Port 27017 lauschen und Anfragen an MongoDB auf demselben Port weiterleiten.

vim test-db-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: mongodb
  labels:
    app: testdb
spec:
  ports:
  - port: 27017
    protocol: TCP
  selector:
    appdb: testdb

Datei test-db-service.yaml

Der nächste Schritt ist die Definition einer Frontend-Anwendung. Erstellen Sie eine neue Datei mit der folgenden Einsatzdefinition.

Diese wird auf Port 5000 abgehört.

Anfragen an MongoDB werden an MONGODB_HOST, d.h. den mongodb-Dienst, weitergeleitet.

vim test-web-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test
spec:
  selector:
    matchLabels:
      app: test
  replicas: 1
  template:
    metadata:
      labels:
        app: test
    spec:
      containers:
      - name: test-app
        image: teamcloudyuga/rsvpapp
        env:
        - name: MONGODB_HOST
          value: mongodb
        ports:
        - containerPort: 5000
          name: web-port

Datei test-web-deployment.yaml

Um auf das Frontend zuzugreifen, werden wir einen Dienst vom Typ NodePort einrichten, der auf Port 31081 lauscht. Das bedeutet, dass auf den Python Flask Webserver unter IP=IP-Of-Any-Node und Port=31081 zugegriffen werden kann. Erstellen Sie einen neuen mit der folgenden Dienstdefinition.

vim test-web-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: test
  labels:
    apps: test
spec:
  type: NodePort
  ports:
  - name: tcp-31081-5000
    nodePort: 31081
    port: 5000
    protocol: TCP
  selector:
    app: test

Datei test-web-service.yaml

Nun sind wir alle bereit, eine zweistufige Beispielanwendung zu erstellen. Bevor wir fortfahren, sollten wir prüfen, ob der Cluster irgendwelche Objekte enthält.

Führen Sie die folgenden Befehle aus, um die im Cluster laufenden Pods, Deployments und Dienste zu überprüfen.

kubectl Pods erhalten

kubectl erhält Einsätze

kubectl bekommen Service

vorhandene Objekte prüfen

Im obigen Screenshot ist zu sehen, dass es im Cluster nur 1 Kubernetes Standard-Dienst gibt.

Führen Sie nun den folgenden Befehl nacheinander in dem Verzeichnis aus, in dem Sie 4 Dateien erstellt haben, um MongoDB-Bereitstellung, MongoDB-Dienst, Python Flask Webserver-Bereitstellung und Python Flask Webserver-Dienst zu erstellen.

kubectl erstellt -f test-db-deployment.yaml

kubectl create -f test-db-service.yaml

kubectl create -f test-web-deployment.yaml

kubectl create -f test-web-service.yaml

Einsätze und Dienste erstellen

Im obigen Screenshot sehen Sie, dass die MongoDB-Bereitstellung, der MongoDB-Dienst, die Python Flask Webserver-Bereitstellung und der Python Flask Webserver-Dienst erfolgreich erstellt wurden.

Um dies zu überprüfen, führen Sie die folgenden Befehle aus.

kubectl get pods

kubectl erhält Einsätze

kubectl bekommen Service

Im folgenden Screenshot sehen Sie, dass 2 Pods und 2 Dienste erstellt wurden. Die erstellten Pods werden durch den von uns erstellten Einsatz gesteuert.

neu erstellte Objekte prüfen

Nun sind wir alle bereit, auf die Anwendung auf IP-of-any-Node:NodePort zuzugreifen, d.h. IP-of-any-Node :31081.

Sobald Sie auf die URL im Browser klicken, sehen Sie die Anwendung wie folgt. Dies ist eine Beispielanwendung, die das öffentlich zugängliche Docker-Bild verwendet und zu CloudYuga gehört. Hier können Sie sehen, dass die RSVP-Anzahl 0 ist, das bedeutet, dass MongoDB keine Daten enthält.

Zugriff auf die Anwendung unter NodeIP:NodePort

Nun können wir ein paar Demo-Einträge hinzufügen.

Wenn wir ein paar Einträge hinzufügen, können wir sehen, dass sich die Anzahl geändert hat. Das bedeutet, dass die Daten in MongoDB gespeichert wurden.

Daten in der Anwendung hinzufügen

Nun, wenn Sie diese Anwendungen nicht mehr benötigen, können Sie alle Objekte löschen, indem Sie den folgenden Befehl in dem Verzeichnis ausführen, in dem Sie alle Ihre Kubernetes-Objektdateien haben.

kubectl löschen -f .

die Einsätze und Dienste insgesamt löschen

Der obige Befehl löscht MongoDB-Bereitstellung, MongoDB-Dienst, Python Flask Webserver-Bereitstellung und Python Flask Webserver-Dienst, die wir erstellt haben.

Um zu überprüfen, ob alle von uns erstellten Objekte erfolgreich gelöscht wurden, führen Sie den folgenden Befehl aus.

kubectl liefert alle

Im folgenden Screenshot sehen Sie, dass es nur einen Standard-Kubernetes-Dienst gibt und die von uns erstellten Objekte nicht mehr existieren.

prüfen, ob alle von uns erstellten Objekte gelöscht wurden

Schlussfolgerung

In diesem Artikel haben wir eine Bereitstellung der MongoDB-Backend-Datenbank und des Dienstes für den Zugriff auf die Datenbank und für das Frontend eine auf Python Flask basierende Anwendungsbereitstellung und einen Dienst für den Zugriff auf dieses Frontend erstellt. Wir sahen auch, wie die Daten in der Backend-Datenbank gespeichert wurden. Dies ist eine 2-Tier-Beispielanwendung, die öffentlich verfügbare Docker-Images verwendet.

Das könnte dich auch interessieren …