Kubernetes ile PHP Uygulamasını Ubuntu 16.04 Üzerinde Dağıtma Rehberi

Giriş

Modern yazılım geliştirme dünyasında, uygulamaların dağıtımı, yönetimi ve ölçeklenmesi giderek karmaşık hale gelmektedir. Mikroservis mimarileri, bulut tabanlı çözümler ve sürekli entegrasyon/sürekli dağıtım (CI/CD) yaklaşımları, bu karmaşıklığı yönetmek için güçlü araçlara olan ihtiyacı artırmıştır. İşte tam bu noktada Kubernetes devreye girer. Kubernetes, konteynerli iş yüklerini ve hizmetlerini otomatikleştirmek için açık kaynaklı bir platformdur. Google tarafından geliştirilen ve şu anda Cloud Native Computing Foundation (CNCF) tarafından sürdürülen Kubernetes, konteyner orkestrasyonunda endüstri standardı haline gelmiştir.

PHP, web geliştirme için en popüler dillerden biridir ve milyonlarca web sitesine güç vermektedir. Geleneksel olarak PHP uygulamaları, Apache veya Nginx gibi bir web sunucusu ve PHP-FPM ile bir LAMP/LEMP yığını üzerinde çalıştırılır. Ancak, konteyner teknolojileri (özellikle Docker) ve Kubernetes’in yükselişiyle birlikte, PHP uygulamalarını daha esnek, ölçeklenebilir ve taşınabilir bir şekilde dağıtmak mümkün hale gelmiştir.

Bu makalede, Ubuntu 16.04 işletim sistemi üzerinde bir Kubernetes kümesi kurmayı ve basit bir PHP uygulamasını bu küme üzerinde dağıtmayı adım adım ele alacağız. Ubuntu 16.04, güncel bir sürüm olmasa da, birçok eski sistemde hala kullanılmaktadır ve Kubernetes’in bu tür ortamlarda nasıl çalıştığını göstermek açısından değerli bir örnek teşkil edecektir. Amacımız, okuyuculara hem Kubernetes’in temel kurulumunu hem de PHP uygulamalarını konteynerleştirip Kubernetes’e dağıtma sürecini pratik bir şekilde öğretmektir. Bu rehber, temel Linux bilgisine, Docker ve Kubernetes kavramlarına aşina olan geliştiriciler ve sistem yöneticileri için tasarlanmıştır.

Ön Gereksinimler

Bu rehbere başlamadan önce aşağıdaki ön gereksinimleri karşıladığınızdan emin olun:

Donanım ve İşletim Sistemi

En az iki adet Ubuntu 16.04 sunucusu (bir Master Node, bir veya daha fazla Worker Node). Her sunucu için en az 2 CPU veya vCPU ve 2GB RAM önerilir.
Sunucular arasında ağ bağlantısı.
Her sunucuda root ayrıcalıklarına sahip bir kullanıcı veya sudo yetkisine sahip bir kullanıcı.

Yazılım ve Temel Bilgiler

Her sunucuda Docker’ın kurulu ve çalışır durumda olması.
kubeadm, kubelet ve kubectl araçlarının kurulması gerekecektir (bu makalede adım adım anlatılacaktır).
Kubernetes’in temel kavramları hakkında bilgi (Pod, Deployment, Service, Namespace vb.).
Temel Linux komut satırı bilgisi.
Konteynerleştirme (Docker) hakkında temel bilgi.

Ağ Gereksinimleri

Kubernetes kümesinin düzgün çalışabilmesi için bazı portların açık olması gerekmektedir. Güvenlik duvarınızda (ufw veya başka bir firewall) aşağıdaki portların açık olduğundan emin olun:

Master Node için:

TCP 6443 (Kubernetes API sunucusu)
TCP 2379-2380 (etcd sunucusu)
TCP 10250 (Kubelet API)
TCP 10251 (kube-scheduler)
TCP 10252 (kube-controller-manager)

Worker Node’lar için:

TCP 10250 (Kubelet API)
TCP 30000-32767 (NodePort hizmetleri için varsayılan aralık)

Ayrıca, küme içi iletişimin sağlanabilmesi için tüm sunucular arasında tüm portlarda (veya özel olarak CNI eklentinizin gerektirdiği portlarda) iletişim izni verilmelidir.

Kubernetes Kümesi Kurulumu (Ubuntu 16.04 Üzerinde)

Bu bölümde, Ubuntu 16.04 sunucuları üzerinde bir Kubernetes kümesini adım adım kuracağız.

3.1. Sunucu Hazırlığı

Tüm master ve worker node’larda aşağıdaki adımları uygulayın.

Swap’ı Kapatma:

Kubernetes, performans ve kararlılık nedenleriyle swap’ın kapalı olmasını gerektirir.

sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

Hostname Ayarları:

Her sunucuya benzersiz bir hostname atayın ve /etc/hosts dosyasını güncelleyin.
Master Node için:

sudo hostnamectl set-hostname master-node
echo "192.168.1.100 master-node" | sudo tee -a /etc/hosts # Master IP adresinizi girin

Worker Node için (her worker için ayrı hostname ve IP):

sudo hostnamectl set-hostname worker-node-1
echo "192.168.1.101 worker-node-1" | sudo tee -a /etc/hosts # Worker IP adresinizi girin

Diğer tüm sunucuların IP ve hostname bilgilerini her sunucunun /etc/hosts dosyasına eklemek iyi bir uygulamadır.

`br_netfilter` Modülünü Etkinleştirme:

Kubernetes ağ eklentilerinin düzgün çalışması için br_netfilter modülünün yüklenmesi ve iptables ayarlarının yapılması gerekir.

sudo modprobe br_netfilter
echo '1' | sudo tee /proc/sys/net/bridge/bridge-nf-call-iptables
echo '1' | sudo tee /proc/sys/net/bridge/bridge-nf-call-ip6tables

Bu ayarların kalıcı olması için /etc/sysctl.conf dosyasına ekleyin:

echo "net.bridge.bridge-nf-call-iptables = 1" | sudo tee -a /etc/sysctl.conf
echo "net.bridge.bridge-nf-call-ip6tables = 1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

3.2. Docker Kurulumu

Ubuntu 16.04 için Docker kurulumu biraz farklılık gösterebilir.

sudo apt update
sudo apt install -y apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu xenial stable"
sudo apt update
sudo apt install -y docker-ce=18.06.3~ce~3-0~ubuntu # Kubernetes ile uyumlu eski bir Docker sürümü belirtmek önemlidir.
sudo systemctl enable docker
sudo systemctl start docker

3.3. Kubeadm, Kubelet, Kubectl Kurulumu

Kubernetes bileşenlerini kurmak için Kubernetes deposunu eklememiz gerekiyor.

sudo apt update
sudo apt install -y apt-transport-https curl
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb http://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt update
sudo apt install -y kubelet=1.15.12-00 kubeadm=1.15.12-00 kubectl=1.15.12-00 # Ubuntu 16.04 için uyumlu eski bir sürüm
sudo apt-mark hold kubelet kubeadm kubectl

Burada 1.15.12-00 sürümü, Ubuntu 16.04 ve Docker 18.06.3 ile uyumlu olduğu bilinen nispeten eski bir Kubernetes sürümüdür. Güncel sürümler eski işletim sistemleriyle uyumsuzluk gösterebilir.

3.4. Master Node Kurulumu

Sadece Master Node üzerinde aşağıdaki komutu çalıştırın.

sudo kubeadm init --pod-network-cidr=192.168.0.0/16 --kubernetes-version=v1.15.12

--pod-network-cidr parametresi, kullanacağımız ağ eklentisinin (bu örnekte Calico) pod’lara atayacağı IP aralığını belirtir. kubernetes-version ise kurulumunu yaptığımız sürümle eşleşmelidir.

Kurulum tamamlandığında, kubeadm size kubectl‘i yapılandırmak için komutlar ve worker node’ları kümeye katmak için bir kubeadm join komutu verecektir. Bu çıktıyı saklayın.

kubectl‘i yapılandırmak için:

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

Şimdi bir ağ eklentisi (CNI) kurmalıyız. Bu örnekte Calico kullanacağız.

kubectl apply -f https://docs.projectcalico.org/v3.8/manifests/calico.yaml

Calico’nun kurulumu biraz zaman alabilir. Durumu kontrol etmek için:

kubectl get pods --all-namespaces

Tüm pod’lar Running durumuna geldiğinde, master node hazır demektir.

3.5. Worker Node’ları Küme Katma

Master Node kurulumu tamamlandığında elde ettiğiniz kubeadm join komutunu her bir Worker Node üzerinde çalıştırın. Örneğin:

sudo kubeadm join 192.168.1.100:6443 --token  --discovery-token-ca-cert-hash sha256:

ve değerlerini kendi çıktınızdaki değerlerle değiştirin.
Tüm worker node’lar katıldıktan sonra, Master Node üzerinden küme durumunu kontrol edebilirsiniz:

kubectl get nodes

Tüm node’ların Ready durumunda olması gerekmektedir.

PHP Uygulaması İçin Docker İmajı Oluşturma

Kubernetes’e dağıtmadan önce PHP uygulamamızı bir Docker imajına dönüştürmemiz gerekiyor.

4.1. Basit Bir PHP Uygulaması

Örnek olarak, basit bir index.php dosyası oluşturalım:

Bu uygulama bir Kubernetes kümesi üzerinde çalışıyor.";
echo "PHP versiyonu: " . phpversion() . "";
?>

Bu dosyayı app adında bir dizine kaydedin.

4.2. Dockerfile Oluşturma

Uygulamamızı çalıştırmak için Nginx ve PHP-FPM içeren bir Dockerfile oluşturalım. Bu, tek bir imajda hem web sunucusunu hem de PHP yorumlayıcısını barındıran basit bir yaklaşımdır. Daha karmaşık senaryolarda Nginx ve PHP-FPM ayrı konteynerlerde çalıştırılabilir.

app dizininin kökünde bir Dockerfile oluşturun:

# Nginx ve PHP-FPM içeren bir taban imajı kullanıyoruz
FROM richarvey/nginx-php-fpm:latest

Uygulama dosyalarımızı konteyner içine kopyala
COPY . /var/www/html/

Nginx yapılandırmasını güncelleyelim (isteğe bağlı, varsayılan çoğu zaman yeterlidir)
Kendi Nginx yapılandırma dosyanızı kopyalayabilirsiniz.
COPY nginx.conf /etc/nginx/sites-available/default.conf

Gerekli PHP uzantılarını yükleyebiliriz (örneğin MySQL desteği için)
RUN docker-php-ext-install pdo_mysql

Composer kullanıyorsanız
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
RUN composer install --no-dev --optimize-autoloader

Nginx ve PHP-FPM varsayılan olarak başlatılır, ek bir CMD'ye gerek yok.
Varsayılan port 80'dir.
EXPOSE 80

Bu Dockerfile, richarvey/nginx-php-fpm imajını temel alır. Bu imaj, Nginx ve PHP-FPM’i tek bir konteynerde çalıştıracak şekilde önceden yapılandırılmıştır. Uygulama dosyalarınızı /var/www/html/ dizinine kopyalar.

4.3. Docker İmajını Oluşturma ve Yayımlama

Dockerfile ve index.php dosyanızın bulunduğu app dizininde aşağıdaki komutu çalıştırarak Docker imajını oluşturun:

docker build -t your-dockerhub-username/php-app:v1.0 .

your-dockerhub-username yerine kendi Docker Hub kullanıcı adınızı yazın.

İmajı oluşturduktan sonra, Kubernetes kümenizin bu imaja erişebilmesi için bir konteyner kayıt defterine (örneğin Docker Hub) yayımlamanız gerekir.
Önce Docker Hub’a giriş yapın:

docker login

Ardından imajı yayımlayın:

docker push your-dockerhub-username/php-app:v1.0

Eğer özel bir kayıt defteri kullanıyorsanız, docker push komutunu uygun şekilde ayarlamanız gerekir.

Kubernetes’e PHP Uygulamasını Dağıtma

Artık Docker imajımız hazır olduğuna göre, PHP uygulamamızı Kubernetes kümemize dağıtabiliriz.

5.1. Kubernetes Manifest Dosyaları

Kubernetes’te uygulamaları dağıtmak için YAML formatında manifest dosyaları kullanırız. Bu dosyalar, kümenin istediğimiz durumu tanımlar.

5.1.1. Namespace Oluşturma

Uygulamalarımızı diğer uygulamalardan izole etmek için bir namespace oluşturalım.
php-app-namespace.yaml:

apiVersion: v1
kind: Namespace
metadata:
  name: php-app-dev

Uygulayın:

kubectl apply -f php-app-namespace.yaml

5.1.2. Deployment Oluşturma

Deployment, uygulamamızın Pod’larını yönetmekten sorumludur. Kaç replika olacağını, hangi Docker imajının kullanılacağını ve hangi portların açılacağını tanımlar.
php-app-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: php-app-deployment
  namespace: php-app-dev
  labels:
    app: php-app
spec:
  replicas: 3 # Uygulamanızdan 3 adet Pod çalıştır
  selector:
    matchLabels:
      app: php-app
  template:
    metadata:
      labels:
        app: php-app
    spec:
      containers:
      - name: php-app-container
        image: your-dockerhub-username/php-app:v1.0 # Kendi Docker imajınızın adını ve etiketini girin
        ports:
        - containerPort: 80 # Uygulamanın dinlediği port
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"
          limits:
            memory: "128Mi"
            cpu: "500m"
        # Ortam değişkenleri veya ConfigMap/Secret kullanımı burada yapılabilir
        # env:
        #   - name: DB_HOST
        #     value: "mysql-service"

Bu deployment, php-app etiketine sahip 3 adet pod oluşturur. Her pod, bizim oluşturduğumuz php-app:v1.0 imajını kullanır ve 80 numaralı portu açar. resources kısmı, pod’ların ne kadar CPU ve bellek kullanabileceğini sınırlar.

5.1.3. Service Oluşturma

Service, Pod’larımıza dışarıdan erişim sağlamak veya küme içindeki diğer Pod’ların bu uygulamaya erişmesini sağlamak için kullanılır. NodePort tipi, uygulamayı her bir worker node’un belirli bir portu üzerinden dışarıya açar.
php-app-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: php-app-service
  namespace: php-app-dev
spec:
  selector:
    app: php-app # Bu service, 'app: php-app' etiketine sahip Pod'ları hedefleyecek
  ports:
    - protocol: TCP
      port: 80 # Service'in dinleyeceği port (küme içinde)
      targetPort: 80 # Pod'un dinlediği port
      nodePort: 30080 # Dışarıdan erişim için Node'un açacağı port (30000-32767 aralığında)
  type: NodePort # Dışarıdan erişim için NodePort kullanıyoruz

Bu servis, php-app etiketine sahip pod’lara yönlendirme yapar. Küme içinde 80 numaralı porttan erişilebilirken, dışarıdan herhangi bir worker node’un 30080 numaralı portu üzerinden erişilebilir olacaktır.

5.1.4. (Opsiyonel) Persistent Volume ve Persistent Volume Claim

PHP uygulamaları genellikle dosya yüklemeleri veya veritabanı gibi kalıcı depolama gerektirebilir. Konteynerler geçicidir, bu yüzden kalıcı veriler için Persistent Volume (PV) ve Persistent Volume Claim (PVC) kullanırız. Bu örnekte basitlik adına bir hostPath PV tanımlayabiliriz, ancak üretim ortamlarında NFS, Ceph, AWS EBS, Azure Disk gibi çözümler tercih edilir.

php-app-pv.yaml:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: php-app-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  hostPath: # Sadece test ve geliştirme için uygundur. Üretim için daha sağlam çözümler kullanın.
    path: "/mnt/data/php-app" # Worker Node'da bu dizin oluşturulmalı

php-app-pvc.yaml:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: php-app-pvc
  namespace: php-app-dev
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 500Mi

Deployment’ınıza PVC’yi bağlamak için:

# ... deployment.yaml içinde
        volumeMounts:
        - name: php-app-storage
          mountPath: /var/www/html/uploads # Uygulamanızın kalıcı depolama ihtiyacı olan dizin
      volumes:
      - name: php-app-storage
        persistentVolumeClaim:
          claimName: php-app-pvc

Bu adımları uygulamadan önce, her worker node’da /mnt/data/php-app dizinini oluşturduğunuzdan emin olun: sudo mkdir -p /mnt/data/php-app && sudo chmod 777 /mnt/data/php-app.

5.1.5. (Opsiyonel) ConfigMap ve Secret

Uygulama yapılandırma dosyaları veya hassas bilgiler (veritabanı şifreleri) için ConfigMap ve Secret kullanmak en iyi yöntemdir.
php-app-configmap.yaml:

apiVersion: v1
kind: ConfigMap
metadata:
  name: php-app-config
  namespace: php-app-dev
data:
  APP_ENV: production
  DEBUG_MODE: "false"

php-app-secret.yaml:

apiVersion: v1
kind: Secret
metadata:
  name: php-app-secret
  namespace: php-app-dev
type: Opaque
data:
  DB_PASSWORD:  # echo -n "your_password" | base64

Deployment’ınızda bunları kullanmak için:

# ... deployment.yaml içinde
        env:
        - name: APP_ENV
          valueFrom:
            configMapKeyRef:
              name: php-app-config
              key: APP_ENV
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: php-app-secret
              key: DB_PASSWORD

5.2. Uygulamayı Dağıtma

Tüm manifest dosyalarınızı (en azından namespace, deployment ve service) aynı dizine koyun ve aşağıdaki komutu çalıştırın:

kubectl apply -f . # Bulunduğunuz dizindeki tüm YAML dosyalarını uygular

5.3. Dağıtımı Doğrulama

Uygulamanızın başarıyla dağıtılıp dağıtılmadığını kontrol edelim:
Pod’ları kontrol edin:

kubectl get pods -n php-app-dev

Tüm pod’ların Running durumunda olması gerekir.

Deployment’ı kontrol edin:

kubectl get deployments -n php-app-dev

Servisleri kontrol edin:

kubectl get services -n php-app-dev

Burada php-app-service için NodePort değerini göreceksiniz (örneğin 30080).

Şimdi uygulamanıza erişmek için herhangi bir Worker Node’un IP adresini ve NodePort’u kullanın. Örneğin: http://:30080
Tarayıcınızda “Merhaba Kubernetes!” mesajını görmeniz gerekir.

Uygulama Yönetimi ve Ölçekleme

Kubernetes, dağıtılan uygulamaların yönetimini ve ölçeklenmesini kolaylaştırır.

6.1. Ölçekleme

Uygulamanızın trafik yükü arttığında, daha fazla pod çalıştırarak ölçekleyebilirsiniz:

kubectl scale deployment php-app-deployment --replicas=5 -n php-app-dev

Bu komut, php-app-deployment adlı dağıtımın pod sayısını 3’ten 5’e çıkaracaktır. Kubernetes, otomatik olarak yeni pod’ları başlatacak ve trafiği onlara yönlendirecektir.

Otomatik ölçekleme için Horizontal Pod Autoscaler (HPA) kullanabilirsiniz. HPA, CPU veya bellek kullanımı gibi metrikleri izleyerek pod sayısını otomatik olarak ayarlar.

6.2. Güncelleme (Rolling Updates)

Uygulamanızın yeni bir sürümünü dağıtmak istediğinizde, Docker imajınızın etiketini güncelleyip deployment manifestini tekrar uygulamanız yeterlidir.
Örneğin, php-app:v2.0 adında yeni bir imajınız varsa, php-app-deployment.yaml dosyasını düzenleyin:

# ...
        image: your-dockerhub-username/php-app:v2.0 # v1.0 yerine v2.0
...

Ardından manifesti tekrar uygulayın:

kubectl apply -f php-app-deployment.yaml

Kubernetes, kesintisiz bir güncelleme sağlamak için rolling update stratejisini kullanır. Eski pod’ları yavaşça sonlandırırken yeni pod’ları başlatır, böylece uygulama her zaman erişilebilir kalır.

6.3. Loglama ve İzleme

Bir pod’un loglarını görmek için:

kubectl logs  -n php-app-dev

Pod’lar genelinde logları toplamak ve analiz etmek için ELK Stack (Elasticsearch, Logstash, Kibana) veya Grafana Loki gibi çözümler kullanılabilir.

Küme kaynaklarını izlemek için Prometheus ve Grafana popüler çözümlerdir. kube-state-metrics ve node-exporter gibi bileşenlerle entegre edilerek detaylı metrikler toplanabilir.

Sık Karşılaşılan Sorunlar ve Çözümleri

Kubernetes ile çalışırken karşılaşabileceğiniz bazı yaygın sorunlar ve çözümleri:

Pod’lar Pending durumunda kalıyor:
- Yeterli kaynak (CPU/RAM) yok mu? kubectl describe pod -n komutuyla olayları kontrol edin.
- Persistent Volume Claim (PVC) bağlanamıyor mu? PV/PVC durumunu kontrol edin.
- Node’lar Ready durumunda mı? kubectl get nodes ile kontrol edin.
Pod’lar CrashLoopBackOff durumunda:
- Uygulama konteyneri içinde bir hata var. kubectl logs -n ile logları kontrol edin.
- Docker imajı bozuk olabilir veya bağımlılıkları eksik olabilir.
- Ortam değişkenleri veya yapılandırma yanlış olabilir.
Servis erişilemiyor:
- kubectl get services -n ile servis durumunu kontrol edin.
- selector etiketleri deployment’taki pod etiketleriyle eşleşiyor mu?
- Güvenlik duvarı kuralları NodePort’u engelliyor olabilir.
- kubectl describe service -n ile olayları kontrol edin.
ImagePullBackOff hatası:
- Docker imaj adı veya etiketi yanlış olabilir.
- Kayıt defteri (Docker Hub) erişilebilir değil veya kimlik doğrulama hatası var.
- docker login ile kimlik doğrulamasını kontrol edin ve Kubernetes Secret olarak imagePullSecrets kullanmayı düşünün.
DNS sorunları (Pod’lar arası iletişimde):
- coredns pod’larının Running durumunda olduğundan emin olun (kubectl get pods -n kube-system).
- Pod’un içinde nslookup ..svc.cluster.local komutuyla DNS çözümlemesini test edin.

Sonuç

Bu makalede, Ubuntu 16.04 üzerinde bir Kubernetes kümesi kurma sürecini ve basit bir PHP uygulamasını bu küme üzerinde dağıtmayı adım adım inceledik. Konteynerleştirme, Docker imajı oluşturma, Kubernetes manifest dosyaları (Deployment, Service, Namespace) yazma ve uygulamayı dağıtma adımlarını başarıyla tamamladık. Ayrıca, uygulamayı ölçekleme, güncelleme ve sık karşılaşılan sorunlara yönelik çözümlere de değindik.

Kubernetes, PHP uygulamalarına modern bir dağıtım ve yönetim yeteneği kazandırarak onları daha esnek, ölçeklenebilir ve dayanıklı hale getirir. Geleneksel LAMP/LEMP yığınlarına kıyasla, Kubernetes ile PHP uygulamaları daha dinamik bir altyapıda çalışabilir, kaynakları daha verimli kullanabilir ve geliştirme süreçlerini hızlandırabilir.

Bu rehber, Kubernetes yolculuğunuz için sağlam bir başlangıç noktası sunmaktadır. Daha ileri adımlar olarak, CI/CD boru hatlarını Kubernetes ile entegre etmek, Ingress Controller kullanarak dışarıdan daha gelişmiş trafik yönlendirme sağlamak, Helm gibi paket yöneticileriyle uygulama dağıtımını otomatikleştirmek ve daha karmaşık çok katmanlı PHP uygulamalarını (veritabanları, kuyruk sistemleri ile birlikte) dağıtmak gibi konuları araştırabilirsiniz. Kubernetes’in sunduğu olanaklar sınırsızdır ve öğrenmeye devam ettikçe uygulamalarınız için daha güçlü ve verimli çözümler geliştirebilirsiniz.

Kubernetes ile PHP Uygulamasını Ubuntu 16.04 Üzerinde Dağıtma Rehberi