Een PHP-applicatie implementeren op een Kubernetes-cluster met Ubuntu 18.04

Kubernetes (alsook bekend als k8s) is een open-source orkestratiesysteem. Het stelt gebruikers in staat om gecontaineriseerde applicaties te implementeren, schalen en beheren met minimale downtime. In deze handleiding leert u hoe u een PHP applicatie implementeert op een Kubernetes-cluster.

Nginx fungeert als een proxy voor PHP-FPM tijdens het draaien van een PHP-applicatie. Het beheren van deze twee services in een enkele container is een lastig proces. Kubernetes helpt ons om ze in twee verschillende containers te beheren en vermindert het gedoe. Het stelt gebruikers ook in staat om de containers te hergebruiken en zich geen zorgen te maken over het bouwen van hun container-image voor elke nieuwe versie van PHP/Nginx.

U zult uw applicatie en proxyservice in twee afzonderlijke containers draaien. De handleiding biedt ook inzicht in hoe u lokale opslag kunt gebruiken om een Persistent Volume (PV) en Persistent Volume Claim (PVC) te maken. U gebruikt deze PVC vervolgens om uw configuratiebestanden en code buiten de container-images te houden. Na het voltooien van deze handleiding kunt u uw Nginx-image hergebruiken voor andere applicaties die een proxyserver vereisen. Dit kunt u bereiken door een configuratie door te geven, in plaats van de image hiervoor opnieuw te bouwen.

Vereisten

1. Een basisbegrip van Kubernetes (k8s) en de bijbehorende objecten. Raadpleeg deze gids voor een gedetailleerd overzicht van het Kubernetes-ecosysteem.
2. Een Kubernetes-cluster dat actief is op Ubuntu 18.04. Volg deze handleiding om uw Kubernetes-cluster te maken met behulp van kubeadm.
3. Daarnaast moet u uw applicatiecode hosten op een openbare URL, bijvoorbeeld GitHub.

Stap 1: PHP-FPM- en Nginx-services maken

Deze stap helpt u bij het maken van PHP-FPM- en Nginx-services. Elke service biedt toegang tot een set pods binnen een cluster. Alle services in een cluster kunnen met elkaar communiceren via hun naam, zonder IP-adressen. De PHP-FPM-service en Nginx-service bieden respectievelijk toegang tot PHP-FPM- en Nginx-pods.

U moet de PHP-FPM-service vertellen hoe deze de Nginx-pods kan vinden, aangezien deze zal fungeren als een proxy voor de PHP-FPM-pods. Hiervoor maakt u gebruik van de automatische service-ontdekking van Kubernetes’ en gebruikt u menselijk leesbare namen om het verzoek naar de respectieve service te routeren.

Om een service te maken, moet u een YAML-bestand maken dat de objectdefinitie bevat. Dit YAML-bestand heeft ten minste de volgende tags:

1. apiVersion: De Kubernetes API-versie waartoe de definitie behoort.
2. kind: Het type Kubernetes-object dat dit YAML-bestand maakt. Bijvoorbeeld: een service, een job, of een pod.
3. metadata: De naam van het object en de verschillende labels die de gebruiker mogelijk op dit object wil toepassen, zijn onder deze tag gedefinieerd.
4. spec: Deze tag bevat de objectspecificatie van uw object, zoals ENV's, de te gebruiken container-image, poorten waarop de containerservice toegankelijk zal zijn.

De PHP-FPM-service maken

Om te beginnen moet u een map maken om uw Kubernetes-objectdefinitie in te bewaren. Log in op uw master-node en maak een map met de naam “definitions:”

Wijzig de map naar de map definitions:

Maak vervolgens uw PHP-FPM-servicebestand als php_service.yaml-bestand:

Stel daarna de apiVersion en kind in in het php_fpm_service.yaml-bestand:

Geef uw service de naam php of php-fpm omdat deze toegang zal bieden tot uw PHP-FPM-applicatie:

Label uw php-service als tier: backend omdat de PHP-applicatie achter deze service zal draaien:

Een service gebruikt de selector-labels om te bepalen welke pods moeten worden benaderd. Elke pod die overeenkomt met deze labels, ongeacht wanneer de pod is gemaakt, wordt bediend. U leert later in deze handleiding hoe u labels aan uw pods toevoegt.

Voeg het tier: backend label toe dat uw pod toewijst aan de backend-tier, samen met het app: php-fpm label om aan te geven dat de pod een PHP-FPM-applicatie uitvoert. U moet deze labels toevoegen na de metadata sectie:

Vervolgens moet u de poort declareren om toegang te krijgen tot deze php-fpm service onder spec. U kunt elke gewenste poort toevoegen, maar we gebruiken poort 9000 in deze handleiding:

Zodra u de bovenstaande stappen hebt voltooid, ziet uw php_fpm_service.yaml bestand er als volgt uit:

Druk op Ctrl + O om het bestand op te slaan en druk vervolgens op Ctrl + X om te stoppen met nano.

De kubectl-opdracht toepassen om de PHP-service te maken

Zodra de objectdefinitie voor uw service is gemaakt, voert u de opdracht kubectl apply uit met het -f argument door uw php_fpm_service.yaml bestand op te geven:

De uitvoer van de bovenstaande opdracht zou moeten zijn:

Voer de onderstaande opdracht uit om te controleren of uw php-fpm-service actief is:

U kunt zien dat de php-fpm-service actief is:

De Nginx-service maken

Nu uw PHP-FPM-service gereed is, is het tijd om ook uw Nginx-service te maken. Maak een nieuw YAML-bestand voor deze service met de naam nginx_service.yaml en open dit in de editor:

Geef deze service de naam nginx omdat deze gericht is op de Nginx-pods. Deze service hoort ook thuis in de backend, dus u moet er een tier: backend label aan toevoegen:

Voer, net als bij de php-fpm-service, de selectorlabels app: nginx en tier: backend toe om de pods te targeten. Voeg de standaard HTTP-poort 80 toe om toegang te krijgen tot deze service:

De Nginx-service kan openbaar toegankelijk zijn op internet vanaf het openbare IP-adres. U kunt het IP-adres van uw worker-node’s toevoegen als your_public_ip. Voeg de onderstaande regels toe onder spec.externalIPs:

Uw nginx_service.yaml bestand zou er als volgt uit moeten zien zodra u alle bovenstaande stappen hebt voltooid:

Sla het bestand op en sluit het nadat u alle vereiste parameters hierboven hebt toegevoegd.

De kubectl-opdracht toepassen om de Nginx-service te maken

U zou de onderstaande uitvoer moeten zien voor de bovenstaande opdracht:
Voer nu de volgende opdracht uit om al uw actieve services te bekijken:
Door de bovenstaande opdracht uit te voeren, zou u zowel uw PHP-FPM- als Nginx-services actief moeten zien:
Let op: als u een van uw actieve services wilt verwijderen, kunt u de onderstaande opdracht uitvoeren:

Stap 2: Lokale opslag en Persistent Volume maken

Kubernetes biedt verschillende opslag-plug-ins die u helpen bij het maken van opslagruimte voor uw omgeving. Deze stap legt uit hoe u een lokale StorageClass maakt en hoe deze Storage Class verder kan worden gebruikt voor het maken van een Persistent Volume.

Een lokale opslag maken

Maak een bestand, bijvoorbeeld storageClass.yaml, in uw editor:

Voeg kind toe als "storageClass" en apiVersion als "storage.k8s.io/v1" als volgt:

Geef deze StorageClass de naam "my-local-storage" en voeg provisioner en volumeBindingMode als volgt toe:

Sla het bestand op en sluit het af. Uw uiteindelijke storageClass.yaml-bestand zou er als volgt uit moeten zien:

Maak nu de StorageClass aan door de opdracht kubectl create uit te voeren, zoals hieronder:

Na het uitvoeren van de bovenstaande opdracht, zou u de onderstaande uitvoer moeten krijgen:

Lokaal Persistent Volume maken

Na het maken van de lokale opslag kunt u uw lokale Persistent Volume maken. Een Persistent Volume, ook wel bekend als PV, is de blokopslag met een specifieke grootte die onafhankelijk is van de levenscyclus van een pod. Een lokaal Persistent Volume is niets anders dan een lokale schijf of een map die beschikbaar is op een Kubernetes-clusternode. Dit lokale Persistent Volume stelt gebruikers in staat om op een zeer eenvoudige maar draagbare manier toegang te krijgen tot de lokale opslag met behulp van een lokale Persistent Volume Claim. U kunt dit lokale Persistent Volume maken met behulp van de storage class die we zojuist hebben gemaakt. Open een bestand, bijvoorbeeld persistentVolume.yaml, in uw editor:

Geef dit persistent volume een naam, bijvoorbeeld "my-local-pv":

U kunt opslagcapaciteit toevoegen op basis van uw gebruik tijdens het maken van een lokaal Persistent Volume. In deze handleiding gebruiken we 5 Gi voor de opslag:

Voeg de accessModes en persistentVolumeReclaimPolicy toe, en geef dezelfde storageClassName op als gebruikt in storageClass.yaml:

Voeg de local.path voor uw Persistent Volume toe zoals hieronder:

Na het toevoegen van alle vereiste velden, zou uw persistentVolume.yaml-bestand er als volgt uit moeten zien:

Lokaal volume voorbereiden

Nu moeten we een lokaal volume voorbereiden op de “worker”-node, zoals we hebben toegevoegd in het persistentVolume.yaml-bestand. Voer de onderstaande commando's uit op de node die u hebt geconfigureerd in persistentVolume. In dit geval is dat de “worker”-node:

Voer het onderstaande commando uit op de master-node waar uw persistentVolume.yaml-bestand aanwezig is:

U zou de onderstaande uitvoer moeten krijgen:

Aangezien u met succes uw lokale opslag en Persistent Volume hebt gemaakt, kunt u nu doorgaan en een Persistent Volume Claim maken om uw applicatiecode en configuratiebestanden te bevatten.

Stap 3: Maak het Persistent Volume

Uw applicatiecode moet veilig worden bewaard terwijl u uw pods beheert of bijwerkt. Hiervoor gebruikt u het Persistent Volume dat in de vorige stap is gemaakt en dat wordt geopend met behulp van een PersistentVolumeClaim, of PVC. Deze PVC koppelt de PV aan op het vereiste pad.

Open een bestand, bijvoorbeeld code_volume.yaml, in uw editor:

Geef uw PVC de naam code door de onderstaande parameters en waarden aan uw bestand toe te voegen:

De spec-sectie van een PVC bevat de volgende items:

1. accessModes: Er zijn verschillende mogelijke waarden voor dit veld, als volgt:
   • ReadWriteOnce – Koppelt het volume aan voor een enkele node met zowel lees- als schrijfrechten.
   • ReadOnlyMany – Koppelt het volume aan voor meerdere nodes met alleen leesrechten.
   • ReadWriteMany – Koppelt het volume aan voor meerdere nodes met zowel lees- als schrijfrechten.
2. resources: Definieert de vereiste opslagruimte.

Aangezien de lokale opslag aan slechts één node is gekoppeld, moet u de accessMode instellen op ReadWriteOnce. In deze tutorial voegt u slechts een klein stukje applicatiecode toe, waardoor 1 GB opslagruimte hier voldoende is. Als u echter een grotere hoeveelheid gegevens of code wilt opslaan, kunt u de parameter storage aanpassen aan uw vereisten. Houd er rekening mee dat zodra het volume is gemaakt, u de opslaggrootte kunt vergroten. Het verkleinen ervan wordt echter niet ondersteund:

Declareer nu de storage class die het Kubernetes-cluster zal gebruiken om aan de volumes toe te wijzen. Gebruik hier de my-local-storage storage class, die in de vorige stap is gemaakt, voor uw storageClassName:

Na het voltooien van de bovenstaande stappen, zou uw code_volume.yaml-bestand er als volgt uit moeten zien:

Sla het bestand nu op en sluit het af.

PVC aanmaken

Maak de code-PVC aan door het kubectl apply-commando uit te voeren:

U zou de volgende uitvoer moeten krijgen die aangeeft dat het object succesvol is gemaakt en klaar is om uw 1GB PVC als volume te kunnen koppelen:

U kunt het volgende commando uitvoeren om het beschikbare Persistent Volume (PV) te controleren:

De uitvoer van het bovenstaande commando zou als volgt moeten zijn:

Alle bovenstaande velden, behalve Reclaim Policy en Status, zijn een overzicht van uw configuratiebestand. De Reclaim Policy definieert wat er met de PV gebeurt zodra de PVC die er toegang toe heeft, wordt verwijderd. De waarde Delete verwijdert de PV uit het Kubernetes-cluster en uit de opslaginfrastructuur. U kunt verwijzen naar de Kubernetes PV-documentatie om een duidelijk begrip te krijgen van Reclaim Policy en Status.

U kunt nu uw pods maken met behulp van een Deployment, aangezien u met succes uw Persistent Volume hebt gemaakt met behulp van de lokale opslag.

Step 4: Deployment maken voor uw PHP-FPM-applicatie

Deze stap helpt u bij het maken van uw PHP-FPM-pod met behulp van Deployment. Deployment gebruikt ReplicaSets om een stabiele manier te bieden om uw pods te maken, bij te werken en te beheren. Een Deployment rolt zijn pods automatisch terug naar een vorig image.

De spec.selector-sleutel in de Deployment toont alle labels van de pods die deze beheert. Het gebruikt ook de template-sleutel om de pods te maken die vereist zijn.

In deze stap introduceren we ook de toepassing van Init Containers. De Init Containers voeren een paar commando's uit vóór de reguliere containers die zijn gespecificeerd onder de template van de pod. Hier zal de Init Container GitHub Gist (https://gist.github.com/) gebruiken om een voorbeeld index.php-bestand op te halen. De inhoud van het voorbeeldbestand is:

PHP-deployment maken

Open een nieuw bestand genaamd php_deployment.yaml in uw editor om uw Deployment te maken:

Noem het Deployment-object nu PHP, aangezien deze Deployment uw PHP-FPM-pods zal beheren. Voeg het label toe tier: backend omdat de pod tot de backend-tier zal behoren:

Geef met de parameter replica het aantal kopieën van deze pod op dat moet worden gemaakt. Het aantal replica's kan variëren afhankelijk van uw vereisten en de beschikbare bronnen. In deze handleiding maakt u slechts één replica van uw pod:

Voeg app: php en tier:backend labels toe onder de selector-sleutel die geeft aan dat deze Deployment pods zal beheren die overeenkomen met deze twee labels:

Nu heeft de objectdefinitie van uw pod een template nodig onder uw Deployment-spec. Deze template definieert de specificatie die nodig is om uw pod te maken. Voeg om te beginnen de labels toe die zijn opgegeven voor de php-serviceselector en de matchLabels van de Deployment. Voeg vervolgens app:php en tier:backend toe onder template.metadata.labels:

First, you need to specify all the volumes that your containers will access. Name this volume code as you had created a PVC named code to hold your application code:

Geef vervolgens de containernaam op, samen met de image die u in uw pod wilt uitvoeren. Er zijn verschillende images beschikbaar in de Docker-store (https://hub.docker.com/explore/), maar in deze handleiding gebruiken we de php:7-fpm image:

Koppel nu de volumes waartoe de container toegang nodig heeft. Aangezien deze container uw php-code zal uitvoeren, heeft deze toegang nodig tot het code-volume dat in de vorige stap is gemaakt. In deze stap leert u ook hoe u uw applicatiecode kunt kopiëren met behulp van een Init Container.

Om de code te downloaden, leert deze handleiding u hoe u een enkele Init Container met busybox gebruikt. Busybox is een kleine container met het hulpprogramma wget dat u hiervoor zult gebruiken.

Voeg eerst uw initContainer toe onder spec.template.spec en geef de busybox-image op:

Om vervolgens de code in het code-volume te downloaden, heeft uw Init Container hier toegang toe nodig. Koppel het code-volume op het pad /code onder spec.template.spec.initContainers:

Elke Init Container moet een opdracht uitvoeren. Deze Init Container zal wget gebruiken om de code te downloaden van Github naar de map /code directory. U kunt een optie -O meegeven om dit gedownloade bestand een naam te geven, en u kunt dit bestand index.php.

Voeg daarnaast de onderstaande regels toe onder install container in spec.template.spec.initContainers:

Nadat u al deze stappen heeft voltooid, zou uw php_deployment.yaml-bestand er als volgt uit moeten zien:

U kunt het bestand nu opslaan en sluiten. Maak vervolgens uw PHP-FPM Deployment aan met behulp van het kubectl apply-commando:

Een succesvolle creatie van de Deployment zou u de onderstaande uitvoer moeten geven:

Deze Deployment begint met het downloaden van de gespecificeerde images, vraagt vervolgens de PersistentVolume aan van uw PersistentVolumeClaim, en voert vervolgens uw initContainers uit. Zodra deze stap is voltooid, worden de containers uitgevoerd en worden de volumes op het opgegeven koppelpunt gekoppeld. Na het voltooien van al deze stappen is uw pod actief en operationeel.

U kunt het onderstaande commando uitvoeren om uw Deployment te bekijken:

Na het uitvoeren van het bovenstaande commando zou u de onderstaande uitvoer moeten krijgen:

U kunt de huidige status van de Deployment begrijpen met behulp van deze uitvoer. Een Deployment is een controller die de gewenste status behoudt. Het DESIRED-veld geeft aan dat het 1 replica heeft van de pod genaamd php. Het CURRENT-veld geeft aan hoeveel replica's van de DESIRED-status momenteel actief zijn. Voor een gezonde pod moet dit overeenkomen met de DESIRED-status. U kunt meer lezen over de overige velden in de Kubernetes Deployments-documentatie.

Om daarna de status van uw actieve pod te controleren, kunt u het onderstaande commando uitvoeren:

De uitvoer van dit commando kan variëren afhankelijk van de tijd die is verstreken sinds u uw Deployment heeft gemaakt. Als het kort na het maken van de Deployment wordt uitgevoerd, zal de uitvoer vergelijkbaar zijn met:

Uitleg:

Deze kolommen vertegenwoordigen de informatie als volgt:

• Ready: Het aantal huidige/gewenste replica's dat deze pod uitvoert.
• Status: De status van uw pod. Init:0/1 geeft aan dat de Init Containers actief zijn en 0 van de 1 Init Containers zijn voltooid.
• Restarts: Dit geeft het aantal keren aan dat dit proces opnieuw is opgestart om de pod te starten.

Het kan een paar minuten duren voordat de status van uw pod verandert in podInitializing afhankelijk van de complexiteit van uw opstartscripts:

Dit geeft aan dat de Init Containers met succes zijn uitgevoerd en dat de containers nu worden geïnitialiseerd:

Zoals u nu kunt zien, is uw pod actief en operationeel. Mocht uw pod echter niet starten, dan kunt u de onderstaande opdrachten uitvoeren voor foutopsporing:

1. Om gedetailleerde informatie over de pod te bekijken:

2.  Om de logs van de pod te bekijken:

3. Om de logs van een specifieke container in de pod te bekijken:

Gefeliciteerd! U hebt de applicatiecode met succes gekoppeld en de PHP-FPM-service is gereed om verbindingen af te handelen. Op vergelijkbare wijze kunt u uw Nginx Deployment maken.

Stap 5: Maak uw Nginx Deployment

In deze stap leert u hoe u Nginx configureert met behulp van een ConfigMap. Een ConfigMap slaat al uw vereiste configuraties op in een sleutel-waarde-indeling die in andere Kubernetes-objectdefinities wordt gebruikt. Met deze aanpak hebt u de flexibiliteit om de Nginx-image te hergebruiken of te vervangen door een andere versie, wanneer dat nodig is. U kunt de ConfigMap bijwerken en deze wijzigingen worden automatisch doorgevoerd in elke pod die deze ConfigMap.

Open om te beginnen een nginx_configmap.yaml-bestand in uw editor:

Noem deze ConfigMap nu nginx-config en voeg deze toe aan de tier: backend microservice:

Daarnaast kunt u de gegevens toevoegen aan de ConfigMap. Voeg een sleutel met de naam config toe en voeg de volledige inhoud van het Nginx-configuratiebestand toe als waarde.

Omdat het voor Kubernetes mogelijk is om verzoeken naar de respectieve hosts voor een service te routeren, kunt u de naam van uw PHP-FPM-service invoeren onder de fastcgi_pass parameter in plaats van het IP-adres. Voeg de volgende regels code toe aan uw nginx_configMap.yaml-bestand:

Zodra dit is voltooid, zal uw nginx_configMap.yaml-bestand er als volgt uitzien:

U kunt de editor nu opslaan en afsluiten. Voer nu de kubectl apply opdracht voor het maken van de ConfigMap:

Daarna zou u de onderstaande uitvoer op uw scherm moeten zien:

U hebt met succes uw Nginx Configmap gemaakt. Nu kunt u uw Nginx Deployment maken.

Nginx Deployment maken

Om beginnen kunt u een nieuw bestand maken met de naam nginx_deployment.yaml in de editor:

Geef deze Deployment de naam nginx en voeg het tier: backend-label eraan toe:

Geef daarna het aantal replica's op door het veld replica toe te voegen in de Deployment-spec en voeg de labels app: nginx en tier: backend eraan toe:

Voeg op dezelfde manier de pod-template toe. Zorg ervoor dat u dezelfde labels toevoegt als die u had toegevoegd in de selector.matchLabels van de Deployment. U kunt het volgende toevoegen:

Geef Nginx toegang tot de eerder gemaakte code-PVC door de volgende parameters toe te voegen onder spec.template.spec.volumes:

Waarschuwing: De inhoud van de sleutel vervangt de mountPath van het volume als er geen bestand is opgegeven. Met andere woorden, u verliest alle inhoud in de doelmap als er niet expliciet een pad is opgegeven.

Geef nu de naam, image en poort op die u in uw pod wilt gebruiken. Hier gebruiken we de nginx:1.7.9 image en poort 80. Voeg ze toe onder spec.template.spec sectie:

Koppel ook het code-volume aan op /code omdat zowel Nginx als PHP-FPM toegang moeten hebben tot het bestand op hetzelfde pad:

De nginx-1.7.9-image laadt automatisch elk configuratiebestand onder de map /etc/nginx/conf.d. Als we nu het config-volume in deze map koppelen, wordt /etc/nginx/conf.d/site.conf gemaakt. Voeg het volgende toe onder de volumeMount-sectie:

Na het voltooien van alle bovenstaande stappen zou je nginx_deployment.yaml-bestand er zo uit moeten zien:

Je kunt het bestand nu opslaan en sluiten en de Nginx Deployment maken door de volgende opdracht uit te voeren:

Na succesvolle uitvoering van de opdracht zou je de volgende uitvoer moeten zien:

Je kunt al je Deployments bekijken door de onderstaande opdrachten uit te voeren:

Je zou nu zowel de Nginx- als de PHP-FPM-Deployments moeten zien:

Bovendien kunt u het volgende commando uitvoeren om de pods op te sommen die worden beheerd door beide hierboven genoemde Deployments:

U zult zien dat beide pods actief zijn en draaien zoals hieronder:

Aangezien al uw Kubernetes-objecten op dit moment actief zijn, kunt u nu de Nginx-service in uw browser openen.

Voer het volgende commando uit om de services op te sommen:

Noteer het External IP van uw Nginx-service:

Nu kunt u, met behulp van dit External IP van de Nginx-service, uw server bezoeken door het typen van http://your_public_ip in uw browser. U zou de uitvoer moeten kunnen zien van php_info() die bevestigt dat uw Kubernetes-services actief zijn en draaien.

Conclusie

In deze handleiding hebt u de twee services gecontaineriseerd om uw PHP-FPM- en Nginx-services onafhankelijk te beheren. Hierdoor verbetert u niet alleen de schaalbaarheid van uw project, maar gebruikt u uw resources ook efficiënt. U hebt ook geleerd hoe u lokale opslag en een Persistent Volume maakt om uw applicatiecode op een volume op te slaan en uw services in de toekomst eenvoudig te kunnen updaten. Hiermee hebt u de bruikbaarheid en het onderhoud van uw code verbeterd.

Bekijk daarnaast ook onze andere handleidingen over Docker en Kubernetes die u kunt vinden op onze blog:

• Kennismaken met Kubernetes
• Een Kubernetes-cluster maken met Kubeadm op Ubuntu 18.04
• Docker-bronnen opschonen – Images, Containers en Volumes
• Laravel, Nginx en MySQL implementeren met Docker Compose
• Docker installeren & beheren op Ubuntu in de openbare cloud

Veel computerplezier!