een Multi-Tier Applicatie inzetten met Kubernetes

Een multi-tier toepassing is een toepassing die over meer dan één laag verdeeld is. Het scheidt op logische wijze de operationele lagen. Het aantal lagen varieert met de bedrijfs- en toepassingsvereisten. In dit artikel zien we een toepassing verdeeld in 2 lagen, backend en frontend laag. We zullen MongoDB gebruiken als backend om gegevens op te slaan en Python Flask als frontend Webserver. We zullen deze twee applicaties inzetten met behulp van deployments in Kubernetes en diensten hebben om er verzoeken naar door te sturen.

Vereisten

  1. Kubernetes Cluster met minstens 1 worker node.
    Als je wilt leren hoe je een Kubernetes Cluster maakt, klik dan hier. Deze gids helpt je een Kubernetes cluster te maken met 1 Master en 2 Nodes op AWS Ubuntu 18.04 EC2 Instances.
  2. Basiskennis van Deployments en Services.
    RaadpleegDeployments enServices om een basiskennis te krijgen.

Wat zullen we doen?

  1. Een Multi-Tier Toepassing inzetten

Zet een Multi-Tier toepassing op

Maak een nieuw bestand met de naam “test-db-deployment.yaml” met de volgende inhoud. Dit zal een inzet van MongoDB definiëren die zal fungeren als database, een backend laag.

vim test-db-deployment.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

test-db-deployment.yaml bestand

Maak nu een dienst die verzoeken aan de MongoDB zal dienen vanuit onze frontend toepassing. Deze dienst zal luisteren op poort 27017 en verzoeken doorsturen naar de MongoDB op dezelfde poort.

vim test-db-service.yaml

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

test-db-service.yaml bestand

De volgende stap is het definiëren van een frontend toepassing. Maak een nieuw bestand met de volgende inzetdefinitie.

Deze zal luisteren op poort 5000.

Verzoeken aan MongoDB zullen worden doorgestuurd naar MONGODB_HOST d.w.z. de mongodb dienst.

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

test-web-deployment.yaml bestand

Om toegang te krijgen tot de frontend, maken we een dienst van het type NodePort die luistert op poort 31081. Dit betekent dat de Python Flask Webserver benaderd kan worden op IP=IP-Of-Any-Node en Port=31081. Maak een nieuwe met de volgende dienstdefinitie.

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

test-web-service.yaml bestand

Nu zijn we helemaal klaar om een 2 traps voorbeeld toepassing te maken. Laten we, voor we verder gaan, controleren of het cluster objecten heeft.

Voer de volgende commando’s uit om te controleren of er pods, deployments en diensten in het cluster draaien.

kubectl get pods

kubectl get deployments

kubectl get service

controleer bestaande objecten

In de bovenstaande schermafbeelding is te zien dat er slechts 1 kubernetes standaarddienst in het cluster is.

Voer nu een voor een het volgende commando uit vanuit de map waar je 4 bestanden hebt aangemaakt om MongoDB inzet, MongoDB dienst, Python Flask Webserver inzet en Python Flask Webserver dienst aan te maken.

kubectl create -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

maak deployments en diensten

In de bovenstaande schermafbeelding zie je dat de MongoDB inzet, MongoDB dienst, Python Flask Webserver inzet en Python Flask Webserver dienst met succes zijn aangemaakt.

Om hetzelfde te verifiëren voer je de volgende commando’s uit.

kubectl get pods

kubectl get deployments

kubectl get service

In de volgende schermafbeelding zie je dat er 2 pods en 2 services zijn aangemaakt. De pods die zijn aangemaakt worden bestuurd door de deployment die we maakten.

controleer pas gemaakte objecten

Nu zijn we helemaal klaar om de toepassing te benaderen opIP-of-any-Node:NodePort, d.w.z. IP-of-any-Node:31081.

Zodra je de URL in de browser aanklikt, zie je de toepassing als volgt. Dit is een voorbeeld toepassing die het publiek beschikbare docker image gebruikt en bij CloudYuga hoort. Hier zie je dat de RSVP count 0 is, dit betekent dat MongoDB er geen gegevens in heeft.

toegang tot de toepassing op NodeIP:NodePort

Nu kunnen we een paar demo entries toevoegen.

Bij het toevoegen van een paar entries zien we dat de telling veranderd is. Dit betekent dat de gegevens in MongoDB zijn opgeslagen.

gegevens toevoegen in de toepassing

Als je deze toepassingen nu niet meer nodig hebt, kun je alle objecten verwijderen door het volgende commando uit te voeren vanuit de map waar je al je Kubernetes object bestanden hebt staan.

kubectl delete -f .

verwijder de installaties en diensten helemaal

Het bovenstaande commando verwijdert de MongoDB inzet, MongoDB dienst, Python Flask Webserver inzet en Python Flask Webserver dienst die we maakten.

Om te controleren of alle objecten die we gemaakt hebben met succes verwijderd zijn, voer je het volgende commando uit.

kubectl get all

In de volgende schermafbeelding zie je dat er nog maar één standaard kubernetes dienst is en dat de objecten die we hadden aangemaakt niet meer bestaan.

controleer of alle objecten die we gemaakt hebben verwijderd zijn

Conclusie

In dit artikel maakten we een inzet van de MongoDB backend database en een dienst om de database te benaderen, en voor de frontend maakten we een op Python Flask gebaseerde applicatie-inzet en een dienst om deze frontend te benaderen. We zagen ook hoe de gegevens in de backend databank werden opgeslagen. Dit is een voorbeeld van een 2-tier toepassing die gebruik maakt van publiek beschikbare docker images.