Lavorando con YAML è indispensabile rispettare le indentazioni all'interno dei file.
La presente procedura oltre che per db MySQL è valida anche in caso di db MariaDB, apportando le opportune modifiche.
- Crea il cluster Kubernetes;
- assegnalo ad un VPC;
- crea una subnet per il cluster assegnando un nome ed un CIDR;
- quando il cluster è attivo, scarica il file di configurazione, puoi usarlo in due modi:
- sostituisci il contenuto della configurazione del tuo client Kubernetes con quello del file scaricato;
- utilizza le variabili di ambiente del tuo Sistema Operativo per esportare la variabile che contiene il path al file di configurazione che vorresti utilizzare.
Nel nostro caso utilizzeremo
kubectl come client di esempio dove la variabile si chiama KUBECONFIG, e quindi su Linux ad esempio utilizzeremo il comando:
export KUBECONFIG=/home/myuser/downloads/filediconf
Se usi
kubectl il primo comando che puoi provare è:
$ kubectl get nodes
Se tutto funziona correttamente dovresti ricevere una lista dei nodi all'interno del tuo node pool.
Creiamo adesso una semplice applicazione WebDI esempio utilizzando il CMS WordPress.
Nella nostra applicazione avremo un load balancer di front end, detto di presentazione, un paio di container per servire le richieste, ed un DB di backend.
Per ogni sezione scriveremo una porzione di codice eseguibile indipendentemente dalle altre.
Questa porzione di codice potrà essere salvata in un file indipendente oppure in un file unico, per semplicità noi procederemo con il definire e scrivere tutto su di un unico file utilizzando i separatori che sono presenti in YAML.
Cominciamo con il creare un deployment per il nostro primo container per WordPress, mettiamo questa porzione di codice all'interno di un file wordpress.yaml, importante ricordarsi di aggiungere i 3 trattini all'inizio ed alla fine del codice, come nell'esempio:
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: wordpress
labels:
app: wordpress
spec:
selector:
matchLabels:
app: wordpress
tier: frontend
strategy:
type: Recreate
template:
metadata:
labels:
app: wordpress
tier: frontend
spec:
containers:
- image: wordpress:latest-apache # Installa l'ultima versione disponibile su Docker Hub
name: wordpress
env:
- name: WORDPRESS_DB_HOST
value: wordpress-mysql
- name: WORDPRESS_DB_PASSWORD
value: PassqUord_WodprEssDB # Normalemtne non andrebbe messa in chiaro qui ma questo è solo un esempio
- name: WORDPRESS_DB_USER
value: wordpress_USer # Wordpress DB username
ports:
- containerPort: 80
name: wordpress
volumeMounts:
- name: wordpress-persistent-storage
mountPath: /var/www/html
volumes:
- name: wordpress-persistent-storage
persistentVolumeClaim:
claimName: wp-pv-claim
---
Per applicare le modifiche è necessario utilizzare il comando:
$ kubectl delete -f wordpress.yaml
Per verificare che il nostro deployment sia andato a buon fine, utilizzare il comando:
$ kubectl get all
Dopo aver configurato il servizio di WordPress, ed aver verificato che tutto sia online senza errori, è il momento di connettere gli storage.
Aggiungiamo le seguenti righe di codice in testa al file che abbiamo già dalla precedente esecuzione:
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: wp-pv-claim
labels:
app: wordpress
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 20Gi
---
Dovremmo essere capaci di vedere adesso il nostro volume appena creato con il comando:
$ kubectl get pvc
Se il volume appare nello stato Bound dopo la creazione, è possibile procedere con il collegamento al container WordPress per creare un container effimero e quindi "usa e getta" con uno storage per i dati persistente che può essere riutilizzato e che non verrà cancellato se distruggiamo o se il pod viene spostato altrove.
Prima di andare avanti riportiamo il nostro deployment a zero con il comando:
$ kubectl delete -f wordpress.yaml
Andiamo alla fine del nostro file, ed aggiungiamo le seguenti righe (parte in verde):
- name: WORDPRESS_DB_USER
value: wordpress_USer # Wordpress DB username
ports:
- containerPort: 80
name: wordpress
volumeMounts:
- name: wordpress-persistent-storage
mountPath: /var/www/html
volumes:
- name: wordpress-persistent-storage
persistentVolumeClaim:
claimName: wp-pv-claim
---
Con questo e con il comando:
$ kubectl apply -f wordpress.yaml
Abbiamo finalmente terminato l'installazione di un container WordPress con collegato uno storage persistente di 20 GB per conservare i nostri dati.
Adesso come ultima cosa dobbiamo creare il load balancer che ci permetterà di raggiungere da rete pubblica il nostro servizio di presentazione.
Fatto questo potremo passare al livello di backend e fare il deploy del database.
Per creare e collegare il load balancer al nostro servizio aggiungiamo le righe sottostanti (parte in verde) alla fine del file wordpress.yaml:
volumes:
- name: wordpress-persistent-storage
persistentVolumeClaim:
claimName: wp-pv-claim
---
apiVersion: v1
kind: Service
metadata:
name: wordpress
labels:
app: wordpress
spec:
ports:
- port: 80
selector:
app: wordpress
tier: frontend
type: LoadBalancer
---
Prima di eseguire di nuovo il file, devi assegnare un indirizzo IP pubblico al tuo load balancer, per farlo accedi ad
Aruba Cloud Management Platform ed acquista un indirizzo
IP pubblico.
Specifica un nome per la tua reservation, e crealo nella solita regione in cui si trova il tuo cluster; gli indirizzi IP vengono annunciati sulla rete pubblica dalla regione in cui vengono riservati, un indirizzo riservato a Roma non potrà essere utilizzato a PSP e viceversa.
Fatto questo da pannello andiamo ad applicare la nostra nuova configurazione con il comando:
$ kubectl apply -f wordpress.yaml
E successivamente verifichiamo l'esito con il comando:
$ kubectl get all
La nostra installazione adesso è parte completa, dovremo però istanziare un DB per far si che il nostro pod WordPress possa lavorare correttamente.
Ora creiamo un deployment per un database MySQL. Usa lo stesso username e password che hai già impostato per WordPress.
Per semplicità possiamo creare un nuovo file oppure incollare tutto il codice sottostante alla fine del precedente file dove abbiamo descritto il deployment del nostro WordPress:
---
apiVersion: v1
kind: Service
metadata:
name: wordpress-mysql
labels:
app: wordpress
spec:
ports:
- port: 3306
selector:
app: wordpress
tier: mysql
clusterIP: None
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: mysql-pv-claim
labels:
app: wordpress
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 20Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: wordpress-mysql
labels:
app: wordpress
spec:
selector:
matchLabels:
app: wordpress
tier: mysql
strategy:
type: Recreate
template:
metadata:
labels:
app: wordpress
tier: mysql
spec:
containers:
- image: mysql:8.0
name: mysql
env:
- name: MYSQL_ROOT_PASSWORD
value: mysqlrootpassword # Utilizzare la password root di MySQL
- name: MYSQL_DATABASE
value: wordpress
- name: MYSQL_USER
value: wordpress
- name: MYSQL_PASSWORD
value: mysqlpassword # Utilizzare la password di MySQL
ports:
- containerPort: 3306
name: mysql
volumeMounts:
- name: mysql-persistent-storage
mountPath: /var/lib/mysql
volumes:
- name: mysql-persistent-storage
persistentVolumeClaim:
claimName: mysql-pv-claim
---
In maniere identica a quello che abbiamo già fatto, andremo a dichiarare il nome di un servizio per MySQL così da permettere a WordPress di raggiungerlo ed utilizzarlo, la dichiarazione dell'istanza MySQL, la dichiarazione dello storage di 20 GB e le direttive per il DB MySQL su come e dove utilizzare lo storage.
Una volta che abbiamo verificato tutti i cambiamenti siano stati correttamente eseguiti rechiamoci all'indirizzo IP del sistema per verificare che il sito web di WordPress sia effettivamente online e che veniate accolti dalla schermata di installazione.
Procedete pure con la installazione e creerete a questo punto un sito web minimale con tanto di pannello di controllo per i contenuti ed un tema.
Dal pannello di controllo di WordPress aggiungete un paio di immagini nella libreria immagini, ed inseritele in un post; queste azioni salveranno dati sia all'interno del DB e quindi nel persistent storage dello stesso, sia nel persistent storage del pod di WordPress.
Verifichiamo adesso la persistenza dei sistemi cancellando i pod WordPress e MySQL e ricreandone di nuovi con i seguenti comandi:
$ kubectl get pods # Per avere la lista dei pod che sono online al momento
$ kubectl delete nomepod-wordpress nomepod-mysql
Se usiamo subito dopo il comando per visualizzare tutti i pod online, vedremo che i deployments hanno già individuato che i containers non sono più online e ne hanno fatti partire di nuovi con esattamente le solite configurazioni e con collegati i soliti volumi.
Se torni al sito WordPress che hai configurato, dovresti vederlo ancora attivo e funzionante, senza problemi.
Per cancellare tutta l'installazione semplicemente eseguire:
$ kubectl delete -f wordpress.yaml