Ubuntu 18.04 ile bir Kubernetes Kümesinde PHP Uygulaması Dağıtma

Hark Labs2021-08-12 · 30 min read

Ubuntu 18.04 ile bir Kubernetes Kümesinde PHP Uygulaması Dağıtma

Kubernetes (k8s olarak da bilinir) açık kaynaklı bir orkestrasyon sistemidir. Kullanıcıların konteynerleştirilmiş uygulamaları minimum kesinti süresiyle dağıtmasına, ölçeklendirmesine ve yönetmesine olanak tanır. Bu öğreticide, bir PHP Uygulamasını bir Kubernetes Kümesinde nasıl dağıtacağınızı öğreneceksiniz.

Nginx, bir PHP uygulamasını çalıştırırken PHP-FPM için bir proxy görevi görür. Bu iki hizmeti tek bir konteynerde yönetmek zor bir süreçtir. Kubernetes bunları iki farklı konteynerde yönetmemize yardımcı olur ve zahmeti azaltır. Ayrıca kullanıcıların konteynerleri yeniden kullanmasına ve her yeni PHP/Nginx sürümü için kendi konteyner imajlarını oluşturma konusunda endişelenmemelerine olanak tanır.

Uygulamanızı ve proxy hizmetinizi iki ayrı konteynerde çalıştıracaksınız. Bu öğretici ayrıca, bir Persistent Volume (PV) ve Persistent Volume Claim (PVC) oluşturmak için yerel depolamanın nasıl kullanılacağına dair bilgiler de sağlayacaktır. Daha sonra yapılandırma dosyalarınızı ve kodunuzu konteyner imajlarının dışında tutmak için bu PVC'yi kullanacaksınız. Bu öğreticiyi tamamladıktan sonra, Nginx imajınızı proxy sunucusu gerektiren diğer uygulamalar için yeniden kullanabileceksiniz. Bunu, imajı yeniden oluşturmak yerine bir yapılandırma ileterek gerçekleştirebilirsiniz.

Önkoşullar

Kubernetes (k8s) ve nesneleri hakkında temel bir anlayış. Şunun için bu kılavuza başvurun: Kubernetes ekosistemine ayrıntılı genel bakış.
Ubuntu 18.04 üzerinde çalışan bir Kubernetes kümesi. Şunun için bu öğreticiyi takip edin: kubeadm kullanarak Kubernetes kümenizi oluşturun.
Ek olarak, uygulama kodunuzu herkese açık bir URL'de barındırmanız gerekir, örneğin, GitHub.

Adım 1: PHP-FPM ve Nginx Hizmetlerini Oluşturma

Bu adım, PHP-FPM ve Nginx hizmetlerini oluşturmanıza yardımcı olacaktır. Herhangi bir hizmet, bir küme içindeki bir dizi pod'a erişim sağlar. Bir kümede bulunan tüm hizmetler, IP adresleri olmadan kendi adlarıyla birbirleriyle iletişim kurabilir. PHP-FPM hizmeti ve Nginx hizmeti, sırasıyla PHP-FPM ve Nginx pod'larına erişim sağlayacaktır.

PHP-FPM pod'ları için bir proxy görevi göreceğinden, PHP-FPM hizmetine Nginx pod'larını nasıl bulacağını söylemeniz gerekecektir. Bunun için Kubernetes’in otomatik hizmet keşfinden yararlanacak ve isteği ilgili hizmete yönlendirmek için okunabilir adlar kullanacaksınız.

Herhangi bir hizmet oluşturmak için, nesne tanımını içeren bir YAML dosyası oluşturmanız gerekecektir. Bu YAML dosyası en azından aşağıdaki etiketlere sahiptir:

apiVersion: Tanımın ait olduğu Kubernetes API sürümü.
kind: Bu YAML dosyasının oluşturduğu Kubernetes nesnesinin türü. Örneğin: bir service, bir job, veya bir pod.
metadata: Nesnenin adı ve kullanıcının bu nesneye uygulamak isteyebileceği farklı labels bu etiket altında tanımlanır.
spec: Bu etiket; ENV'ler, kullanılacak konteyner imajı, konteyner hizmetine erişilebilecek bağlantı noktaları gibi nesnenizin nesne özelliklerini içerir.

PHP-FPM hizmetini oluşturma

Başlamak için, Kubernetes nesne tanımınızı tutmak üzere bir dizin oluşturmalısınız. Master düğümünüzde oturum açın ve “definitions:”

mkdir definitions

1	mkdir definitions

Dizini definitions dizini olarak değiştirin:

cd definitions

1	cd definitions

Ardından, PHP-FPM hizmet dosyanızı php_service.yaml dosyası olarak oluşturun:

nano php_fpm_service.yaml

1	nano php_fpm_service.yaml

Bundan sonra, apiVersion ve kind değerlerini php_fpm_service.yaml dosyasında ayarlayın:

apiVersion: v1
kind: Service

1 2	apiVersion: v1 kind: Service

PHP-FPM uygulamanıza erişim sağlayacağı için hizmetinizi php veya php-fpm olarak adlandırın:

…
Metadata:
  name: php

…

Metadata:

PHP uygulaması bu hizmetin arkasında çalışacağından, php hizmetinizi tier: backend olarak etiketleyin:

…
  labels:
    tier: backend

…

labels:

tier: backend

Bir hizmet, hangi pod'lara erişeceğini belirlemek için selector etiketlerini kullanır. Pod'un ne zaman oluşturulduğuna bakılmaksızın, bu etiketlerle eşleşen her pod'a hizmet verilir. Bu öğreticinin ilerleyen kısımlarında pod'larınıza nasıl etiket ekleyeceğinizi öğreneceksiniz.

Pod'unuzu backend katmanına atayan tier: backend etiketini ve pod'un bir PHP-FPM uygulaması çalıştırdığını belirten app: php-fpm etiketini dahil edin. Bu etiketleri şu bölümden sonra eklemelisiniz: metadata bölümü:

…
spec:
  selector:
    app: php-fpm
    tier: backend

…

spec:

selector:

app: php-fpm

tier: backend

Ardından, bu servise erişmek için portu tanımlamanız gerekir: php-fpm servisi, şunun altında: spec. İstediğiniz herhangi bir portu ekleyebilirsiniz, ancak biz bu eğitimde 9000 portunu kullanacağız:

...
  ports:
    - protocol: TCP
      port: 9000

...

ports:

- protocol: TCP

port: 9000

Yukarıdaki adımları tamamladıktan sonra, php_fpm_service.yaml dosyanız şu şekilde görünecektir:

apiVersion: v1
kind: Service
metadata:
  name: php
  labels:
    tier: backend
spec:
  selector:
    app: php
    tier: backend
  ports:
  - protocol: TCP
    port: 9000

apiVersion: v1

kind: Service

metadata:

labels:

tier: backend

spec:

selector:

app: php

tier: backend

ports:

- protocol: TCP

port: 9000

Dosyayı kaydetmek için Ctrl + O tuşlarına basın, ardından çıkmak için Ctrl + X tuşlarına basarak şundan çıkın: nano.

PHP servisini oluşturmak için kubectl komutunu uygulama

Servisiniz için nesne tanımı oluşturulduktan sonra, kubectl apply komutunu -f parametresiyle ve php_fpm_service.yaml dosyanızı belirterek çalıştırın:

kubectl apply -f php_fpm_service.yaml

1	kubectl apply -f php_fpm_service.yaml

Yukarıdaki komutun çıktısı şu şekilde olmalıdır:

service/php created

1	service/php created

php-fpm servisinizin çalıştığını doğrulamak için aşağıdaki komutu çalıştırın:

$ kubectl get svc

1	$ kubectl get svc

php-fpm servisinin çalışır durumda olduğunu görebileceksiniz:

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

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

Not: Kubernetes çeşitli servis türlerini destekler. php-fpm servisiniz varsayılan ClusterIP servis türünü kullanır. Bu servis türü dahili bir IP atar ve servisin yalnızca Kubernetes kümesi içinden erişilebilir olmasını sağlar.

Nginx servisini oluşturma

PHP-FPM servisiniz artık hazır olduğuna göre, Nginx servisinizi de oluşturma zamanı geldi. Editörde bu servis için nginx_service.yaml adında yeni bir YAML dosyası oluşturun ve açın:

$ nano nginx_service.yaml

1	$ nano nginx_service.yaml

Nginx pod'larını hedefleyeceği için bu servisi nginx olarak adlandırın. Bu servis de backend katmanına ait olduğundan, ona bir tier: backend etiketi eklemelisiniz:

apiVersion: v1
kind: Service
metadata:
  name: nginx
  labels:
    tier: backend

apiVersion: v1

kind: Service

metadata:

labels:

tier: backend

php-fpm servisinde yaptığımız gibi, pod'ları hedeflemek için app: nginx ve tier: backend seçici etiketlerini ekleyin. Bu servise erişmek için varsayılan HTTP portu olan 80 portunu ekleyin:

...
spec:
  selector:
    app: nginx
    tier: backend
  ports:
  - protocol: TCP
    port: 80

...

spec:

selector:

app: nginx

tier: backend

ports:

- protocol: TCP

port: 80

Nginx servisine genel IP adresinden internet üzerinden herkese açık olarak erişilebilir. Worker node’unuzun IP’sini your_public_ip olarak ekleyebilirsiniz. Aşağıdaki satırları şu bölümün altına ekleyin: spec.externalIPs:

...

spec:
  externalIPs:
  - your_public_ip

...

spec:

externalIPs:

- your_public_ip

Yukarıdaki adımların tümünü tamamladığınızda, nginx_service.yaml dosyanız aşağıdaki gibi görünmelidir:

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

apiVersion: v1

kind: Service

metadata:

labels:

tier: backend

spec:

selector:

app: nginx

tier: backend

ports:

- protocol: TCP

port: 80

externalIPs:

- your_public_ip

Yukarıdaki tüm gerekli parametreleri ekledikten sonra dosyayı kaydedip kapatın.

Nginx servisini oluşturmak için kubectl komutunu uygulama

kubectl apply -f nginx_service.yaml

1	kubectl apply -f nginx_service.yaml

Yukarıdaki komut için aşağıdaki çıktıyı görmelisiniz:

service/nginx oluşturuldu

1	servis/nginx oluşturuldu

Şimdi, çalışan tüm servislerinizi görüntülemek için aşağıdaki komutu yürütün:

$ kubectl get svc

1	$ kubectl get svc

Yukarıdaki komutu çalıştırarak hem PHP-FPM hem de Nginx servislerinizin çalışır durumda olduğunu görebilmelisiniz:

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

İSİM TÜR KÜME-IP HARİCİ-IP PORT(S) YAŞ

kubernetes ClusterIP 10.96.0.1 <yok> 443/TCP 13m

nginx ClusterIP 10.102.160.47 your_public_ip 80/TCP 50s

php ClusterIP 10.100.59.238 <yok> 9000/TCP 8m

Çalışan servislerinizden herhangi birini silmek isterseniz aşağıdaki komutu yürütebileceğinizi unutmayın:

$ kubectl delete svc/servis_adi

1	$ kubectl delete svc/servis_adi

Adım 2: Yerel Depolama ve Kalıcı Birim (Persistent Volume) Oluşturma

Kubernetes, ortamınız için depolama alanı oluşturmanıza yardımcı olan çeşitli depolama eklentileri sunar. Bu adım, yerel bir StorageClass oluşturma ve bu Depolama Sınıfının Kalıcı Birim oluşturmak için daha sonra nasıl kullanılabileceği konusunda size yol gösterecektir.

Yerel depolama oluşturma

Editörünüzde, örneğin storageClass.yaml adında bir dosya oluşturun:

$nano storageClass.yaml

1	$nano storageClass.yaml

kind değerini "storageClass" ve apiVersion değerini "storage.k8s.io/v1" olarak aşağıdaki gibi ekleyin:

kind: StorageClass
apiVersion: storage.k8s.io/v1

1 2	kind: StorageClass apiVersion: storage.k8s.io/v1

Bu StorageClass'ı "my-local-storage" olarak adlandırın ve provisioner ile volumeBindingMode alanlarını aşağıdaki gibi ekleyin:

…
metadata:
  name: my-local-storage
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: Immediate

…

metadata:

provisioner: kubernetes.io/no-provisioner

volumeBindingMode: Immediate

Dosyayı kaydedip kapatın; nihai storageClass.yaml dosyanız şu şekilde görünmelidir:

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: my-local-storage
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer

kind: StorageClass

apiVersion: storage.k8s.io/v1

metadata:

provisioner: kubernetes.io/no-provisioner

volumeBindingMode: WaitForFirstConsumer

Şimdi, aşağıdaki gibi kubectl create komutunu çalıştırarak StorageClass'ı oluşturun:

$ kubectl create -f storageClass.yaml

1	$ kubectl create -f storageClass.yaml

Yukarıdaki komutu çalıştırdıktan sonra aşağıdaki çıktıyı almalısınız:

storageclass.storage.k8s.io/my-local-storage oluşturuldu

1	storageclass.storage.k8s.io/my-local-storage oluşturuldu

Yerel Kalıcı Birim (Persistent Volume) Oluşturma

Yerel Depolama oluşturduktan sonra yerel Kalıcı Biriminizi oluşturabilirsiniz. PV olarak da bilinen Kalıcı Birim, bir podun yaşam döngüsünden bağımsız olan, belirli boyuttaki blok depolamadır. Yerel bir Kalıcı Birim, bir Kubernetes küme düğümünde bulunan yerel bir disk veya dizinden başka bir şey değildir. Bu yerel Kalıcı Birim, kullanıcılarının yerel bir Kalıcı Birim Talebi (Persistent Volume Claim) kullanarak yerel depolamaya son derece basit ama taşınabilir bir şekilde erişmesini sağlar. Bu yerel Kalıcı Birimi, az önce oluşturduğumuz depolama sınıfını kullanarak oluşturabilirsiniz. Editörünüzde, örneğin persistentVolume.yaml adında bir dosya açın:

$ nano persistentVolume.yaml

1	$ nano persistentVolume.yaml

Bu kalıcı birime, örneğin "my-local-pv":

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-local-pv

apiVersion: v1

kind: PersistentVolume

metadata:

Yerel bir Kalıcı Birim oluştururken kullanımınıza göre depolama kapasitesi ekleyebilirsiniz. Bu eğitimde depolama için 5 Gi kullanacağız:

…
spec:
  capacity:
    storage: 5Gi

…

spec:

capacity:

storage: 5Gi

accessModes, persistentVolumeReclaimPolicy alanlarını ekleyin ve storageClass.yaml dosyasında kullanılanla aynı storageClassName değerini sağlayın:

…
  accessModes:
  - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: my-local-storage

…

accessModes:

- ReadWriteOnce

persistentVolumeReclaimPolicy: Retain

storageClassName: my-local-storage

Not: persistentVolumeReclaimPolicy, talebi (Persistent Volume Claim) serbest bırakıldığında Kalıcı Birime (Persistent Volume) ne olacağını belirtir. Bu parametre için geçerli üç seçenek vardır: Retain, Delete ve Recycle. Kodumuzda Retain seçeneğini kullanacağız. Daha fazla ayrıntı için persistentVolumeReclaimPolicy alanını buradan kontrol edebilirsiniz: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.21/#persistentvolumeclaim-v1-core

Kalıcı Biriminiz için local.path değerini aşağıdaki gibi ekleyin:

…
  local:
    path: /mnt/disk/vol

…

local:

path: /mnt/disk/vol

Not: Bu yerel yolun (/mnt/disk/vol) Kubernetes küme düğümünüzde mevcut olduğundan emin olun.

Gerekli tüm alanları ekledikten sonra, persistentVolume.yaml dosyanız şu şekilde görünmelidir:

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

apiVersion: v1

kind: PersistentVolume

metadata:

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

Not: Makinenizin doğru düğüm adını kullanmalısınız. Bu durumda bu ad: “worker.”

Yerel Birimi Hazırlama

Şimdi, persistentVolume.yaml dosyasında eklediğimiz gibi “worker” düğümünde yerel bir birim hazırlamamız gerekiyor. persistentVolume içinde yapılandırdığınız düğümde aşağıdaki komutları çalıştırın. Bu durumda bu düğüm “worker” düğümüdür:

$ DIRNAME="vol"
$ mkdir -p /mnt/disk/$DIRNAME
$ chmod 777 /mnt/disk/$DIRNAME

$ DIRNAME="vol"

$ mkdir -p /mnt/disk/$DIRNAME

$ chmod 777 /mnt/disk/$DIRNAME

Not: Dizini oluşturmak ve yukarıda gösterildiği gibi izni değiştirmek için yeterli yetkiniz olduğundan emin olun. Yetkiniz yoksa komutları doğru kullanıcıyla çalıştırın.

Aşağıdaki komutu, persistentVolume.yaml dosyanızın bulunduğu master düğümde çalıştırın:

kubectl create -f persistentVolume.yaml

1	kubectl create -f persistentVolume.yaml

Aşağıdaki çıktıyı almalısınız:

persistentvolume/my-local-pv created

1	persistentvolume/my-local-pv created

Yerel depolama alanınızı ve Kalıcı Biriminizi (Persistent Volume) başarıyla oluşturduğunuza göre, artık uygulama kodunuzu ve yapılandırma dosyalarınızı tutmak için bir Kalıcı Birim Talebi (Persistent Volume Claim) oluşturmaya geçebilirsiniz.

Adım 3: Kalıcı Birimi Oluşturma

Pod'larınızı yönetirken veya güncellerken uygulama kodunuzun güvende tutulması gerekir. Bunun için, bir önceki adımda oluşturulan ve bir PersistentVolumeClaim (PVC) kullanılarak erişilen Kalıcı Birimi (Persistent Volume) kullanacaksınız. Bu PVC, PV'yi gerekli yola bağlar.

Editörünüzde, örneğin code_volume.yaml, adında bir dosya açın:

$ nano code_volume.yaml

1	$ nano code_volume.yaml

Dosyanıza aşağıdaki parametreleri ve değerleri ekleyerek PVC'nizi code olarak adlandırın:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: code

apiVersion: v1

kind: PersistentVolumeClaim

metadata:

Bir PVC'nin spec bölümü aşağıdaki öğeleri içerir:

accessModes: Bu alan için olası çeşitli değerler aşağıdaki gibidir:
- ReadWriteOnce – Birimi, hem okuma hem de yazma izinleriyle tek bir düğüm için bağlar.
- ReadOnlyMany – Birimi, yalnızca okuma izniyle birçok düğüm için bağlar.
- ReadWriteMany – Birimi, hem okuma hem de yazma izinleriyle birçok düğüm için bağlar.
resources: Gerekli depolama alanını tanımlar.

Yerel depolama yalnızca tek bir düğüme bağlandığından, accessMode değerini ReadWriteOnce olarak ayarlamanız gerekecektir. Bu öğreticide yalnızca küçük bir uygulama kodu parçası ekleyeceksiniz, bu nedenle burada 1 GB depolama alanı yeterli olacaktır. Ancak, daha büyük miktarda veri veya kod depolamak istiyorsanız, depolama parametresini gereksinimlerinize göre değiştirebilirsiniz. Birim oluşturulduktan sonra depolama boyutunu artırabileceğinizi unutmayın. Ancak, boyutun azaltılması desteklenmez:

...
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

...

spec:

accessModes:

- ReadWriteOnce

resources:

requests:

storage: 1Gi

Şimdi, Kubernetes kümesinin birimlere tahsis etmek için kullanacağı depolama sınıfını bildirin. storageClassName değeriniz için burada, önceki adımda oluşturulan my-local-storage depolama sınıfını kullanın:

...
  storageClassName: my-local-storage

1 2	... storageClassName: my-local-storage

Yukarıdaki adımları tamamladıktan sonra, code_volume.yaml dosyanız şu şekilde görünmelidir:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: code
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
  storageClassName: my-local-storage

apiVersion: v1

kind: PersistentVolumeClaim

metadata:

spec:

accessModes:

- ReadWriteOnce

resources:

requests:

storage: 1Gi

storageClassName: my-local-storage

Şimdi dosyayı kaydedip çıkın.

PVC Oluşturma

kubectl apply komutunu çalıştırarak code PVC'sini oluşturun:

$ kubectl apply -f code_volume.yaml

1	$ kubectl apply -f code_volume.yaml

Nesnenin başarıyla oluşturulduğunu ve 1 GB PVC'nizi birim olarak bağlamaya hazır olduğunu belirten aşağıdaki çıktıyı almalısınız:

persistentvolumeclaim/code created

1	persistentvolumeclaim/code created

Mevcut Kalıcı Birimi (PV) kontrol etmek için aşağıdaki komutu yürütebilirsiniz:

$ kubectl get pv

1	$ kubectl get pv

Yukarıdaki komutun çıktısı aşağıdaki gibi olmalıdır:

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

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

Geri Kazanım Politikası (Reclaim Policy) ve Durum (Status) dışındaki yukarıdaki tüm alanlar, yapılandırma dosyanızın genel bir özetidir. Geri Kazanım Politikası, ona erişen PVC silindiğinde PV'ye ne olacağını tanımlar. Delete değeri, PV'yi hem Kubernetes kümesinden hem de depolama altyapısından kaldırır. Geri Kazanım Politikası ve Durum hakkında net bir anlayışa sahip olmak için Kubernetes PV documentation başvurabilirsiniz.

Yerel depolamayı kullanarak Kalıcı Biriminizi başarıyla oluşturduğunuza göre, artık bir Deployment kullanarak pod'larınızı oluşturabilirsiniz.

Adım 4: PHP-FPM Uygulamanız için Deployment Oluşturma

Bu adım, Deployment kullanarak PHP-FPM pod'unuzu oluşturmanıza yardımcı olacaktır. Deployment, pod'larınızı oluşturmak, güncellemek ve yönetmek için kararlı bir yol sağlamak üzere ReplicaSet'leri kullanır. Bir Deployment, pod'larını otomatik olarak önceki bir imaja geri döndürür.

Deployment içindeki spec.selector anahtarı, yönettiği pod'ların tüm etiketlerini listeler. Ayrıca gerekli pod'ları oluşturmak için template anahtarını kullanır.

Bu adımda ayrıca Init Containers uygulamasını da tanıtacağız. Init Container'lar, pod’un şablonu altında belirtilen normal konteynerlerden önce birkaç komut çalıştırır. Burada Init Container, örnek bir index.php dosyası almak için GitHub Gist (https://gist.github.com/) kullanacaktır. Örnek dosyanın içeriği şöyledir:

<?php
echo phpinfo();

1 2	<?php echo phpinfo();

PHP Deployment Oluşturma

Deployment'ınızı oluşturmak için düzenleyicinizde php_deployment.yaml adında yeni bir dosya açın:

$ nano php_deployment.yaml

1	$ nano php_deployment.yaml

Şimdi, bu Deployment PHP-FPM pod'larınızı yöneteceğinden Deployment nesnesini PHP olarak adlandırın. Şu etiketi ekleyin: tier: backend çünkü pod backend katmanına ait olacak:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: php
  labels:
    tier: backend

apiVersion: apps/v1

kind: Deployment

metadata:

labels:

tier: backend

replica parametresini kullanarak, bu pod'un oluşturulması gereken kopya sayısını belirtin. Replika sayısı, gereksinimlerinize ve mevcut kaynaklara bağlı olarak değişebilir. Bu öğreticide, pod'unuzun yalnızca bir replikasını oluşturacaksınız:

...

spec:
  replicas: 1

...

spec:

replicas: 1

Şunu ekleyin: app: php ve tier:backend etiketlerini, bu Deployment'ın bu iki etiketle eşleşen pod'ları yöneteceğini belirten selector anahtarının altına ekleyin:

...
  selector:
    matchLabels:
      app: php
      tier: backend

...

selector:

matchLabels:

app: php

tier: backend

Şimdi, pod'unuzun nesne tanımının Deployment spec'iniz altında bir şablona (template) ihtiyacı var. Bu şablon, pod'unuzu oluşturmak için gereken özellikleri tanımlar. Başlamak için, php servis seçicisi ve Deployment'ın matchLabels'ı için belirtilen etiketleri ekleyin. Ardından şunu ekleyin: app:php ve tier:backend şunun altına: template.metadata.labels:

...

  template:
    metadata:
      labels:
        app: php
        tier: backend

...

template:

metadata:

labels:

app: php

tier: backend

Not: Bir pod birden fazla konteynere veya birime (volume) sahip olabilir ve bunları birbirlerinden ayırt edebilmek için her birinin farklı bir isme ihtiyacı olacaktır. Her bir birimi bir konteynere seçici olarak bağlamak (mount) için bir bağlama yolu (mount path) belirtebilirsiniz.

İlk olarak, konteynerlerinizin erişeceği tüm birimleri (volumes) belirtmeniz gerekir. Uygulama kodunuzu tutmak için code adında bir PVC oluşturduğunuzdan, bu birimi code olarak adlandırın:

...
    spec:
      volumes:
      - name: code
        persistentVolumeClaim:
          claimName: code

...

spec:

volumes:

- name: code

persistentVolumeClaim:

claimName: code

Ardından, pod'unuzun içinde çalıştırmak istediğiniz imajla birlikte konteyner adını belirtin. Docker mağazasında (https://hub.docker.com/explore/) çeşitli imajlar mevcuttur, ancak bu öğreticide şu imajı kullanacağız: php:7-fpm imajı:

...
      containers:
      - name: php
        image: php:7-fpm

...

containers:

- name: php

image: php:7-fpm

Şimdi, konteynerin erişmesi gereken birimleri bağlayın (mount edin). Bu konteyner php kodunuzu çalıştıracağından, bir önceki adımda oluşturulan code birimine erişmesi gerekecektir. Bu adımda ayrıca Init Container kullanarak uygulama kodunuzu nasıl kopyalayacağınızı da öğreneceksiniz.

Not: Kurulum sürecinizin karmaşıklığına bağlı olarak, uygulamanızı derleyen bir betiği çalıştırmak için tek bir initContainer kullanabilir veya komut başına bir initContainer kullanabilirsiniz. Birimlerin initContainer'a bağlandığından (mount edildiğinden) emin olmanız gerekir.

Kodu indirmek için bu öğretici, busybox ile tek bir Init Container'ı nasıl kullanacağınız konusunda size rehberlik edecektir. Busybox, bunu gerçekleştirmek için kullanacağınız wget aracına sahip küçük bir konteynerdir.

İlk olarak, initContainer'ınızı şunun altına ekleyin: spec.template.spec ve busybox imajını belirtin:

...
      initContainers:
      - name: install
        image: busybox

...

initContainers:

- name: install

image: busybox

Ardından, kodu code birimine indirmek için Init Container'ınızın bu birime erişmesi gerekecektir. code birimini şu yola bağlayın: /code (şunun altındaki yol): spec.template.spec.initContainers:

...
        volumeMounts:
        - name: code
          mountPath: /code

...

volumeMounts:

- name: code

mountPath: /code

Her Init Container'ın bir komut çalıştırması gerekir. Bu Init Container, code kodunu Github üzerinden /code dizinine indirmek için wget kullanacaktır. İndirilen bu dosyaya bir isim vermek için bir -O seçeneği geçebilirsiniz ve bu dosyayı index.php.

Not: Init Container kullanarak sunucunuza çektiğiniz koda güvendiğinizden emin olun. Kaynak kodu inceleyebilir ve ne yaptığından emin olabilirsiniz.

Ayrıca, install konteynerinin altına şu satırları ekleyin: spec.template.spec.initContainers:

...
        command:
        - wget
        - "-O"
        - "/code/index.php"
        - https://raw.githubusercontent.com/do-community/php-kubernetes/master/index.php

...

command:

- wget

- "-O"

- "/code/index.php"

- https://raw.githubusercontent.com/do-community/php-kubernetes/master/index.php

Tüm bu adımları tamamladıktan sonra, php_deployment.yaml dosyanız şu şekilde görünmelidir:

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

apiVersion: apps/v1

kind: Deployment

metadata:

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

Artık dosyayı kaydedip çıkabilirsiniz. Ardından, şu komutu kullanarak PHP-FPM Deployment'ınızı oluşturun: kubectl apply komutu:

$ kubectl apply -f php_deployment.yaml

1	$ kubectl apply -f php_deployment.yaml

Deployment'ın başarıyla oluşturulması size aşağıdaki çıktıyı vermelidir:

deployment.apps/php created

1	deployment.apps/php created

Bu Deployment, belirtilen imajları indirerek başlar, ardından PersistentVolume kaynağını PersistentVolumeClaim üzerinden talep eder ve ardından initContainers bileşenlerinizi çalıştırır. Bu adım tamamlandıktan sonra, konteynerler çalışacak ve birimleri belirtilen bağlama noktasına bağlayacaktır. Tüm bu adımları tamamladıktan sonra pod'unuz çalışır durumda olacaktır.

Deployment'ınızı görüntülemek için aşağıdaki komutu çalıştırabilirsiniz:

$ kubectl get deployments

1	$ kubectl get deployments

Yukarıdaki komutu çalıştırdıktan sonra aşağıdaki çıktıyı almalısınız:

NAME      DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
php       1         1         1            0           19s

1 2	NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE php 1 1 1 0 19s

Bu çıktının yardımıyla Deployment'ın mevcut durumunu anlayabilirsiniz. Deployment, istenen durumu koruyan bir denetleyicidir. DESIRED alanı, php adlı pod'un 1 replikasına sahip olduğunu belirtir. CURRENT alanı, şu anda DESIRED durumunun kaç replikasının çalıştığını gösterir. Sağlıklı bir pod için bu değerin DESIRED durumuyla eşleşmesi gerekir. Kalan alanlar hakkında daha fazla bilgiyi Kubernetes Deployments Dokümantasyonu.

Bundan sonra, çalışan pod'unuzun durumunu kontrol etmek için aşağıdaki komutu çalıştırabilirsiniz:

$ kubectl get pods

1	$ kubectl get pods

Bu komutun çıktısı, Deployment'ınızı oluşturmanızın üzerinden geçen süreye bağlı olarak değişebilir. Deployment oluşturulduktan kısa bir süre sonra çalıştırılırsa çıktı şuna benzer olacaktır:

NAME                   READY     STATUS     RESTARTS   AGE
php-5d8f6bbf7f-56df2   0/1       Init:0/1   0          9s

1 2	NAME READY STATUS RESTARTS AGE php-5d8f6bbf7f-56df2 0/1 Init:0/1 0 9s

Açıklama:

Bu sütunlar aşağıdaki bilgileri temsil eder:

Ready: Bu pod'u çalıştıran mevcut/istenen replika sayısı.
Durum: Pod'unuzun durumu. Init:0/1, Init Konteynerlerinin çalıştığını ve 1 Init Konteynerinden 0'ının çalışmayı tamamladığını belirtir.
Yeniden Başlatmalar: Bu, pod'u başlatmak için bu işlemin kaç kez yeniden başlatıldığını gösterir.

Başlangıç betiklerinizin karmaşıklığına bağlı olarak pod'unuzun durumunun podInitializing olarak değişmesi birkaç dakika sürebilir:

NAME                   READY     STATUS            RESTARTS   AGE
php-5d8f6bbf7f-56df2   0/1       podInitializing   0          39s

1 2	NAME READY STATUS RESTARTS AGE php-5d8f6bbf7f-56df2 0/1 podInitializing 0 39s

Bu, Init Konteynerlerinin başarıyla çalıştığını ve şimdi konteynerlerin başlatıldığını gösterir:

NAME                   READY   STATUS    RESTARTS   AGE
php-5d8f6bbf7f-56df2   1/1     Running   0          4m10s

1 2	NAME READY STATUS RESTARTS AGE php-5d8f6bbf7f-56df2 1/1 Running 0 4m10s

Şimdi görebileceğiniz gibi, pod'unuz çalışır durumdadır. Ancak pod'unuzun başlamaması durumunda, hata ayıklama amacıyla aşağıdaki komutları çalıştırabilirsiniz:

1. Pod'un ayrıntılı bilgilerini görüntülemek için:

$ kubectl describe pods pod-name

1	$ kubectl describe pods pod-name

2. Pod'un günlüklerini (loglarını) görüntülemek için:

$ kubectl logs pod-name

1	$ kubectl logs pod-name

Not: “kubectl logs” komutu için birden fazla seçenek mevcuttur, bu konuda daha fazlasını keşfetmek için “kubectl logs –help” komutunu çalıştırabilirsiniz.

3. Pod içindeki belirli bir konteynerin günlüklerini görüntülemek için:

$ kubectl logs pod-name container-name

1	$ kubectl logs pod-name container-name

Tebrikler! Uygulama kodunu başarıyla bağladınız ve PHP-FPM servisi bağlantıları karşılamaya hazır. Benzer şekilde, Nginx Dağıtımınızı (Deployment) oluşturabilirsiniz.

Adım 5: Nginx Dağıtımınızı Oluşturun

Bu adım, bir ConfigMap kullanarak Nginx'i nasıl yapılandıracağınız konusunda size rehberlik edecektir. Bir ConfigMap, diğer Kubernetes nesne tanımlarında kullanılacak tüm gerekli yapılandırmalarınızı anahtar-değer (key-value) biçiminde tutar. Bu yaklaşımla, gerektiğinde Nginx görüntüsünü yeniden kullanma veya farklı bir sürümle değiştirme esnekliğine sahip olursunuz. ConfigMap nesnesini güncelleyebilirsiniz ve bu değişiklikler, bu ConfigMap.

nesnesini bağlayan tüm pod'lara otomatik olarak yansıtılacaktır. Başlamak için, editörünüzde bir nginx_configmap.yaml dosyası açın:

$ nano nginx_configMap.yaml

1	$ nano nginx_configMap.yaml

Şimdi, bu ConfigMap'i nginx-config olarak adlandırın ve tier: backend mikro servisine ekleyin:

apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-config
  labels:
    tier: backend

apiVersion: v1

kind: ConfigMap

metadata:

labels:

tier: backend

Ek olarak, verileri ConfigMap'e ekleyebilirsiniz. config adında bir anahtar ekleyin ve tüm Nginx yapılandırma dosyası içeriklerini değer olarak ekleyin.

Kubernetes'in istekleri bir servis için ilgili ana bilgisayarlara yönlendirmesi mümkün olduğundan, IP adresi yerine fastcgi_pass parametresinin altına PHP-FPM servisinizin adını girebilirsiniz. nginx_configMap.yaml dosyanıza aşağıdaki kod satırlarını ekleyin:

...
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;
        }
    }

...

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;

}

Tamamlandığında, nginx_configMap.yaml dosyanız şu şekilde görünecektir:

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;
        }
    }

apiVersion: v1

kind: ConfigMap

metadata:

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;

}

Artık düzenleyiciyi kaydedip kapatabilirsiniz. Şimdi kubectl apply komutunu çalıştırarak şu nesneyi oluşturun: ConfigMap:

$ kubectl apply -f nginx_configMap.yaml

1	$ kubectl apply -f nginx_configMap.yaml

Bundan sonra, ekranınızda aşağıdaki çıktıyı görmelisiniz:

configmap/nginx-config created

1	configmap/nginx-config created

Nginx Configmap'inizi başarıyla oluşturdunuz. Şimdi Nginx Deployment'ınızı oluşturabilirsiniz.

Nginx Deployment Oluşturma

Başlamak için, düzenleyicide nginx_deployment.yaml adında yeni bir dosya oluşturabilirsiniz:

$ nano nginx_deployment.yaml

1	$ nano nginx_deployment.yaml

Bu Deployment'ı nginx olarak adlandırın ve ona tier: backend etiketini ekleyin:

apiVersion: apps/v1

kind: Deployment
metadata:
  name: nginx
  labels:
    tier: backend

apiVersion: apps/v1

kind: Deployment

metadata:

labels:

tier: backend

Bundan sonra, Deployment spesifikasyonuna replica alanını ekleyerek replika sayısını belirtin ve ona app: nginx ve tier: backend etiketlerini ekleyin:

...
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
      tier: backend

...

spec:

replicas: 1

selector:

matchLabels:

app: nginx

tier: backend

Benzer şekilde, pod şablonunu ekleyin. Deployment’ın selector.matchLabels alanına eklediğiniz etiketlerin aynısını eklediğinizden emin olun. Aşağıdakileri ekleyebilirsiniz:

...
  template:
    metadata:
      labels:
        app: nginx
        tier: backend

...

template:

metadata:

labels:

app: nginx

tier: backend

Daha önce oluşturulan code PVC'sine Nginx erişimi vermek için, aşağıdaki parametreleri şu bölümün altına ekleyin: spec.template.spec.volumes:

...
    spec:
      volumes:
      - name: code
        persistentVolumeClaim:
          claimName: code

...

spec:

volumes:

- name: code

persistentVolumeClaim:

claimName: code

Not: Bir pod, ConfigMap'i bir birim (volume) olarak bağlayabilir. Dosya adını ve anahtarı belirterek, değeri içerik olacak şekilde bir dosya oluşturacağız. Bu ConfigMap'i kullanmak için yolu, anahtarın içeriğini barındıran dosyanın adına ayarlayın. config anahtarından bir site.conf dosyası oluşturabilirsiniz. spec.template.spec.volumes altına aşağıdakileri ekleyin:

...
      - name: config
        configMap:
          name: nginx-config
          items:
          - key: config
            path: site.conf

...

- name: config

configMap:

items:

- key: config

path: site.conf

Uyarı: Bir dosya belirtilmezse, anahtarın içeriği birimin mountPath değerinin yerini alacaktır. Başka bir deyişle, bir yol açıkça belirtilmezse hedef klasördeki tüm içeriği kaybedersiniz.

Şimdi, podunuzda kullanmak istediğiniz adı, imajı ve portu belirtin. Burada nginx:1.7.9 imajını ve 80 portunu kullanacağız. Bunları şunun altına ekleyin: spec.template.spec bölümü:

...
      containers:
      - name: nginx
        image: nginx:1.7.9
        ports:
        - containerPort: 80

...

containers:

- name: nginx

image: nginx:1.7.9

ports:

- containerPort: 80

Ayrıca, kod birimini /code dizinine bağlayın, çünkü hem Nginx hem de PHP-FPM'in dosyaya aynı yoldan erişmesi gerekecektir:

...
        volumeMounts:
        - name: code
          mountPath: /code

...

volumeMounts:

- name: code

mountPath: /code

The nginx-1.7.9 imajı, /etc/nginx/conf.d klasörü altındaki tüm yapılandırma dosyalarını otomatik olarak yükler. Şimdi, yapılandırma birimini bu dizine bağlarsak, /etc/nginx/conf.d/site.conf dosyasını oluşturacaktır. volumeMount bölümünün altına aşağıdakileri ekleyin:

...
        - name: config
          mountPath: /etc/nginx/conf.d

...

- name: config

mountPath: /etc/nginx/conf.d

Yukarıdaki tüm adımları tamamladıktan sonra, nginx_deployment.yaml dosyanız şu şekilde görünmelidir:

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

apiVersion: apps/v1

kind: Deployment

metadata:

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:

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

Artık dosyayı kaydedip çıkabilir ve aşağıdaki komutu çalıştırarak Nginx Deployment'ı oluşturabilirsiniz:

$ kubectl apply -f nginx_deployment.yaml

1	$ kubectl apply -f nginx_deployment.yaml

Komut başarıyla çalıştırıldığında aşağıdaki çıktıyı görmelisiniz:

deployment.apps/nginx created

1	deployment.apps/nginx oluşturuldu

Aşağıdaki komutları çalıştırarak tüm Deployment'larınızı listeleyebilirsiniz:

$ kubectl get deployments

1	$ kubectl get deployments

Şimdi hem Nginx hem de PHP-FPM Deployment'larını görmelisiniz:

Ayrıca, yukarıda listelenen her iki Deployment tarafından yönetilen pod'ları listelemek için aşağıdaki komutu yürütebilirsiniz:

$ kubectl get pods

1	$ kubectl get pods

Her iki pod'unuzun da aşağıdaki gibi çalışır durumda olduğunu göreceksiniz:

Bu noktada tüm Kubernetes nesneleriniz aktif olduğundan, artık tarayıcınızdan Nginx servisine erişebilirsiniz.

Servisleri listelemek için aşağıdaki komutu çalıştırın:

$ kubectl get services -o wide

1	$ kubectl get services -o wide

Nginx servisinizin Harici IP'sini (External IP) not edin:

Şimdi, Nginx servisinin bu Harici IP'sini kullanarak, tarayıcınıza http://your_public_ip yazarak sunucunuzu ziyaret edebilirsiniz. Kubernetes servislerinizin çalışır durumda olduğunu onaylayan php_info() çıktısını görebilmelisiniz.

Sonuç

Bu öğreticide, PHP-FPM ve Nginx servislerinizi bağımsız olarak yönetmek için bu iki servisi konteynerleştirdiniz. Bunu yaparak, yalnızca projenizin ölçeklenebilirliğini artırmakla kalmayacak, aynı zamanda kaynaklarınızı da verimli bir şekilde kullanacaksınız. Ayrıca, uygulama kodunuzu bir birimde depolamak ve gelecekte servislerinizi kolayca güncelleyebilmek için yerel depolama ve bir Persistent Volume (Kalıcı Birim) oluşturmayı da öğrendiniz. Böylece kodunuzun kullanılabilirliğini ve bakımı kolaylığını artırdınız.

Ayrıca, Docker ve Kubernetes konularına odaklanan ve blogumuzda:

Keyifli Çalışmalar!

Hark Labs

Yazar · CloudSigma

Preslav Dobrev, CloudSigma'da Kreatif Tasarımcı olarak görev yapmakta olup geleneksel ve yenilikçi pazarlama kanallarını kullanarak tutarlı bir kurumsal kimlik oluşturmaya odaklanmaktadır. Sanatsal vizyonu stratejik pazarlamayla harmanlayarak etkili marka anlatıları oluşturma konusunda oldukça yeteneklidir.

Ubuntu 18.04 ile bir Kubernetes Kümesinde PHP Uygulaması Dağıtma

Önkoşullar

Adım 1: PHP-FPM ve Nginx Hizmetlerini Oluşturma

PHP-FPM hizmetini oluşturma

PHP servisini oluşturmak için kubectl komutunu uygulama

Nginx servisini oluşturma

Nginx servisini oluşturmak için kubectl komutunu uygulama

Adım 2: Yerel Depolama ve Kalıcı Birim (Persistent Volume) Oluşturma

Yerel depolama oluşturma

Yerel Kalıcı Birim (Persistent Volume) Oluşturma

Yerel Birimi Hazırlama

Adım 3: Kalıcı Birimi Oluşturma

PVC Oluşturma

Adım 4: PHP-FPM Uygulamanız için Deployment Oluşturma

PHP Deployment Oluşturma

Adım 5: Nginx Dağıtımınızı Oluşturun

Nginx Deployment Oluşturma

Sonuç

Hark Labs

Yorumlar