Déployer WordPress dans GKE avec Persistent Disk et Cloud SQL

Ce tutoriel explique comment configurer un déploiement WordPress à instance répliquée unique sur Google Kubernetes Engine (GKE) à l'aide d'une base de données MySQL. Plutôt que d'installer MySQL, utilisez Cloud SQL, qui fournit une version gérée de MySQL. WordPress stocke les données à l'aide des ressources PersistentVolumes (PV) et PersistentVolumeClaims (PVC).

Un PV est une représentation du volume de stockage dans le cluster qui a été provisionné par un administrateur, ou provisionné de manière dynamique par Kubernetes, pour traiter une requête effectuée dans une PVC. Une PVC est une requête de stockage d'une certaine classe de stockage effectuée par un utilisateur et qui peut être traitée par un PV. Les PV et les PVC sont indépendants des cycles de vie des pods et préservent les données en redémarrant, en reprogrammant, mais également en supprimant des pods. WordPress utilise Persistent Disk comme espace de stockage pour soutenir les PV.

Arrière-plan

WordPress est un outil de création de blogs qui utilise une base de données relationnelle pour stocker les articles de blog ainsi que les métadonnées et objets associés, et le système de fichiers local pour stocker des éléments tels que des images dans un article de blog. Ce tutoriel utilise l'image Docker WordPress officielle de Docker Hub.

En général, le système de fichiers racine d'un conteneur ne convient pas pour stocker des données persistantes. Les conteneurs que vous exécutez sur GKE sont généralement des entités qui peuvent être supprimées, et le gestionnaire du cluster peut supprimer, expulser ou reprogrammer tout conteneur devenu indisponible en raison de défaillances de nœuds ou pour d'autres raisons. En cas de défaillance des nœuds, toutes les données enregistrées dans le système de fichiers racine d'un conteneur sont perdues.

L'utilisation de PV reposant sur un disque persistant vous permet de stocker vos données de plate-forme WordPress en dehors des conteneurs. Ainsi, même si les conteneurs sont supprimés, leurs données sont conservées. Avec la classe de stockage par défaut, votre disque persistant (et donc vos données) ne se déplace pas avec votre pod si celui-ci est replanifié sur un autre nœud. Il existe différentes manières de déplacer les données, mais cela n'entre pas dans le cadre de ce tutoriel. Pour en savoir plus, consultez la page Volumes persistants avec disques persistants.

WordPress nécessite un PV pour le stockage des données. Dans le cadre de ce tutoriel, vous utilisez la classe de stockage par défaut pour créer dynamiquement un disque persistant et un PVC pour le déploiement.

Configurer votre environnement

1. Dans Cloud Shell, définissez la région par défaut pour Google Cloud CLI :

   gcloud config set compute/region region
   

   Remplacez les éléments suivants :

   • region : choisissez la région la plus proche de vous. Pour en savoir plus, consultez la page Régions et zones.

2. Définissez la variable d'environnement PROJECT_ID sur l'ID de votre projetGoogle Cloud (project-id).

   export PROJECT_ID=project-id
   

3. Téléchargez les fichiers manifestes d'application à partir du dépôt GitHub :

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   

4. Accédez au répertoire qui contient le fichier wordpress-persistent-disks :

   cd kubernetes-engine-samples/quickstarts/wordpress-persistent-disks
   

5. Définissez la variable d'environnement WORKING_DIR :

   WORKING_DIR=$(pwd)
   

   Dans le cadre de ce tutoriel, vous créez des objets Kubernetes à l'aide de fichiers manifestes au format YAML.

Créer un cluster GKE

Créez un cluster GKE sur lequel héberger votre conteneur d'applications WordPress.

• Dans Cloud Shell, créez un cluster GKE nommé persistent-disk-tutorial :

  CLUSTER_NAME=persistent-disk-tutorial
  gcloud container clusters create-auto $CLUSTER_NAME
  

  Une fois créé, connectez-vous au cluster :

  gcloud container clusters get-credentials $CLUSTER_NAME --location REGION
  

Créer un PV et une PVC reposant sur un disque persistant

Créez un PVC en tant qu'espace de stockage requis pour WordPress. GKE dispose d'une ressource StorageClass par défaut qui vous permet de provisionner de manière dynamique les PV reposant sur un disque persistant. Créez les PVC requises pour le déploiement à l'aide du fichier wordpress-volumeclaim.yaml.

Ce fichier manifeste décrit une PVC qui demande 200 Go d'espace de stockage. Une ressource StorageClass n'a pas été définie dans le fichier. Par conséquent, cette PVC utilise la ressource StorageClass par défaut pour provisionner un PV reposant sur un disque persistant.

1. Dans Cloud Shell, déployez le fichier manifeste :

   kubectl apply -f $WORKING_DIR/wordpress-volumeclaim.yaml
   

   Il peut s'écouler jusqu'à dix secondes avant que le PV reposant sur un disque persistant ne soit provisionné et associé à votre PVC. Vous pouvez vérifier l'état à l'aide de la commande suivante :

   kubectl get persistentvolumeclaim
   

   Le résultat affiche un PersistentVolumeClaim dont l'état est Pending, semblable à celui-ci :

   NAME                    STATUS    VOLUME   CAPACITY   ACCESS MODES   STORAGECLASS   AGE
   wordpress-volumeclaim   Pending                                      standard-rwo   5s
   

   Ce PersistentVolumeClaim reste à l'état Pending jusqu'à ce que vous l'utilisiez plus loin dans ce tutoriel.

Créer une instance Cloud SQL pour MySQL

1. Dans Cloud Shell, créez une instance nommée mysql-wordpress-instance :

   INSTANCE_NAME=mysql-wordpress-instance
   gcloud sql instances create $INSTANCE_NAME
   

2. Ajoutez le nom de la connexion de l'instance en tant que variable d'environnement :

   export INSTANCE_CONNECTION_NAME=$(gcloud sql instances describe $INSTANCE_NAME \
       --format='value(connectionName)')
   

3. Créez une base de données pour que WordPress stocke ses données :

   gcloud sql databases create wordpress --instance $INSTANCE_NAME
   

4. Créez un utilisateur de base de données nommé wordpress et un mot de passe pour que WordPress puisse s'authentifier auprès de l'instance :

   CLOUD_SQL_PASSWORD=$(openssl rand -base64 18)
   gcloud sql users create wordpress --host=% --instance $INSTANCE_NAME \
       --password $CLOUD_SQL_PASSWORD
   

   Si vous fermez votre session Cloud Shell, vous perdez le mot de passe. Notez le mot de passe, car vous en aurez besoin dans la suite du tutoriel.

Vous avez terminé la configuration de la base de données pour votre nouveau blog WordPress.

Déployer WordPress

Avant de pouvoir déployer WordPress, vous devez créer un compte de service. Créez un secret Kubernetes pour conserver les identifiants du compte de service et un autre pour conserver les identifiants de la base de données.

Configurer un compte de service et créer des secrets

1. Pour permettre à votre application WordPress d'accéder à l'instance MySQL via un proxy Cloud SQL, créez un compte de service:

   SA_NAME=cloudsql-proxy
   gcloud iam service-accounts create $SA_NAME --display-name $SA_NAME
   

2. Ajoutez l'adresse e-mail du compte de service en tant que variable d'environnement :

   SA_EMAIL=$(gcloud iam service-accounts list \
       --filter=displayName:$SA_NAME \
       --format='value(email)')
   

3. Ajoutez le rôle cloudsql.client à votre compte de service :

   gcloud projects add-iam-policy-binding $PROJECT_ID \
       --role roles/cloudsql.client \
       --member serviceAccount:$SA_EMAIL
   

4. Créez une clé pour le compte de service :

   gcloud iam service-accounts keys create $WORKING_DIR/key.json \
       --iam-account $SA_EMAIL
   

   Cette commande télécharge une copie du fichier key.json.

5. Créez un secret Kubernetes pour les identifiants MySQL :

   kubectl create secret generic cloudsql-db-credentials \
       --from-literal username=wordpress \
       --from-literal password=$CLOUD_SQL_PASSWORD
   

6. Créez un secret Kubernetes pour les identifiants du compte de service :

   kubectl create secret generic cloudsql-instance-credentials \
       --from-file $WORKING_DIR/key.json
   

Déployer WordPress

L'étape suivante consiste à déployer votre conteneur WordPress dans le cluster GKE.

Le fichier manifeste wordpress_cloudsql.yaml décrit un déploiement qui crée un seul pod exécutant un conteneur avec une instance WordPress. Ce conteneur lit la variable d'environnement WORDPRESS_DB_PASSWORD contenant le secret cloudsql-db-credentials que vous avez créé.

Ce fichier manifeste configure également le conteneur WordPress de sorte qu'il communique avec MySQL via le proxy Cloud SQL exécuté dans le conteneur side-car. La valeur d'adresse de l'hôte est définie dans la variable d'environnement WORDPRESS_DB_HOST.

1. Préparez le fichier en remplaçant la variable d'environnement INSTANCE_CONNECTION_NAME :

   cat $WORKING_DIR/wordpress_cloudsql.yaml.template | envsubst > \
       $WORKING_DIR/wordpress_cloudsql.yaml
   

2. Déployez le fichier manifeste wordpress_cloudsql.yaml :

   kubectl create -f $WORKING_DIR/wordpress_cloudsql.yaml
   

   Le déploiement de ce fichier manifeste prend quelques minutes lorsqu'un disque persistant est associé au nœud de calcul.

3. Regardez le déploiement afin de voir l'état passer à running :

   kubectl get pod -l app=wordpress --watch
   

   Lorsque le résultat affiche l'état Running, vous pouvez passer à l'étape suivante.

   NAME                     READY     STATUS    RESTARTS   AGE
   wordpress-387015-02xxb   2/2       Running   0          2m47s
   

Exposer le service WordPress

À l'étape précédente, vous avez déployé un conteneur WordPress. Toutefois, il n'est actuellement pas accessible en dehors de votre cluster, car il ne possède pas d'adresse IP externe. Vous pouvez exposer votre application WordPress au trafic provenant d'Internet en créant et en configurant un service Kubernetes avec un équilibreur de charge externe associé. Pour en savoir plus sur l'exposition d'applications à l'aide de services dans GKE, consultez le guide d'utilisation.

1. Créez un service de type:LoadBalancer :

   kubectl create -f $WORKING_DIR/wordpress-service.yaml
   

   La création d'un équilibreur de charge peut prendre quelques minutes.

2. Regardez le déploiement et attendez qu'une adresse IP externe ait été attribuée au service :

   kubectl get svc -l app=wordpress --watch
   

3. Lorsque le résultat affiche une adresse IP externe, vous pouvez passer à l'étape suivante : Notez que votre adresse IP externe est différente de l'exemple suivant.

   NAME        CLUSTER-IP      EXTERNAL-IP    PORT(S)        AGE
   wordpress   10.51.243.233   203.0.113.3    80:32418/TCP   1m
   

4. Notez le champ d'adresse EXTERNAL_IP à utiliser ultérieurement.

Avertissement : Ne laissez pas votre installation WordPress avec un équilibreur de charge qui expose le cluster sur la page d'installation. D'autres visiteurs peuvent configurer un site Web sur votre cluster et l'utiliser pour diffuser du contenu potentiellement malveillant. Continuez à configurer votre blog WordPress, ou bien nettoyez ce déploiement.

Configurer votre blog WordPress

Dans cette section, vous allez configurer votre blog WordPress.

1. Dans votre navigateur, accédez à l'URL suivante, en remplaçant external-ip-address par l'adresse EXTERNAL_IP du service qui expose votre instance WordPress :

   http://external-ip-address
   

2. Sur la page WordPress installation (Installation de WordPress), sélectionnez une langue, puis cliquez sur Continue (Continuer).

3. Complétez la page Information needed (Informations requises), puis cliquez sur Install WordPress (Installer WordPress).

4. Cliquez sur Log In (Se connecter).

5. Saisissez le nom d'utilisateur et le mot de passe que vous avez créés précédemment.

6. Vous disposez désormais d'un blog. Pour accéder à votre blog, accédez à l'URL suivante dans votre navigateur :

   http://external-ip-address