Kubernetes (más néven k8s) egy nyílt forráskódú orchestrációs rendszer. Lehetővé teszi a felhasználók számára a konténerizált alkalmazások telepítését, skálázását és kezelését minimális állásidővel. Ebben az útmutatóban megtanulhatja, hogyan telepíthet egy PHP alkalmazást egy Kubernetes fürtön.
Az Nginx proxyként működik a PHP-FPM felé a PHP alkalmazás futtatása közben. E két szolgáltatás kezelése egyetlen konténerben nehéz folyamat. A Kubernetes segít nekünk két külön konténerben kezelni őket, és csökkenti a nehézségeket. Lehetővé teszi továbbá a felhasználók számára a konténerek újrafelhasználását, így nem kell aggódniuk a konténerkép (container image) felépítése miatt minden új PHP/Nginx verzióhoz.
Az alkalmazást és a proxy szolgáltatást két külön konténerben fogja futtatni. Az útmutató bemutatja azt is, hogyan használhatja a helyi tárolót egy Persistent Volume (PV) és Persistent Volume Claim (PVC) létrehozásához. Ezt követően ezt a PVC-t fogja használni a konfigurációs fájlok és a kód konténerképeken kívül tartására. Az útmutató elvégzése után újra felhasználhatja az Nginx képét más olyan alkalmazásokhoz, amelyek proxy szervert igényelnek. Ezt egy konfiguráció átadásával érheti el, ahelyett, hogy újraépítené a képet hozzá.
Előfeltételek
- A Kubernetes (k8s) és objektumainak alapvető ismerete. Tekintse meg ezt az útmutatót a Kubernetes ökoszisztéma részletes áttekintéséhez.
- Egy működő Kubernetes fürt Ubuntu 18.04-en. Kövesse ezt az útmutatót a Kubernetes fürt létrehozásához a kubeadm használatával.
- Ezenkívül az alkalmazás kódját egy nyilvános URL-címen kell tárolnia, például a GitHub.
1. lépés: PHP-FPM és Nginx szolgáltatások létrehozása
Ez a lépés segít a PHP-FPM és Nginx szolgáltatások létrehozásában. Minden szolgáltatás hozzáférést biztosít a fürtön belüli podok egy csoportjához. A fürtben lévő összes szolgáltatás képes kommunikálni egymással a nevük alapján, IP-címek nélkül. A PHP-FPM szolgáltatás és az Nginx szolgáltatás hozzáférést biztosít a PHP-FPM, illetve az Nginx podokhoz.
Meg kell adnia a PHP-FPM szolgáltatásnak, hogyan találja meg az Nginx podokat, mivel az proxyként fog működni a PHP-FPM podok számára. Ehhez kihasználja a Kubernetes’ automatikus szolgáltatásfelfedezését, és olvasható neveket használ a kérés megfelelő szolgáltatáshoz való irányításához.
Bármely szolgáltatás létrehozásához létre kell hoznia egy YAML fájlt, amely az objektumdefiníciót tartalmazza. Ez a YAML fájl legalább a következő címkékkel rendelkezik:
apiVersion: A Kubernetes API verziója, amelyhez a definíció tartozik.kind: A Kubernetes objektum típusa, amelyet ez a YAML fájl létrehoz. Például egyservice, egyjob, vagy egypod.metadata: Az objektum neve és a különbözőlabelscímkék, amelyeket a felhasználó alkalmazni szeretne erre az objektumra, ezen tag alatt vannak meghatározva.spec: Ez a tag tartalmazza az objektum specifikációját, például a környezeti változókat (ENV), a használandó konténerképet, valamint azokat a portokat, amelyeken a konténer szolgáltatás elérhető lesz.
A PHP-FPM szolgáltatás létrehozása
Kezdésként hozzon létre egy könyvtárat a Kubernetes objektumdefiníciók tárolására. Jelentkezzen be a master csomópontra, és hozzon létre egy “definitions:”
|
1 |
mkdir definitions |
Váltson át a definitions könyvtárra:
|
1 |
cd definitions |
Ezután hozza létre a PHP-FPM szolgáltatásfájlt mint php_service.yaml fájlt:
|
1 |
nano php_fpm_service.yaml |
Ezt követően állítsa be az apiVersion és kind értékeket a php_fpm_service.yaml fájlban:
|
1 2 |
apiVersion: v1 kind: Service |
Nevezze el a szolgáltatást php vagy php-fpm névre, mivel ez biztosít majd hozzáférést a PHP-FPM alkalmazásához:
|
1 2 3 |
… Metadata: name: php |
Lássa el a php szolgáltatást a tier: backend címkével, mivel a PHP alkalmazás e mögött a szolgáltatás mögött fog futni:
|
1 2 3 |
… labels: tier: backend |
A szolgáltatás a selector címkéket használja annak meghatározására, hogy mely podokat érje el. Minden olyan pod kiszolgálásra kerül, amely illeszkedik ezekre a címkékre, függetlenül attól, hogy mikor jött létre. Az útmutató későbbi részében megtanulhatja, hogyan adhat hozzá címkéket a podokhoz.
Adja hozzá a tier: backend címkét, amely a podot a backend réteghez rendeli, valamint a app: php-fpm címkét, amely jelzi, hogy a pod egy PHP-FPM alkalmazást futtat. Ezeket a címkéket a metadata szakasz után kell hozzáadnia:
|
1 2 3 4 5 |
… spec: selector: app: php-fpm tier: backend |
Ezután meg kell adnia a portot a php-fpm szolgáltatás eléréséhez a spec alatt. Bármilyen tetszőleges portot megadhat, de ebben az útmutatóban a 9000 portot fogjuk használni:
|
1 2 3 4 |
... ports: - protocol: TCP port: 9000 |
A fenti lépések elvégzése után a php_fpm_service.yaml fájl így fog kinézni:
|
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 |
Nyomja meg a Ctrl + O billentyűkombinációt a fájl mentéséhez, majd a Ctrl + X billentyűkombinációt a kilépéshez a nano.
A kubectl parancs alkalmazása a PHP szolgáltatás létrehozásához
Miután a szolgáltatás objektumdefiníciója létrejött, futtassa a kubectl apply parancsot a -f argumentummal, megadva a php_fpm_service.yaml fájlt:
|
1 |
kubectl apply -f php_fpm_service.yaml |
A fenti parancs kimenetének a következőnek kell lennie:
|
1 |
service/php created |
Futtassa az alábbi parancsot annak ellenőrzésére, hogy a php-fpm szolgáltatás fut-e:
|
1 |
$ kubectl get svc |
Látni fogja, hogy a php-fpm szolgáltatás elindult és fut:
|
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 |
Az Nginx szolgáltatás létrehozása
Mivel a PHP-FPM szolgáltatás már kész, itt az ideje, hogy létrehozza az Nginx szolgáltatást is. Hozzon létre és nyisson meg egy új YAML-fájlt ehhez a szolgáltatáshoz nginx_service.yaml néven a szerkesztőben:
|
1 |
$ nano nginx_service.yaml |
Nevezze el ezt a szolgáltatást nginx néven, mivel ez az Nginx podokat fogja megcélozni. Ez a szolgáltatás is a backendhez tartozik, így hozzá kell adnia egy tier: backend címkét:
|
1 2 3 4 5 6 |
apiVersion: v1 kind: Service metadata: name: nginx labels: tier: backend |
A php-fpm szolgáltatáshoz hasonlóan adja hozzá az app: nginx és tier: backend címkéket a podok megcélzásához. Adja meg az alapértelmezett HTTP-portot 80 a szolgáltatás eléréséhez:
|
1 2 3 4 5 6 7 8 |
... spec: selector: app: nginx tier: backend ports: - protocol: TCP port: 80 |
Az Nginx szolgáltatás nyilvánosan elérhető lehet az interneten a nyilvános IP-címről. Megadhatja a worker node IP-címét mint your_public_ip. Adja hozzá az alábbi sorokat a spec.externalIPs:
|
1 2 3 4 5 |
... spec: externalIPs: - your_public_ip |
A nginx_service.yaml fájlnak a fenti lépések elvégzése után így kell kinéznie:
|
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 |
Mentse el és zárja be a fájlt, miután hozzáadta az összes szükséges fenti paramétert.
A kubectl parancs alkalmazása az Nginx szolgáltatás létrehozásához
|
1 |
kubectl apply -f nginx_service.yaml |
|
1 |
service/nginx created |
|
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/service_name |
Step 2: Create Local Storage and Persistent Volume
A Kubernetes különféle tárolási beépülő modulokat biztosít, amelyek segítenek tárhelyet létrehozni a környezet számára. Ez a lépés bemutatja, hogyan hozhat létre egy helyi StorageClass-t, és hogyan használható ez a Storage Class a továbbiakban egy perzisztens kötet (Persistent Volume) létrehozásához.
Helyi tárhely létrehozása
Hozzon létre egy fájlt, például storageClass.yaml néven a szerkesztőjében:
|
1 |
$nano storageClass.yaml |
Adja meg a kind értékeként a "storageClass"-t, az apiVersion értékeként pedig a "storage.k8s.io/v1"-et a következőképpen:
|
1 2 |
kind: StorageClass apiVersion: storage.k8s.io/v1 |
Nevezze el ezt a StorageClass-t "my-local-storage" néven, és adja hozzá a provisioner és volumeBindingMode mezőket az alábbiak szerint:
|
1 2 3 4 5 |
… metadata: name: my-local-storage provisioner: kubernetes.io/no-provisioner volumeBindingMode: Immediate |
Mentse el és lépjen ki a fájlból; a végleges storageClass.yaml fájlnak így kell kinéznie:
|
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 |
Most hozza létre a StorageClass-t a kubectl create parancs futtatásával, az alábbiak szerint:
|
1 |
$ kubectl create -f storageClass.yaml |
A fenti parancs futtatása után a következő kimenetet kell kapnia:
|
1 |
storageclass.storage.k8s.io/my-local-storage created |
Helyi perzisztens kötet (Persistent Volume) létrehozása
A helyi tárhely (Local Storage) létrehozása után létrehozhatja a helyi perzisztens kötetet (Persistent Volume). A perzisztens kötet, más néven PV, egy meghatározott méretű blokkos tárhely, amely független a pod életciklusától. A helyi perzisztens kötet nem más, mint egy helyi lemez vagy könyvtár, amely elérhető egy Kubernetes fürtcsomóponton. Ez a helyi perzisztens kötet lehetővé teszi a felhasználók számára, hogy egy helyi perzisztens kötetigénylés (Persistent Volume Claim) segítségével rendkívül egyszerű, mégis hordozható módon férjenek hozzá a helyi tárhelyhez. Ezt a helyi perzisztens kötetet az imént létrehozott storage class használatával hozhatja létre. Nyisson meg egy fájlt, például persistentVolume.yaml néven a szerkesztőjében:
|
1 |
$ nano persistentVolume.yaml |
Adjon nevet ennek a perzisztens kötetnek, például "my-local-pv":
|
1 2 3 4 |
apiVersion: v1 kind: PersistentVolume metadata: name: my-local-pv |
A helyi perzisztens kötet létrehozásakor a használatának megfelelő tárolókapacitást adhat hozzá. Ebben az útmutatóban 5 Gi-t fogunk használni a tárhelyhez:
|
1 2 3 4 |
… spec: capacity: storage: 5Gi |
Adja hozzá az accessModes, persistentVolumeReclaimPolicy mezőket, és adja meg ugyanazt a storageClassName-et, mint amit a storageClass.yaml fájlban használt:
|
1 2 3 4 5 |
… accessModes: - ReadWriteOnce persistentVolumeReclaimPolicy: Retain storageClassName: my-local-storage |
Adja hozzá a local.path értéket a Persistent Volume-hoz az alábbiak szerint:
|
1 2 3 |
… local: path: /mnt/disk/vol |
After adding all the required fields, your persistentVolume.yaml fájlnak így kell kinéznie:
|
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 |
Helyi kötet előkészítése
Most elő kell készítenünk egy helyi kötetet a “worker” csomóponton, ahogyan azt a persistentVolume.yaml fájlban megadtuk. Futtassa az alábbi parancsokat azon a csomóponton, amelyet a persistentVolume-ban konfigurált. Ebben az esetben ez a “worker” csomópont:
|
1 2 3 |
$ DIRNAME="vol" $ mkdir -p /mnt/disk/$DIRNAME $ chmod 777 /mnt/disk/$DIRNAME |
Futtassa az alábbi parancsot a master csomóponton, ahol a persistentVolume.yaml fájl található:
|
1 |
kubectl create -f persistentVolume.yaml |
Az alábbi kimenetet kell kapnia:
|
1 |
persistentvolume/my-local-pv created |
Miután sikeresen létrehozta a helyi tárhelyet és a Persistent Volume-ot, most már továbbléphet, és létrehozhat egy Persistent Volume Claim-et az alkalmazáskód és a konfigurációs fájlok tárolására.
3. lépés: A Persistent Volume létrehozása
Az alkalmazás kódját biztonságban kell tartani, miközben a podokat kezeli vagy frissíti. Ehhez az előző lépésben létrehozott Persistent Volume-ot fogja használni, amelyhez egy PersistentVolumeClaim (vagy PVC) segítségével lehet hozzáférni. Ez a PVC csatlakoztatja a PV-t a szükséges útvonalon.
Nyisson meg egy fájlt, például a code_volume.yaml fájlt a szerkesztőjében:
|
1 |
$ nano code_volume.yaml |
Nevezze el a PVC-t „code”-nak az alábbi paraméterek és értékek fájlhoz való hozzáadásával:
|
1 2 3 4 |
apiVersion: v1 kind: PersistentVolumeClaim metadata: name: code |
Egy PVC spec szekciója a következő elemeket tartalmazza:
- accessModes: Erre a mezőre a következő különböző értékek lehetségesek:
- ReadWriteOnce – Csatlakoztatja a kötetet egyetlen csomóponthoz, írási és olvasási jogosultsággal is.
- ReadOnlyMany – Csatlakoztatja a kötetet több csomóponthoz, csak olvasási jogosultsággal.
- ReadWriteMany – Csatlakoztatja a kötetet több csomóponthoz, írási és olvasási jogosultsággal is.
- resources: Meghatározza a szükséges tárhelyet.
Mivel a helyi tárhely csak egyetlen csomóponthoz van csatolva, az accessMode értékét ReadWriteOnce-ra kell állítania. Ebben az útmutatóban csak egy kis darab alkalmazáskódot fog hozzáadni, így az 1 GB tárhely elegendő lesz itt. Ha azonban nagyobb mennyiségű adatot vagy kódot szeretne tárolni, a tárolási paramétert az igényeinek megfelelően módosíthatja. Vegye figyelembe, hogy a kötet létrehozása után növelheti a tárhely méretét. A csökkentése azonban nem támogatott:
|
1 2 3 4 5 6 7 |
... spec: accessModes: - ReadWriteOnce resources: requests: storage: 1Gi |
Most deklarálja azt a tárolóosztályt, amelyet a Kubernetes-fürt a kötetek kiosztásához fog használni. Használja az előző lépésben létrehozott my-local-storage tárolóosztályt itt a storageClassName értékeként:
|
1 2 |
... storageClassName: my-local-storage |
A fenti lépések elvégzése után a(z) code_volume.yaml fájlnak így kell kinéznie:
|
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 |
Most mentse el és lépjen ki a fájlból.
PVC létrehozása
Hozza létre a code PVC-t a kubectl apply parancs futtatásával:
|
1 |
$ kubectl apply -f code_volume.yaml |
A következő kimenetet kell kapnia, amely jelzi, hogy az objektum sikeresen létrejött, és készen áll az 1 GB-os PVC kötetként való csatolására:
|
1 |
persistentvolumeclaim/code created |
A következő parancs futtatásával ellenőrizheti az elérhető állandó kötetet (Persistent Volume - PV):
|
1 |
$ kubectl get pv |
A fenti parancs kimenetének a következőnek kell lennie:
|
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 |
A fenti mezők mindegyike – a Reclaim Policy és a Status kivételével – a konfigurációs fájl áttekintése. A Reclaim Policy határozza meg, hogy mi történik a PV-vel, miután az azt elérő PVC-t törlik. A Delete érték eltávolítja a PV-t a Kubernetes-fürtből, valamint a tárolási infrastruktúrából is. Hivatkozhat a Kubernetes PV dokumentációra , hogy tisztán megértse a Reclaim Policy és a Status működését.
Most már létrehozhatja a podokat egy Deployment használatával, mivel sikeresen létrehozta a Persistent Volume-ot a helyi tárhely használatával.
Step 4: Create Deployment for your PHP-FPM Application
Ez a lépés segít létrehozni a PHP-FPM podot a Deployment segítségével. A Deployment ReplicaSet-eket használ, hogy stabil módot biztosítson a podok létrehozására, frissítésére és kezelésére. A Deployment automatikusan visszaállítja a podokat egy korábbi képre.
A spec.selector kulcs a Deploymentben felsorolja az általa kezelt podok összes címkéjét. A template kulcsot is használja a szükséges podok létrehozásához.
Ebben a lépésben bemutatjuk az Init Containers alkalmazását. Az Init Containers futtatnak néhány parancsot a pod sablonjában megadott normál konténerek előtt. Itt az Init Container a GitHub Gist-et (https://gist.github.com/) fogja használni egy minta index.php fájl lekéréséhez. A mintafájl tartalma:
|
1 2 |
<?php echo phpinfo(); |
PHP Deployment létrehozása
Nyisson meg egy új, php_deployment.yaml nevű fájlt a szerkesztőben a Deployment létrehozásához:
|
1 |
$ nano php_deployment.yaml |
Most nevezze el a Deployment objektumot PHP-nak, mivel ez a Deployment fogja kezelni a PHP-FPM podokat. Adja hozzá a következő címkét: tier: backend, mert a pod a backend réteghez fog tartozni:
|
1 2 3 4 5 6 |
apiVersion: apps/v1 kind: Deployment metadata: name: php labels: tier: backend |
A replica paraméter segítségével adja meg, hogy a podból hány másolatot kell létrehozni. A replikák száma az Ön igényeitől és a rendelkezésre álló erőforrásoktól függően változhat. Ebben az útmutatóban csak egy replikát fog létrehozni a podból:
|
1 2 3 4 |
... spec: replicas: 1 |
Adja hozzá az app: php és tier:backend címkéket a selector kulcs alatt, ami azt jelzi, hogy ez a Deployment azokat a podokat fogja kezelni, amelyek megegyeznek ezzel a két címkével:
|
1 2 3 4 5 |
... selector: matchLabels: app: php tier: backend |
Most a pod’jának objektumdefiníciójához szükség van egy sablonra (template) a Deployment spec-je alatt. Ez a sablon határozza meg a pod létrehozásához szükséges specifikációt. Kezdésként adja hozzá a php szolgáltatásválasztóhoz (service selector) és a Deployment matchLabels részéhez megadott címkéket. Ezután adja hozzá az app:php és tier:backend címkéket a template.metadata.labels:
|
1 2 3 4 5 6 7 |
... template: metadata: labels: app: php tier: backend |
Először meg kell adnia az összes olyan kötetet, amelyhez a konténerei hozzá fognak férni. Nevezze el ezt a kötetet code-nak, mivel korábban már létrehozott egy code nevű PVC-t az alkalmazáskód tárolására:
|
1 2 3 4 5 6 |
... spec: volumes: - name: code persistentVolumeClaim: claimName: code |
Ezután adja meg a konténer nevét, valamint azt az image-et, amelyet a podon belül futtatni szeretne. Különböző image-ek érhetők el a Docker áruházban (https://hub.docker.com/explore/), de ebben az útmutatóban a php:7-fpm image-et fogjuk használni:
|
1 2 3 4 |
... containers: - name: php image: php:7-fpm |
Most csatolja azokat a köteteket, amelyekhez a konténernek hozzáférésre van szüksége. Mivel ez a konténer fogja futtatni a PHP-kódot, hozzá kell férnie az előző lépésben létrehozott code kötethez. Ebben a lépésben azt is megtanulhatja, hogyan másolhatja át az alkalmazáskódot egy Init Container segítségével.
A kód letöltéséhez ez az útmutató bemutatja, hogyan használhat egyetlen, busybox-ot futtató Init Container-t. A busybox egy kisméretű konténer wget segédprogrammal, amelyet erre a célra fog használni.
Először adja hozzá az initContainer-t a spec.template.spec alatt, és adja meg a busybox image-et:
|
1 2 3 4 |
... initContainers: - name: install image: busybox |
Ezután ahhoz, hogy letöltse a kódot a code kötetbe, az Init Container-nek hozzá kell férnie ahhoz. Csatolja a code kötetet a /code útvonalra a spec.template.spec.initContainers:
|
1 2 3 4 |
... volumeMounts: - name: code mountPath: /code |
Minden Init Container-nek futtatnia kell egy parancsot. Ez az Init Container a wget-et fogja használni, hogy letöltse a kódot a(z) Github-ról a(z) /code könyvtárba. Átadhat egy -O opciót, hogy nevet adjon a letöltött fájlnak, és elnevezheti ezt a fájlt index.php.
Ezenkívül adja hozzá az alábbi sorokat az install konténer alatt a következőben: 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 |
Miután elvégezte ezeket a lépéseket, a php_deployment.yaml fájlnak így kell kinéznie:
|
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 |
Most már elmentheti a fájlt és kiléphet. Ezután hozza létre a PHP-FPM Deploymentet a kubectl apply paranccsal:
|
1 |
$ kubectl apply -f php_deployment.yaml |
A Deployment sikeres létrehozása után az alábbi kimenetet kell kapnia:
|
1 |
deployment.apps/php created |
Ez a Deployment a megadott lemezképek letöltésével kezdődik, majd lekéri a PersistentVolume erőforrást a PersistentVolumeClaim igényből, majd futtatja az Ön initContainers konténereit. Amint ez a lépés befejeződött, a konténerek elindulnak, és csatolják a köteteket a megadott csatolási ponthoz. Ezen lépések elvégzése után a pod elindul és futni fog.
A Deployment megtekintéséhez futtassa az alábbi parancsot:
|
1 |
$ kubectl get deployments |
A fenti parancs futtatása után az alábbi kimenetet kell kapnia:
|
1 2 |
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE php 1 1 1 0 19s |
Ebből a kimenetből megértheti a Deployment aktuális állapotát. A Deployment egy olyan vezérlő, amely fenntartja a kívánt állapotot. A DESIRED mező azt határozza meg, hogy a php nevű podból 1 replikával rendelkezik. A CURRENT mező azt jelzi, hogy a DESIRED állapotból jelenleg hány replika fut. Egy egészséges pod esetén ennek meg kell egyeznie a DESIRED állapottal. A többi mezőről további információt talál a Kubernetes Deployments dokumentációjában.
Ezután a futó pod állapotának ellenőrzéséhez futtassa az alábbi parancsot:
|
1 |
$ kubectl get pods |
E parancs kimenete a Deployment létrehozása óta eltelt időtől függően változhat. Ha röviddel a Deployment létrehozása után futtatja, a kimenet a következőhöz hasonló lesz:
|
1 2 |
NAME READY STATUS RESTARTS AGE php-5d8f6bbf7f-56df2 0/1 Init:0/1 0 9s |
Magyarázat:
Ezek az oszlopok az alábbi információkat képviselik:
- Ready: Az ezt a podot futtató aktuális/kívánt replikák száma.
- Status: A pod állapota. Az Init:0/1 azt jelzi, hogy az Init konténerek futnak, és az 1-ből 0 Init konténer fejezte be a futást.
- Restarts: Ez jelzi, hogy ez a folyamat hányszor indult újra a pod elindításához.
Eltarthat néhány percig, amíg a pod állapota megváltozik erre: podInitializing az indítóparancsfájlok összetettségétől függően:
|
1 2 |
NÉV KÉSZ ÁLLAPOT ÚJRAINDÍTÁSOK KOR php-5d8f6bbf7f-56df2 0/1 podInitializing 0 39s |
Ez azt jelzi, hogy az Init konténerek sikeresen lefutottak, és most a konténerek inicializálása zajlik:
|
1 2 |
NÉV KÉSZ ÁLLAPOT ÚJRAINDÍTÁSOK KOR php-5d8f6bbf7f-56df2 1/1 Running 0 4m10s |
Ahogy most láthatja, a pod már működik és fut. Ha azonban a pod nem indul el, hibakeresési céllal futtathatja az alábbi parancsokat:
1. A pod részletes információinak megtekintéséhez:
|
1 |
$ kubectl describe pods pod-name |
2. A pod naplófájljainak megtekintéséhez:
|
1 |
$ kubectl logs pod-name |
3. A pod egy adott konténerének naplófájljainak megtekintéséhez:
|
1 |
$ kubectl logs pod-name container-name |
Gratulálunk! Sikeresen csatolta az alkalmazáskódot, és a PHP-FPM szolgáltatás készen áll a kapcsolatok kezelésére. Hasonló módon létrehozhatja az Nginx Deploymentet is.
5. lépés: Az Nginx Deployment létrehozása
Ez a lépés bemutatja, hogyan konfigurálhatja az Nginx-et egy ConfigMap segítségével. A ConfigMap kulcs-érték formátumban tárolja az összes szükséges konfigurációt, amelyeket más Kubernetes objektumdefiníciókban fog használni. Ezzel a megközelítéssel rugalmasan újrahasználhatja vagy lecserélheti az Nginx rendszerképet egy másik verzióra, amikor csak szükséges. Frissítheti a ConfigMap objektumot, és az automatikusan replikálja a változtatásokat minden olyan podra, amely csatolja ezt a ConfigMap.
Első lépésként nyisson meg egy nginx_configmap.yaml fájlt a szerkesztőjében:
|
1 |
$ nano nginx_configMap.yaml |
Most nevezze el ezt a ConfigMap-et nginx-config néven, és adja hozzá a tier: backend mikroszolgáltatáshoz:
|
1 2 3 4 5 6 |
apiVersion: v1 kind: ConfigMap metadata: name: nginx-config labels: tier: backend |
Ezenkívül hozzáadhatja az adatokat a ConfigMap-hez. Adjon hozzá egy config nevű kulcsot, és értéknek adja meg az Nginx konfigurációs fájl teljes tartalmát.
Mivel a Kubernetes képes a kéréseket egy szolgáltatás megfelelő gazdagépeihez irányítani, a PHP-FPM szolgáltatás nevét is megadhatja a fastcgi_pass paraméter alatt az IP-címe helyett. Adja hozzá a következő kódsorokat az nginx_configMap.yaml fájlhoz:
|
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; } } |
Ha elkészült, a(z) nginx_configMap.yaml fájl így fog kinézni:
|
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; } } |
Most már elmentheti és bezárhatja a szerkesztőt. Most futtassa a(z) kubectl apply parancsot a(z) ConfigMap:
|
1 |
$ kubectl apply -f nginx_configMap.yaml |
Ezt követően a következő kimenetet kell látnia a képernyőn:
|
1 |
configmap/nginx-config created |
Sikeresen létrehozta az Nginx Configmap-et. Most már létrehozhatja az Nginx Deployment-et.
Nginx Deployment létrehozása
Kezdésként létrehozhat egy új fájlt nginx_deployment.yaml névvel a szerkesztőben:
|
1 |
$ nano nginx_deployment.yaml |
Nevezze el ezt a Deploymentet nginx névvel, és adja hozzá a(z) tier: backend címkét:
|
1 2 3 4 5 6 7 |
apiVersion: apps/v1 kind: Deployment metadata: name: nginx labels: tier: backend |
Ezt követően adja meg a replikák számát a(z) replica mező hozzáadásával a Deployment specifikációjában, majd adja hozzá az app: nginx és tier: backend címkéket:
|
1 2 3 4 5 6 7 |
... spec: replicas: 1 selector: matchLabels: app: nginx tier: backend |
Hasonlóképpen adja hozzá a pod sablont. Győződjön meg arról, hogy ugyanazokat a címkéket adja hozzá, mint amelyeket a Deployment selector.matchLabels mezőjében megadott. A következőket adhatja hozzá:
|
1 2 3 4 5 6 |
... template: metadata: labels: app: nginx tier: backend |
Biztosítson hozzáférést az Nginx számára a korábban létrehozott code PVC-hez a következő paraméterek hozzáadásával a(z) 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 |
Figyelmeztetés: A kulcs tartalma felülírja a kötet mountPath útvonalát, ha nincs fájl megadva. Más szóval, a célmappa teljes tartalma elveszik, ha az elérési út nincs kifejezetten megadva.
Most adja meg a podban használni kívánt nevet, képet és portot. Itt a(z) nginx:1.7.9 képet és a(z) 80 portot. Adja hozzá őket a(z) spec.template.spec szakasz:
|
1 2 3 4 5 6 |
... containers: - name: nginx image: nginx:1.7.9 ports: - containerPort: 80 |
Ezenkívül csatolja a code kötetet a(z) /code helyre, mivel mind az Nginx-nek, mind a PHP-FPM-nek ugyanazon az útvonalon kell elérnie a fájlt:
|
1 2 3 4 |
... volumeMounts: - name: code mountPath: /code |
A(z) nginx-1.7.9 rendszerkép automatikusan betölt minden konfigurációs fájlt a(z) /etc/nginx/conf.d mappából. Ha most ebbe a könyvtárba csatoljuk a config kötetet, az létrehozza a(z) /etc/nginx/conf.d/site.conf fájlt. Adja hozzá a következőket a(z) volumeMount szakasz alá:
|
1 2 3 |
... - name: config mountPath: /etc/nginx/conf.d |
A fenti lépések végrehajtása után a(z) nginx_deployment.yaml fájlnak így kell kinéznie:
|
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 |
Most már elmentheti és bezárhatja a fájlt, majd létrehozhatja az Nginx Deploymentet a következő parancs futtatásával:
|
1 |
$ kubectl apply -f nginx_deployment.yaml |
A parancs sikeres végrehajtása után a következő kimenetet kell látnia:
|
1 |
deployment.apps/nginx created |
Az összes Deploymentet kilistázhatja az alábbi parancsok végrehajtásával:
|
1 |
$ kubectl get deployments |
Most már látnia kell mind az Nginx, mind a PHP-FPM Deploymentet:
Továbbá a következő parancs futtatásával listázhatja a fenti Deploymentek által kezelt podokat:
|
1 |
$ kubectl get pods |
Látni fogja, hogy mindkét pod fut és működik az alábbiak szerint:
Mivel ezen a ponton az összes Kubernetes objektum aktív, most már elérheti az Nginx szolgáltatást a böngészőjében.
Futtassa a következő parancsot a szolgáltatások listázásához:
|
1 |
$ kubectl get services -o wide |
Jegyezze fel az Nginx szolgáltatás külső IP-címét (External IP):
Most, az Nginx szolgáltatás külső IP-címét használva, meglátogathatja a szerverét a következő beírásával: http://your_public_ip a böngészőjében. Látnia kell a php_info() kimenetét, ami megerősíti, hogy a Kubernetes szolgáltatásai futnak és működnek.
Összegzés
Ebben az útmutatóban a PHP-FPM és Nginx szolgáltatások független kezelése érdekében konténerizálta a két szolgáltatást. Ezzel nemcsak a projekt skálázhatóságát javítja, hanem az erőforrásait is hatékonyan használja fel. Megtanulta azt is, hogyan hozhat létre helyi tárhelyet és egy Persistent Volume-ot az alkalmazáskód kötetben való tárolásához, hogy a jövőben könnyen frissíthesse szolgáltatásait. Ezzel javította a kód használhatóságát és karbantarthatóságát.
Továbbá tekintse meg a Dockerre és Kubernetesre fókuszáló egyéb útmutatóinkat, amelyeket itt talál: a blogunkon:
- Ismerkedés a Kubernetes-szel
- Kubernetes fürt létrehozása Kubeadm használatával Ubuntu 18.04-en
- Docker erőforrások tisztítása – képek, konténerek és kötetek
- Laravel, Nginx és MySQL telepítése Docker Compose segítségével
- Hogyan telepítsük & üzemeltessük a Dockert Ubuntun a nyilvános felhőben
Kellemes számítástechnikát!
Hozzászólások
Még nincsenek hozzászólások. Legyen Ön az első.