Une application multiniveau est une application répartie sur plusieurs couches. Il sépare logiquement les couches opérationnelles. Le nombre de couches varie en fonction des besoins de l'entreprise et des applications. Dans cet article, nous verrons une application divisée en 2 couches, couche backend et couche frontend. Nous utiliserons MongoDB comme backend pour stocker des 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 les demandes.
Prérequis
- Cluster Kubernetes avec au moins 1 nœud de travail.
Si vous souhaitez apprendre à créer un cluster Kubernetes, cliquez ici. Ce guide vous aidera à créer un cluster Kubernetes avec 1 maître et 2 nœuds sur les instances AWS Ubuntu 18.04 EC2. - Compréhension de base des déploiements et des services.
Consultez Déploiements et Services pour obtenir une compréhension de base.
Qu'allons-nous faire ?
- Déployer une application multiniveau
Déployer une application multiniveau
Créez 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 backend.
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
Maintenant, créez un service qui servira les requêtes à MongoDB à partir de notre application frontale. Ce service écoutera sur le port 27017 et transmettra les requêtes à 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
L'étape suivante consiste à définir une application frontale. Créez un nouveau fichier contenant la définition de déploiement suivante.
Ceci écoutera sur le port 5000.
Les requêtes 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
Pour accéder au frontend, nous allons créer 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éez 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
Maintenant, nous sommes tous prêts à créer un exemple d'application à 2 niveaux. Avant de continuer, vérifions si le cluster contient des objets.
Exécutez les commandes suivantes pour vérifier les pods, les déploiements et les services en cours d'exécution dans le cluster.
kubectl obtenir des pods
kubectl obtenir les déploiements
kubectl obtenir le service
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écutez la commande suivante une par une à partir du répertoire dans lequel vous avez 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
Dans la capture d'écran ci-dessus, vous pouvez voir que le déploiement MongoDB, le service MongoDB, le déploiement du serveur Web Python Flask et le service du serveur Web Python Flask ont été créés avec succès.
Pour vérifier la même chose, exécutez les commandes suivantes.
kubectl obtenir des pods
kubectl obtenir les déploiements
kubectl obtenir le service
Dans la capture d'écran suivante, vous pouvez 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éé.
Maintenant, nous sommes tous prêts à accéder à l'application sur IP-of-any-Node :NodePort, c'est-à-dire IP-of-any-Node :31081.
Une fois que vous avez cliqué sur l'URL dans le navigateur, vous verrez l'application comme suit. Il s'agit d'un exemple d'application qui utilise l'image docker accessible au public et appartient à CloudYuga. Ici, vous pouvez voir que le nombre de RSVP est 0, cela signifie que MongoDB ne contient aucune donnée.
Maintenant, nous pouvons ajouter quelques entrées de démonstration.
En ajoutant quelques entrées, nous pouvons voir que le nombre a changé. Cela signifie que les données ont été stockées dans MongoDB.
Désormais, lorsque vous n'avez plus besoin de ces applications, vous pouvez supprimer tous les objets en exécutant la commande suivante à partir du répertoire où se trouvent tous vos fichiers d'objets Kubernetes.
kubectl delete -f .
La commande ci-dessus supprimera le déploiement MongoDB, le service MongoDB, le déploiement du serveur Web Python Flask et le service de serveur Web Python Flask 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écutez la commande suivante.
kubectl obtient tout
Dans la capture d'écran suivante, vous pouvez 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.
Conclusion
Dans cet article, nous avons créé un déploiement de la base de données et du service backend MongoDB pour accéder à la base de données et pour le frontend, nous avons créé un déploiement et un service d'application basés sur Python Flask pour y accéder. l'extrémité avant. Nous avons également constaté que les données étaient stockées dans la base de données principale. Il s'agit d'un exemple d'application à 2 niveaux qui utilise des images docker accessibles au public.