Comment déployer une application multi-niveaux avec Kubernetes

Une application multi-tiers est une application répartie sur plusieurs couches. Elle sépare logiquement les couches opérationnelles. Le nombre de couches varie en fonction des exigences de l’entreprise et de l’application. Dans cet article, nous allons voir une application divisée en 2 couches, la couche backend et la couche frontend. Nous utiliserons MongoDB comme backend pour stocker les données et Python Flask comme serveur Web frontal. Nous déploierons ces deux applications à l’aide de déploiements dans Kubernetes et disposerons de services pour leur transmettre des demandes.

Pré-requis

  1. Cluster Kubernetes avec au moins 1 nœud de travail.
    Si tu veux apprendre à créer un cluster Kubernetes, clique ici. Ce guide t’aidera à créer un cluster Kubernetes avec 1 maître et 2 nœuds sur des instances EC2 AWS Ubuntu 18.04.
  2. Compréhension de base des Déploiements et Services.
    Reporte-toi àDéploiements etServices pour avoir une compréhension de base.

Que ferons-nous ?

  1. Déployer une application multi-niveaux

Déployer une application multi-niveaux

Crée un nouveau fichier nommé « test-db-deployment.yaml » avec le contenu suivant. Cela définira un déploiement de MongoDB qui agira comme une base de données, une couche dorsale.

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

Fichier test-db-deployment.yaml

Maintenant, crée un service qui servira les demandes à MongoDB depuis notre application frontale. Ce service écoutera sur le port 27017 et transmettra les demandes à MongoDB sur le même port.

vim test-db-service.yaml

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

Fichier test-db-service.yaml

L’étape suivante consiste à définir une application frontale. Crée un nouveau fichier contenant la définition de déploiement suivante.

Cette application écoutera sur le port 5000.

Les demandes adressées à MongoDB seront transmises à MONGODB_HOST, c’est-à-dire au service MongoDB.

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

fichier test-web-deployment.yaml

Pour accéder au frontend, nous créerons un service de type NodePort écoutant sur le port 31081. Cela signifie que le serveur Web Python Flask est accessible sur IP=IP-Of-Any-Node et Port=31081. Crée un nouveau avec la définition de service suivante.

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

fichier test-web-service.yaml

Maintenant, nous sommes prêts à créer une application échantillon à 2 niveaux. Avant de continuer, vérifions si le cluster a des objets.

Exécute les commandes suivantes pour vérifier les pods, les déploiements et les services en cours d’exécution dans le cluster.

kubectl get pods

kubectl get deployments

kubectl get service

Vérifier les objets existants

Dans la capture d’écran ci-dessus, on peut voir qu’il n’y a qu’un seul service kubernetes par défaut dans le cluster.

Maintenant, exécute la commande suivante une par une à partir du répertoire où tu as créé 4 fichiers pour créer le déploiement MongoDB, le service MongoDB, le déploiement Python Flask Webserver et le service Python Flask Webserver.

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

créer des déploiements et des services

Dans la capture d’écran ci-dessus, tu peux voir que le déploiement MongoDB, le service MongoDB, le déploiement Python Flask Webserver et le service Python Flask Webserver ont été créés avec succès.

Pour le vérifier, exécute les commandes suivantes.

kubectl get pods

kubectl get deployments

kubectl get service

Dans la capture d’écran suivante, tu peux voir que 2 pods et 2 services ont été créés. Les pods qui ont été créés sont contrôlés par le déploiement que nous avons créé.

Vérifie les objets nouvellement créés

Maintenant, nous sommes prêts à accéder à l’application surIP-of-any-Node:NodePort, c’est-à-dire IP-of-any-Node:31081.

Une fois que tu as tapé l’URL dans le navigateur, tu verras l’application comme suit. Il s’agit d’un exemple d’application qui utilise l’image docker disponible publiquement et qui appartient à CloudYuga. Ici, tu peux voir que le nombre de RSVP est de 0, ce qui signifie que MongoDB ne contient aucune donnée.

accède à l'application sur NodeIP:NodePort

Maintenant, nous pouvons ajouter quelques entrées de démonstration.

En ajoutant quelques entrées, nous pouvons voir que le compte a changé. Cela signifie que les données ont été stockées dans MongoDB.

ajoute des données dans l'application

Maintenant, lorsque tu n’as plus besoin de ces applications, tu peux supprimer tous les objets en exécutant la commande suivante depuis le répertoire où se trouvent tous tes fichiers d’objets Kubernetes.

kubectl delete -f .

supprime les déploiements et les services tous ensemble

La commande ci-dessus supprimera le déploiement MongoDB, le service MongoDB, le déploiement Python Flask Webserver et le service Python Flask Webserver que nous avons créés.

Pour vérifier si tous les objets que nous avons créés ont été supprimés avec succès, exécute la commande suivante.

kubectl get all

Dans la capture d’écran suivante, tu peux voir qu’il n’y a qu’un seul service kubernetes par défaut et que les objets que nous avions créés n’existent plus.

Vérifie si tous les objets que nous avons créés ont été supprimés.

Conclusion

Dans cet article, nous avons créé un déploiement de la base de données backend MongoDB et un service pour accéder à la base de données et pour le frontend, nous avons créé un déploiement d’application basé sur Python Flask et un service pour accéder à ce frontend. Nous avons également vu les données être stockées dans la base de données backend. Il s’agit d’un exemple d’application à 2 niveaux qui utilise des images docker disponibles publiquement.

Vous aimerez aussi...