Un'applicazione multilivello è un'applicazione distribuita su più livelli. Separa logicamente i livelli operativi. Il numero di livelli varia in base ai requisiti aziendali e dell'applicazione. In questo articolo vedremo un'applicazione divisa in 2 livelli, backend e frontend. Useremo MongoDB come back-end per archiviare dati e Python Flask come server Web front-end. Distribuiremo queste due applicazioni utilizzando le distribuzioni in Kubernetes e disponiamo di servizi per inoltrare loro le richieste.
Prerequisiti
- Cluster Kubernetes con almeno 1 nodo di lavoro.
Se vuoi imparare a creare un Cluster Kubernetes, fai clic qui. Questa guida ti aiuterà a creare un cluster Kubernetes con 1 master e 2 nodi su istanze AWS Ubuntu 18.04 EC2. - Conoscenza di base di implementazioni e servizi.
Fai riferimento a implementazioni e servizi per ottenere una comprensione di base.
Cosa faremo?
- Distribuire un'applicazione multilivello
Distribuisci un'applicazione multilivello
Crea un nuovo file denominato "test-db-deployment.yaml" con il seguente contenuto. Questo definirà una distribuzione di MongoDB che fungerà da database, un livello di back-end.
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
Ora, crea un servizio che servirà le richieste al MongoDB dalla nostra applicazione frontend. Questo servizio ascolterà sulla porta 27017 e inoltrerà le richieste a MongoDB sulla stessa porta.
vim test-db-service.yaml
apiVersion: v1
kind: Service
metadata:
name: mongodb
labels:
app: testdb
spec:
ports:
- port: 27017
protocol: TCP
selector:
appdb: testdb
Il passaggio successivo è definire un'applicazione frontend. Crea un nuovo file contenente la seguente definizione di distribuzione.
Questo sarà in ascolto sulla porta 5000.
Le richieste a MongoDB verranno inoltrate a MONGODB_HOST, ovvero al servizio 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
Per accedere al frontend, creeremo un servizio di tipo NodePort in ascolto sulla porta 31081. Ciò significa che è possibile accedere al server Web Python Flask su IP=IP-Of-Any-Node e Porta=31081. Creane uno nuovo con la seguente definizione di servizio.
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
Ora siamo pronti per creare un'applicazione di esempio a 2 livelli. Prima di procedere, controlliamo se il cluster ha degli oggetti.
Esegui i seguenti comandi per controllare pod, distribuzioni e servizi in esecuzione nel cluster.
kubectl ottieni i pod
kubectl ottiene implementazioni
kubectl ottieni il servizio
Nello screenshot sopra, si può vedere che c'è solo 1 servizio predefinito kubernetes nel cluster.
Ora, esegui il comando seguente uno per uno dalla directory in cui hai creato 4 file per creare la distribuzione MongoDB, il servizio MongoDB, la distribuzione Python Flask Webserver e il servizio 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
Nello screenshot sopra, puoi vedere che la distribuzione di MongoDB, il servizio MongoDB, la distribuzione di Python Flask Webserver e il servizio di Python Flask Webserver sono stati creati correttamente.
Per verificare lo stesso, esegui i seguenti comandi.
kubectl ottieni i pod
kubectl ottiene implementazioni
kubectl ottieni il servizio
Nello screenshot seguente, puoi vedere che sono stati creati 2 pod e 2 servizi. I pod che sono stati creati sono controllati dalla distribuzione che abbiamo creato.
Ora siamo pronti per accedere all'applicazione su IP-of-any-Node:NodePort, ovvero IP-of-any-Node:31081.
Una volta premuto l'URL nel browser, vedrai l'applicazione come segue. Questa è un'applicazione di esempio che utilizza l'immagine della finestra mobile disponibile pubblicamente e appartiene a CloudYuga. Qui puoi vedere che il conteggio RSVP è 0, questo significa che MongoDB non contiene dati.
Ora possiamo aggiungere alcune voci demo.
Dopo aver aggiunto alcune voci, possiamo vedere che il conteggio è cambiato. Ciò significa che i dati sono stati archiviati in MongoDB.
Ora, quando non hai più bisogno di queste applicazioni, puoi eliminare tutti gli oggetti eseguendo il comando seguente dalla directory in cui hai tutti i file degli oggetti Kubernetes.
kubectl delete -f .
Il comando sopra eliminerà la distribuzione di MongoDB, il servizio MongoDB, la distribuzione di Python Flask Webserver e il servizio di Python Flask Webserver che abbiamo creato.
Per verificare se tutti gli oggetti che abbiamo creato sono stati eliminati correttamente, esegui il comando seguente.
kubectl ottieni tutto
Nella schermata seguente, puoi vedere che esiste un solo servizio kubernetes predefinito e gli oggetti che avevamo creato non esistono più.
Conclusione
In questo articolo, abbiamo creato una distribuzione del database e del servizio back-end MongoDB per accedere al database e per il front-end, abbiamo creato una distribuzione e un servizio dell'applicazione basata su Python Flask per accedervi fine frontale. Abbiamo anche visto i dati essere archiviati nel database di back-end. Questa è un'applicazione di esempio a 2 livelli che utilizza immagini Docker disponibili pubblicamente.