Ubuntu 18.04’te Kubernetes ile PHP Uygulaması Nasıl Dağıtılır

Giriş

Kubernetes, açık kaynaklı bir konteyner düzenleme sistemidir. Kapalı kalma süresi konusunda endişelenmeden konteynerler oluşturmanıza, güncellemenize ve ölçeklendirmenize olanak tanır.

Bir PHP uygulamasını çalıştırmak için Nginx, PHP-FPM için bir vekil görevi görür . Bu kurulumu tek bir kapsayıcıda kapsayıcı hale getirmek zahmetli bir süreç olabilir, ancak Kubernetes her iki hizmeti de ayrı kapsayıcılarda yönetmeye yardımcı olacaktır. Kubernetes kullanmak, konteynerlerinizi yeniden kullanılabilir ve değiştirilebilir durumda tutmanıza olanak tanır ve her yeni Nginx veya PHP sürümü olduğunda konteyner görüntünüzü yeniden oluşturmanız gerekmez.

Bu eğitimde, ayrı konteynerlerde çalışan Nginx ve PHP-FPM ile bir Kubernetes kümesinde bir PHP 7 uygulaması konuşlandıracaksınız. Ayrıca, DigitalOcean’ın Blok Depolama sistemini kullanarak yapılandırma dosyalarınızı ve uygulama kodunuzu konteyner görüntüsünün dışında nasıl tutacağınızı da öğreneceksiniz . Bu yaklaşım, görüntüyü yeniden oluşturmak yerine bir yapılandırma birimini ileterek bir web / proxy sunucusuna ihtiyaç duyan herhangi bir uygulama için Nginx görüntüsünü yeniden kullanmanıza olanak tanır.

Önkoşullar

• Kubernetes nesnelerine ilişkin temel bir anlayış. Bizim göz atın Giriş Kubernetes için daha fazla bilgi için makaleyi.
• Ubuntu 18.04 üzerinde çalışan bir Kubernetes kümesi. Bunu, Ubuntu 18.04 üzerinde Kubeadm Kullanarak Kubernetes 1.14 Kümesi Oluşturma öğreticisini izleyerek ayarlayabilirsiniz .
• Depolama birimimizi oluşturmak için bir DigitalOcean hesabı ve okuma ve yazma izinlerine sahip bir API erişim belirteci. API erişim jetonunuz yoksa buradan oluşturabilirsiniz .
• Uygulama kodunuz, Github gibi herkese açık bir URL’de barındırılıyor .

Adım 1 – PHP-FPM ve Nginx Hizmetlerinin Oluşturulması

Bu adımda, PHP-FPM ve Nginx hizmetlerini oluşturacaksınız. Bir hizmet, küme içinden bir dizi bölmeye erişime izin verir. Bir küme içindeki hizmetler, IP adreslerine ihtiyaç duymadan doğrudan adları aracılığıyla iletişim kurabilir. PHP-FPM hizmeti, PHP-FPM bölmelerine erişime izin verirken, Nginx hizmeti Nginx bölmelerine erişime izin verecektir.

Nginx bölmeleri PHP-FPM bölmelerine proxy uygulayacağından, hizmete bunları nasıl bulacağını söylemeniz gerekir. IP adreslerini kullanmak yerine, istekleri uygun hizmete yönlendirmek için insan tarafından okunabilir adları kullanmak için Kubernetes’in otomatik hizmet keşfinden yararlanacaksınız.

Hizmeti oluşturmak için bir nesne tanımlama dosyası oluşturacaksınız. Her Kubernetes nesne tanımı, en azından aşağıdaki öğeleri içeren bir YAML dosyasıdır:

• apiVersion: Tanımın ait olduğu Kubernetes API sürümü.
• kind: Bu dosyanın temsil ettiği Kubernetes nesnesi. Örneğin, a podveya service.
• metadata: Bu name, nesneye labelsuygulamak isteyebileceğiniz her şeyle birlikte nesneyi içerir .
• spec: Bu, kapsayıcı görüntüsü veya kapsayıcıya erişilebilecek bağlantı noktaları gibi, oluşturduğunuz nesnenin türüne bağlı olarak belirli bir yapılandırma içerir.

Önce, Kubernetes nesne tanımlarınızı tutmak için bir dizin oluşturacaksınız.

Ana düğümünüze SSH uygulayın ve definitionsKubernetes nesne tanımlarınızı tutacak dizini oluşturun .

mkdir definitions

Yeni oluşturulan definitionsdizine gidin :

cd definitions

Bir php_service.yamldosya oluşturarak PHP-FPM hizmetinizi oluşturun :

nano php_service.yaml

Set kindolarak Servicebu nesne bir hizmet olduğunu belirtmek için:php_service.yaml

apiVersion: v1
kind: Service

phpPHP-FPM’ye erişim sağlayacağı için hizmeti adlandırın :php_service.yaml

...
metadata:
  name: php

Mantıksal olarak farklı nesneleri etiketlerle gruplayacaksınız. Bu eğitimde, nesneleri ön uç veya arka uç gibi “katmanlara” gruplamak için etiketleri kullanacaksınız. PHP bölmeleri bu hizmetin arkasında çalışacak, bu nedenle onu olarak etiketleyeceksiniz tier: backend.php_service.yaml

...
  labels:
    tier: backend

Bir hizmet, selectoretiketleri kullanarak hangi bölmelere erişileceğini belirler . Kapsülün servisten önce mi sonra mı oluşturulduğundan bağımsız olarak, bu etiketlerle eşleşen bir bölmeye hizmet verilecektir. Eğiticide daha sonra bölmeleriniz için etiketler ekleyeceksiniz.

tier: backendKapsülü arka uç katmanına atamak için etiketi kullanın . app: phpBu bölmenin PHP çalıştırdığını belirtmek için etiketi de ekleyeceksiniz . Bu iki etiketi metadatabölümden sonra ekleyin .php_service.yaml

...
spec:
  selector:
    app: php
    tier: backend

Ardından, bu hizmete erişmek için kullanılan bağlantı noktasını belirtin. 9000Bu eğitimde port kullanacaksınız . php_service.yamlŞunun altındaki dosyaya ekleyin spec:php_service.yaml

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

Tamamladığınız php_service.yamldosya şöyle görünecek:php_service.yaml

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

Hit CTRL + Osonra dosyayı kaydetmek için, ve CTRL + Xçıkışa nano.

Artık hizmetiniz için nesne tanımını oluşturduğunuza göre, hizmeti çalıştırmak kubectl applyiçin -fbağımsız değişkenle birlikte komutu kullanacak ve php_service.yamldosyanızı belirteceksiniz .

Hizmetinizi oluşturun:

kubectl apply -f php_service.yaml

Bu çıktı, hizmet oluşturmayı doğrular:

Outputservice/php created

Hizmetinizin çalıştığını doğrulayın:

kubectl get svc

PHP-FPM hizmetinizin çalıştığını göreceksiniz:

OutputNAME         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

There are various service types that Kubernetes supports. Your php service uses the default service type, ClusterIP. This service type assigns an internal IP and makes the service reachable only from within the cluster.

Now that the PHP-FPM service is ready, you will create the Nginx service. Create and open a new file called nginx_service.yaml with the editor:

nano nginx_service.yaml

This service will target Nginx pods, so you will name it nginx. You will also add a tier: backend label as it belongs in the back-end tier:nginx_service.yaml

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

Similar to the php service, target the pods with the selector labels app: nginx and tier: backend. Make this service accessible on port 80, the default HTTP port.nginx_service.yaml

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

Nginx hizmeti, Droplet’inizin genel IP adresinden internete herkesin erişimine açık olacaktır. your_public_ipsenin dan bulunabilir DigitalOcean Kontrol Paneli . Altına şunu spec.externalIPsekleyin:nginx_service.yaml

...
spec:
  externalIPs:
  - your_public_ip

Kişisel nginx_service.yamldosya şu şekilde olacaktır:nginx_service.yaml

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    

Dosyayı kaydedin ve kapatın. Nginx hizmetini oluşturun:

kubectl apply -f nginx_service.yaml

Servis çalışırken aşağıdaki çıktıyı göreceksiniz:

Outputservice/nginx created

Çalışan tüm hizmetleri şunları çalıştırarak görüntüleyebilirsiniz:

kubectl get svc

Çıktıda listelenen hem PHP-FPM hem de Nginx hizmetlerini göreceksiniz:

OutputNAME         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

Lütfen bir servisi silmek istiyorsanız çalıştırabileceğinizi unutmayın:

kubectl delete svc/service_name

Artık PHP-FPM ve Nginx hizmetlerinizi oluşturduğunuza göre, uygulama kodunuzu ve yapılandırma dosyalarınızı nerede saklayacağınızı belirtmeniz gerekecek.

Adım 2 – DigitalOcean Depolama Eklentisinin Kurulması

Kubernetes, ortamınız için depolama alanı oluşturabilen farklı depolama eklentileri sağlar. Bu adımda, DigitalOcean üzerinde blok depolama oluşturmak için DigitalOcean depolama eklentisini kuracaksınız. Kurulum tamamlandığında, do-block-storageblok depolamanızı oluşturmak için kullanacağınız adlı bir depolama sınıfı ekleyecektir .

Önce DigitalOcean API jetonunuzu depolamak için bir Kubernetes Gizli nesnesi yapılandıracaksınız. Gizli nesneler, SSH anahtarları ve şifreler gibi hassas bilgileri aynı ad alanı içindeki diğer Kubernetes nesneleriyle paylaşmak için kullanılır. Ad alanları, Kubernetes nesnelerinizi mantıksal olarak ayırmanın bir yolunu sağlar.

Editörle adlandırılmış bir dosya açın secret.yaml:

nano secret.yaml

Gizli nesnenizi adlandıracak digitaloceanve kube-systemad alanına ekleyeceksiniz . kube-systemAd Kubernetes’ iç hizmetler için varsayılan ad alanı ve aynı zamanda çeşitli bileşenlerini başlatmak için eklenti DigitalOcean depolama tarafından kullanılır.secret.yaml

apiVersion: v1
kind: Secret
metadata:
  name: digitalocean
  namespace: kube-system

Bir specanahtar yerine , bir Gizli anahtar gerekli bilgileri tutmak için a dataveya stringDataanahtarını kullanır . dataParametresi alınan otomatik olarak kodu çözülmüş bir kodlanmış veri base64 tutar. stringDataSırları alırken parametre değil çıkış verilerini otomatik olarak oluşturma veya güncelleme sırasında kodlanır olmayan kodlanmış verileri tutan ve yapar. stringDataKolaylık sağlamak için bu öğreticide kullanacaksınız .

Ekle access-tokenolarak stringData:secret.yaml

...
stringData:
  access-token: your-api-token

Dosyayı kaydedin ve çıkın.

Kişisel secret.yamldosya şu şekilde olacaktır:secret.yaml

apiVersion: v1
kind: Secret
metadata:
  name: digitalocean
  namespace: kube-system
stringData:
  access-token: your-api-token

Sırrı oluşturun:

kubectl apply -f secret.yaml

Bu çıktıyı Gizli oluşturmada göreceksiniz:

Outputsecret/digitalocean created

Sırrı aşağıdaki komutla görüntüleyebilirsiniz:

kubectl -n kube-system get secret digitalocean

Çıktı şuna benzer görünecektir:

OutputNAME           TYPE      DATA      AGE
digitalocean   Opaque    1         41s

OpaqueBu gizli için standart olan salt okunur tipi araçlar stringDataSırlar. Gizli tasarım spesifikasyonunda bunun hakkında daha fazla bilgi edinebilirsiniz . DATAAlan, bu sır saklanan öğelerin sayısını gösterir. Bu durumda, 1sakladığınız tek bir anahtarınız olduğu için gösterilir .

Sırrınız yerinde olduğuna göre, DigitalOcean blok depolama eklentisini kurun :

kubectl apply -f https://raw.githubusercontent.com/digitalocean/csi-digitalocean/master/deploy/kubernetes/releases/csi-digitalocean-v1.1.0.yaml

Aşağıdakine benzer çıktı göreceksiniz:

Outputcsidriver.storage.k8s.io/dobs.csi.digitalocean.com created
customresourcedefinition.apiextensions.k8s.io/volumesnapshotclasses.snapshot.storage.k8s.io created
customresourcedefinition.apiextensions.k8s.io/volumesnapshotcontents.snapshot.storage.k8s.io created
customresourcedefinition.apiextensions.k8s.io/volumesnapshots.snapshot.storage.k8s.io created
storageclass.storage.k8s.io/do-block-storage created
statefulset.apps/csi-do-controller created
serviceaccount/csi-do-controller-sa created
clusterrole.rbac.authorization.k8s.io/csi-do-provisioner-role created
clusterrolebinding.rbac.authorization.k8s.io/csi-do-provisioner-binding created
clusterrole.rbac.authorization.k8s.io/csi-do-attacher-role created
clusterrolebinding.rbac.authorization.k8s.io/csi-do-attacher-binding created
clusterrole.rbac.authorization.k8s.io/csi-do-snapshotter-role created
clusterrolebinding.rbac.authorization.k8s.io/csi-do-snapshotter-binding created
daemonset.apps/csi-do-node created
serviceaccount/csi-do-node-sa created
clusterrole.rbac.authorization.k8s.io/csi-do-node-driver-registrar-role created
clusterrolebinding.rbac.authorization.k8s.io/csi-do-node-driver-registrar-binding created
error: unable to recognize "https://raw.githubusercontent.com/digitalocean/csi-digitalocean/master/deploy/kubernetes/releases/csi-digitalocean-v1.1.0.yaml": no matches for kind "VolumeSnapshotClass" in version "snapshot.storage.k8s.io/v1alpha1"

Bu eğitimde hataları göz ardı etmek güvenlidir.

Artık DigitalOcean depolama eklentisini kurduğunuza göre, uygulama kodunuzu ve yapılandırma dosyalarınızı saklamak için blok depolama alanı oluşturabilirsiniz.

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

Sırrınız yerinde ve blok depolama eklentisi kuruluyken, artık Kalıcı Biriminizi oluşturmaya hazırsınız . Kalıcı Birim veya PV, bir bölmenin yaşam döngüsünden bağımsız olarak yaşayan, belirli bir boyuttaki blok depolamadır. Kalıcı Birim kullanmak, uygulama kodunuzu kaybetme endişesi olmadan bölmelerinizi yönetmenize veya güncellemenize olanak tanır. Kalıcı PersistentVolumeClaimBirime, PV’yi gerekli yola monte eden a veya PVC kullanılarak erişilir .

code_volume.yamlEditörünüzle adlandırılmış bir dosya açın :

nano code_volume.yaml

codeDosyanıza aşağıdaki parametreleri ve değerleri ekleyerek PVC’yi adlandırın :code_volume.yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: code

specBir PVC için aşağıdaki öğeleri içerir:

• accessModeskullanım durumuna göre değişir. Bunlar:
  • ReadWriteOnce – birimi tek bir düğüm tarafından okuma-yazma olarak bağlar
  • ReadOnlyMany – birimi birçok düğüm tarafından salt okunur olarak bağlar
  • ReadWriteMany – Birimi birçok düğüm tarafından okuma-yazma olarak bağlar
• resources – ihtiyacınız olan depolama alanı

Eğer set böylece DigitalOcean blok depolama yalnızca tek bir düğüm monte edilir accessModesetmek ReadWriteOnce. Bu eğitim, az miktarda uygulama kodu eklemeniz için size rehberlik edecek, bu nedenle bu kullanım durumunda 1 GB yeterli olacaktır. Birimde daha büyük miktarda kod veya veri depolamayı planlıyorsanız, storageparametreyi gereksinimlerinize uyacak şekilde değiştirebilirsiniz . Birim oluşturduktan sonra depolama miktarını artırabilirsiniz ancak diskin küçültülmesi desteklenmez.code_volume.yaml

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

Ardından, Kubernetes’in birimleri sağlamak için kullanacağı depolama sınıfını belirtin. do-block-storageDigitalOcean blok depolama eklentisi tarafından oluşturulan sınıfı kullanacaksınız .code_volume.yaml

...
  storageClassName: do-block-storage

Kişisel code_volume.yamldosya şu şekilde olacaktır:code_volume.yaml

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

Dosyayı kaydedin ve çıkın.

codePVC’yi kullanarak oluşturun kubectl:

kubectl apply -f code_volume.yaml

Aşağıdaki çıktı, nesnenin başarıyla oluşturulduğunu ve 1GB PVC’nizi bir birim olarak monte etmeye hazır olduğunuzu söyler.

Outputpersistentvolumeclaim/code created

Mevcut Kalıcı Birimleri (PV) görüntülemek için:

kubectl get pv

PV’nizin listelendiğini göreceksiniz:

OutputNAME                                       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

Yukarıdaki alanlar, Reclaim Policyve dışındaki yapılandırma dosyanıza genel bir bakıştır Status. Reclaim PolicyPVC silinir eriştikten sonra PV ne yapıldığını tanımlar. DeletePV’yi Kubernetes’ten ve DigitalOcean altyapısından kaldırır. Sen hakkında daha fazla bilgi edinebilirsiniz Reclaim Policyve Statusgelen Kubernetes PV belgelerinde .

DigitalOcean blok depolama eklentisini kullanarak bir Persistent Volume başarıyla oluşturdunuz. Kalıcı Biriminiz artık hazır olduğuna göre, bölmelerinizi bir Dağıtım kullanarak oluşturacaksınız.

Adım 4 – Bir PHP-FPM Dağıtımı Oluşturma

Bu adımda, PHP-FPM bölmenizi oluşturmak için bir Dağıtımı nasıl kullanacağınızı öğreneceksiniz. Dağıtımlar, ReplicaSets kullanarak bölmeleri oluşturmak, güncellemek ve yönetmek için tek tip bir yol sağlar . Güncelleme beklendiği gibi çalışmazsa, Dağıtım bölmelerini otomatik olarak önceki bir görüntüye geri alır.

Dağıtım spec.selectoranahtarı, yöneteceği bölmelerin etiketlerini listeler. Ayrıca templategerekli bölmeleri oluşturmak için anahtarı kullanacaktır .

Bu adım aynı zamanda Başlatma Konteynerlerinin kullanımını da tanıtacaktır. Başlatma Kapsayıcıları , bölmenin templateanahtarı altında belirtilen normal kapsayıcılardan önce bir veya daha fazla komut çalıştırır . Bu öğreticide, Başlangıç ​​Konteynırınız kullanarak GitHub Gist’ten bir örnek index.phpdosya getirecektir . Örnek dosyanın içeriği şu şekildedir:wgetindex.php

<?php
echo phpinfo(); 

Dağıtımınızı oluşturmak için php_deployment.yaml, düzenleyicinizle çağrılan yeni bir dosya açın :

nano php_deployment.yaml

Bu Dağıtım, PHP-FPM bölmelerinizi yönetecek, böylece Dağıtım nesnesini adlandıracaksınız php. Bölmeler arka uç katmanına aittir, bu nedenle şu tier: backendetiketi kullanarak Dağıtımı bu grupta gruplayacaksınız :php_deployment.yaml

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

For the Deployment spec, you will specify how many copies of this pod to create by using the replicas parameter. The number of replicas will vary depending on your needs and available resources. You will create one replica in this tutorial:php_deployment.yaml

...
spec:
  replicas: 1

This Deployment will manage pods that match the app: php and tier: backend labels. Under selector key add:php_deployment.yaml

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

Next, the Deployment spec requires the template for your pod’s object definition. This template will define specifications to create the pod from. First, you will add the labels that were specified for the php service selectors and the Deployment’s matchLabels. Add app: php and tier: backend under template.metadata.labels:php_deployment.yaml

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

A pod can have multiple containers and volumes, but each will need a name. You can selectively mount volumes to a container by specifying a mount path for each volume.

First, specify the volumes that your containers will access. You created a PVC named code to hold your application code, so name this volume code as well. Under spec.template.spec.volumes, add the following:php_deployment.yaml

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

Next, specify the container you want to run in this pod. You can find various images on the Docker store, but in this tutorial you will use the php:7-fpm image.

Under spec.template.spec.containers, add the following:php_deployment.yaml

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

Ardından, konteynerin erişim gerektirdiği birimleri bağlayacaksınız. Bu kapsayıcı PHP kodunuzu çalıştıracak, bu nedenle codebirime erişmesi gerekecek . Bağlama noktası olarak mountPathbelirtmek için de kullanacaksınız /code.

Altına şunu spec.template.spec.containers.volumeMountsekleyin:php_deployment.yaml

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

Artık biriminizi taktığınıza göre, uygulama kodunuzu birimden almanız gerekir. Bunu gerçekleştirmek için daha önce FTP / SFTP kullanmış veya kodu bir SSH bağlantısı üzerinden klonlamış olabilirsiniz, ancak bu adım size kodu bir Başlatma Kabı kullanarak nasıl kopyalayacağınızı gösterecektir.

Kurulum işleminizin karmaşıklığına bağlı olarak, initContaineruygulamanızı oluşturan bir komut dosyasını çalıştırmak için tek bir komut kullanabilir veya initContainerkomut başına bir tane kullanabilirsiniz . Birimlerin initContainer.

Bu öğreticide, busyboxkodu indirmek için tek bir Başlatma Kabı kullanacaksınız . bunu gerçekleştirmek için kullanacağınız yardımcı programı busyboxiçeren küçük bir resimdir wget.

Altına spec.template.spec, sizin ekleyin initContainerve busyboxresmi belirtin :php_deployment.yaml

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

Başlangıç ​​Konteynırınızın codekodu o konuma indirebilmesi için birime erişmesi gerekecektir . Altında spec.template.spec.initContainers, hacim monte codeat /codeyolu:php_deployment.yaml

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

Her Başlatma Konteynerinin bir command. Kişisel Init Konteyner kullanacak wgetindirmek için kod adlı Github içine /codeçalışan dizinine. -OSeçeneği indirilen dosyanın bir isim verir ve bu dosyayı adlandırır index.php.

Not: Çektiğiniz koda güvendiğinizden emin olun. Sunucunuza çekmeden önce, kodun ne yaptığından emin olmak için kaynak kodunu inceleyin.

İçindeki installkonteynerin altına spec.template.spec.initContainersşu satırları ekleyin:php_deployment.yaml

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

Tamamladığınız php_deployment.yamldosya şöyle görünecek:php_deployment.yaml

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

Dosyayı kaydedin ve düzenleyiciden çıkın.

PHP-FPM Dağıtımını şununla oluşturun kubectl:

kubectl apply -f php_deployment.yaml

Dağıtım oluşturulduktan sonra aşağıdaki çıktıyı göreceksiniz:

Outputdeployment.apps/php created

Özetlemek gerekirse, bu Dağıtım, belirtilen görüntüleri indirerek başlayacaktır. Daha sonra sizden talep PersistentVolumeedecek PersistentVolumeClaimve initContainers. Tamamlandığında, kapsayıcılar çalışacak ve volumesbelirtilen bağlama noktasına monte edilecektir. Tüm bu adımlar tamamlandıktan sonra, bölmeniz hazır ve çalışır durumda olacaktır.

Dağıtımınızı şunları çalıştırarak görüntüleyebilirsiniz:

kubectl get deployments

Çıktıyı göreceksiniz:

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

Bu çıktı, Dağıtımın mevcut durumunu anlamanıza yardımcı olabilir. A Deployment, istenen durumu koruyan denetleyicilerden biridir . templateEğer belirtir oluşturulan DESIREDdevlet 1 olacak replicasadlandırılmış Kapsülün php. CURRENTAlan birçok kopyaları çalıştıran nasıl, bu nedenle bu eşleşmesi gerekir gösteren DESIREDdevlet. Kubernetes Dağıtımları belgelerinde kalan alanlar hakkında bilgi edinebilirsiniz .

Bu Dağıtımın başlattığı bölmeleri aşağıdaki komutla görüntüleyebilirsiniz:

kubectl get pods

Bu komutun çıktısı, Dağıtımı oluşturduktan sonra ne kadar zaman geçtiğine bağlı olarak değişir. Oluşturduktan kısa bir süre sonra çalıştırırsanız, çıktı muhtemelen şöyle görünecektir:

OutputNAME                   READY     STATUS     RESTARTS   AGE
php-86d59fd666-bf8zd   0/1       Init:0/1   0          9s

Sütunlar aşağıdaki bilgileri temsil eder:

• Ready: replicasBu bölmeyi çalıştırma sayısı .
• Status: Bölmenin durumu. InitBaşlatma Konteynerlerinin çalıştığını gösterir. Bu çıktıda, 1 Başlatma Konteynırından 0’ı çalışmayı bitirdi.
• Restarts: Bölmeyi başlatmak için bu işlemin kaç kez yeniden başlatıldığı. Init Container’larınızdan herhangi biri başarısız olursa bu sayı artacaktır. Dağıtım, istenen duruma ulaşana kadar onu yeniden başlatacaktır.

Başlangıç ​​komut dosyalarınızın karmaşıklığına bağlı olarak, durumun şu şekilde değişmesi birkaç dakika sürebilir podInitializing:

OutputNAME                   READY     STATUS            RESTARTS   AGE
php-86d59fd666-lkwgn   0/1       podInitializing   0          39s

Bu, Başlangıç ​​Konteynerlerinin bittiği ve konteynerlerin başlatıldığı anlamına gelir. Komutu tüm kapsayıcılar çalışırken çalıştırırsanız, bölme durumunun olarak değiştiğini göreceksiniz Running.

OutputNAME                   READY     STATUS            RESTARTS   AGE
php-86d59fd666-lkwgn   1/1       Running   0          1m

Şimdi bölmenizin başarıyla çalıştığını görüyorsunuz. Bölmeniz başlamazsa, aşağıdaki komutlarla hata ayıklayabilirsiniz:

• Bir bölmenin ayrıntılı bilgilerini görüntüleyin:

kubectl describe pods pod-name

• Bir bölme tarafından oluşturulan günlükleri görüntüleyin:

kubectl logs pod-name

• Bir bölmedeki belirli bir kapsayıcı için günlükleri görüntüleyin:

kubectl logs pod-name container-name

Uygulama kodunuz bağlanmıştır ve PHP-FPM hizmeti artık bağlantıları işlemeye hazırdır. Artık Nginx Dağıtımınızı oluşturabilirsiniz.

Adım 5 – Nginx Dağıtımının Oluşturulması

Bu adımda, Nginx’i yapılandırmak için bir ConfigMap kullanacaksınız . ConfigMap, yapılandırmanızı diğer Kubernetes nesne tanımlarında başvurabileceğiniz bir anahtar-değer biçiminde tutar. Bu yaklaşım, gerekirse görüntüyü yeniden kullanma veya farklı bir Nginx sürümüyle değiştirme esnekliği sağlayacaktır. ConfigMap’in güncellenmesi, değişiklikleri otomatik olarak onu monte eden herhangi bir bölmeye kopyalar.

nginx_configMap.yamlDüzenleyicinizle ConfigMap’iniz için bir dosya oluşturun :

nano nginx_configMap.yaml

ConfigMap’i adlandırın nginx-configve tier: backendmikro hizmette gruplandırın :nginx_configMap.yaml

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

Ardından, dataConfigMap için ekleyeceksiniz. Anahtarı adlandırın configve Nginx yapılandırma dosyanızın içeriğini değer olarak ekleyin. Bu öğreticiden örnek Nginx yapılandırmasını kullanabilirsiniz .

Kubernetes, istekleri bir hizmet için uygun ana bilgisayara yönlendirebildiğinden, fastcgi_passparametreye IP adresi yerine PHP-FPM hizmetinizin adını girebilirsiniz . Aşağıdakileri nginx_configMap.yamldosyanıza ekleyin :nginx_configMap.yaml

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

Kişisel nginx_configMap.yamldosya şu şekilde olacaktır:nginx_configMap.yaml

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

Dosyayı kaydedin ve düzenleyiciden çıkın.

ConfigMap’i oluşturun:

kubectl apply -f nginx_configMap.yaml

Aşağıdaki çıktıyı göreceksiniz:

Outputconfigmap/nginx-config created

ConfigMap’inizi oluşturmayı tamamladınız ve şimdi Nginx Dağıtımınızı oluşturabilirsiniz.

nginx_deployment.yamlDüzenleyicide yeni bir dosya açarak başlayın :

nano nginx_deployment.yaml

Dağıtımı adlandırın nginxve etiketi ekleyin tier: backend:nginx_deployment.yaml

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

replicasKonuşlandırmada bir tane istediğinizi belirtin spec. Bu Dağıtım etiketlerle bölmeleri yönetecek app: nginxve tier: backend. Aşağıdaki parametreleri ve değerleri ekleyin:nginx_deployment.yaml

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

Ardından bölmeyi ekleyin template. Dağıtım için eklediğiniz etiketlerin aynısını kullanmanız gerekir selector.matchLabels. Aşağıdakileri ekleyin:nginx_deployment.yaml

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

codeDaha önce oluşturduğunuz PVC’ye Nginx erişimi verin . Altına şunu spec.template.spec.volumesekleyin:nginx_deployment.yaml

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

Bölmeler bir ConfigMap’i birim olarak bağlayabilir. Bir dosya adı ve anahtarının belirtilmesi, içerik olarak değeri olan bir dosya oluşturacaktır. ConfigMap’i kullanmak için, .pdf pathdosyasının içeriğini tutacak dosyanın adına ayarlayın key. site.confAnahtardan bir dosya oluşturmak istiyorsunuz config. Altına spec.template.spec.volumesaşağıdakileri ekleyin:nginx_deployment.yaml

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

Uyarı : Bir dosya belirtilmezse, birimin içeriği birimin keyyerini alacaktır mountPath. Bu, bir yol açıkça belirtilmezse, hedef klasördeki tüm içeriği kaybedeceğiniz anlamına gelir.

Ardından, bölmenizi oluşturmak için görüntüyü belirleyeceksiniz. Bu eğitim, nginx:1.7.9imajı kararlılık için kullanacaktır , ancak Docker mağazasında diğer Nginx imajlarını da bulabilirsiniz . Ayrıca, Nginx’i bağlantı noktasında kullanılabilir hale getirin 80. spec.template.specEkle altında :nginx_deployment.yaml

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

Nginx ve PHP-FPM’nin dosyaya aynı yoldan erişmesi gerekir, bu nedenle codebirimi şu adresten bağlayın /code:nginx_deployment.yaml

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

nginx:1.7.9Resim otomatik altında herhangi bir yapılandırma dosyalarını yükleyecektir /etc/nginx/conf.ddizine. Birimi configbu dizine bağlamak dosyayı oluşturacaktır /etc/nginx/conf.d/site.conf. Altında volumeMountsaşağıdaki ekleyin:nginx_deployment.yaml

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

Kişisel nginx_deployment.yamldosya şu şekilde olacaktır:nginx_deployment.yaml

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

Dosyayı kaydedin ve düzenleyiciden çıkın.

Nginx Dağıtımını Oluşturun:

kubectl apply -f nginx_deployment.yaml

Aşağıdaki çıktı, Dağıtımınızın artık oluşturulduğunu gösterir:

Outputdeployment.apps/nginx created

Dağıtımlarınızı şu komutla listeleyin:

kubectl get deployments

Nginx ve PHP-FPM Dağıtımlarını göreceksiniz:

OutputNAME      DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
nginx     1         1         1            0           16s
php       1         1         1            1           7m

Her iki Dağıtım tarafından yönetilen bölmeleri listeleyin:

kubectl get pods

Çalışan bölmeleri göreceksiniz:

OutputNAME                     READY     STATUS    RESTARTS   AGE
nginx-7bf5476b6f-zppml   1/1       Running   0          32s
php-86d59fd666-lkwgn     1/1       Running   0          7m

Artık tüm Kubernetes nesneleri aktif olduğuna göre, tarayıcınızda Nginx hizmetini ziyaret edebilirsiniz.

Çalışan hizmetleri listeleyin:

kubectl get services -o wide

Nginx hizmetiniz için Harici IP’yi alın:

OutputNAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE       SELECTOR
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP    39m       <none>
nginx        ClusterIP   10.102.160.47   your_public_ip 80/TCP     27m       app=nginx,tier=backend
php          ClusterIP   10.100.59.238   <none>        9000/TCP   34m       app=php,tier=backend

Tarayıcınızda yazarak sunucunuzu ziyaret edin . Sen çıktısını göreceksiniz ve Kubernetes servisleri çalışır durumda olduğunu doğruladı.http://your_public_ipphp_info()

Sonuç

Bu kılavuzda, PHP-FPM ve Nginx hizmetlerini bağımsız olarak yönetebilmeniz için kapsayıcı hale getirdiniz. Bu yaklaşım sadece siz büyüdükçe projenizin ölçeklenebilirliğini artırmakla kalmayacak, aynı zamanda kaynakları verimli bir şekilde kullanmanıza da olanak sağlayacaktır. Gelecekte hizmetlerinizi kolayca güncelleyebilmeniz için uygulama kodunuzu da bir birimde sakladınız.

Kaynak