Creare Deployment Kubernetes su Jelastic Cloud

Introduzione

Finora abbiamo visto come avviare un cluster Kubernetes in locale e quali sono i principali comandi kubectl per interagire coi Pod. Alla creazione di un cluster, però, non esiste ancora nessun Pod in esecuzione. I Pod, che contengono ciascuno uno o più Container, devono essere deployati all’interno del cluster.

I deployment sono costrutti ad alto livello che definiscono i deploy di un’intera applicazione, definiscono cioè in che modo questa è distribuita su tutto il cluster. Un singolo deployment può essere formato da più istanze, o Pod, che a loro volta ospitano dei container, tipicamente Docker.
 

Creare e gestire un cluster Kubernetes su Aruba Cloud

Nei capitoli precedenti, abbiamo usato Kubernetes in locale per prendere dimestichezza con i comandi principali, per cui ora siamo pronti a spostarci su cloud. Andiamo quindi a creare un cluster su Aruba Cloud, che mette a disposizione Jelastic Cloud, un servizio CaaS (Container as a Service) per la gestione automatica e semplificata di Container e cluster Kubernetes. Se non hai un account Aruba Cloud, o sei già cliente ma non hai mai provato Jelastic Cloud, attivalo gratuitamente qui attiva gratuitamente Jelastic Cloud.
Accediamo al Pannello di Controllo del nostro account Aruba Cloud e andiamo sulla voce “Container”. Si aprirà il pannello di Gestione Account Jelastic Cloud. Per utilizzare Jelastic, dobbiamo creare un account di servizio, per cui andiamo su Aggiungi Account. Selezioniamo il piano tariffario “pay-per-use” e accediamo all’ArubaCloud Dashboard.
Ecco i procedimenti per creare un ambiente Kubernetes su Jelastic:

• Andiamo su “Create New Environment”
• Docker -> Kubernetes Cluster
• Selezioniamo una topologia. Per testare le applicazioni e il funzionamento di K8s, si può usare la topologia Development. Nel corso di questo tutorial, useremo la versione Production. Potrai cambiare la tua topologia in qualunque momento.
• Spuntiamo anche “Enable Remote API Access” per poter accedere al cluster tramite API.

Verrà inizializzato un cluster Kubernetes e forniti l’indirizzo IP per monitorare l’applicazione nel browser e il token segreto di accesso all’API e alla dashboard Kubernetes.
Il modo migliore per interagire con l’api-server è usare la CLI di Kubernetes. Così sarà possibile gestire il nostro cluster Kubernetes cloud direttamente da riga di comando in locale. Per configurare kubectl e connetterci al cluster sul cloud Aruba, eseguiamo i seguenti comandi:

$ kubectl config set-cluster mycluster --server={API_URL}
$ kubectl config set-context mycluster --cluster=mycluster
$ kubectl config set-credentials user --token={TOKEN}
$ kubectl config set-context mycluster --user=user
$ kubectl config use-context mycluster

Dove mycluster è l’alias del cluster Kubernetes, user è il nome utente, {API_URL} è il link del Remote API Access, e {TOKEN} è il token di accesso della dashboard Kubernetes.
Se durante l’installazione non è stato abilitato l’accesso remoto all’API, si può comunque accedere alla CLI di Kubernetes direttamente dalla console di Jelastic, tramite accesso SSH nel nodo desiderato, seguendo i seguenti passaggi:





Altrimenti, è possibile abilitare in qualsiasi momento l’uso dell’API remota dal Master Node del cluster come segue:





Per verificare se l’accesso al cluster è avvenuto correttamente, eseguiamo il comando kubectl get nodes nel terminale locale:

$ kubectl get nodes

Output:

NAME                                 STATUS   ROLES    AGE     VERSION
node23842-env-0427797…-aruba.cloud   Ready    master   3d15h   v1.18.10
node23843-env-0427797…-aruba.cloud   Ready             3d15h   v1.18.10
node23844-env-0427797…-aruba.cloud   Ready    master   3d15h   v1.18.10
node23845-env-0427797…-aruba.cloud   Ready    master   3d15h   v1.18.10
node23846-env-0427797…-aruba.cloud   Ready             3d15h   v1.18.10

Cos’è un deployment

Un deployment non è altro che un file che descrive la nostra applicazione e i suoi microservizi. Il file di deployment descrive le risorse, i riferimenti e le variabili d’ambiente che servono per connettere tra loro i container Docker, data una serie di parametri di configurazione. Di solito, un deployment è realizzato in formato YAML, oppure può essere specificato all’interno di un’immagine iso.
Il file YAML, una volta caricato sul cluster, viene prima interpretato e poi gestito per andare infine a effettuare il deploy. A questo punto, il file di descrizione si trasforma in Pod. Il Pod contiene, in pratica, un servizio distribuito. Kubernetes gestisce in maniera automatica la replicazione di questi servizi.
Tramite il file YAML è possibile:

• Creare Pod e immagini
• Aggiornare Pod e immagini senza causare disservizi
• Mettere in pausa e far ripartire un deployment

Lo stato dei deployment e qualsiasi altra informazione sul cluster Kubernetes può essere consultata sull’interfaccia grafica di K8s. Possiamo entrare nella dashboard a partire dal pannello di controllo di Jelastic.
Dalla dashboard è possibile monitorare i nodi master e worker, i Pod, i deployment e tutto il resto.

Vediamo ora come creare un deployment per avviare un Pod sul nostro cluster.

Creare un deployment da un’immagine

Ora che abbiamo fatto una panoramica sui deployment, vogliamo provare a crearne uno usando il server Nginx. Precisamente, quello che faremo sarà:

• Definire il deployment
• Inserire il deployment nel nostro cluster Kubernetes
• Esporre il deployment come servizio all’esterno di Kubernetes

Un deployment può avere uno o più istanze Pod. Nel caso più semplice, definisce un singolo Pod con una singola replica.
In questo primo esempio andiamo a creare un deployment per la gestione di un singolo Pod che esegue un Container basato su un'immagine Docker predefinita fornita tramite URL. Per farlo eseguiamo il comando:

$ kubectl create deployment hello-node --image=k8s.gcr.io/echoserver:1.4

Una volta avviato un deployment possiamo usare i seguenti comandi per monitorarlo:
Per vedere i deployment creati:

$ kubectl get deployments

Output:

NAME                     READY   UP-TO-DATE   AVAILABLE   AGE
hello-kubernetes         2/2     2            2           3d15h
hello-node               0/1     1            0           11s
nfs-client-provisioner   3/3     3            3           3d15h

Per vedere lo stato dei Pod del cluster:

$ kubectl get pods

Output:

NAME                                  READY   STATUS    RESTARTS   AGE
hello-kubernetes-654bc95db8-j7d7n     1/1     Running   2          3d15h
hello-kubernetes-654bc95db8-nwqtw     1/1     Running   2          3d15h
hello-node-7bf657c596-766j6           1/1     Running   0          45s

Analogamente, possiamo monitorare lo stato dei deployment direttamente dalla dashboard K8s. Per far partire la dashboard eseguiamo il comando kubectl proxy e usiamo il token di accesso fornitoci da Jelastic Cloud per accedere.

Altri esempi di comandi kubectl possono essere:

$ kubectl rollout status

Per verificare lo stato del deployment. È importante definire comunque il nome del deployment, anche se ne hai creato uno solo:

$ kubectl rollout status deployment.apps/nome-deployment

L’output del comando sarà simile a:

Output:

deployment "hello-node" successfully rolled out

A questo punto abbiamo verificato che il nuovo deployment è stato deployato con successo ed è finalmente in esecuzione. In un ambiente di produzione, avrai spesso bisogno di modificare, aggiornare e ampliare l’applicazione esistente. In seguito, vedremo delle operazioni apposite.
Per consultare tutti i comandi della command line esegui:

kubectl --help.

Creare un deployment da file YAML

Andiamo ora a definire un deployment per un’istanza Pod definendo un file YAML. Il nostro deployment esempio sarà un server Nginx.
Apriamo un editor di testo e creiamo un nuovo file vuoto nominato deployment.yaml, quindi inseriamo il seguente contenuto:

apiVersion: apps/v1
kind: Deployment
metadata:
    name: nginx-deployment
spec:
    selector:
        matchLabels:
            app: nginx
    replicas: 1
    template:
        metadata:
            labels:
                app: nginx
        spec:
            containers:
                - name: nginx
                  image: nginx:9.0

Bisogna fare attenzione ai tab: assicuriamoci di avere il tab configurato con 4 spazi, dato che YAML è sensibile agli spazi bianchi e uno spazio in più potrebbe causare un errore durante il deployment.
A questo punto, inseriamo il nostro deployment sul cluster:

$ kubectl apply -f ./deployment.yaml

Dopo aver applicato il deployment, l’immagine del server nginx specificata nel file YAML sarà prelevata dal container registry e l’applicazione sarà schedulata da Kubernetes all’interno del cluster così come è stato definito all’interno del file. Per verificare l’avvenuta creazione del deployment, eseguiamo:

$ kubectl rollout status deployment nginx-deployment

L’output sarà del tipo:

Output:

Waiting for deployment "nginx-deployment" rollout to finish: 0 of 1 updated replicas are available...

deployment "nginx-deployment" successfully rolled out

Una volta applicato il deployment, esponiamo il Pod all’esterno del cluster:

$ kubectl expose deployment nginx-deployment --type=NodePort --port 8080

Output:

service/nginx-deployment exposed

Modificare e eliminare un deployment

Una volta creato un deployment, questo può essere modificato applicando un nuovo file YAML o una nuova immagine.
Ecco alcuni comandi principali per la gestione dei deployment:

Comando	Descrizione
$ kubectl apply -f path-to-file/deployment-update.yaml	Applicare un nuovo yaml per aggiornare un deployment
$ kubectl edit deployment nginx-deployment /path-to-image/image)	Modificare un deployment cambiando l’immagine del container
$ kubectl rollout status deployment nginx-deployment	Verificare lo stato dell’aggiornamento del deployment
$ kubectl delete deployment nginx-deployment	Eliminare un deployment
$ kubectl rollout history nginx-deployment	Monitorare lo storico delle modifiche apportate a un deployment

In questa serie, abbiamo visto come creare e gestire un cluster di produzione sul Cloud Aruba e come deployare un Pod sul cluster e i principali metodi per monitorare lo stato dei deployment, tramite riga di comando kubectl. In particolare, abbiamo visto che si può creare un deployment a partire dall’immagine di un Container oppure a partire da un file YAML, che descrive la configurazione dei Pod e le sue repliche. Abbiamo anche visto che per ottenere un URL accessibile del nostro Pod abbiamo bisogno di esportare il nostro deployment. Ma cosa significa “esportare”, e perché dobbiamo farlo?
Il prossimo step consisterà proprio nell’apprendere cosa significa esportare un deployment e cosa sono i Service di Kubernetes.