*L'auteur a choisi le Diversity in Tech Fund pour recevoir un don dans le cadre du programme Write for DOnations.*

Introduction

Laravel est l'une des infrastructures d'application PHP les plus populaires aujourd'hui. Son déploiement se fait généralement avec une base de données MySQL, mais il peut être configuré pour utiliser une variété d'options de stockage de données de backend. Laravel est fier de profiter des nombreuses fonctionnalités modernes de PHP et de son vaste écosystème complet de package.

Kubernetes est une plate-forme d'orchestration de conteneurs qui peut être hébergée sur des Kubernetes clusters afin de simplifier la gestion et la configuration de conteneurs en production. Helm est un gestionnaire de packages Kubernetes qui facilite la configuration et l'installation des services et des pods sur Kubernetes.

Dans ce guide, vous allez créer une application Laravel PHP, développer votre application dans une image Docker et déployer cette image dans un cluster Kubernetes en utilisant le LAMP Helm chart. Ensuite, vous configurerez un contrôleur d'entrée pour ajouter SSL et un nom de domaine personnalisé à votre application. Une fois terminé, vous disposerez d'une application Laravel fonctionnelle connectée à une base de données MySQL qui s'exécute sur un cluster Kubernetes.

Conditions préalables

Docker installé sur la machine à partir de laquelle vous accédez à votre cluster. Vous pouvez trouver des instructions détaillées sur l'installation de Docker pour la plupart des distributions Linux ici ou sur le site web de Docker pour d'autres systèmes d'exploitation.

Un compte sur Docker Hub pour stocker les images Docker que vous allez créer pendant ce tutoriel.

Un cluster Kubernetes 1.17+ avec votre connexion configurée sur kubectl par défaut. Pour apprendre à créer un cluster Kubernetes sur the cloud provider, voir notre Kubernetes Quickstart. Pour apprendre à se connecter au cluster, consultez Comment se connecter à un cluster Kubernetes.

Le gestionnaire de paquets Helm 3 installé sur votre machine locale. Exécutez la première étape et ajoutez le référentiel stable à partir de la deuxième étape du tutoriel Comment installer un logiciel sur des clusters Kubernetes avec le Helm 3 Package Manager.

Un nom de domaine entièrement enregistré avec un enregistrement A disponible. Ce tutoriel utilisera <^>your_domain<^>. Vous pouvez acheter un nom de domaine sur Namecheap, en obtenir un gratuitement sur Freenom, ou utiliser le bureau d'enregistrement de domaine de votre choix. Pour le moment, ne vous souciez pas d'associer l'enregistrement A de votre domaine à un IP. Une fois que vous serez à l'étape 5 et que votre contrôleur Ingress est opérationnel, vous connecterez alors <^>your_domain<^> à l'IP qui convient.

Étape 1 — Création d'une nouvelle application Laravel

Au cours de cette étape, vous utiliserez Docker pour créer une nouvelle application Laravel 7. Cependant, vous devriez pouvoir suivre le même processus avec une application Laravel existante qui utilise MySQL comme base de données de sauvegarde. La nouvelle application que vous créez vérifiera que Laravel est bien connecté à la base de données et affichera le nom de la base de données.

Tout d'abord, allez dans votre répertoire principal. Ensuite, créez une nouvelle application Laravel à l'aide d'un conteneur Docker composer :

				
					
cd ~

docker run --rm -v $(pwd):/app composer create-project --prefer-dist laravel/laravel laravel-kubernetes

Une fois le conteneur créé et tous les paquets Composer installés, vous devriez voir une nouvelle installation de Laravel dans votre répertoire actuel sous le nom de laravel-kubernetes/. Allez dans ce dossier :

				
					
cd ~/laravel-kubernetes

Vous exécuterez le reste des commandes de ce tutoriel à partir de là.

Cette application a pour rôle de tester votre connexion à la base de données et d'afficher son nom dans votre navigateur. Pour tester la connexion à la base de données, ouvrez le fichier ./resources/views/welcome.blade.php dans un éditeur de texte :

				
					
nano ./resources/views/welcome.blade.php

Trouvez la section <div class="links">...</div> et remplacez son contenu par ce qui suit :

				
					
[label ./resources/views/welcome.blade.php]

...

&lt;div class="links"&gt;

   &lt;^&gt;&lt;strong&gt;Database Connected: &lt;/strong&gt;&lt;^&gt;

    &lt;^&gt;@php&lt;^&gt;

        &lt;^&gt;try {&lt;^&gt;

            &lt;^&gt;DB::connection()-&gt;getPDO();&lt;^&gt;

            &lt;^&gt;echo DB::connection()-&gt;getDatabaseName();&lt;^&gt;

            &lt;^&gt;} catch (\Exception $e) {&lt;^&gt;

            &lt;^&gt;echo 'None';&lt;^&gt;

        &lt;^&gt;}&lt;^&gt;

    &lt;^&gt;@endphp&lt;^&gt;

&lt;/div&gt;

...

Enregistrez et fermez le fichier.

Voilà l'intégralité de la personnalisation que vous devez apporter à l'application Laravel par défaut dans le cadre de ce tutoriel. Une fois terminé, ce bref extrait de PHP testera votre connexion à la base de données et affichera le nom de la base de données sur l'écran de démarrage de Laravel dans votre navigateur web.

À l'étape suivante, vous utiliserez Docker pour créer une image contenant cette application Laravel et Docker Compose afin de tester son exécution locale et sa connexion à une base de données MySQL.

Étape 2 — Conteneurisation de votre application Laravel

Maintenant que vous avez créé une nouvelle application Laravel, vous devez créer votre code sur une image Docker, puis tester l'image avec Docker Compose. Bien que ce tutoriel ait pour objectif de vous apprendre à déployer votre application sur un cluster Kubernetes, Docker Compose est un moyen pratique de tester votre image et votre configuration Docker localement avant de l'exécuter dans le cloud. Cette boucle de rétroaction rapide peut s'avérer très utile pour effectuer et tester de petits changements.

Tout d'abord, en utilisant nano ou votre éditeur de texte préféré, créez un fichier à la racine de votre application Laravel que vous appelerez Dockerfile :

				
					
nano ./Dockerfile

Ajoutez le contenu suivant. Docker utilisera ce fichier pour créer votre code dans une image :

				
					
[label ./Dockerfile]

FROM php:7.4-apache



# Install packages

RUN apt-get update &amp;&amp; apt-get install -y \

    git \

    zip \

    curl \

    sudo \

    unzip \

    libicu-dev \

    libbz2-dev \

    libpng-dev \

    libjpeg-dev \

    libmcrypt-dev \

    libreadline-dev \

    libfreetype6-dev \

    g++



# Apache configuration

ENV APACHE_DOCUMENT_ROOT=/var/www/html/public

RUN sed -ri -e 's!/var/www/html!${APACHE_DOCUMENT_ROOT}!g' /etc/apache2/sites-available/*.conf

RUN sed -ri -e 's!/var/www/!${APACHE_DOCUMENT_ROOT}!g' /etc/apache2/apache2.conf /etc/apache2/conf-available/*.conf

RUN a2enmod rewrite headers



# Common PHP Extensions

RUN docker-php-ext-install \

    bz2 \

    intl \

    iconv \

    bcmath \

    opcache \

    calendar \

    pdo_mysql



# Ensure PHP logs are captured by the container

ENV LOG_CHANNEL=stderr



# Set a volume mount point for your code

VOLUME /var/www/html



# Copy code and run composer

COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

COPY . /var/www/tmp

RUN cd /var/www/tmp &amp;&amp; composer install --no-dev



# Ensure the entrypoint file can be run

RUN chmod +x /var/www/tmp/docker-entrypoint.sh

ENTRYPOINT ["/var/www/tmp/docker-entrypoint.sh"]



# The default apache run command

CMD ["apache2-foreground"]

Enregistrez et fermez le fichier.

Ce Dockerfile commence avec le PHP 7.4 Apache Docker Image que se trouve sur Docker Hub, puis installe plusieurs des paquets Linux qui sont généralement nécessaires aux applications Laravel. Ensuite, il crée des fichiers de configuration Apache et active les réécritures d'en-tête. Le Dockerfile installe plusieurs extensions PHP communes et ajoute une variable d'environnement afin que les journaux de Laravel soient bien acheminés vers le conteneur via stderr. Cela vous permettra de consulter les journaux Laravel en personnalisant vos journaux Docker Compose ou Kubernetes.

Enfin, le Dockerfile copie tous les codes de votre application Laravel sur /var/www/tmp et installe les dépendances Composer. Il définit ensuite un ENTRYPOINT, mais vous aurez besoin de créer ce fichier, ce que nous allons faire ensuite.

Dans le répertoire racine de votre projet, créez un nouveau fichier que vous appellerez docker-entrypoint.sh. Ce fichier s'exécutera lorsque votre conteneur sera exécuté localement ou dans le cluster Kubernetes. Il copiera ensuite votre code d'application Laravel du répertoire /var/www/tmp dans /var/www/html où Apache sera capable de le servir.

				
					
nano ./docker-entrypoint.sh

Maintenant, ajoutez le script suivant :

				
					
[label ./docker-entrypoint.sh]

#!/bin/bash



cp -R /var/www/tmp/. /var/www/html/

chown -R www-data:www-data /var/www/html



exec "$@"

La ligne finale, exec "$@" indique au shell d'exécuter toute commande ensuite passée à titre d'argument de l'entrée. Ceci est important car Docker doit continuer à exécuter la commande d'exécution d'Apache (apache2-foreground) une fois ce script exécuté. Enregistrez et fermez le fichier.

Ensuite, créez un fichier .dockerignore dans le répertoire racine de votre application. Lors de la création de votre image Docker, ce fichier veillera à ce qu'elle ne soit pas polluée par des paquets ou des fichiers d'environnement qui ne devraient pas y être copiés :

				
					
nano ./.dockerignore

				
					
[label ./.dockerignore]

.env

/vendor

Enregistrez et fermez le fichier.

Avant de pouvoir exécuter votre application localement avec Docker Compose, vous devez créer un dernier fichier nommé docker-compose.yml. Mais, lors de la configuration de ce fichier YAML, vous devez saisir la APP_KEY générée par Laravel lors de l'installation. Trouvez-la en ouvrant et en faisant une recherche dans le fichier . /.env ou en exécutant les commandes chat et grep suivantes :

				
					
cat .env | grep ^APP_KEY

Vous verrez un résultat similaire à ce qui suit :

				
					
[secondary_label Output]

APP_KEY=&lt;^&gt;base64:0EHhVpgg ... UjGE=&lt;^&gt;

Copiez votre clé dans votre presse-papiers. Veillez à bien inclure le préfixe base64: Maintenant, créez le fichier docker-compose.yml dans le répertoire racine de votre application :

				
					
nano ./docker-compose.yml

Ici, nous allons inclure l'image PHP de votre application Laravel ainsi qu'un conteneur MySQL pour exécuter votre base de données. Ajoutez le contenu suivant :

				
					
[label ./docker-compose.yml]

version: '3.5'

services:

  php:

    image: &lt;^&gt;your_docker_hub_username&lt;^&gt;/laravel-kubernetes:latest

    restart: always

    ports:

      - 8000:80

    environment:

      - APP_KEY="&lt;^&gt;your_laravel_app_key&lt;^&gt;"

      - APP_ENV=local

      - APP_DEBUG=true

      - DB_PORT=3306

      - DB_HOST=mysql

      - DB_DATABASE

      - DB_USERNAME

      - DB_PASSWORD

  mysql:

    image: mysql:5.7

    restart: always

    environment:

      - MYSQL_ROOT_PASSWORD=${DB_ROOT_PASSWORD}

      - MYSQL_DATABASE=${DB_DATABASE}

      - MYSQL_USER=${DB_USERNAME}

      - MYSQL_PASSWORD=${DB_PASSWORD}

Utilisez la variable APP_KEY que vous avez copiée dans votre presse-papiers pour la variable <^>your_laravel_app_key<^> et utilisez votre nom d'utilisateur Docker Hub pour la variable <^>your_docker_hub_username<^>. Enregistrez et fermez le fichier.

Vous allez créer la première image localement en utilisant docker build. La deuxième image est l'image officielle de MySQL Docker, disponible sur Docker Hub. Toutes deux nécessitent plusieurs variables d'environnement que vous allez inclure lors de l'exécution des conteneurs.

Pour créer l'image Docker qui contient votre application Laravel, exécutez la commande suivante. Veillez à bien remplacer <^>your_docker_hub_username<^> par votre nom d'utilisateur ou le nom d'utilisateur de votre équipe dans Docker Hub où cette image sera sauvegardée :

				
					
docker build -t &lt;^&gt;your_docker_hub_username&lt;^&gt;/laravel-kubernetes:latest .

Ensuite, vous pouvez exécuter les deux conteneurs avec Docker Compose et les identifiants de base de données nécessaires :

				
					
DB_ROOT_PASSWORD=rootpassword DB_DATABASE=local_db DB_USERNAME=admin DB_PASSWORD=password docker-compose up -d

Au besoin, vous pouvez modifier les quatre variables d'environnement utilisées ici (DB_ROOT_PASSWORD, DB_DATABASE, DB_USERNAME, DB_PASSWORD). Cependant, étant donné vous testez votre application que localement, inutile de les sécuriser pour le moment.

Il vous faudra près de 30 secondes pour que votre base de données MySQL soit initialisée et que vos conteneurs soient prêts. Une fois que cela est fait, vous pouvez consulter votre application Laravel sur votre machine sur localhost:8000.

Votre application PHP se connectera à votre base de données MySQL. Une fois connecté, vous verrez apparaître le texte « Database Connected: local_db » apparaître sous le logo Laravel.

Maintenant que vous avez testé votre image Docker localement avec Docker Compose, vous pouvez arrêter les conteneurs en exécutant docker-compose down :

				
					
docker-compose down

Dans la section suivante, vous allez pousser votre image Docker sur Docker Hub afin que votre chart Helm puisse l'utiliser et déployer votre application dans votre cluster Kubernetes.

Étape 3 — Poussez votre image Docker dans Docker Hub

Votre code doit être disponible dans un registre de conteneurs pour que le chart Helm LAMP que vous utiliserez puisse le déployer sur Kubernetes. Bien que vous puissiez pousser votre image dans un registre privé ou autohébergé, aux fins de ce tutoriel, vous utiliserez un registre Docker public et gratuit sur Docker Hub.

Accédez à votre compte dans Docker Hub en utilisant votre navigateur web. Créez ensuite un nouveau référentiel nommé laravel-kubernetes.

Si vous n'êtes pas connecté à Docker Hub depuis votre machine locale, vous devez ensuite vous y connecter. Vous pouvez le faire grâce à la ligne de commande suivante :

				
					
docker login -u &lt;^&gt;your_docker_hub_username&lt;^&gt;

Saisissez vos identifiants de connexion lorsque vous serez invité à le faire. Il est généralement nécessaire de le faire qu'une seule fois par machine. En effet, Docker enregistrera vos identifiants dans ~/.docker/config.json dans votre répertoire personnel.

Enfin, poussez votre image dans Docker Hub :

				
					
docker push &lt;^&gt;your_docker_hub_username&lt;^&gt;/laravel-kubernetes:latest

En fonction de la vitesse de votre connexion, le téléchargement de votre application peut prendre quelques minutes. Cependant, une fois Docker terminé, vous verrez un hachage cryptographique et la taille de votre image dans le terminal. Elle ressemblera à cela :

				
					
[secondary_label Output]

latest: digest: sha256:df4bdeda91484c8c26a989b13b8f27ab14d93ab2e676e3c396714cb3811c4086 size: 4918

Maintenant que votre application Laravel est conteneurisée et que vous avez poussé une image dans Docker Hub, vous pouvez utiliser l'image dans un déploiement de chart Helm ou Kubernetes. Au cours de la prochaine étape, vous allez configurer des valeurs personnalisées en fonction du chart LAMP Helm et le déployer dans votre cluster Kubernetes.

Étape 4 — Configuration et déploiement de l'application avec chart LAMP Helm

Helm propose un certain nombre de Charts pour vous aider à configurer des applications Kubernetes en utilisant des combinaisons d'outils prédéfinies. Même si vous pouvez écrire vos propres fichiers de service Kubernetes pour effectuer un déploiement similaire, dans cette section vous verrez que l'utilisation d'un chart Helm nécessite beaucoup moins de configuration.

Tout d'abord, vous aurez besoin d'un répertoire pour y stocker tous vos fichiers de configuration Helm. Créez un nouveau répertoire dans la racine de votre projet Laravel que vous nommerez helm/ :

				
					
mkdir ./helm

Dans le répertoire helm/, vous allez créer deux nouveaux fichiers : values.yml et secrets.yml. Commencez par créer et ouvrir values.yml :

				
					
nano ./helm/values.yml

Le fichier values.yml comprendra des options de configuration non secrètes qui remplaceront les valeurs par défaut dans le chart LAMP Helm. Ajoutez les configurations suivantes, tout en veillant bien à remplacer <^>your_docker_hub_username<^> par votre nom d'utilisateur :

				
					
[label ./helm/values.yml]

php:

  repository: "&lt;^&gt;your_docker_hub_username&lt;^&gt;/laravel-kubernetes"

  tag: "latest"

  fpmEnabled: false

  envVars:

    - name: APP_ENV

      value: production

    - name: APP_DEBUG

      value: false

    - name: DB_PORT

      value: 3306

    - name: DB_HOST

      value: localhost

Enregistrez et fermez le fichier.

Maintenant, créez un fichier secrets.yml :

				
					
nano ./helm/secrets.yml

secrets.yml ne sera pas archivé dans le contrôle de version. Il contiendra des informations de configuration sensibles comme votre mot de passe et votre clé d'app Laravel. Ajoutez les configurations suivantes, en les ajustant au besoin pour qu'elles soient adaptées à vos identifiants :

				
					
[label ./helm/secrets.yml]

mysql:

  rootPassword: "&lt;^&gt;your_database_root_password&lt;^&gt;"

  user: &lt;^&gt;your_database_user&lt;^&gt;

  password: "&lt;^&gt;your_database_password&lt;^&gt;"

  database: &lt;^&gt;your_database_name&lt;^&gt;



php:

  envVars:

    - name: APP_KEY

      value: "&lt;^&gt;your_laravel_app_key&lt;^&gt;"

    - name: DB_DATABASE

      value: &lt;^&gt;your_database_name&lt;^&gt;

    - name: DB_USERNAME

      value: &lt;^&gt;your_database_user&lt;^&gt;

    - name: DB_PASSWORD

      value: "&lt;^&gt;your_database_password&lt;^&gt;"

Veillez à utiliser des combinaisons de noms d'utilisateur et de mot de passe difficiles à trouver pour votre base de données de production. Utilisez la même <^>your_laravel_app_key<^> que celle indiquée ci-dessus. Sinon, ouvrez une nouvelle fenêtre et générez un nouveau fichier en exécutant la commande suivante. Vous pouvez ensuite copier la nouvelle valeur configurée par Laravel dans votre fichier .env :

				
					
docker run --rm -v $(pwd):/app php:cli php /app/artisan key:generate

Sauvegardez et fermez secrets.yml.

Ensuite, afin d'empêcher votre fichier secrets.yml d'être intégré à l'image Docker ou d'être sauvegardé dans le contrôle de version, veillez à bien ajouter la ligne suivante à la fois dans vos fichiers .dockerignore et .gitignore. Ouvrez et ajoutez /helm/secrets.yml dans chaque fichier, ou exécutez la commande suivante pour ajouter les deux :

				
					
echo '/helm/secrets.yml' &gt;&gt; ./.dockerignore &amp;&amp; echo '/helm/secrets.yml' &gt;&gt; ./.gitignore

Maintenant que vous avez créé les fichiers de configuration Helm pour votre application et l'image Docker, vous pouvez installer ce chart Helm comme une nouvelle version dans votre cluster Kubernetes. Installez votre chart dans le répertoire racine de votre application :

				
					
helm install laravel-kubernetes -f helm/values.yml -f helm/secrets.yml stable/lamp

Vous verrez un résultat similaire à ce qui suit :

				
					
[secondary_label Output]

NAME: laravel-kubernetes

LAST DEPLOYED: Mon May 18 13:21:20 2020

NAMESPACE: default

STATUS: deployed

REVISION: 1

Il faudra une à deux minutes pour que votre application soit disponible. Cependant, vous pouvez exécuter cette commande pour surveiller les services Kubernetes dans votre cluster :

				
					
kubectl get services -w

Recherchez le nom de votre application :

				
					
[secondary_label Output]

NAME                        TYPE            CLUSTER-IP          EXTERNAL-IP     PORT(S)

laravel-kubernetes-lamp     LoadBalancer    &lt;^&gt;your_cluster_ip&lt;^&gt;      &lt;^&gt;your_external_ip&lt;^&gt;   80:32175/TCP,3306:32243/TCP

Lorsque votre nouveau service laravel-kubernetes-lamp affiche une adresse IP sous EXTERNAL-IP, vous pouvez consulter <^>your_external_ip<^> pour voir l'application qui est exécutée dans votre cluster Kubernetes. Votre application se connectera à votre base de données. Vous verrez alors le nom de la base de données apparaître sous le logo Laravel, comme ce fut le cas lors de l'exécution locale de votre application dans Docker Compose.

L'exécution d'une application web sur une adresse IP non sécurisée est adaptée pour une démonstration de faisabilité. Cependant, votre site web n'est pas prêt à être publié sans certificat SSL et un nom de domaine personnalisé. Avant que vous configuriez cela à l'étape suivante, désinstallez votre version via la ligne de commande suivante :

				
					
helm delete laravel-kubernetes

Au cours de la prochaine étape, vous allez étendre cette première configuration Helm pour ajouter un contrôleur Ingress, un certificat SSL et un domaine personnalisé à votre application Laravel.

Étape 5 — Ajout d'un contrôleur Ingress et SSL à votre cluster Kubernetes

Dans Kubernetes, un contrôleur Ingress est chargé d'exposer les services de votre application sur Internet. À l'étape précédente, le chart LAMP Helm a créé un équilibreur de charge the cloud provider et a exposé votre application directement via l'adresse IP de l'équilibreur de charge.

Vous pourriez résilier SSL et votre nom de domaine directement sur l'équilibreur de charge. Cependant, étant donné que vous travaillez dans Kubernetes, il serait plus pratique de gérer celà au même endroit. Pour plus d'informations sur les contrôleurs Ingress et des détails sur les étapes suivantes, consultez Comment configurer un Ingress Nginx sur Kubernetes en utilisant Helm.

Le chart LAMP Helm intègre une option de configuration pour prendre en charge Ingress. Ouvrez votre fichier helm/values.yml :

				
					
nano ./helm/values.yml

Maintenant, ajoutez les lignes suivantes :

				
					
[label ./helm/values.yml]

...

# Use Ingress Controller

service:

  type: ClusterIP

  HTTPPort: 80

ingress:

  enabled: true

  domain: &lt;^&gt;your_domain&lt;^&gt;

Cela indique à votre déploiement de ne pas installer d'équilibreur de charge et d'exposer l'application dans le port 80 du cluster Kubernetes où le contrôleur Ingress l'exposera sur Internet. Sauvegardez et fermez values.yml.

Maintenant, exécutez la commande helm install que vous avez exécutée précédemment pour que votre application Laravel s'exécute à nouveau. Veillez à exécuter la commande à partir du répertoire racine de votre application :

				
					
helm install laravel-kubernetes -f helm/values.yml -f helm/secrets.yml stable/lamp

Ensuite, installez le contrôleur nginx-ingress sur votre cluster Kubernetes en utilisant le contrôleur Nginx Ingress maintenu sous Kubernetes :

				
					
helm install nginx-ingress stable/nginx-ingress --set controller.publishService.enabled=true

Après l'installation, vous aurez un résultat similaire à ce qui suit :

				
					
[secondary_label Output]

NAME: nginx-ingress

LAST DEPLOYED: Mon May 18 13:28:34 2020

NAMESPACE: default

STATUS: deployed

REVISION: 1

Vous avez également besoin d'une Ressource Ingress pour exposer le déploiement de votre application Laravel. Créez un nouveau fichier dans le répertoire racine de votre application que vous nommerez ingress.yml :

				
					
nano ./ingress.yml

Ce fichier définit l'hôte de votre application, le gestionnaire de certificat SSL, le service de backend et le nom de port de votre application. Ajoutez les configurations suivantes en remplacant <^>your_domain<^> avec le domaine de votre choix :

				
					
[label ./ingress.yml]

apiVersion: networking.k8s.io/v1beta1

kind: Ingress

metadata:

  name: laravel-kubernetes-ingress

  annotations:

    kubernetes.io/ingress.class: nginx

    cert-manager.io/cluster-issuer: letsencrypt-prod

spec:

  tls:

    - hosts:

        - &lt;^&gt;your_domain&lt;^&gt;

      secretName: laravel-kubernetes-tls

  rules:

    - host: &lt;^&gt;your_domain&lt;^&gt;

      http:

        paths:

          - backend:

              serviceName: laravel-kubernetes-lamp

              servicePort: 80

Enregistrez et fermez le fichier.

Ensuite, vous deviez installer Cert-Manager et créer un émetteur qui vous permettra de créer des certificats SSL de production en utilisant Let's Encrypt. Cert-Manager nécessite des Custom Resource Definitions que vous pouvez appliquer à partir du Cert-Manager repository en utilisant la ligne de commande suivante :

				
					
kubectl apply --validate=false -f https://github.com/jetstack/cert-manager/releases/download/v0.15.0/cert-manager.crds.yaml

Cela créera un certain nombre de ressources Kubernetes qui s'afficheront dans la ligne de commande :

				
					
[secondary_label Output]

customresourcedefinition.apiextensions.k8s.io/certificaterequests.cert-manager.io created

customresourcedefinition.apiextensions.k8s.io/certificates.cert-manager.io created

customresourcedefinition.apiextensions.k8s.io/challenges.acme.cert-manager.io created

customresourcedefinition.apiextensions.k8s.io/clusterissuers.cert-manager.io created

customresourcedefinition.apiextensions.k8s.io/issuers.cert-manager.io created

customresourcedefinition.apiextensions.k8s.io/orders.acme.cert-manager.io create

Cert-Manager a également besoin d'un namespace pour l'isoler dans votre cluster Kubernetes :

				
					
kubectl create namespace cert-manager

Vous verrez ce résultat :

				
					
[secondary_label Output]

namespace/cert-manager created

Étant donné que le Cert-Manager de Jetstack ne fait pas partie des charts maintenus par Kubernetes, vous aurez également besoin d'ajouter le référentiel Helm Jetstack. Exécutez la commande suivante pour le rendre disponible dans Helm :

				
					
helm repo add jetstack https://charts.jetstack.io

Si l'ajout est correctement effectué, vous obtiendrez le résultat suivant :

				
					
[secondary_label Output]

"jetstack" has been added to your repositories

Maintenant, vous êtes prêt à installer Cert-Manager dans l'espace de nommage cert-manager de votre cluster Kubernetes :

				
					
helm install cert-manager --version v0.15.0 --namespace cert-manager jetstack/cert-manager

Une fois terminé, vous verrez apparaître un résumé du déploiement similaire à ce qui suit :

				
					
[secondary_label Output]

NAME: cert-manager

LAST DEPLOYED: Mon May 18 13:32:08 2020

NAMESPACE: cert-manager

STATUS: deployed

REVISION: 1

Le dernier fichier que vous devez ajouter dans le répertoire racine de votre application Laravel est un fichier de configuration de Kubernetes production_issuer.yml. Créez le fichier :

				
					
nano ./production_issuer.yml

Maintenant, ajoutez ce qui suit :

				
					
apiVersion: cert-manager.io/v1alpha2

kind: ClusterIssuer

metadata:

  name: letsencrypt-prod

spec:

  acme:

    # Email address used for ACME registration

    email: &lt;^&gt;your_email_address&lt;^&gt;

    server: https://acme-v02.api.letsencrypt.org/directory

    privateKeySecretRef:

      # Name of a secret used to store the ACME account private key

      name: letsencrypt-prod-private-key

    # Add a single challenge solver, HTTP01 using nginx

    solvers:

      - http01:

          ingress:

            class: nginx

Enregistrez et fermez le fichier.

Let's Encrypt enverra toutes les notifications importantes et tous les avertissements d'expiration à <^>your_email_address<^>. Veillez donc à bien ajouter une adresse que vous consultez régulièrement. Sauvegardez ce fichier et créez une nouvelle ressource à la fois pour votre ressource Ingress et votre émetteur de production dans votre cluster Kubernetes :

				
					
kubectl create -f ingress.yml

kubectl create -f production_issuer.yml

Enfin, mettez à jour les enregistrements DNS de votre nom de domaine pour qu'un enregistrement A pointe vers l'adresse IP de votre équilibreur de charge. Pour trouver l'adresse IP de votre contrôleur Ingress, saisissez ce qui suit :

				
					
kubectl get service nginx-ingress-controller

				
					
[secondary_label Output]

NAME                       TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)                      AGE

nginx-ingress-controller   LoadBalancer   &lt;^&gt;your_cluster_ip&lt;^&gt;      &lt;^&gt;your_external_ip&lt;^&gt;   80:30187/TCP,443:31468/TCP   6m10s

Utilisez l'adresse <^>your_external_ip<^> comme adresse IP de votre Enregistrement A de DNS. Le processus de mise à jour de vos enregistrements DNS varie en fonction de l'endroit où vous gérez vos noms de domaine et l'hébergement DNS. Cependant, si vous utilisez the cloud provider, vous pouvez consulter notre guide Comment gérer vos enregistrements DNS.

Une fois que vos enregistrements DNS sont mis à jour et votre certificat SSL est configuré, votre application sera disponible sur <^>your_domain<^> et SSL sera activée.

Même si votre application et votre base de données PHP sont déjà connectées, vous aurez encore besoin de migrer la base de données. Au cours de la dernière étape, vous verrez comment exécuter des Artisan commands sur votre pod Kubernetes pour migrer la base de données et effectuer d'autres tâches de maintenance communes.

Étape 6 — Exécution de commandes à distance

Même si votre application Laravel fonctionne et est connectée à la base de données MySQL dans Kubernetes, vous aurez besoin d'effectuer plusieurs opérations communes sur une nouvelle installation Laravel. Une de ces tâches communes est la migration de base de données.

Avant que vous puissiez exécuter une commande Artisan sur votre application Laravel, vous devez connaître le nom du pod qui exécute votre conteneur d'application Laravel. En utilisant la ligne de commande suivante, vous pouvez consulter tous les pods de votre cluster Kubernetes :

				
					
kubectl get pods

Vous verrez un résultat similaire à ce qui suit :

				
					
[secondary_label Output]

NAME                                             READY   STATUS    RESTARTS   AGE

&lt;^&gt;laravel-kubernetes-lamp-77fb989b46-wczgb&lt;^&gt;         2/2     Running   0          16m

Sélectionnez le pod pour votre déploiement laravel-kubernetes-lamp-... Veillez à bien utiliser le nom dans votre résultat et non celui mentionné ci-dessus. Maintenant, vous pouvez y exécuter kubectl exec. Par exemple, exécutez une migration de base de données en utilisant la commande artisan migrate. Vous allez ajouter la balise --force car vous exécutez le pod en production :

				
					
kubectl exec &lt;^&gt;laravel-kubernetes-lamp-77fb989b46-wczgb&lt;^&gt; -- php artisan migrate --force

Cette commande générera un résultat :

				
					
[secondary_label Output]

Migration table created successfully.

Migrating: 2014_10_12_000000_create_users_table

Migrated:  2014_10_12_000000_create_users_table (0.16 seconds)

Migrating: 2019_08_19_000000_create_failed_jobs_table

Migrated:  2019_08_19_000000_create_failed_jobs_table (0.05 seconds)

Vous avez maintenant déployé correctement Laravel 7 et MySQL dans Kubernetes et exécuté une tâche essentielle de maintenance de la base de données.

Conclusion

Dans ce tutoriel, vous avez appris à conteneuriser une application PHP Laravel, à la connecter à une base de données MySQL, à pousser une image Docker contenant votre code sur Docker Hub, puis à utiliser un chart Helm pour la déployer sur un cluster Kubernetes. Enfin, vous avez ajouté un SSL et un nom de domaine personnalisé et appris à exécuter des outils de ligne de commande sur vos pods en cours d'exécution.

Par rapport à l'hébergement traditionnel de pile LAMP, Kubernetes et Helm vous offrent un certain nombre d'avantages : extensibilité, échange de services sans connexion directe à votre serveur, outils de mises à jour en roulement et contrôle de votre environnement d'hébergement. Cela dit, la complexité initiale de la conteneurisation et de la configuration rendent le démarrage de votre application assez difficile. En utilisant ce guide comme point de départ, il est plus facile de déployer Laravel sur Kubernetes. À partir de là, vous pourriez envisager d'en apprendre plus sur la puissance de Laravel ou sur l'ajout d'outils de surveillance à Kubernetes (Linkerd, par exemple), que vous pouvez installer manuellement avec notre guide ou avec un the cloud provider 1-Click.

Comment déployer Laravel 7 et MySQL sur Kubernetes en utilisant Helm

Table of Contents

Introduction

Conditions préalables

Étape 1 — Création d'une nouvelle application Laravel

Étape 2 — Conteneurisation de votre application Laravel

Étape 3 — Poussez votre image Docker dans Docker Hub

Étape 4 — Configuration et déploiement de l'application avec chart LAMP Helm

Étape 5 — Ajout d'un contrôleur Ingress et SSL à votre cluster Kubernetes

Étape 6 — Exécution de commandes à distance

Conclusion

Links

Newsletter

Contact

Comment déployer Laravel 7 et MySQL sur Kubernetes en utilisant Helm

Table of Contents

Introduction

Conditions préalables

Étape 1 &mdash; Création d'une nouvelle application Laravel

Étape 2 &mdash; Conteneurisation de votre application Laravel

Étape 3 &mdash; Poussez votre image Docker dans Docker Hub

Étape 4 &mdash; Configuration et déploiement de l'application avec chart LAMP Helm

Étape 5 &mdash; Ajout d'un contrôleur Ingress et SSL à votre cluster Kubernetes

Étape 6 &mdash; Exécution de commandes à distance

Conclusion

Links

Newsletter

Contact

Étape 1 — Création d'une nouvelle application Laravel

Étape 2 — Conteneurisation de votre application Laravel

Étape 3 — Poussez votre image Docker dans Docker Hub

Étape 4 — Configuration et déploiement de l'application avec chart LAMP Helm

Étape 5 — Ajout d'un contrôleur Ingress et SSL à votre cluster Kubernetes

Étape 6 — Exécution de commandes à distance