Cómo implementar una instancia de WordPress en Kubernetes

Introducción

Como el sistema de administración de contenido más popular a nivel mundial, WordPress ejecuta sitios web de varios tamaños, tanto en términos de cantidad de contenido como de tráfico web. La implementación de WordPress en Kubernetes es una forma eficiente de habilitar la escala horizontal de un sitio web y manejar con éxito los aumentos repentinos de tráfico del sitio web.

Este tutorial explica dos métodos para implementar WordPress en Kubernetes:usar gráficos de Helm y crear su implementación desde cero.

Requisitos previos

• Un clúster de Kubernetes con kubectl
• Telmo 3
• Privilegios administrativos en el sistema

Implementación de WordPress en Kubernetes con un Helm Chart

Los gráficos de Helm vienen con instalaciones de aplicaciones preconfiguradas que se pueden implementar con unos pocos comandos simples.

1. Agregue el repositorio que contiene el gráfico de WordPress Helm que desea implementar:

helm repo add [repo-name] [repo-address]

El sistema confirma la adición exitosa del repositorio. El ejemplo utiliza el gráfico de Bitnami.

2. Actualice los repositorios locales de Helm:

helm repo update

3. Instale el gráfico con el comando helm install.

helm install [release-name] [repo-address]

Espere a que se despliegue el gráfico.

4. El servicio de WordPress usa LoadBalancer como una forma de exponer el servicio. Si está utilizando minikube, abra otra ventana de terminal y escriba el siguiente comando para emular LoadBalancer:

minikube tunnel

5. Cuando minikube muestra el mensaje En ejecución estado, minimizar la ventana y volver a la anterior.

6. Verifique la preparación de la implementación escribiendo:

kubectl get all

El comando enumera y muestra el estado de los pods, los servicios y las implementaciones.

7. Una vez que los pods y la implementación estén listos, use el siguiente comando para exportar el SERVICE_IP variable de entorno:

export SERVICE_IP=$(kubectl get svc --namespace default wp-test-wordpress --template "{{ range (index .status.loadBalancer.ingress 0) }}{{.}}{{ end }}")

8. Ahora use el comando echo para mostrar la dirección IP del servicio:

echo "WordPress URL: http://$SERVICE_IP/"

9. Escriba la dirección en la barra de direcciones de su navegador. Comienza la instalación de WordPress.

Implementación de WordPress en Kubernetes con volúmenes persistentes

Al implementar WordPress con una configuración personalizada, debe crear una serie de archivos YAML para WordPress y la base de datos que utilizará la aplicación. El siguiente ejemplo usa MySQL, pero también puede optar por MariaDB.

1. Use un editor de texto para crear el archivo YAML para aprovisionar almacenamiento para la base de datos MySQL.

nano mysql-storage.yaml

El archivo define un volumen de almacenamiento persistente (PV) y reclama ese almacenamiento con PersistentVolumeClaim (PVC). El ejemplo usa la siguiente configuración:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mysql-pv
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim
  labels:
    app: wordpress
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

Guarde el archivo y salga.

2. Cree la configuración de implementación de MySQL YAML.

nano mysql-deployment.yaml

El archivo de implementación contiene los datos relacionados con la imagen del contenedor y el almacenamiento. El claimName la declaración en la parte inferior debe corresponder al nombre de la PVC que creó en el Paso 1 .

apiVersion: apps/v1
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.7
        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

Guarde el archivo y salga.

3. Cree la configuración de servicio YAML para la base de datos.

nano mysql-service.yaml

El archivo especifica el puerto que utiliza WordPress para conectarse al servicio:

apiVersion: v1
kind: Service
metadata:
  name: wordpress-mysql
  labels:
    app: wordpress
spec:
  ports:
    - port: 3306
  selector:
    app: wordpress
    tier: mysql
  clusterIP: None

Guarde el archivo y salga.

4. Ahora cree los mismos archivos YAML para WordPress. Comience con la asignación de almacenamiento:

nano wordpress-storage.yaml

El ejemplo usa la siguiente configuración:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: wp-pv
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: wp-pv-claim
  labels:
    app: wordpress
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

Guarde el archivo y salga.

5. Cree el archivo de implementación:

nano wordpress-deployment.yaml

El archivo proporciona la imagen de Docker y conecta la implementación de WordPress con el PVC:

apiVersion: apps/v1
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:5.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

Guarde el archivo y salga.

6. Crea el servicio YAML:

nano wordpress-service.yaml

El ejemplo usa LoadBalancer para exponer el servicio:

apiVersion: v1
kind: Service
metadata:
  name: wordpress
  labels:
    app: wordpress
spec:
  ports:
    - port: 80
  selector:
    app: wordpress
    tier: frontend
  type: LoadBalancer

Guarde el archivo y salga.

7. Cree el archivo kustomization.yaml, que se utilizará para aplicar la configuración fácilmente:

nano kustomization.yaml

El archivo contiene dos partes:

• secretGenerator produce el secreto de Kubernetes que pasa la información de inicio de sesión a los contenedores.
• resources La sección enumera todos los archivos que participarán en la configuración. Enumere los archivos que creó en los pasos anteriores.

secretGenerator:
- name: mysql-pass
  literals:
  - password=test123
resources:
  - mysql-storage.yaml
  - mysql-deployment.yaml
  - mysql-service.yaml
  - wordpress-storage.yaml
  - wordpress-deployment.yaml
  - wordpress-service.yaml

Guarde el archivo y salga.

8. Aplique los archivos enumerados en kustomization.yaml con el siguiente comando:

kubectl apply -k ./

El sistema confirma la creación exitosa del secreto, los servicios, los PV, los PVC y las implementaciones:

9. Compruebe si los pods y las implementaciones están listas:

kubectl get all

10. Si usa minikube, abra otra ventana de terminal e inicie minikube tunnel para proporcionar emulación de equilibrio de carga:

minikube tunnel

Una vez que se esté ejecutando la emulación, minimice la ventana y regrese a la anterior.

11. Escriba el siguiente comando para exponer la URL del servicio que usará para acceder a la instancia de WordPress implementada:

minikube service wordpress-service --url

La URL se muestra como salida del comando:

12. Copie la URL y péguela en su navegador web. Comienza la instalación de WordPress.