Kubernetes (tiež známy ako k8s) je open-source orchestračný systém. Umožňuje používateľom nasadzovať, škálovať a spravovať kontajnerizované aplikácie s minimálnym výpadkom. V tomto návode sa dozviete, ako nasadiť PHP aplikáciu v Kubernetes clusteri.
Nginx funguje ako proxy pre PHP-FPM počas behu PHP aplikácie. Správa týchto dvoch služieb v jednom kontajneri je náročný proces. Kubernetes nám pomáha spravovať ich v dvoch rôznych kontajneroch a znižuje náročnosť. Taktiež umožňuje používateľom opätovne použiť kontajnery a nestarať sa o zostavovanie ich obrazu kontajnera pre každú novú verziu PHP/Nginx.
Svoju aplikáciu a proxy službu spustíte v dvoch samostatných kontajneroch. Návod tiež poskytne informácie o tom, ako použiť lokálne úložisko na vytvorenie Persistent Volume (PV) a Persistent Volume Claim (PVC). Tento PVC potom použijete na uchovanie vašich konfiguračných súborov a kódu mimo obrazov kontajnerov. Po dokončení tohto návodu budete môcť znova použiť svoj Nginx obraz pre iné aplikácie, ktoré vyžadujú proxy server. Môžete to dosiahnuť odovzdaním konfigurácie namiesto opätovného zostavovania obrazu.
Požiadavky
- Základné porozumenie Kubernetes (k8s) a jeho objektom. Pozrite si túto príručku pre podrobný prehľad ekosystému Kubernetes.
- Kubernetes cluster, ktorý je spustený a beží na Ubuntu 18.04. Postupujte podľa tohto návodu na vytvorenie vášho Kubernetes clustera pomocou kubeadm.
- Okrem toho musíte hostovať kód svojej aplikácie na verejnej URL adrese, napríklad na GitHub.
Krok 1: Vytvorenie služieb PHP-FPM a Nginx
Tento krok vám pomôže vytvoriť služby PHP-FPM a Nginx. Akákoľvek služba poskytuje prístup k skupine podov v rámci clustera. Všetky služby prítomné v clusteri môžu navzájom komunikovať pomocou svojich názvov, bez IP adries. Služba PHP-FPM a služba Nginx poskytnú prístup k podom PHP-FPM a Nginx.
Budete musieť službe PHP-FPM povedať, ako nájsť pody Nginx, keďže bude fungovať ako proxy pre pody PHP-FPM. Na to využijete automatické zisťovanie služieb v Kubernetes’ a použijete čitateľné názvy na smerovanie požiadavky na príslušnú službu.
Na vytvorenie akejkoľvek služby budete musieť vytvoriť YAML súbor, ktorý obsahuje definíciu objektu. Tento YAML súbor má aspoň nasledujúce značky:
apiVersion: Verzia Kubernetes API, do ktorej definícia patrí.kind: Typ objektu Kubernetes, ktorý tento YAML súbor vytvára. Napríklad:service,jobalebopod.metadata: Názov objektu a rôznelabels, ktoré by používateľ mohol chcieť použiť na tento objekt, sú definované pod touto značkou.spec: Táto značka obsahuje špecifikáciu vášho objektu, ako sú premenné prostredia (ENV), obraz kontajnera, ktorý sa má použiť, a porty, na ktorých bude služba kontajnera prístupná.
Vytvorenie služby PHP-FPM
Na začiatok by ste mali vytvoriť adresár na uloženie definícií vašich objektov Kubernetes. Prihláste sa do svojho hlavného (master) uzla a vytvorte adresár s názvom “definitions:”
|
1 |
mkdir definitions |
Zmeňte adresár na adresár definitions:
|
1 |
cd definitions |
Ďalej vytvorte súbor služby PHP-FPM ako súbor php_service.yaml:
|
1 |
nano php_fpm_service.yaml |
Potom nastavte apiVersion a kind v súbore php_fpm_service.yaml:
|
1 2 |
apiVersion: v1 kind: Service |
Pomenujte svoju službu ako php alebo php-fpm pretože poskytne prístup k vašej PHP-FPM aplikácii:
|
1 2 3 |
… Metadata: name: php |
Označte svoju php službu ako tier: backend keďže PHP aplikácia pobeží za touto službou:
|
1 2 3 |
… labels: tier: backend |
Služba používa selector štítky (labels) na určenie, ku ktorým podom má pristupovať. Akýkoľvek pod, ktorý zodpovedá týmto štítkom, bez ohľadu na to, kedy bol vytvorený, je obsluhovaný. Ako pridať štítky k vašim podom sa dozviete neskôr v tomto návode.
Zahrňte tier: backend štítok, ktorý priradí váš pod do backendovej vrstvy, spolu so štítkom app: php-fpm na označenie, že pod spúšťa aplikáciu PHP-FPM. Tieto štítky musíte pridať za sekciu metadata :
|
1 2 3 4 5 |
… spec: selector: app: php-fpm tier: backend |
Ďalej musíte deklarovať port na prístup k tejto službe php-fpm pod spec. Môžete pridať ľubovoľný port podľa vlastného výberu, ale v tomto návode použijeme port 9000 v tomto návode:
|
1 2 3 4 |
... ports: - protocol: TCP port: 9000 |
Po dokončení vyššie uvedených krokov bude váš súbor php_fpm_service.yaml vyzerať takto:
|
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 |
Stlačením Ctrl + O uložte súbor a stlačením Ctrl + X ukončite nano.
Použitie príkazu kubectl na vytvorenie služby PHP
Keď je definícia objektu pre vašu službu vytvorená, spustite príkaz kubectl apply s argumentom -f a špecifikujte váš súbor php_fpm_service.yaml :
|
1 |
kubectl apply -f php_fpm_service.yaml |
Výstup z vyššie uvedeného príkazu by mal byť:
|
1 |
service/php created |
Spustením nižšie uvedeného príkazu overte, či vaša služba php-fpm beží:
|
1 |
$ kubectl get svc |
Uvidíte, že služba php-fpm je spustená a beží:
|
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 |
Vytvorenie služby Nginx
Keďže vaša služba PHP-FPM je už pripravená, je čas vytvoriť aj službu Nginx. Vytvorte a otvorte nový súbor YAML pre túto službu s názvom nginx_service.yaml v editore:
|
1 |
$ nano nginx_service.yaml |
Pomenujte túto službu ako nginx, pretože bude cieľom pre pody Nginx. Táto služba tiež patrí do backendu, takže by ste k nej mali pridať štítok tier: backend :
|
1 2 3 4 5 6 |
apiVersion: v1 kind: Service metadata: name: nginx labels: tier: backend |
Podobne ako v službe php-fpm, pridajte štítky selektora app: nginx a tier: backend na zacielenie podov. Pridajte predvolený HTTP port 80 na prístup k tejto službe:
|
1 2 3 4 5 6 7 8 |
... spec: selector: app: nginx tier: backend ports: - protocol: TCP port: 80 |
Služba Nginx môže byť verejne prístupná na internete z verejnej IP adresy. IP adresu vášho pracovného uzla môžete pridať ako your_public_ip. Pridajte riadky nižšie pod spec.externalIPs:
|
1 2 3 4 5 |
... spec: externalIPs: - your_public_ip |
Váš súbor nginx_service.yaml by mal po dokončení všetkých vyššie uvedených krokov vyzerať ako ten nižšie:
|
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 |
Po pridaní všetkých požadovaných parametrov vyššie súbor uložte a zatvorte.
Použitie príkazu kubectl na vytvorenie služby Nginx
|
1 |
kubectl apply -f nginx_service.yaml |
|
1 |
služba/nginx vytvorené |
|
1 |
$ kubectl get svc |
|
1 2 3 4 |
NÁZOV TYP CLUSTER-IP EXTERNAL-IP PORT(S) VEK 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/service_name |
Krok 2: Vytvorenie lokálneho úložiska a trvalého zväzku
Kubernetes poskytuje rôzne úložné zásuvné moduly, ktoré vám pomôžu vytvoriť úložný priestor pre vaše prostredie. Tento krok vás prevedie vytvorením lokálneho StorageClass a tým, ako sa táto Storage Class dá ďalej použiť na vytvorenie trvalého zväzku.
Vytvorenie lokálneho úložiska
Vytvorte súbor, napríklad storageClass.yaml, vo vašom editore:
|
1 |
$nano storageClass.yaml |
Pridajte kind ako "storageClass" a apiVersion ako "storage.k8s.io/v1" nasledovne:
|
1 2 |
kind: StorageClass apiVersion: storage.k8s.io/v1 |
Pomenujte túto StorageClass ako "my-local-storage" a pridajte provisioner a volumeBindingMode nasledovne:
|
1 2 3 4 5 |
… metadata: name: my-local-storage provisioner: kubernetes.io/no-provisioner volumeBindingMode: Immediate |
Uložte a zatvorte súbor. Váš finálny súbor storageClass.yaml by mal vyzerať takto:
|
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 |
Teraz vytvorte StorageClass spustením príkazu kubectl create, ako je uvedené nižšie:
|
1 |
$ kubectl create -f storageClass.yaml |
Po spustení vyššie uvedeného príkazu by ste mali dostať nasledujúci výstup:
|
1 |
storageclass.storage.k8s.io/my-local-storage vytvorené |
Vytvorenie lokálneho trvalého zväzku
Po vytvorení lokálneho úložiska môžete vytvoriť svoj lokálny trvalý zväzok (Persistent Volume). Trvalý zväzok, známy aj ako PV, je blokové úložisko určenej veľkosti, ktoré je nezávislé od životného cyklu podu. Lokálny trvalý zväzok nie je nič iné ako lokálny disk alebo adresár, ktorý je k dispozícii na uzle klastra Kubernetes. Tento lokálny trvalý zväzok umožňuje používateľom pristupovať k lokálnemu úložisku pomocou lokálneho nároku na trvalý zväzok (Persistent Volume Claim) veľmi jednoduchým, no prenosným spôsobom. Tento lokálny trvalý zväzok môžete vytvoriť pomocou tejto triedy úložiska, ktorú sme práve vytvorili. Otvorte súbor, napríklad persistentVolume.yaml, vo vašom editore:
|
1 |
$ nano persistentVolume.yaml |
Dajte tomuto trvalému zväzku názov, napríklad "my-local-pv":
|
1 2 3 4 |
apiVersion: v1 kind: PersistentVolume metadata: name: my-local-pv |
Pri vytváraní lokálneho trvalého zväzku môžete pridať kapacitu úložiska podľa potreby. V tomto návode použijeme pre úložisko 5 Gi:
|
1 2 3 4 |
… spec: capacity: storage: 5Gi |
Pridajte accessModes, persistentVolumeReclaimPolicy a uveďte rovnaký storageClassName, aký bol použitý v súbore storageClass.yaml:
|
1 2 3 4 5 |
… accessModes: - ReadWriteOnce persistentVolumeReclaimPolicy: Retain storageClassName: my-local-storage |
Pridajte local.path pre váš Persistent Volume nasledovne:
|
1 2 3 |
… local: path: /mnt/disk/vol |
Po pridaní všetkých požadovaných polí by mal váš súbor persistentVolume.yaml vyzerať takto:
|
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 |
Príprava lokálneho zväzku
Teraz musíme pripraviť lokálny zväzok na uzle “worker”, ako sme pridali v súbore persistentVolume.yaml . Spustite nižšie uvedené príkazy na uzle, ktorý ste nakonfigurovali v persistentVolume. V tomto prípade je to uzol “worker”:
|
1 2 3 |
$ DIRNAME="vol" $ mkdir -p /mnt/disk/$DIRNAME $ chmod 777 /mnt/disk/$DIRNAME |
Spustite nižšie uvedený príkaz na master uzle, kde sa nachádza váš súbor persistentVolume.yaml :
|
1 |
kubectl create -f persistentVolume.yaml |
Mali by ste získať nasledujúci výstup:
|
1 |
persistentvolume/my-local-pv created |
Keďže ste úspešne vytvorili svoje lokálne úložisko a Persistent Volume, môžete teraz pokračovať a vytvoriť Persistent Volume Claim na uloženie kódu aplikácie a konfiguračných súborov.
Krok 3: Vytvorenie Persistent Volume
Kód vašej aplikácie musí byť v bezpečí, kým spravujete alebo aktualizujete svoje pody. Na tento účel použijete Persistent Volume vytvorený v predchádzajúcom kroku, ku ktorému sa pristupuje pomocou PersistentVolumeClaim alebo PVC. Tento PVC pripojí PV na požadovanú cestu.
Otvorte súbor, napríklad code_volume.yaml, vo vašom editore:
|
1 |
$ nano code_volume.yaml |
Pomenujte svoj PVC ako code pridaním nižšie uvedených parametrov a hodnôt do vášho súboru:
|
1 2 3 4 |
apiVersion: v1 kind: PersistentVolumeClaim metadata: name: code |
Sekcia spec v PVC obsahuje nasledujúce položky:
- accessModes: Pre toto pole existujú rôzne možné hodnoty nasledovne:
- ReadWriteOnce – Pripojí zväzok pre jeden uzol s právami na čítanie aj zápis.
- ReadOnlyMany – Pripojí zväzok pre viacero uzlov iba s právom na čítanie.
- ReadWriteMany – Pripojí zväzok pre viacero uzlov s právami na čítanie aj zápis.
- resources: Definuje požadovaný úložný priestor.
Keďže lokálne úložisko je pripojené iba k jednému uzlu, budete musieť nastaviť accessMode na ReadWriteOnce. V tomto návode pridáte iba malú časť kódu aplikácie, preto tu bude stačiť 1 GB úložiska. Ak však chcete uložiť väčšie množstvo dát alebo kódu, môžete parameter úložiska upraviť podľa svojich požiadaviek. Upozorňujeme, že po vytvorení zväzku budete môcť veľkosť úložiska zväčšiť. Jeho zmenšenie však nie je podporované:
|
1 2 3 4 5 6 7 |
... spec: accessModes: - ReadWriteOnce resources: requests: storage: 1Gi |
Teraz deklarujte triedu úložiska (storage class), ktorú bude cluster Kubernetes používať na prideľovanie zväzkom. Pre váš storageClassName tu použite triedu úložiska my-local-storage vytvorenú v predchádzajúcom kroku:
|
1 2 |
... storageClassName: my-local-storage |
Po dokončení vyššie uvedených krokov by mal váš súbor code_volume.yaml vyzerať takto:
|
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 |
Teraz súbor uložte a zatvorte.
Vytvorenie PVC
Vytvorte PVC pre kód spustením príkazu kubectl apply:
|
1 |
$ kubectl apply -f code_volume.yaml |
Mali by ste dostať nasledujúci výstup, ktorý indikuje, že objekt bol úspešne vytvorený a je pripravený na pripojenie vášho 1GB PVC ako zväzku:
|
1 |
persistentvolumeclaim/code created |
Na kontrolu dostupného perzistentného zväzku (PV) môžete spustiť nasledujúci príkaz:
|
1 |
$ kubectl get pv |
Výstup vyššie uvedeného príkazu by mal byť nasledujúci:
|
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 |
Všetky vyššie uvedené polia, okrem Reclaim Policy a Status, sú prehľadom vášho konfiguračného súboru. Reclaim Policy definuje, čo sa stane s PV po vymazaní PVC, ktoré k nemu pristupuje. Hodnota Delete odstráni PV z clustera Kubernetes, ako aj z infraštruktúry úložiska. Môžete si prečítať dokumentáciu k PV v Kubernetes, aby ste jasne porozumeli Reclaim Policy a Status.
Teraz môžete vytvoriť svoje pody pomocou Deploymentu, keďže ste úspešne vytvorili svoj Persistent Volume pomocou lokálneho úložiska.
Krok 4: Vytvorenie Deploymentu pre vašu aplikáciu PHP-FPM
Tento krok vám pomôže vytvoriť váš pod PHP-FPM pomocou Deploymentu. Deployment používa ReplicaSety na poskytovanie stabilného spôsobu vytvárania, aktualizácie a správy vašich podov. Deployment automaticky vráti svoje pody na predchádzajúci obraz (image).
Kľúč spec.selector v Deploymente uvádza všetky štítky podov, ktoré spravuje. Používa tiež kľúč template na vytvorenie požadovaných podov.
V tomto kroku si tiež predstavíme použitie Init Containerov. Init Containery spúšťajú niekoľko príkazov pred bežnými kontajnermi, ktoré sú špecifikované v šablóne podu. V tomto prípade Init Container použije GitHub Gist (https://gist.github.com/) na získanie vzorového súboru index.php. Obsah vzorového súboru je:
|
1 2 |
<?php echo phpinfo(); |
Vytvorenie PHP Deploymentu
Otvorte nový súbor s názvom php_deployment.yaml vo vašom editore na vytvorenie Deploymentu:
|
1 |
$ nano php_deployment.yaml |
Teraz pomenujte objekt Deployment ako PHP, pretože tento Deployment bude spravovať vaše pody PHP-FPM. Pridajte štítok tier: backend pretože pod bude patriť do backendovej vrstvy:
|
1 2 3 4 5 6 |
apiVersion: apps/v1 kind: Deployment metadata: name: php labels: tier: backend |
Pomocou parametra replica špecifikujte počet kópií tohto podu, ktoré sa majú vytvoriť. Počet replík sa môže líšiť v závislosti od vašich požiadaviek a dostupných zdrojov. V tomto návode vytvoríte iba jednu repliku vášho podu:
|
1 2 3 4 |
... spec: replicas: 1 |
Pridajte app: php a tier:backend štítky pod kľúčom selector, ktorý označuje, že tento Deployment bude spravovať pody, ktoré zodpovedajú týmto dvom štítkom:
|
1 2 3 4 5 |
... selector: matchLabels: app: php tier: backend |
Teraz definícia objektu vášho podu potrebuje šablónu (template) pod špecifikáciou vášho Deploymentu. Táto šablóna definuje špecifikáciu, ktorá je potrebná na vytvorenie vášho podu. Na začiatok pridajte štítky, ktoré boli špecifikované pre selektor služby php a matchLabels Deploymentu. Potom pridajte app:php a tier:backend pod 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 |
Ďalej špecifikujte názov kontajnera spolu s obrazom (image), ktorý chcete spustiť vo vnútri vášho podu. V obchode Docker sú k dispozícii rôzne obrazy (https://hub.docker.com/explore/), ale v tomto návode použijeme obraz php:7-fpm :
|
1 2 3 4 |
... containers: - name: php image: php:7-fpm |
Teraz pripojte zväzky, ku ktorým kontajner vyžaduje prístup. Keďže tento kontajner bude spúšťať váš php kód, bude potrebovať prístup k zväzku code vytvorenému v predchádzajúcom kroku. V tomto kroku sa tiež dozviete, ako skopírovať kód vašej aplikácie pomocou Init Containeru.
Na stiahnutie kódu vás tento návod prevedie tým, ako použiť jeden Init Container s busyboxom. Busybox je malý kontajner s nástrojom wget, ktorý na to použijete.
First, add your initContainer under spec.template.spec a špecifikujte obraz busybox:
|
1 2 3 4 |
... initContainers: - name: install image: busybox |
Potom, aby bolo možné stiahnuť kód do zväzku code, váš Init Container k nemu bude potrebovať prístup. Pripojte zväzok code na cestu /code pod spec.template.spec.initContainers:
|
1 2 3 4 |
... volumeMounts: - name: code mountPath: /code |
Každý Init Container vyžaduje spustenie príkazu. Tento Init Container použije wget na stiahnutie code z Github do adresára /code. Môžete odovzdať voľbu -O, aby ste tomuto stiahnutému súboru dali názov, a tento súbor môžete pomenovať index.php.
Okrem toho pridajte nasledujúce riadky pod kontajner install v 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 |
Po dokončení všetkých týchto krokov by mal váš php_deployment.yaml súbor vyzerať takto:
|
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 |
Teraz môžete súbor uložiť a ukončiť. Ďalej vytvorte svoj PHP-FPM Deployment pomocou kubectl apply príkazu:
|
1 |
$ kubectl apply -f php_deployment.yaml |
Úspešné vytvorenie Deploymentu by vám malo poskytnúť nasledujúci výstup:
|
1 |
deployment.apps/php created |
Tento Deployment začne stiahnutím špecifikovaných obrazov, potom požiada o PersistentVolume z vášho PersistentVolumeClaim, a potom spustí vaše initContainers. Po dokončení tohto kroku sa kontajnery spustia a pripoja zväzky do špecifikovaného bodu pripojenia. Po dokončení všetkých týchto krokov bude váš pod spustený a funkčný.
Na zobrazenie vášho Deploymentu môžete spustiť nasledujúci príkaz:
|
1 |
$ kubectl get deployments |
Po spustení vyššie uvedeného príkazu by ste mali dostať nasledujúci výstup:
|
1 2 |
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE php 1 1 1 0 19s |
Aktuálny stav Deploymentu môžete pochopiť pomocou tohto výstupu. Deployment je kontrolér, ktorý udržiava požadovaný stav. Pole DESIRED špecifikuje, že má 1 repliku podu s názvom php. Pole CURRENT indikuje, koľko replík DESIRED stavu momentálne beží. Pre zdravý pod by sa to malo zhodovať s DESIRED stavom. Viac informácií o zostávajúcich poliach sa dozviete v Kubernetes Deployments Dokumentácii.
Potom môžete spustiť nasledujúci príkaz na kontrolu stavu vášho spusteného podu:
|
1 |
$ kubectl get pods |
Výstup tohto príkazu sa môže líšiť v závislosti od času, ktorý uplynul od vytvorenia vášho Deploymentu. Ak ho spustíte krátko po vytvorení Deploymentu, výstup bude podobný tomuto:
|
1 2 |
NAME READY STATUS RESTARTS AGE php-5d8f6bbf7f-56df2 0/1 Init:0/1 0 9s |
Vysvetlenie:
Tieto stĺpce predstavujú informácie nasledovne:
- Ready: Počet aktuálnych/požadovaných replík spustených v tomto pode.
- Status: Stav vášho podu. Init:0/1 indikuje, že bežia Init kontajnery a 0 z 1 Init kontajnerov dokončilo beh.
- Restarts: Toto označuje počet, koľkokrát sa tento proces reštartoval, aby sa spustil pod.
Môže trvať niekoľko minút, kým sa stav vášho podu zmení na podInitializing v závislosti od zložitosti vašich spúšťacích skriptov:
|
1 2 |
NAME READY STATUS RESTARTS AGE php-5d8f6bbf7f-56df2 0/1 podInitializing 0 39s |
Toto indikuje, že Init kontajnery úspešne prebehli a teraz sa inicializujú samotné kontajnery:
|
1 2 |
NAME READY STATUS RESTARTS AGE php-5d8f6bbf7f-56df2 1/1 Running 0 4m10s |
Ako teraz môžete vidieť, váš pod je spustený a beží. Ak by sa však váš pod nespustil, môžete na účely ladenia spustiť nasledujúce príkazy:
1. Na zobrazenie podrobných informácií o pode:
|
1 |
$ kubectl describe pods pod-name |
2. Na zobrazenie logov podu:
|
1 |
$ kubectl logs pod-name |
3. Na zobrazenie logov konkrétneho kontajnera v pode:
|
1 |
$ kubectl logs pod-name container-name |
Gratulujeme! Úspešne ste pripojili kód aplikácie a služba PHP-FPM je pripravená spracovávať pripojenia. Podobne môžete vytvoriť svoj Nginx Deployment.
Step 5: Create your Nginx Deployment
Tento krok vás prevedie konfiguráciou Nginx pomocou ConfigMap. ConfigMap uchováva všetky vaše požadované konfigurácie vo formáte kľúč-hodnota, ktoré sa použijú v iných definíciách objektov Kubernetes. S týmto prístupom budete mať flexibilitu opätovne použiť alebo vymeniť obraz Nginx za inú verziu, kedykoľvek to bude potrebné. Môžete aktualizovať ConfigMap a automaticky replikuje tieto zmeny do akéhokoľvek podu, ktorý pripája tento ConfigMap.
Na začiatok otvorte súbor nginx_configmap.yaml vo vašom editore:
|
1 |
$ nano nginx_configMap.yaml |
Teraz pomenujte tento ConfigMap ako nginx-config a pridajte ho do mikroslužby tier: backend:
|
1 2 3 4 5 6 |
apiVersion: v1 kind: ConfigMap metadata: name: nginx-config labels: tier: backend |
Okrem toho môžete pridať dáta do ConfigMap. Pridajte kľúč s názvom config a ako hodnotu pridajte celý obsah konfiguračného súboru Nginx.
Keďže Kubernetes dokáže smerovať požiadavky na príslušných hostiteľov pre danú službu, môžete namiesto IP adresy zadať názov vašej služby PHP-FPM pod parameter fastcgi_pass. Pridajte nasledujúce riadky kódu do vášho súboru 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; } } |
Po dokončení bude váš nginx_configMap.yaml súbor vyzerať takto:
|
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; } } |
Teraz môžete editor uložiť a ukončiť. Teraz vykonajte kubectl apply príkaz na vytvorenie ConfigMap:
|
1 |
$ kubectl apply -f nginx_configMap.yaml |
Potom by ste mali na obrazovke vidieť nasledujúci výstup:
|
1 |
configmap/nginx-config created |
Úspešne ste vytvorili svoj Nginx Configmap. Teraz môžete vytvoriť svoj Nginx Deployment.
Vytvorenie Nginx Deploymentu
Na začiatok môžete vytvoriť nový súbor s názvom nginx_deployment.yaml v editore:
|
1 |
$ nano nginx_deployment.yaml |
Pomenujte tento Deployment nginx a pridajte k nemu tier: backend štítok:
|
1 2 3 4 5 6 7 |
apiVersion: apps/v1 kind: Deployment metadata: name: nginx labels: tier: backend |
Potom špecifikujte počet replík pridaním poľa replica v špecifikácii Deploymentu a pridajte k nemu štítky app: nginx a tier: backend:
|
1 2 3 4 5 6 7 |
... spec: replicas: 1 selector: matchLabels: app: nginx tier: backend |
Podobne pridajte šablónu podu. Uistite sa, že pridáte rovnaké štítky, aké ste pridali v selector.matchLabels Deploymentu. Môžete pridať nasledujúce:
|
1 2 3 4 5 6 |
... template: metadata: labels: app: nginx tier: backend |
Poskytnite Nginxu prístup k PVC kódu, ktorý bol vytvorený predtým, pridaním nasledujúcich parametrov pod 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 |
Varovanie: Obsah kľúča nahradí mountPath zväzku, ak nie je špecifikovaný súbor. Inými slovami, stratíte všetok obsah v cieľovom priečinku, ak cesta nie je explicitne špecifikovaná.
Teraz špecifikujte názov, obraz a port, ktoré chcete použiť vo svojom pode. Tu použijeme obraz nginx:1.7.9 a port 80. Pridajte ich pod spec.template.spec sekcia:
|
1 2 3 4 5 6 |
... containers: - name: nginx image: nginx:1.7.9 ports: - containerPort: 80 |
Taktiež pripojte zväzok kódu na /code, keďže Nginx aj PHP-FPM budú potrebovať prístup k súboru na rovnakej ceste:
|
1 2 3 4 |
... volumeMounts: - name: code mountPath: /code |
Obraz nginx-1.7.9 automaticky načíta akýkoľvek konfiguračný súbor v priečinku /etc/nginx/conf.d. Ak teraz pripojíme konfiguračný zväzok do tohto adresára, vytvorí sa /etc/nginx/conf.d/site.conf. Pridajte nasledovné pod volumeMount sekciu:
|
1 2 3 |
... - name: config mountPath: /etc/nginx/conf.d |
Po dokončení všetkých vyššie uvedených krokov by mal váš súbor nginx_deployment.yaml vyzerať takto:
|
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 |
Teraz môžete súbor uložiť, zatvoriť a vytvoriť Nginx Deployment spustením nasledujúceho príkazu:
|
1 |
$ kubectl apply -f nginx_deployment.yaml |
Po úspešnom vykonaní príkazu by ste mali vidieť nasledujúci výstup:
|
1 |
deployment.apps/nginx created |
Všetky svoje Deploymenty môžete zobraziť spustením nasledujúcich príkazov:
|
1 |
$ kubectl get deployments |
Teraz by ste mali vidieť Deploymenty pre Nginx aj PHP-FPM:
Ďalej môžete spustiť nasledujúci príkaz na zobrazenie zoznamu podov, ktoré sú spravované oboma vyššie uvedenými Deploymentmi:
|
1 |
$ kubectl get pods |
Uvidíte, že oba vaše pody sú spustené a fungujú nasledovne:
Keďže všetky vaše objekty Kubernetes sú v tomto bode aktívne, teraz môžete pristupovať k službe Nginx vo vašom prehliadači.
Spustite nasledujúci príkaz na zobrazenie zoznamu služieb:
|
1 |
$ kubectl get services -o wide |
Poznačte si External IP vašej služby Nginx:
Teraz, pomocou tejto External IP služby Nginx, môžete navštíviť svoj server zadaním http://your_public_ip vo vašom prehliadači. Mali by ste vidieť výstup z php_info(), ktorý potvrdzuje, že vaše služby Kubernetes sú spustené a fungujú.
Záver
V tomto návode ste na nezávislú správu služieb PHP-FPM a Nginx tieto dve služby kontajnerizovali. Týmto spôsobom nielen zlepšíte škálovateľnosť svojho projektu, ale budete aj efektívne využívať svoje zdroje. Naučili ste sa tiež, ako vytvoriť lokálne úložisko a Persistent Volume na uloženie kódu vašej aplikácie na zväzok a mať možnosť v budúcnosti jednoducho aktualizovať svoje služby. Týmto spôsobom ste zlepšili použiteľnosť a udržiavateľnosť vášho kódu.
Okrem toho sa pozrite na naše ďalšie návody zamerané na Docker a Kubernetes, ktoré nájdete na našom blogu:
- Zoznámenie sa s Kubernetes
- Ako vytvoriť Kubernetes klaster pomocou Kubeadm na Ubuntu 18.04
- Vyčistenie zdrojov Docker – obrazy, kontajnery a zväzky
- Nasadenie Laravel, Nginx a MySQL pomocou Docker Compose
- Ako nainštalovať & prevádzkovať Docker na Ubuntu vo verejnom cloude
Príjemnú prácu!
Komentáre
Zatiaľ žiadne komentáre. Buďte prvý.