1.8 Use case: creazione ed assegnazione volumi per WordPress con MySQL

Lavorando con YAML è indispensabile rispettare le indentazioni all'interno dei file.

Creare:

• pod WordPress con volume persistente di 20GB;
• pod MySQL con volume persistente di 20GB;
• load balancer con indirizzo IP pubblico per arrivare a WordPress;
• load balancer privato per far lavorare WordPress con MySQL.

• Crea il cluster Kubernetes;
• assegnalo ad un VPC;
• crea una subnet per il cluster assegnando un nome ed un CIDR;
• una volta che il cluster è attivo scarica il file di configurazione;
• rimpiazza con il contenuto del file di configurazione la config per il tuo client al cluster di Kubernetes oppure 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 utlizzare 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 questo si visualizza correttamente come creato e con status Bound allora è il momento di connetterlo al nostro 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, visto che andremo ad assegnare un indirizzo IP pubblico al nostro LB load balancer, sarà necessario passare dalla Nuova Piattaforma di Gestione Cloud ed acquistare 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:

$ kuiectl 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.
Utilizziamo quello che abbiamo fatto sino ad ora e creiamo un deployment per un DB MySQL con username e password uguali a quelle già utilizzate per il deploy 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 provate a tornare sul sito WordPress che avete configurato dovreste poter continuare a visualizzare il sito WordPress senza problemi.
Per cancellare tutta l'installazione semplicemente eseguire:

$ kubectl delete –f wordpress.yaml