Cómo instalar WordPress en Kubernetes en Linode

WordPress es conocido como una de las herramientas de blogs más populares. Utiliza una base de datos relacional para almacenar los contenidos: artículos, metadatos involucrados, mientras que PersistentVolume (PV) y PersistentVolumeClaim (PVC) almacenan datos de activos.

Este tutorial le mostrará la forma de instalar una única réplica de un sitio de WordPress utilizando la base de datos MySQL en Kubernetes en Linode.

Configurar un clúster de Kubernetes en Linode

Esta sección recorrerá todos los pasos para configurar un Kubernetes en linode.com. Primero, registremos una cuenta en Linode y luego inicie sesión en Linode Dashboard. Vaya al submenú de Kubernetes, luego haga clic en el botón ‘Agregar un clúster’ en la esquina superior derecha y complete el campo: Etiqueta de clúster, elija una región adecuada y elija la versión de Kubernetes.

Luego, agreguemos grupos de nodos para su clúster de Kubernetes. En este tutorial, configuraremos un clúster de 1 nodo con un plan ‘Dedicado de 4 GB’, el nodo tiene 4 GB de RAM, 2 CPU y 80 GB de almacenamiento.

Por último, haga clic en «Crear clúster» para aprovisionar el clúster de Kubernetes.

Esperando unos minutos, el clúster de Kubernetes se aprovisionó correctamente. Descarguemos el archivo Kubeconfig a su máquina local, para que pueda interactuar con el clúster cómodamente.

En su máquina local, cree una carpeta llamada .kube en el directorio de inicio y mueva el archivo descargado a esa carpeta:

$ mkdir ~/.kube
$ mv wordpress-kubeconfig.yaml .kube/config

Además, debes instalar la herramienta kubectl:

$ curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.18.0/bin/linux/amd64/kubectl
$ chmod +x kubectl
$ sudo mv kubectl /usr/local/bin

Ahora puede obtener la información de su clúster de Kubernetes ejecutando el siguiente comando:

$ kubectl get node

NAME                                                STATUS   ROLES    AGE    VERSION
lke11043-13758-5f73eca05dae    Ready       5m   v1.18.8

Crear PersistentVolume y PersistentVolumeClaim

Tanto WordPress como MySQL necesitan PersistentVolume (PV) para almacenar datos. PersistentVolume (PV) y PersistentVolumeClaim (PVC) son independientes del ciclo de vida del pod de la aplicación. Cuando reinicia, reprograma o elimina un Pod, el PV y el PVC aún permanecen y conservan los datos.

En primer lugar, proporcione un PersistentVolume (PV) y un PersistentVolumeClaim (PVC) lo reclamará. Crea el archivo de manifiesto llamado pvc-mysql-wp.yaml como sigue:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim
  labels:
    app: wordpress
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: wp-pv-claim
  labels:
    app: wordpress
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi

Usando el comando kubectl aplicar para crear el PV:

$ kubectl apply -f pvc-mysql-wp.yaml                                                                                                                                  
persistentvolumeclaim/mysql-pv-claim created
persistentvolumeclaim/wp-pv-claim created 

Verifique que los PV se aprovisionaron automáticamente después de crear PVC:

$ kubectl get pv                    
NAME                   CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                    STORAGECLASS                  REASON   AGE
pvc-658d8d2da7a241bd   20Gi       RWO            Retain           Bound    default/wp-pv-claim      linode-block-storage-retain            5m
pvc-ca93cd86df0d49c8   20Gi       RWO            Retain           Bound    default/mysql-pv-claim   linode-block-storage-retain            5m1s

Crear contraseña para la base de datos MySQL

Kubernetes usa Secret para almacenar datos confidenciales como contraseñas o claves privadas.

Vamos a crear un archivo secret.yaml con su editor favorito de la siguiente manera:

apiVersion: v1
kind: Secret
metadata:
  name: mysql-pass
type: Opaque
data:
  password: yourpassword

Aplicar el manifiesto:

$ kubectl apply -f secret.yaml
secret/mysql-pass created

Verifique que el secreto se haya creado correctamente:

$ kubectl get secret
NAME                  TYPE                                  DATA   AGE
default-token-gcgp4   kubernetes.io/service-account-token   3      7h52m
mysql-pass            Opaque                                1      2m33s 

Implementar MySQL

Puede utilizar el siguiente archivo de manifiesto para crear una implementación de instancia única de MySQL. El PersistentVolume se montará en / var / lib / mysql.

Vamos a crear un archivo mysql-deployment.yaml:

apiVersion: v1
kind: Service
metadata:
  name: wordpress-mysql
  labels:
    app: wordpress
spec:
  ports:
    - port: 3306
  selector:
    app: wordpress
    tier: mysql
  clusterIP: None
---
apiVersion: apps/v1 # for versions before 1.9.0 use apps/v1beta2
kind: Deployment
metadata:
  name: wordpress-mysql
  labels:
    app: wordpress
spec:
  selector:
    matchLabels:
      app: wordpress
      tier: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: wordpress
        tier: mysql
    spec:
      containers:
      - image: mysql:5.6
        name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-pass
              key: password
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim

Luego, aplique el manifiesto anterior:

$ kubectl apply -f mysql-deployment.yaml       
service/wordpress-mysql unchanged
deployment.apps/wordpress-mysql created

Verifique que el pod de MySQL se haya implementado correctamente:

$ kubectl get pod
NAME                               READY   STATUS    RESTARTS   AGE
wordpress-mysql-57464b4779-vtjrf   1/1     Running   0          3m33s

Implementar WordPress

Puede usar el siguiente manifiesto para implementar WordPress en su clúster de Kubernetes. El PersistentVolume utilizado por el contenedor de WordPress se montará en / var / www / html.

El servicio wordpress tiene tipo LoadBalancer para poder acceder desde fuera del cluster.

Vamos a crear un archivo wordpress-deployment.yaml:

apiVersion: v1
kind: Service
metadata:
  name: wordpress
  labels:
    app: wordpress
spec:
  ports:
    - port: 80
  selector:
    app: wordpress
    tier: frontend
  type: LoadBalancer
---
apiVersion: apps/v1 # for versions before 1.9.0 use apps/v1beta2
kind: Deployment
metadata:
  name: wordpress
  labels:
    app: wordpress
spec:
  selector:
    matchLabels:
      app: wordpress
      tier: frontend
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: wordpress
        tier: frontend
    spec:
      containers:
      - image: wordpress:4.8-apache
        name: wordpress
        env:
        - name: WORDPRESS_DB_HOST
          value: wordpress-mysql
        - name: WORDPRESS_DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-pass
              key: password
        ports:
        - containerPort: 80
          name: wordpress
        volumeMounts:
        - name: wordpress-persistent-storage
          mountPath: /var/www/html
      volumes:
      - name: wordpress-persistent-storage
        persistentVolumeClaim:
          claimName: wp-pv-claim

Ahora, ejecutemos el siguiente comando para implementar WordPress:

$ kubectl apply -f wordpress-deployment.yaml 
service/wordpress created
deployment.apps/wordpress created

Verifique que WordPress esté funcionando:

$ kubectl get pod
NAME                               READY   STATUS    RESTARTS   AGE
wordpress-6857459697-wmgn9         1/1     Running   0          3m34s
wordpress-mysql-57464b4779-vtjrf   1/1     Running   0          32m

Verifique que todos los servicios se estén ejecutando:

$ kubectl get svc                           
NAME              TYPE           CLUSTER-IP       EXTERNAL-IP      PORT(S)        AGE
kubernetes        ClusterIP      10.128.0.1                  443/TCP        12h
wordpress         LoadBalancer   10.128.108.139   172.104.37.236   80:30567/TCP   5s
wordpress-mysql   ClusterIP      None                        3306/TCP       29m

Ahora puedes acceder a la página de WordPress mediante la IP EXTERAL del servicio wordpress. Copiemos y peguemos en su navegador web:

Conclusión

WordPress es una herramienta de blogs realmente poderosa para cualquier creador de contenido y también para desarrolladores. Este tutorial ha pasado por todos los pasos para crear un clúster de Kubernetes en Linode y configurar la página de WordPress en él.

Gracias por leer y deje su sugerencia en la sección de comentarios a continuación.