Kubernetes (noto anche come k8s) è un sistema di orchestrazione open-source. Consente agli utenti di distribuire, scalare e gestire applicazioni containerizzate con tempi di inattività minimi. In questo tutorial imparerai come distribuire un'applicazione PHP su un cluster Kubernetes.
Nginx si comporta come un proxy per PHP-FPM durante l'esecuzione di un'applicazione PHP. Gestire questi due servizi in un singolo container è un processo difficile. Kubernetes ci aiuta a gestirli in due container diversi e riduce le complicazioni. Consente inoltre agli utenti di riutilizzare i container senza doversi preoccupare di creare la propria immagine del container per ogni nuova versione di PHP/Nginx.
Eseguirai la tua applicazione e il servizio proxy in due container separati. Il tutorial fornirà anche approfondimenti su come utilizzare lo storage locale per creare un Volume Persistente (PV) e una Persistent Volume Claim (PVC). Utilizzerai quindi questa PVC per mantenere i tuoi file di configurazione e il codice all'esterno delle immagini dei container. Dopo aver completato questo tutorial, sarai in grado di riutilizzare la tua immagine Nginx per altre applicazioni che richiedono un server proxy. Puoi ottenere questo risultato passando una configurazione, invece di ricostruire l'immagine per essa.
Prerequisiti
- Una comprensione di base di Kubernetes (k8s) e dei suoi oggetti. Fai riferimento a questa guida per una panoramica dettagliata dell'ecosistema Kubernetes.
- Un cluster Kubernetes attivo e funzionante su Ubuntu 18.04. Segui questo tutorial per creare il tuo cluster Kubernetes utilizzando kubeadm.
- Inoltre, è necessario ospitare il codice dell'applicazione su un URL pubblico, ad esempio, GitHub.
Passo 1: Creare i servizi PHP-FPM e Nginx
Questo passaggio ti aiuterà a creare i servizi PHP-FPM e Nginx. Qualsiasi servizio fornisce l'accesso a un insieme di pod all'interno di un cluster. Tutti i servizi presenti in un cluster possono comunicare tra loro con i loro nomi, senza indirizzi IP. Il servizio PHP-FPM e il servizio Nginx forniranno l'accesso rispettivamente ai pod PHP-FPM e Nginx.
Dovrai indicare al servizio PHP-FPM come trovare i pod Nginx, poiché fungerà da proxy per i pod PHP-FPM. Per fare questo, sfrutterai l'individuazione automatica dei servizi di Kubernetes’ e utilizzerai nomi leggibili dall'uomo per instradare la richiesta al rispettivo servizio.
Per creare qualsiasi servizio, dovrai creare un file YAML che contiene la definizione dell'oggetto. Questo file YAML ha almeno i seguenti tag:
apiVersion: La versione dell'API di Kubernetes a cui appartiene la definizione.kind: Il tipo di oggetto Kubernetes creato da questo file YAML. Ad esempio: unservice, unjob, o unpod.metadata: Il nome dell'oggetto e le diverseetichetteche l'utente potrebbe voler applicare a questo oggetto sono definite sotto questo tag.spec: Questo tag contiene la specifica dell'oggetto, come le variabili d'ambiente (ENV), l'immagine del container da utilizzare, le porte su cui il servizio del container sarà accessibile.
Creazione del servizio PHP-FPM
Per iniziare, dovresti creare una directory per conservare le definizioni degli oggetti Kubernetes. Accedi al tuo nodo master e crea una directory chiamata “definitions:”
|
1 |
mkdir definitions |
Cambia la directory in quella delle definizioni:
|
1 |
cd definitions |
Successivamente, crea il tuo file di servizio PHP-FPM come php_service.yaml :
|
1 |
nano php_fpm_service.yaml |
Dopodiché, imposta apiVersion e kind nel file php_fpm_service.yaml :
|
1 2 |
apiVersion: v1 kind: Service |
Assegna al tuo servizio il nome php o php-fpm poiché fornirà l'accesso alla tua applicazione PHP-FPM:
|
1 2 3 |
… Metadata: name: php |
Etichetta il tuo servizio php come tier: backend poiché l'applicazione PHP verrà eseguita dietro questo servizio:
|
1 2 3 |
… labels: tier: backend |
Un servizio utilizza le etichette di selector per determinare a quali pod accedere. Qualsiasi pod che corrisponda a queste etichette, indipendentemente da quando è stato creato, viene servito. Imparerai come aggiungere etichette ai tuoi pod più avanti in questo tutorial.
Includi l'etichetta tier: backend che assegna il tuo pod al tier backend, insieme all'etichetta app: php-fpm per indicare che il pod esegue un'applicazione PHP-FPM. Devi aggiungere queste etichette dopo la sezione metadata:
|
1 2 3 4 5 |
… spec: selector: app: php-fpm tier: backend |
Successivamente, devi dichiarare la porta per accedere a questo servizio php-fpm sotto spec. Puoi aggiungere qualsiasi porta a tua scelta, ma in questo tutorial useremo la porta 9000 in questo tutorial:
|
1 2 3 4 |
... ports: - protocol: TCP port: 9000 |
Una volta completati i passaggi precedenti, il tuo file php_fpm_service.yaml apparirà così:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
apiVersion: v1 kind: Service metadata: name: php labels: tier: backend spec: selector: app: php tier: backend ports: - protocol: TCP port: 9000 |
Premi Ctrl + O per salvare il file, quindi premi Ctrl + X per uscire da nano.
Applicazione del comando kubectl per creare il servizio PHP
Una volta creata la definizione dell'oggetto per il tuo servizio, esegui il comando kubectl apply con l'argomento -f specificando il tuo file php_fpm_service.yaml:
|
1 |
kubectl apply -f php_fpm_service.yaml |
L'output del comando precedente dovrebbe essere:
|
1 |
service/php creato |
Esegui il comando seguente per verificare che il tuo servizio php-fpm sia in esecuzione:
|
1 |
$ kubectl get svc |
Sarai in grado di vedere il servizio php-fpm attivo e funzionante:
|
1 2 3 |
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 10m php ClusterIP 10.100.59.238 <none> 9000/TCP 5m |
Creazione del servizio Nginx
Poiché il tuo servizio PHP-FPM è ora pronto, è il momento di creare anche il tuo servizio Nginx. Crea e apri un nuovo file YAML per questo servizio, chiamato nginx_service.yaml nell'editor:
|
1 |
$ nano nginx_service.yaml |
Assegna a questo servizio il nome nginx poiché avrà come target i pod Nginx. Anche questo servizio appartiene al backend, quindi dovresti aggiungervi l'etichetta tier: backend:
|
1 2 3 4 5 6 |
apiVersion: v1 kind: Service metadata: name: nginx labels: tier: backend |
Come abbiamo fatto nel servizio php-fpm, aggiungi le etichette del selettore app: nginx e tier: backend per indirizzare i pod. Aggiungi la porta HTTP predefinita 80 per accedere a questo servizio:
|
1 2 3 4 5 6 7 8 |
... spec: selector: app: nginx tier: backend ports: - protocol: TCP port: 80 |
Il servizio Nginx può essere accessibile pubblicamente su Internet dall'indirizzo IP pubblico. Puoi aggiungere l'IP del tuo nodo worker come your_public_ip. Aggiungi le righe seguenti sotto spec.externalIPs:
|
1 2 3 4 5 |
... spec: externalIPs: - your_public_ip |
Il tuo file nginx_service.yaml dovrebbe apparire come quello qui sotto una volta completati tutti i passaggi precedenti:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
apiVersion: v1 kind: Service metadata: name: nginx labels: tier: backend spec: selector: app: nginx tier: backend ports: - protocol: TCP port: 80 externalIPs: - your_public_ip |
Salva e chiudi il file dopo aver aggiunto tutti i parametri richiesti sopra.
Applicazione del comando kubectl per creare il servizio Nginx
|
1 |
kubectl apply -f nginx_service.yaml |
|
1 |
service/nginx creato |
|
1 |
$ kubectl get svc |
|
1 2 3 4 |
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 13m nginx ClusterIP 10.102.160.47 your_public_ip 80/TCP 50s php ClusterIP 10.100.59.238 <none> 9000/TCP 8m |
|
1 |
$ kubectl delete svc/nome_servizio |
Passaggio 2: Creare lo storage locale e il volume persistente
Kubernetes fornisce vari plug-in di storage che ti aiutano a creare spazio di archiviazione per il tuo ambiente. Questo passaggio ti guiderà su come creare un StorageClass locale e su come questa Storage Class possa essere ulteriormente utilizzata per creare un Persistent Volume.
Creazione di uno storage locale
Crea un file, ad esempio storageClass.yaml, nel tuo editor:
|
1 |
$nano storageClass.yaml |
Aggiungi kind come "storageClass" e apiVersion come "storage.k8s.io/v1" come segue:
|
1 2 |
kind: StorageClass apiVersion: storage.k8s.io/v1 |
Assegna a questa StorageClass il nome "my-local-storage" e aggiungi provisioner e volumeBindingMode come segue:
|
1 2 3 4 5 |
… metadata: name: my-local-storage provisioner: kubernetes.io/no-provisioner volumeBindingMode: Immediate |
Salva ed esci dal file; il tuo file storageClass.yaml finale dovrebbe apparire così:
|
1 2 3 4 5 6 |
kind: StorageClass apiVersion: storage.k8s.io/v1 metadata: name: my-local-storage provisioner: kubernetes.io/no-provisioner volumeBindingMode: WaitForFirstConsumer |
Ora, crea la StorageClass eseguendo il comando kubectl create, come indicato di seguito:
|
1 |
$ kubectl create -f storageClass.yaml |
Dopo aver eseguito il comando sopra indicato, dovresti ottenere il seguente output:
|
1 |
storageclass.storage.k8s.io/my-local-storage creato |
Creazione di un Persistent Volume locale
Dopo aver creato lo Storage locale, puoi creare il tuo Persistent Volume locale. Un Persistent Volume, noto anche come PV, è lo storage a blocchi di dimensioni specificate che è indipendente dal ciclo di vita di un pod. Un Persistent Volume locale non è altro che un disco locale o una directory disponibile su un nodo del cluster Kubernetes. Questo Persistent Volume locale consente ai suoi utenti di accedere allo storage locale utilizzando una Persistent Volume Claim locale in modo molto semplice ma portabile. Puoi creare questo Persistent Volume locale utilizzando la storage class appena creata. Apri un file, ad esempio persistentVolume.yaml, nel tuo editor:
|
1 |
$ nano persistentVolume.yaml |
Assegna a questo persistent volume un nome, ad esempio "my-local-pv":
|
1 2 3 4 |
apiVersion: v1 kind: PersistentVolume metadata: name: my-local-pv |
Puoi aggiungere capacità di archiviazione in base al tuo utilizzo durante la creazione di un Persistent Volume locale. In questo tutorial, utilizzeremo 5 Gi per lo storage:
|
1 2 3 4 |
… spec: capacity: storage: 5Gi |
Aggiungi accessModes, persistentVolumeReclaimPolicy e fornisci lo stesso storageClassName utilizzato in storageClass.yaml:
|
1 2 3 4 5 |
… accessModes: - ReadWriteOnce persistentVolumeReclaimPolicy: Retain storageClassName: my-local-storage |
Aggiungi il local.path per il tuo Persistent Volume come segue:
|
1 2 3 |
… local: path: /mnt/disk/vol |
Dopo aver aggiunto tutti i campi richiesti, il tuo file persistentVolume.yaml dovrebbe apparire così:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
apiVersion: v1 kind: PersistentVolume metadata: name: my-local-pv spec: capacity: storage: 5Gi accessModes: - ReadWriteOnce persistentVolumeReclaimPolicy: Retain storageClassName: my-local-storage local: path: /mnt/disk/vol nodeAffinity: required: nodeSelectorTerms: - matchExpressions: - key: kubernetes.io/hostname operator: In values: - worker |
Preparazione del volume locale
Ora dobbiamo preparare un volume locale sul nodo “worker” come abbiamo aggiunto nel file persistentVolume.yaml. Esegui i comandi seguenti sul nodo che hai configurato in persistentVolume. In questo caso, si tratta del nodo “worker”:
|
1 2 3 |
$ DIRNAME="vol" $ mkdir -p /mnt/disk/$DIRNAME $ chmod 777 /mnt/disk/$DIRNAME |
Esegui il comando seguente sul nodo master in cui è presente il tuo file persistentVolume.yaml:
|
1 |
kubectl create -f persistentVolume.yaml |
Dovresti ottenere il seguente output:
|
1 |
persistentvolume/my-local-pv created |
Dopo aver creato con successo lo storage locale e il Persistent Volume, puoi procedere e creare una Persistent Volume Claim per contenere il codice dell'applicazione e i file di configurazione.
Passo 3: Creare il Persistent Volume
Il codice della tua applicazione deve essere protetto mentre gestisci o aggiorni i tuoi pod. A tale scopo, utilizzerai il Persistent Volume creato nel passaggio precedente, a cui si accede tramite una PersistentVolumeClaim, o PVC. Questa PVC monta il PV nel percorso richiesto.
Apri un file, ad esempio code_volume.yaml, nel tuo editor:
|
1 |
$ nano code_volume.yaml |
Assegna alla tua PVC il nome code aggiungendo i seguenti parametri e valori al tuo file:
|
1 2 3 4 |
apiVersion: v1 kind: PersistentVolumeClaim metadata: name: code |
La sezione spec di una PVC contiene i seguenti elementi:
- accessModes: Ci sono vari valori possibili per questo campo, come segue:
- ReadWriteOnce – Monta il volume per un singolo nodo con permessi sia di lettura che di scrittura.
- ReadOnlyMany – Monta il volume per molti nodi con solo permesso di lettura.
- ReadWriteMany – Monta il volume per molti nodi con permessi sia di lettura che di scrittura.
- resources: Definisce lo spazio di archiviazione richiesto.
Poiché lo storage locale è montato solo su un singolo nodo, dovrai impostare accessMode su ReadWriteOnce. In questo tutorial aggiungerai solo una piccola porzione di codice dell'applicazione, quindi 1 GB di storage sarà sufficiente in questo caso. Tuttavia, se desideri memorizzare una quantità maggiore di dati o codice, puoi modificare il parametro di storage in base alle tue esigenze. Nota che una volta creato il volume, sarai in grado di aumentare le dimensioni dello storage. Tuttavia, la riduzione non è supportata:
|
1 2 3 4 5 6 7 |
... spec: accessModes: - ReadWriteOnce resources: requests: storage: 1Gi |
Ora, dichiara la storage class che il cluster Kubernetes utilizzerà per l'allocazione ai volumi. Usa qui la storage class my-local-storage, creata nel passaggio precedente, per il tuo storageClassName:
|
1 2 |
... storageClassName: my-local-storage |
Dopo aver completato i passaggi precedenti, il tuo code_volume.yaml file dovrebbe apparire così:
|
1 2 3 4 5 6 7 8 9 10 11 |
apiVersion: v1 kind: PersistentVolumeClaim metadata: name: code spec: accessModes: - ReadWriteOnce resources: requests: storage: 1Gi storageClassName: my-local-storage |
Ora salva ed esci dal file.
Creazione del PVC
Crea il PVC code eseguendo il comando kubectl apply:
|
1 |
$ kubectl apply -f code_volume.yaml |
Dovresti ottenere il seguente output che indica che l'oggetto è stato creato con successo ed è pronto per poter montare il tuo PVC da 1 GB come volume:
|
1 |
persistentvolumeclaim/code created |
Puoi eseguire il comando seguente per verificare il Persistent Volume (PV) disponibile:
|
1 |
$ kubectl get pv |
L'output del comando precedente dovrebbe essere il seguente:
|
1 2 |
NAME CAPACITY ACCESS MODES RECLAIM POLICY STATUS CLAIM STORAGECLASS REASON AGE pvc-ca4df10f-ab8c-11e8-b89d-12331aa95b13 1Gi RWO Delete Bound default/code do-block-storage 2m |
Tutti i campi sopra indicati, ad eccezione di Reclaim Policy e Status, sono una panoramica del tuo file di configurazione. La Reclaim Policy definisce cosa succede al PV una volta eliminato il PVC che vi accede. Il valore Delete rimuove il PV dal cluster Kubernetes e dall'infrastruttura di storage. Puoi fare riferimento alla documentazione sui PV di Kubernetes per avere una chiara comprensione di Reclaim Policy e Status.
Ora puoi creare i tuoi pod utilizzando un Deployment, poiché hai creato con successo il tuo Persistent Volume utilizzando lo storage locale.
Step 4: Creare il Deployment per l'applicazione PHP-FPM
Questo passaggio ti aiuterà a creare il tuo pod PHP-FPM utilizzando Deployment. Il Deployment utilizza i ReplicaSet per fornire un modo stabile per creare, aggiornare e gestire i pod. Un Deployment ripristina automaticamente i suoi pod a un'immagine precedente.
La chiave spec.selector nel Deployment elenca tutte le etichette dei pod che gestisce. Utilizza anche la chiave template per creare i pod richiesti.
In questo passaggio, introdurremo anche l'applicazione degli Init Containers. Gli Init Container eseguono alcuni comandi prima dei normali container specificati nel template del pod. Qui, l'Init Container utilizzerà GitHub Gist (https://gist.github.com/) per ottenere un file index.php di esempio. Il contenuto del file di esempio è:
|
1 2 |
<?php echo phpinfo(); |
Creazione del Deployment PHP
Apri un nuovo file chiamato php_deployment.yaml nel tuo editor per creare il tuo Deployment:
|
1 |
$ nano php_deployment.yaml |
Ora, assegna al Deployment il nome PHP, poiché questo Deployment gestirà i tuoi pod PHP-FPM. Aggiungi l'etichetta tier: backend perché il pod apparterrà al tier backend:
|
1 2 3 4 5 6 |
apiVersion: apps/v1 kind: Deployment metadata: name: php labels: tier: backend |
Utilizzando il parametro replica, specifica il numero di copie di questo pod che devono essere create. Il numero di repliche può variare in base ai tuoi requisiti e alle risorse disponibili. In questo tutorial, creerai una sola replica del tuo pod:
|
1 2 3 4 |
... spec: replicas: 1 |
Aggiungi app: php e tier:backend sotto la chiave selector che indica che questo Deployment gestirà i pod che corrispondono a queste due etichette:
|
1 2 3 4 5 |
... selector: matchLabels: app: php tier: backend |
Ora, la definizione dell'oggetto del tuo pod richiede un template sotto la spec del tuo Deployment. Questo template definisce la specifica necessaria per creare il tuo pod. Per iniziare, aggiungi le etichette specificate per il selettore del servizio php e i matchLabels del Deployment. Quindi aggiungi app:php e tier:backend sotto template.metadata.labels:
|
1 2 3 4 5 6 7 |
... template: metadata: labels: app: php tier: backend |
First, you need to specify all the volumes that your containers will access. Name this volume code as you had created a PVC named code to hold your application code:
|
1 2 3 4 5 6 |
... spec: volumes: - name: code persistentVolumeClaim: claimName: code |
Successivamente, specifica il nome del container insieme all'immagine che desideri eseguire all'interno del tuo pod. Sono disponibili varie immagini sul Docker store (https://hub.docker.com/explore/), ma in questo tutorial utilizzeremo l'immagine php:7-fpm :
|
1 2 3 4 |
... containers: - name: php image: php:7-fpm |
Ora, monta i volumi a cui il container richiede l'accesso. Poiché questo container eseguirà il tuo codice PHP, avrà bisogno di accedere al volume code creato nel passaggio precedente. In questo passaggio imparerai anche come copiare il codice della tua applicazione utilizzando un Init Container.
Per scaricare il codice, questo tutorial ti guiderà su come utilizzare un singolo Init Container con busybox. Busybox è un piccolo container con l'utility wget che utilizzerai per raggiungere questo scopo.
Per prima cosa, aggiungi il tuo initContainer sotto spec.template.spec e specifica l'immagine busybox:
|
1 2 3 4 |
... initContainers: - name: install image: busybox |
Quindi, per scaricare il codice nel volume code, il tuo Init Container dovrà avervi accesso. Monta il volume code nel percorso /code sotto spec.template.spec.initContainers:
|
1 2 3 4 |
... volumeMounts: - name: code mountPath: /code |
Ogni Init Container richiede l'esecuzione di un comando. Questo Init Container utilizzerà wget per scaricare il code da Github nella directory /code. Puoi passare un'opzione -O per dare un nome a questo file scaricato, e puoi chiamare questo file index.php.
Inoltre, aggiungi le righe seguenti sotto install container in spec.template.spec.initContainers:
|
1 2 3 4 5 6 |
... command: - wget - "-O" - "/code/index.php" - https://raw.githubusercontent.com/do-community/php-kubernetes/master/index.php |
Dopo aver completato tutti questi passaggi, il tuo php_deployment.yaml file dovrebbe apparire così:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
apiVersion: apps/v1 kind: Deployment metadata: name: php labels: tier: backend spec: replicas: 1 selector: matchLabels: app: php tier: backend template: metadata: labels: app: php tier: backend spec: volumes: - name: code persistentVolumeClaim: claimName: code containers: - name: php image: php:7-fpm volumeMounts: - name: code mountPath: /code initContainers: - name: install image: busybox volumeMounts: - name: code mountPath: /code command: - wget - "-O" - "/code/index.php" - https://raw.githubusercontent.com/do-community/php-kubernetes/master/index.php |
Ora puoi salvare il file e uscire. Successivamente, crea il tuo Deployment PHP-FPM utilizzando kubectl apply il comando:
|
1 |
$ kubectl apply -f php_deployment.yaml |
La creazione corretta del Deployment dovrebbe fornire il seguente output:
|
1 |
deployment.apps/php created |
Questo Deployment inizia scaricando le immagini specificate, quindi richiederà il PersistentVolume dal tuo PersistentVolumeClaim, e poi eseguirà i tuoi initContainers. Una volta completato questo passaggio, i container verranno eseguiti e monteranno i volumi nel punto di montaggio specificato. Dopo aver completato tutti questi passaggi, il tuo pod sarà attivo e funzionante.
Puoi eseguire il comando seguente per visualizzare il tuo Deployment:
|
1 |
$ kubectl get deployments |
Dopo aver eseguito il comando precedente, dovresti ottenere il seguente output:
|
1 2 |
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE php 1 1 1 0 19s |
Puoi comprendere lo stato corrente del Deployment con l'aiuto di questo output. Un Deployment è un controller che mantiene lo stato desiderato. Il campo DESIRED specifica che ha 1 replica del pod denominato php. Il campo CURRENT indica quante repliche dello stato DESIRED sono attualmente in esecuzione. Per un pod integro, questo dovrebbe corrispondere allo stato DESIRED state. Puoi saperne di più sui campi rimanenti nella Documentazione dei Deployment di Kubernetes.
Successivamente, per verificare lo stato del tuo pod in esecuzione, puoi eseguire il comando seguente:
|
1 |
$ kubectl get pods |
L'output di questo comando può variare a seconda del tempo trascorso dalla creazione del Deployment. Se viene eseguito poco dopo la creazione del Deployment, l'output sarà simile a:
|
1 2 |
NAME READY STATUS RESTARTS AGE php-5d8f6bbf7f-56df2 0/1 Init:0/1 0 9s |
Spiegazione:
Queste colonne rappresentano le informazioni come segue:
- Ready: Il numero di repliche correnti/desiderate che eseguono questo pod.
- Stato: lo stato del tuo pod. Init:0/1 indica che gli Init Container sono in esecuzione e 0 su 1 Init Container hanno terminato l'esecuzione.
- Riavvii: questo indica il numero di volte che questo processo è stato riavviato per avviare il pod.
Il tuo pod può richiedere alcuni minuti affinché lo stato cambi in podInitializing a seconda della complessità dei tuoi script di avvio:
|
1 2 |
NAME READY STATUS RESTARTS AGE php-5d8f6bbf7f-56df2 0/1 podInitializing 0 39s |
Questo indica che gli Init Container sono stati eseguiti con successo e ora i container si stanno inizializzando:
|
1 2 |
NAME READY STATUS RESTARTS AGE php-5d8f6bbf7f-56df2 1/1 Running 0 4m10s |
Come puoi vedere ora, il tuo pod è attivo e funzionante. Tuttavia, nel caso in cui il tuo pod non si avvii, puoi eseguire i comandi seguenti a scopo di debug:
1. Per visualizzare informazioni dettagliate sul pod:
|
1 |
$ kubectl describe pods pod-name |
2. Per visualizzare i log del pod:
|
1 |
$ kubectl logs pod-name |
3. Per visualizzare i log di un container specifico nel pod:
|
1 |
$ kubectl logs pod-name container-name |
Congratulazioni! Hai montato con successo il codice dell'applicazione e il servizio PHP-FPM è pronto a gestire le connessioni. Allo stesso modo, puoi creare il tuo Deployment Nginx.
Passo 5: Crea il tuo Deployment Nginx
Questo passo ti guiderà su come configurare Nginx utilizzando una ConfigMap. Una ConfigMap mantiene tutte le configurazioni richieste in un formato chiave-valore che verrà utilizzato in altre definizioni di oggetti Kubernetes. Con questo approccio, avrai la flessibilità di riutilizzare o sostituire l'immagine Nginx con una versione diversa, quando necessario. Puoi aggiornare la ConfigMap e replicherà automaticamente tali modifiche a qualsiasi pod che monta questa ConfigMap.
Per iniziare, apri un file nginx_configmap.yaml nel tuo editor:
|
1 |
$ nano nginx_configMap.yaml |
Ora, assegna a questa ConfigMap il nome nginx-config e aggiungila al microservizio tier: backend:
|
1 2 3 4 5 6 |
apiVersion: v1 kind: ConfigMap metadata: name: nginx-config labels: tier: backend |
Inoltre, puoi aggiungere i dati alla ConfigMap. Aggiungi una chiave denominata config e aggiungi l'intero contenuto del file di configurazione di Nginx come valore.
Poiché è possibile per Kubernetes instradare le richieste ai rispettivi host per un servizio, puoi inserire il nome del tuo servizio PHP-FPM sotto il parametro fastcgi_pass invece del suo indirizzo IP. Aggiungi le seguenti righe di codice al tuo file nginx_configMap.yaml :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
... data: config : | server { index index.php index.html; error_log /var/log/nginx/error.log; access_log /var/log/nginx/access.log; root /code; location / { try_files $uri $uri/ /index.php?$query_string; } location ~ \.php$ { try_files $uri =404; fastcgi_split_path_info ^(.+\.php)(/.+)$; fastcgi_pass php:9000; fastcgi_index index.php; include fastcgi_params; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; fastcgi_param PATH_INFO $fastcgi_path_info; } } |
Once completed, your nginx_configMap.yaml file will look like this:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
apiVersion: v1 kind: ConfigMap metadata: name: nginx-config labels: tier: backend data: config : | server { index index.php index.html; error_log /var/log/nginx/error.log; access_log /var/log/nginx/access.log; root /code; location / { try_files $uri $uri/ /index.php?$query_string; } location ~ \.php$ { try_files $uri =404; fastcgi_split_path_info ^(.+\.php)(/.+)$; fastcgi_pass php:9000; fastcgi_index index.php; include fastcgi_params; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; fastcgi_param PATH_INFO $fastcgi_path_info; } } |
Ora puoi salvare e uscire dall'editor. Ora esegui il kubectl apply comando per creare il ConfigMap:
|
1 |
$ kubectl apply -f nginx_configMap.yaml |
Successivamente, dovresti vedere il seguente output sullo schermo:
|
1 |
configmap/nginx-config created |
Hai creato con successo la tua Configmap di Nginx. Ora puoi creare il tuo Deployment di Nginx.
Creazione del Deployment Nginx
Per iniziare, puoi creare un nuovo file chiamato nginx_deployment.yaml nell'editor:
|
1 |
$ nano nginx_deployment.yaml |
Assegna a questo Deployment il nome nginx e aggiungi l'etichetta tier: backend ad esso:
|
1 2 3 4 5 6 7 |
apiVersion: apps/v1 kind: Deployment metadata: name: nginx labels: tier: backend |
Successivamente, specifica il numero di repliche aggiungendo il campo replica nella spec del Deployment e aggiungi le etichette app: nginx e tier: backend ad esso:
|
1 2 3 4 5 6 7 |
... spec: replicas: 1 selector: matchLabels: app: nginx tier: backend |
Allo esso modo, aggiungi il template del pod. Assicurati di aggiungere le stesse etichette che avevi aggiunto nel selector.matchLabels del Deployment. Puoi aggiungere quanto segue:
|
1 2 3 4 5 6 |
... template: metadata: labels: app: nginx tier: backend |
Consenti a Nginx di accedere alla PVC code creata in precedenza aggiungendo i seguenti parametri sotto spec.template.spec.volumes:
|
1 2 3 4 5 6 |
... spec: volumes: - name: code persistentVolumeClaim: claimName: code |
|
1 2 3 4 5 6 7 |
... - name: config configMap: name: nginx-config items: - key: config path: site.conf |
Attenzione: il contenuto della chiave sostituirà il mountPath del volume se non viene specificato un file. In altre parole, perderai tutti i contenuti nella cartella di destinazione se non viene specificato esplicitamente un percorso.
Ora, specifica il nome, l'immagine e la porta che desideri utilizzare nel tuo pod. Qui utilizzeremo l'immagine nginx:1.7.9 e la porta 80. Aggiungili sotto spec.template.spec sezione:
|
1 2 3 4 5 6 |
... containers: - name: nginx image: nginx:1.7.9 ports: - containerPort: 80 |
Inoltre, monta il volume del codice su /code poiché sia Nginx che PHP-FPM dovranno accedere al file nello stesso percorso:
|
1 2 3 4 |
... volumeMounts: - name: code mountPath: /code |
L'immagine nginx-1.7.9 carica automaticamente qualsiasi file di configurazione nella cartella /etc/nginx/conf.d. Ora, se montiamo il volume di configurazione in questa directory, creerà /etc/nginx/conf.d/site.conf. Aggiungi quanto segue sotto la sezione volumeMount:
|
1 2 3 |
... - name: config mountPath: /etc/nginx/conf.d |
Dopo aver completato tutti i passaggi precedenti, il tuo file nginx_deployment.yaml dovrebbe apparire così:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
apiVersion: apps/v1 kind: Deployment metadata: name: nginx labels: tier: backend spec: replicas: 1 selector: matchLabels: app: nginx tier: backend template: metadata: labels: app: nginx tier: backend spec: volumes: - name: code persistentVolumeClaim: claimName: code - name: config configMap: name: nginx-config items: - key: config path: site.conf containers: - name: nginx image: nginx:1.7.9 ports: - containerPort: 80 volumeMounts: - name: code mountPath: /code - name: config mountPath: /etc/nginx/conf.d |
Ora puoi salvare e chiudere il file e creare il Deployment di Nginx eseguendo il seguente comando:
|
1 |
$ kubectl apply -f nginx_deployment.yaml |
In caso di esecuzione corretta del comando, dovresti vedere il seguente output:
|
1 |
deployment.apps/nginx creato |
Puoi elencare tutti i tuoi Deployment eseguendo i comandi seguenti:
|
1 |
$ kubectl get deployments |
Ora dovresti vedere sia il Deployment di Nginx che quello di PHP-FPM:
Inoltre, puoi eseguire il seguente comando per elencare i pod gestiti da entrambi i Deployment sopra elencati:
|
1 |
$ kubectl get pods |
Vedrai che entrambi i tuoi pod sono attivi e funzionanti come segue:
Poiché tutti i tuoi oggetti Kubernetes sono attivi a questo punto, ora puoi accedere al servizio Nginx sul tuo browser.
Esegui il seguente comando per elencare i servizi:
|
1 |
$ kubectl get services -o wide |
Prendi nota dell'External IP del tuo servizio Nginx:
Ora, utilizzando questo External IP del servizio Nginx, puoi visitare il tuo server digitando http://your_public_ip sul tuo browser. Dovresti essere in grado di vedere l'output di php_info() che conferma che i tuoi servizi Kubernetes sono attivi e funzionanti.
Conclusione
In questo tutorial, per gestire i tuoi servizi PHP-FPM e Nginx in modo indipendente, hai containerizzato i due servizi. In questo modo, non solo migliorerai la scalabilità del tuo progetto, ma utilizzerai anche le tue risorse in modo efficiente. Hai anche imparato come creare uno storage locale e un Persistent Volume per memorizzare il codice della tua applicazione su un volume ed essere in grado di aggiornare facilmente i tuoi servizi in futuro. In questo modo, hai migliorato l'usabilità e la manutenibilità del tuo codice.
Inoltre, dai un'occhiata agli altri nostri tutorial incentrati su Docker e Kubernetes che puoi trovare sul nostro blog:
- Conoscere Kubernetes
- Come creare un cluster Kubernetes utilizzando Kubeadm su Ubuntu 18.04
- Pulire le risorse Docker – Immagini, container e volumi
- Distribuire Laravel, Nginx e MySQL con Docker Compose
- Come installare & utilizzare Docker su Ubuntu nel cloud pubblico
Buon computing!
Commenti
Ancora nessun commento. Scrivi il primo.