Ricerca nel sito web

Come distribuire un'applicazione multilivello con Kubernetes

Su questa pagina

  1. Prerequisiti
  2. Cosa faremo?
  3. Distribuisci un'applicazione multilivello
  4. Conclusione

Un'applicazione multilivello è un'applicazione distribuita su più di un livello. Separa logicamente i livelli operativi. Il numero di livelli varia in base ai requisiti aziendali e applicativi. In questo articolo vedremo un'applicazione divisa in 2 layer, backend e frontend. Useremo MongoDB come backend per archiviare dati e Python Flask come server Web frontend. Distribuiremo queste due applicazioni utilizzando le distribuzioni in Kubernetes e disporremo di servizi per inoltrare loro le richieste.

Prerequisiti

  1. 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.
  2. Comprensione di base di deployment e servizi.
    Consulta Servizi per avere una conoscenza di base.

Che cosa faremo?

  1. Distribuisci 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. var slotId=div-gpt-ad-howtoforge_com-medrectangle-3-0;var ffid=1;var alS=1021%1000;var container=document.getElementById(slotId);container.style.width=100%;var ins =document.createElement(ins);ins.id=slotId+-asloaded;ins.className=adsbygoogle ezasloaded;ins.dataset.adClient=pid;ins.dataset.adChannel=cid;if(ffid==2){ins.dataset .fullWidthResponsive=true;}

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 a 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 consiste nel definire un'applicazione frontend. Crea un nuovo file contenente la seguente definizione di distribuzione.

Questo ascolterà sulla porta 5000.

Le richieste a MongoDB verranno inoltrate a MONGODB_HOST, ovvero il 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 Port=31081. Creare un 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 tutti pronti per creare un'applicazione di esempio a 2 livelli. Prima di procedere, controlliamo se il cluster ha oggetti.

Esegui i seguenti comandi per controllare i pod, le distribuzioni e i servizi in esecuzione nel cluster.

kubectl ottieni i pod

kubectl ottiene le distribuzioni

kubectl ottieni il servizio

Nello screenshot sopra, si può vedere che c'è solo 1 servizio predefinito kubernetes nel cluster.

Ora, esegui il seguente comando uno alla volta dalla directory in cui hai creato 4 file per creare la distribuzione MongoDB, il servizio MongoDB, la distribuzione del server Web Python Flask e il servizio  il server Web Python Flask.

kubectl create -f test-db-deployment.yaml

kubectl crea -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 MongoDB, il servizio MongoDB, la distribuzione del server Web Python Flask e il servizio server Web Python Flask sono stati creati correttamente.

Per verificare lo stesso, eseguire i seguenti comandi.

kubectl ottieni i pod

kubectl ottiene le distribuzioni

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 dal deployment che abbiamo creato.

Ora siamo tutti pronti per accedere all'applicazione su IP-of-any-Node:31081.

Dopo aver premuto l'URL nel browser, vedrai l'applicazione come segue. Questa è un'applicazione di esempio che utilizza l'immagine docker 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 avrai più bisogno di queste applicazioni, puoi eliminare tutti gli oggetti eseguendo il seguente comando dalla directory in cui sono presenti tutti i tuoi file oggetto Kubernetes.

kubectl elimina -f .

Il comando precedente eliminerà la distribuzione di MongoDB, il servizio MongoDB, la distribuzione del server Web Python Flask e il servizio del server Web Python Flask che abbiamo creato.

Per verificare se tutti gli oggetti che abbiamo creato sono stati eliminati correttamente, esegui il seguente comando.

kubectl ottieni tutto

Nello screenshot 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 un deployment del database e del servizio di back-end MongoDB per accedere al database e per il front-end, abbiamo creato un deployment e un servizio dell'applicazione basato su Python Flask per accedere a questo front-end. Abbiamo anche visto i dati che venivano archiviati nel database di back-end. Questa è un'applicazione di livello 2 di esempio che utilizza immagini docker disponibili pubblicamente.