Cómo implementar Laravel 7 y MySQL en Kubernetes con Helm

El autor seleccionó la organización Diversity in Tech Fund para que reciba una donación como parte del programa Write for DOnations.

Introducción

Laravel es actualmente uno de los frameworks de aplicaciones PHP de código abierto más populares. Generalmente, se implementa con una base de datos de MySQL, pero puede configurarse para utilizar una variedad de opciones de almacenamiento de datos backend. Laravel se enorgullece de aprovechar muchas de las características modernas y el vasto ecosistema de paquetes de PHP.

Kubernetes es una plataforma de orquestación de contenedores que puede alojarse en los clústeres de Kubernetes de DigitalOcean para que se encargue de una gran parte del trabajo administrativo de configuración y ejecución de contenedores en producción. Helm es un administrador de paquetes de Kubernetes que facilita la configuración e instalación de servicios y pods en Kubernetes.

En esta guía, creará una aplicación PHP de Laravel, compilará la aplicación en una imagen de Docker e implementará esa imagen en un clúster de Kubernetes de DigitalOcean utilizando el chart de Helm de LAMP. A continuación, configurará un controlador Ingress para agregar SSL y un nombre de dominio personalizado a la aplicación. Al finalizar, tendrá una aplicación de Laravel funcional conectada a una base de datos que se ejecuta en un clúster de Kubernetes.

Requisitos previos

• Docker instalado en el equipo desde el que accederá a su clúster. Puede encontrar instrucciones detalladas sobre cómo instalar Docker en la mayoría de las distribuciones de Linux aquí o en el sitio web de Docker si se trata de otros sistemas operativos.
• Una cuenta en Docker Hub para almacenar las imágenes de Docker que creará durante este tutorial.
• Un clúster de Kubernetes 1.17+ de DigitalOcean con una configuración de conexión predeterminada kubectl. Para aprender a crear un clúster de Kubernetes en DigitalOcean, consulte la Guía de inicio rápido sobre Kubernetes. Para obtener información sobre cómo conectarse al clúster, consulte Cómo establecer conexión con un clúster de Kubernetes de DigitalOcean.
• Un administrador de paquetes de Helm 3 instalado en su equipo local. Complete el primer paso y agregue el repositorio stable que se describe en el segundo paso del tutorial Cómo instalar software en clústeres de Kubernetes con el administrador de paquetes Helm 3.
• Un nombre de dominio registrado por completo con un registro A disponible. Para este tutorial, se utilizará your_domain en todo momento. Puede adquirir un nombre de dominio en Namecheap, obtener uno gratuito en Freenom o utilizar un registrador de dominios de su elección. En este momento, no es necesario asociar el registro A de su dominio con una dirección IP. Una vez que llegue al paso 5 y que haya establecido el controlador Ingress, vinculará your_domain con la IP pertinente.

Paso 1: Crear una nueva aplicación Laravel

En este paso, utilizará Docker para crear una nueva aplicación Laravel 7, pero debería poder realizar el mismo procedimiento con una aplicación Laravel existente que utilice MySQL como copia de seguridad de la base de datos. La nueva aplicación que compile verificará que Laravel esté conectada a la base de datos y mostrará el nombre de la base de datos.

Primero, vaya al directorio de inicio y, luego, utilice un contenedor de Docker composer para crear una nueva aplicación Laravel:

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

Una vez que esté listo el contenedor y que se hayan instalado todos los paquetes de Composer, debería ver una nueva instalación de Laravel denominada laravel-kubernetes/ en el directorio actual. Diríjase a esa carpeta:

cd ~/laravel-kubernetes

A partir de aquí, ejecutará el resto de los comandos de este tutorial.

El objetivo de esta aplicación es probar la conexión de la base de datos y mostrar su nombre en el navegador. Para probar la conexión de la base de datos, abra el archivo ./resources/views/welcome.blade.php en un editor de texto:

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

Busque la sección <div class="links">...</div> y sustituya el contenido por lo siguiente:

...
<div class="links">
   <strong>Database Connected: </strong>
    @php
        try {
            DB::connection()->getPDO();
            echo DB::connection()->getDatabaseName();
            } catch (\Exception $e) {
            echo 'None';
        }
    @endphp
</div>
...

Guarde y cierre el archivo.

Ese es todo el proceso de personalización que deberá realizar en la aplicación predeterminada Laravel para este tutorial. Una vez que haya terminado, este breve fragmento de PHP probará la conexión de la base de datos y mostrará el nombre de dicha base de datos en la pantalla de presentación de Laravel en el navegador web.

En el siguiente paso, utilizará Docker para compilar una imagen que contenga esta aplicación de Laravel y Docker Compose para probar que se ejecuta de manera local y que se conecta a una base de datos de MySQL.

Paso 2: Disponer la aplicación de Laravel en un contenedor

Ahora que creó una nueva aplicación de Laravel, deberá compilar el código en una imagen de Docker y, luego, evaluar la imagen con Docker Compose. Si bien el objetivo de este tutorial es implementar la aplicación en un clúster de Kubernetes, Docker Compose es una forma práctica de probar la imagen y la configuración de Docker de manera local antes de ejecutarla en la nube. Este proceso de retroalimentación rápido puede ser útil para realizar y probar modificaciones pequeñas.

Primero, con nano o el editor de texto que prefiera, cree un archivo llamado Dockerfile en la raíz de la aplicación de Laravel:

nano ./Dockerfile

Añada el siguiente contenido: Docker utilizará este archivo para compilar el código en una imagen:

FROM php:7.4-apache

# Install packages
RUN apt-get update && 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 && 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"]

Guarde y cierre el archivo.

Este archivo Dockerfile comienza con una imagen de Docker de Apache PHP 7.4 que se encuentra en Docker Hub y, luego, instala varios paquetes de Linux que generalmente los requieren las aplicaciones de Laravel. A continuación, crea archivos de configuración de Apache y habilita la reescritura de encabezados. El archivo Dockerfile instala varias extensiones comunes de PHP y agrega una variable de entorno para asegurarse de que los registros de Laravel se transmitan al contenedor a través de stderr. Esto le permitirá ver los registros de Laravel mediante el seguimiento de los registros de Docker Compose o Kubernetes.

Por último, Dockerfile copia todo el código de la aplicación de Laravel a /var/www/tmp e instala las dependencias de Composer. Después, establece un ENTRYPOINT, pero deberá crear ese archivo, que es lo que haremos a continuación.

En el directorio raíz de su proyecto, cree un nuevo archivo denominado docker-entrypoint.sh. Este archivo se ejecutará cuando el contenedor se ejecute de manera local o en el clúster de Kubernetes, y copiará el código de la aplicación de Laravel del directorio /var/www/tmp a /var/www/html, donde Apache podrá presentarlo.

nano ./docker-entrypoint.sh

Ahora agregue la siguiente secuencia de comandos:

#!/bin/bash

cp -R /var/www/tmp/. /var/www/html/
chown -R www-data:www-data /var/www/html

exec "$@"

La última línea, exec "$@", le indica al shell que ejecute cualquier comando que transmitió como argumento de entrada. Esto es importante porque queremos que Docker siga ejecutando el comando Ejecutar de Apache (apache2-foregrund) después de esta secuencia de comandos. Guarde y cierre el archivo.

A continuación, cree un archivo .dockerignore en el directorio raíz de la aplicación. Este archivo garantizará que cuando compile la imagen de Docker, no se contamine con archivos de entorno o paquetes que no deberían copiarse allí:

nano ./.dockerignore

.env
/vendor

Guarde y cierre el archivo.

El archivo docker-compose.yml es el último que debe crear antes de poder ejecutar la aplicación de manera local con Docker Compose. Sin embargo, durante la configuración de este archivo YAML, deberá ingresar la APP_KEY que generó Laravel durante la instalación. Para encontrar esta clave, abra y busque en el archivo . /.env o ejecute los siguientes comandos cat y grep:

cat .env | grep ^APP_KEY

Verá un resultado similar a este:

Output
APP_KEY=base64:0EHhVpgg ... UjGE=

Copie la clave en el portapapeles. Asegúrese de incluir el prefijo base64:. Ahora cree el archivo docker-compose.yml en el directorio raíz de la aplicación:

nano ./docker-compose.yml

Aquí incluiremos la imagen PHP de la aplicación de Laravel y también un contenedor de MySQL para ejecutar la base de datos. Añada el siguiente contenido:

version: '3.5'
services:
  php:
    image: your_docker_hub_username/laravel-kubernetes:latest
    restart: always
    ports:
      - 8000:80
    environment:
      - APP_KEY="your_laravel_app_key"
      - 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}

Utilice la variable APP_KEY que copió en el portapapeles para la variable your_laravel_app_key, y el nombre de usuario de Docker Hub para la variable your_docker_hub_username. Guarde y cierre el archivo.

Creará la primera imagen de manera local con docker.build. La segunda imagen es la imagen de Docker de MySQL oficial que está disponible en Docker Hub. Ambas requieren diversas variables de entorno, las cuales incluirá cuando ejecute los contenedores.

Para compilar la imagen de Docker que contiene la aplicación de Laravel, ejecute el siguiente comando. Asegúrese de sustituir your_docker_hub_username por su nombre de usuario o el nombre de usuario de su equipo en Docker Hub, donde se almacenará esta imagen:

docker build -t your_docker_hub_username/laravel-kubernetes:latest .

A continuación, puede ejecutar los dos contenedores utilizando Docker Compose con las credenciales necesarias de la base de datos:

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

Si quiere, puede modificar las cuatro variables de entorno que se utilizan aquí (DB_ROOT_PASSWORD, DB_DATABASE, DB_USERNAME y DB_PASSWORD) pero, dado que solo está probando la aplicación de manera local, aún no es necesario protegerlas.

El proceso de iniciar la base de datos de MySQL y preparar los contenedores puede tardar hasta 30 segundos. Una vez que lo estén, puede ver la aplicación de Laravel en su equipo en localhost:8000.

Su aplicación PHP se conectará a la base de datos de MySQL. Tras una conexión exitosa, el texto “Database Connected: local_db”(Base de datos conectada: local_db) aparecerá debajo del logotipo de Laravel.

Ahora que probó la imagen de Docker de manera local con Docker Compose, puede ejecutar docker-compose down para desactivar los contenedores:

docker-compose down

En la siguiente sección, transferirá la imagen de Docker a Docker Hub para que su chart de Helm pueda utilizarla para implementar la aplicación en el clúster de Kubernetes.

Paso 3: Introducir la imagen de Docker en Docker Hub

El chart de Helm de LAMP que utilizará para implementar el código en Kubernetes requiere que el código esté disponible en un registro de contenedores. Si bien puede transferir la imagen a un registro privado o con alojamiento propio, a los efectos de este tutorial, utilizará un registro de Docker público y gratuito en Docker Hub.

En el navegador web, acceda a su cuenta en Docker Hub y, luego, cree un nuevo repositorio llamado laravel-kubernetes.

A continuación, si no se conectó a Docker Hub desde el equipo local, deberá iniciar sesión en Docker Hub. Puede hacerlo con la siguiente línea de comandos:

docker login -u your_docker_hub_username

Cuando se le solicite, ingrese las credenciales de inicio de sesión. Generalmente, solo debe realizar esta acción una vez en cada equipo, ya que Docker guardará las credenciales en ~/.docker/config.json en el directorio de inicio.

Por último, transfiera la imagen a Docker Hub:

docker push your_docker_hub_username/laravel-kubernetes:latest

Dependiendo de la velocidad de conexión, puede tomar algunos minutos cargar la aplicación, pero una vez que Docker termine, verá un último resumen de la función hash y el tamaño de la imagen en el terminal. El aspecto será similar a este:

Output
latest: digest: sha256:df4bdeda91484c8c26a989b13b8f27ab14d93ab2e676e3c396714cb3811c4086 size: 4918

Ahora que la aplicación de Laravel está en un contenedor y que introdujo una imagen en Docker Hub, puede utilizar la imagen en la implementación de un chart de Helm o de Kubernetes. En el siguiente paso, configurará valores personalizados en base al chart de Helm de LAMP y lo implementará en el clúster de Kubernetes de DigitalOcean.

Paso 4: Configurar e implementar la aplicación con el chart de Helm de LAMP

Helm proporciona varios Charts para ayudarlo a configurar aplicaciones de Kubernetes utilizando combinaciones de herramientas predeterminadas. Si bien podría escribir archivos de servicio de Kubernetes propios para lograr una implementación similar, en esta sección observará que al utilizar un Chart de Helm se requerirá un proceso de configuración mucho menor.

Primero, necesitará un directorio para almacenar todos los archivos de configuración de Helm. En la raíz de su proyecto Laravel, cree un nuevo directorio llamado helm/:

mkdir ./helm

Dentro del directorio helm/ crearemos dos nuevos archivos: values.yml y secrets.yml. Primero, cree y abra values.yml:

nano ./helm/values.yml

El archivo values.yml incluirá opciones de configuración no secretas que anularán los valores predeterminados en el gráfico de Helm de LAMP. Agregue las siguientes opciones de configuración, asegurándose de sustituir your_docker_hub_username por su nombre de usuario:

php:
  repository: "your_docker_hub_username/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

Guarde y cierre el archivo.

Ahora cree un archivo secrets.yml:

nano ./helm/secrets.yml

secrets.yml no se verificará en el control de versiones. Contendrá información de configuración confidencial, como la contraseña de la base de datos y la clave de la aplicación de Laravel. Agregue la siguiente configuración, y adáptela según corresponda para que coincida con sus credenciales:

mysql:
  rootPassword: "your_database_root_password"
  user: your_database_user
  password: "your_database_password"
  database: your_database_name

php:
  envVars:
    - name: APP_KEY
      value: "your_laravel_app_key"
    - name: DB_DATABASE
      value: your_database_name
    - name: DB_USERNAME
      value: your_database_user
    - name: DB_PASSWORD
      value: "your_database_password"

Asegúrese de utilizar combinaciones de nombre de usuario y contraseña seguras para su base de datos de producción, y utilice la misma your_laravel_app_key que empleó anteriormente, o ejecute el siguiente comando para abrir una ventana de terminal nueva y generar una nueva clave. Luego, puede copiar el nuevo valor que establezca Laravel en el archivo .env:

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

Guarde y cierre secrets.yml.

A continuación, para evitar que el archivo secrets.yml se integre en la imagen de Docker o se guarde en el control de versiones, asegúrese de agregar la siguiente línea en los archivos .dockerignore y .gitignore. Abra cada archivo y anexe /helm/secrets.yml a cada uno, o bien ejecute el siguiente comando para agregarlo a ambos:

echo '/helm/secrets.yml' >> ./.dockerignore && echo '/helm/secrets.yml' >> ./.gitignore

Ahora que ha creado los archivos de configuración de Helm para su aplicación y la imagen de Docker, puede instalar este chart de Helm como una nueva versión en el clúster de Kubernetes. Instale el chart desde el directorio raíz de la aplicación:

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

Verá un resultado similar a este:

Output
NAME: laravel-kubernetes
LAST DEPLOYED: Mon May 18 13:21:20 2020
NAMESPACE: default
STATUS: deployed
REVISION: 1

La aplicación estará disponible en uno o dos minutos, pero puede ejecutar este comando para controlar el servicio de Kubernetes en el clúster:

kubectl get services -w

Busque el nombre de su aplicación:

Output
NAME                        TYPE            CLUSTER-IP          EXTERNAL-IP     PORT(S)
laravel-kubernetes-lamp     LoadBalancer    your_cluster_ip      your_external_ip   80:32175/TCP,3306:32243/TCP

Cuando el nuevo servicio laravel-kubernetes-lamp muestre una dirección IP en EXTERNAL-IP, puede visitar your_external_ip para ver la aplicación ejecutándose en el clúster de Kubernetes. La aplicación se conectará a la base de datos, y verá el nombre de dicha base de datos debajo del logotipo de Laravel, como sucedió cuando ejecutó la aplicación de manera local en Docker Compose.

Es aceptable ejecutar una aplicación web en una dirección IP no segura cuando se trata de una prueba de concepto, pero sin un certificado SSL y un nombre de dominio personalizado, el sitio web no está listo para producción. Antes de configurar esto en el siguiente paso, desinstale la versión mediante la línea de comandos:

helm delete laravel-kubernetes

En el siguiente paso, ampliará la primera configuración de Helm para agregar un controlador Ingress, un certificado SSL y un dominio personalizado a la aplicación de Laravel.

Paso 5: Agregar un controlador Ingress y SSL al clúster de Kubernetes

En Kubernetes, un controlador Ingress es el responsable de exteriorizar los servicios de su aplicación a Internet. En el paso anterior, el chart de Helm de LAMP creó un equilibrador de carga de DigitalOcean y expuso la aplicación de manera directa a través de la dirección IP del equilibrador de carga.

Podría terminar SSL y el nombre de dominio directamente en el equilibrador de carga, pero, debido a que está trabajando en Kubernetes, podría resultar más práctico administrar todo en el mismo lugar. Para obtener más información sobre los controladores Ingress y detalles sobre los siguientes pasos, consulte Cómo configurar un Ingress de Nginx en Kubernetes de DigitalOcean utilizando Helm.

El chart de Helm de LAMP incluye una opción de configuración para admitir Ingress. Abra el archivo helm/values.yml:

nano ./helm/values.yml

Ahora agregue las siguientes líneas:

...
# Use Ingress Controller
service:
  type: ClusterIP
  HTTPPort: 80
ingress:
  enabled: true
  domain: your_domain

Esto indica que durante la implementación no se instale un equilibrador de carga y que, en su lugar, se exponga la aplicación al puerto 80 del clúster de Kubernetes, donde el controlador Ingress lo exteriorizará a Internet. Guarde y cierre values.yml.

Ahora ejecute el comando helm install que ejecutó anteriormente para que se volviera a ejecutar la aplicación de Laravel. Asegúrese de ejecutar el comando desde el directorio raíz de la aplicación:

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

A continuación, instale el controlador nginx-ingress en el clúster de Kubernetes utilizando el controlador Ingress de Nginx que mantiene Kubernetes:

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

Una vez completada la instalación, verá un resultado similar a este:

Output
NAME: nginx-ingress
LAST DEPLOYED: Mon May 18 13:28:34 2020
NAMESPACE: default
STATUS: deployed
REVISION: 1

También necesita un recurso de Ingress para exponer la implementación de la aplicación de Laravel. Cree un nuevo archivo denominado ingress.yml en el directorio raíz de la aplicación:

nano ./ingress.yml

Este archivo define el host de la aplicación, el administrador del certificado SSL, el servicio de backend y el nombre del puerto. Agregue las siguientes opciones de configuración, sustituyendo your_domain por el dominio de su elección:

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:
        - your_domain
      secretName: laravel-kubernetes-tls
  rules:
    - host: your_domain
      http:
        paths:
          - backend:
              serviceName: laravel-kubernetes-lamp
              servicePort: 80

Guarde y cierre el archivo.

A continuación, debería instalar Cert-Manager y crear un emisor que le permitirá crear certificados SSL de producción utilizando Let’s Encrypt. Cert-Manager requiere definiciones de recursos personalizados que puede aplicar desde el repositorio de Cert-Manager mediante la línea de comandos:

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

Esto creará varios recursos de Kubernetes que se mostrarán en la línea de comandos:

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 también requiere un espacio de nombres para aislarlo en el clúster de Kubernetes:

kubectl create namespace cert-manager

Obtendrá el siguiente resultado:

Output
namespace/cert-manager created

Debido a que el Cert-Manager de Jetstack no es uno de los charts que mantiene Kubernetes, también deberá agregar el repositorio de Helm para Jetstack. Ejecute el siguiente comando para habilitarlo en Helm:

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

Si se agrega de manera correcta, se mostrará el siguiente resultado:

Output
"jetstack" has been added to your repositories

Ahora está listo para instalar Cert-Manager en el espacio de nombres de cert-manager del clúster de Kubernetes:

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

Cuando finalice, verá un resumen del despliegue similar al siguiente:

Output
NAME: cert-manager
LAST DEPLOYED: Mon May 18 13:32:08 2020
NAMESPACE: cert-manager
STATUS: deployed
REVISION: 1

El archivo de configuración de Kubernetes production_issuer.yml es el último archivo que deberá agregar al directorio raíz de la aplicación de Laravel. Cree el archivo:

nano ./production_issuer.yml

Ahora, agregue lo siguiente:

apiVersion: cert-manager.io/v1alpha2
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    # Email address used for ACME registration
    email: your_email_address
    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

Guarde y cierre el archivo.

Let’s Encrypt enviará a your_email_address cualquier aviso importante y advertencia de vencimiento, así que asegúrese de agregar una dirección que revisará de manera regular. Guarde este archivo y cree un nuevo recurso en el clúster de Kubernetes para el recurso de Ingress y para el emisor de producción:

kubectl create -f ingress.yml
kubectl create -f production_issuer.yml

Por último, actualice los registros DNS de su nombre de dominio para que dirija un registro A a la dirección IP del equilibrador de carga. Para encontrar la dirección IP del controlador Ingress escriba:

kubectl get service nginx-ingress-controller

Output
NAME                       TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)                      AGE
nginx-ingress-controller   LoadBalancer   your_cluster_ip      your_external_ip   80:30187/TCP,443:31468/TCP   6m10s

Utilice la dirección your_external_ip como la dirección IP para su registro DNS tipo A. El proceso para actualizar los registros DNS varía en función de dónde gestiona los nombres de dominio y el hosting de DNS, pero si utiliza DigitalOcean, puede consultar nuestra guía sobre Cómo administrar registros DNS.

Una vez que se actualice el registro DNS y se genere el certificado SSL, la aplicación estará disponible en your_domain y se habilitará SSL.

Si bien la aplicación de PHP y la base de datos ya están conectadas, aún deberá ejecutar migraciones de base de datos. En el último paso, aprenderá a ejecutar los comandos Artisan en el pod de Kubernetes para realizar migraciones de base de datos y otras tareas comunes de mantenimiento.

Paso 6: Ejecutar comandos remotos

Mientras se ejecuta la aplicación de Laravel y se mantiene conectada a la base de datos de MySQL en Kubernetes, existen varias operaciones comunes que debería ejecutar en una nueva instalación de Laravel. Una tarea común que debería realizar son las migraciones de base de datos.

Antes de poder ejecutar un comando Artisan en la aplicación de Laravel, debe conocer el nombre del pod que está ejecutando el container de dicha aplicación. Puede ver todos los pods de su clúster de Kubernetes mediante la siguiente línea de comandos:

kubectl get pods

Verá un resultado similar a este:

Output
NAME                                             READY   STATUS    RESTARTS   AGE
laravel-kubernetes-lamp-77fb989b46-wczgb         2/2     Running   0          16m

Seleccione el pod para la implementación de laravel-kubernetes-lamp-.... Asegúrese de utilizar el nombre del resultado y no el que aparece arriba. Ahora puede ejecutar kubectl exec en él. Por ejemplo, ejecute una migración de base de datos utilizando el comando artisan migrate. Agregará el indicador --force porque está ejecutando el pod en producción:

kubectl exec laravel-kubernetes-lamp-77fb989b46-wczgb -- php artisan migrate --force

Este comando arrojará un resultado como el siguiente:

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)

De esta manera, implementó de manera exitosa Laravel 7 y MySQL en Kubernetes y realizó una tarea de mantenimiento de la base de datos indispensable.

Conclusión

En este tutorial, aprendió a disponer una aplicación PHP de Laravel en un container, conectarla con una base de datos de MySQL, introducir una imagen de Docker que contiene su código en Docker Hub y, luego, utilizar un chart de Helm para implementar esa imagen en un clúster de Kubernetes de DigitalOcean. Por último, agregó SSL y un nombre de dominio personalizado, y aprendió a ejecutar herramientas de línea de comandos en los pods en ejecución.

En comparación del hosting tradicional de la pila LAMP, Kubernetes y Helm ofrecen varias ventajas: escalabilidad, la capacidad de cambiar servicios sin tener que iniciar sesión en el servidor de manera directa, herramientas para realizar actualizaciones progresivas y control sobre el entorno de hosting. Dicho esto, la complejidad de utilizar contenedores y configurar la aplicación al principio eleva la barrera a la hora de comenzar a utilizarlos. Con esta guía como punto de partida, la implementación de Laravel en Kubernetes se vuelve factible. A partir de aquí, quizás quiera aprender más sobre la capacidad de Laravel o agregar herramientas de monitoreo a Kubernetes como Linkerd, que puede instalar de manera manual siguiendo nuestra guía o con un solo clic de DigitalOcean.