Kubernetes, realizzare un'applicazione: il data layer

Dopo aver studiato molto riguardo Kubernetes ed aver appreso tutti i principi fondamentali della sua architettura è il momento di mettere questa conoscenza al lavoro creando un'applicazione.

Struttura dell'applicazione e tecnologie utilizzate

Ci dedicheremo ad un'applicazione Web composta da due strati:

• un data layer che si occuperà della gestione dei dati basandosi su un database;
• un'applicazione lato server, accessibile agli utenti, che si relazionerà con il database.

Tale struttura potrebbe essere stratificata ulteriormente, trattandosi della struttura minimale che può essere utilizzata. Tuttavia non siamo particolarmente interessati a realizzare un software complesso, ragioneremo invece sull'organizzazione da stabilire, sulle componenti di Kubernetes da scegliere e soprattutto sulla velocità con cui questa piattaforma mette in condizione di implementare operatività e comunicazione.

Inoltre noi, in questo caso, scegliamo di utilizzare il linguaggio di sviluppo PHP ed il database MySQL ma tutti i principi che richiameremo e gli approcci che sposeremo potranno essere adottati per qualsiasi altra tecnologia si voglia coinvolgere.

Definizione dei servizi

Rifacendoci all'architettura a microservizi, la nostra applicazione sarà imperniata su due servizi che andranno a costituire i layer di cui abbiamo parlato. Sarà proprio questo il momento in cui risulterà evidente come mai la componente di Kubernetes che offre connettività in rete prende proprio il nome di Service!

Entrambi gli strati saranno pertanto costituiti da:

• una componente Deployment che gestirà la struttura della parte operativa attivando i Pod, gestendone il ciclo di vita e curandone il versionamento;
• un'altra componente - un Service - che svolgerà il ruolo di connettore per i Pod retrostanti verso il resto dell'applicazione.

Per prima cosa, creeremo il data layer.

La gestione dei dati

Il database che utilizzeremo sarà basato su MySQL, pertanto avremo a che fare con uno dei protagonisti del settore del data storage. Avremo quindi a disposizione immagini Docker già pronte tra cui scegliere in base a versione e piattaforma di riferimento.

Supponiamo di aver scelto la versione 5.6 di MySQL, disponibile in DockerHub. Le problematiche principali che vanno gestite con un database sono:

• memorizzazione persistente dei dati. Per questo, ci affideremo ai Volume di cui abbiamo studiato un'implementazione di base che può fare al caso nostro. Ciò sebbene ve ne siano altre più avanzate che si scopriranno andando avanti con l'approfondimento;
• gestione della password, possibilmente impiegando i Secret. Anche in questo caso ci rifaremo ad argomenti che abbiamo approfondito nel corso della guida.

Diamo ora uno sguardo al codice che abbiamo scelto di usare (file data-layer.yaml):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: data-layer-deployment
spec:
  selector:
    matchLabels:
      app: mysqlsrv
  template:
    metadata:
      labels:
        app: mysqlsrv
    spec:
      containers:
        - name: mysql-server
          image: mysql:5.6
          env:
          - name: MYSQL_ROOT_PASSWORD
            valueFrom:
              secretKeyRef:
                name: passwd-secret
                key: password
          volumeMounts:
            - name: data-storage
              mountPath: /var/lib/mysql
      volumes:
        - name: data-storage
          hostPath:
             path: /datastorage
---
apiVersion: v1
kind: Service
metadata:
  name: data-layer-service
spec:
  ports:
  - port: 3306
  selector:
    app: mysqlsrv

Prima di avviarlo creiamo un Secret per conservare la password che nel nostro caso sarà "topolino" (ovviamente, si tratta solo di un esempio: cercate sempre di scegliere password che rispecchino i migliori standard di sicurezza):

$ kubectl create secret generic \
       passwd-secret --from-literal=password=topolino

e successivamente avviamo il nostro data layer:

kubectl apply -f data-layer.yaml

Fatto questo potremo verificare di avere Pod, Deployment e Service tutti in esecuzione:

$ kubectl get pods
NAME                                     READY   STATUS    RESTARTS   AGE
data-layer-deployment-7bfb95674b-hc29d   1/1     Running   0          2m
$ kubectl get deploy
NAME                    READY   UP-TO-DATE   AVAILABLE   AGE
data-layer-deployment   1/1     1            1           2m
$ kubectl get svc
NAME                 TYPE           CLUSTER-IP       EXTERNAL-IP      PORT(S)          AGE
data-layer-service   ClusterIP      10.105.77.39      <none>     3306/TCP         2m26s
kubernetes           ClusterIP      10.96.0.1         <none>     443/TCP          16m

I dati per il test

La nostra sperimentazione principale consisterà nell'entrare nel Pod e creare alcuni dati di prova, non necessariamente finalizzati all'applicazione ma solo a scopo di test per il nostro database.
Puntiamo pertanto al Pod a disposizione invocando il client MySQL che vi è all'interno:

$ kubectl exec -it data-layer-deployment-7bfb95674b-xppqq -- mysql -u root -p
Enter password:
...
...
mysql> CREATE DATABASE scuola;
Query OK, 1 row affected (0.00 sec)
mysql> USE scuola;
Database changed
mysql> CREATE TABLE allievi(
    -> nome varchar(50),
    -> cognome varchar(50),
    -> classe int)
    -> ;
Query OK, 0 rows affected (0.02 sec)
mysql> INSERT INTO allievi (nome, cognome, classe) VALUES ('Silvia','Rossi',25);
Query OK, 1 row affected (0.01 sec)

Come possiamo notare, il server MySQL è operativo. Infatti abbiamo potuto creare un database, una tabella ed un record. Ora non ci resta che predisporre un'applicazione che lo sfrutti per poi ottimizzare il tutto.