Como implantar o Laravel 7 e o MySQL no Kubernetes usando o Helm

O autor selecionou a Diversity in Tech Fund​​​​​ para receber uma doação como parte do programa Write for DOnations.

Introdução

O Laravel é um dos frameworks de aplicação PHP de código aberto mais populares atualmente. Ele é comumente implantado com um banco de dados MySQL, mas pode ser configurado para usar uma variedade de opções de armazenamento de dados de backend. O Laravel se orgulha de tirar proveito de muitos dos recursos modernos do PHP e do extenso ecossistema de pacotes.

O Kubernetes é uma plataforma de orquestração de contêiner que pode ser hospedada em clusters Kubernetes da DigitalOcean para retirar grande parte do trabalho de administração da instalação e operação de contêineres em produção. O Helm é um gerenciador de pacotes do Kubernetes que facilita a configuração e instalação de serviços e pods no Kubernetes.

Neste guia, você irá criar uma aplicação Laravel PHP, compilar sua aplicação dentro de uma imagem Docker, e implantar essa imagem em um cluster Kubernetes da DigitalOcean usando o LAMP Helm chart. Em seguida, você irá configurar um controlador Ingress para adicionar SSL e um nome de domínio personalizado à sua aplicação. Quando concluída, você terá uma aplicação Laravel funcionando conectada a um banco de dados MySQL que está em execução em um cluster do Kubernetes.

Pré-requisitos

• O Docker instalado na máquina a partir da qual você irá acessar seu cluster. Você pode encontrar instruções sobre como fazer a instalação do Docker para a maioria das distribuições Linux aqui ou no site do Docker para outros sistemas operacionais.
• Uma conta do Docker Hub para armazenar as imagens do Docker que você criará neste tutorial.
• Um cluster Kubernetes 1.17+ na DigitalOcean com sua conexão configurada como o kubectl padrão. Para aprender como criar um cluster Kubernetes na DigitalOcean, consulte o Kubernetes Quickstart. Para aprender como se conectar ao cluster, consulte How to Connect to a DigitalOcean Kubernetes Cluster.
• O gerenciador de pacotes Helm 3 instalado em sua máquina local. Complete o primeiro passo e adicione o repositório stable do segundo passo do tutorial How To Install Software on Kubernetes Clusters with the Helm 3 Package Manager.
• Um nome de domínio totalmente registrado com um registro A disponível. Este tutorial utilizará o your_domain durante todo o processo. Você pode comprar um nome de domínio em Namecheap, obter um gratuitamente em Freenom ou usar o registrado de domínios de sua escolha. No momento, não se preocupe em associar o registro A do seu domínio a um IP. Quando você chegar no Passo 5 e seu controlador Ingress estiver pronto, você irá conectar your_domain ao IP adequado.

Passo 1 — Criando uma nova aplicação Laravel

Neste passo, você irá usar o Docker para criar uma nova aplicação Laravel 7, mas você deve ser capaz de seguir o mesmo processo com uma aplicação Laravel existente que usa o MySQL como banco de banco de dados de backend. A nova aplicação que você compilar irá verificar se o Laravel está conectado ao banco de dados e exibirá o nome do banco de dados.

Primeiro, vá para seu diretório home e crie uma nova aplicação Laravel usando um contêiner Docker composer:

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

Depois que o contêiner estiver pronto e todos os pacotes do Composer estiverem instalados, você deve ver uma nova instalação do Laravel em seu diretório atual chamada laravel-kubernetes/. Navegue até essa pasta:

cd ~/laravel-kubernetes

Você executará o resto dos comandos deste tutorial a partir daqui.

O objetivo desta aplicação é testar a conexão do seu banco de dados e exibir seu nome no seu navegador. Para testar a conexão do banco de dados, abra o arquivo ./resources/views/welcome.blade.php em um editor de texto:

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

Encontre a seção <div class="links">...</div> e substitua seu conteúdo pelo seguinte:

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

Salve e feche o arquivo.

Essa é toda a personalização que você precisará fazer na aplicação Laravel padrão para este tutorial. Uma vez concluído, este breve trecho de PHP irá testar sua conexão com o banco de dados e exibirá o nome do banco de dados na tela de splash do Laravel em seu navegador Web.

No próximo passo, você irá usar o Docker para compilar uma imagem contendo esta aplicação Laravel e o Docker Compose para testar se ele funciona localmente e se conecta a um banco de dados MySQL.

Passo 2 — Conteinerizando sua aplicação Laravel

Agora que você criou uma nova aplicação Laravel, você precisará compilar seu código dentro de uma imagem Docker e então testar a imagem com o Docker Compose. Embora o objetivo deste tutorial seja implantar sua aplicação em um cluster Kubernetes, o Docker Compose é uma maneira conveniente de testar sua imagem e configuração do Docker localmente antes de executá-la na nuvem. Este loop de feedback rápido pode ser útil para fazer e testar pequenas mudanças.

Primeiro, usando o nano ou seu editor de texto preferido, crie um arquivo na raiz da sua aplicação Laravel chamado Dockerfile:

nano ./Dockerfile

Adicione o conteúdo a seguir: O Docker irá usar este arquivo para compilar seu código em uma imagem:

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"]

Salve e feche o arquivo.

Este Dockerfile começa com a imagem Docker PHP 7.4 Apache encontrada no Docker Hub, em seguida, instala vários pacotes Linux que são comumente exigidos pelas aplicações Laravel. Em seguida, ele cria arquivos de configuração do Apache e habilita reescritas de cabeçalho. O Dockerfile instala várias extensões PHP comuns e adiciona uma variável de ambiente para garantir que os logs do Laravel sejam transmitidos ao contêiner via stderr. Isso permitirá que você veja os logs do Laravel fazendo um tail dos logs do Docker Compose ou do Kubernetes.

Finalmente, o Dockerfile copia todo o código em sua aplicação Laravel para /var/www/tmp e instala as dependências do Composer. Em seguida, ele define um ENTRYPOINT, mas você precisará criar esse arquivo, o que faremos a seguir.

No diretório raiz do seu projeto, crie um novo arquivo chamado docker-entrypoint.sh. Este arquivo será executado quando o seu contêiner for executado localmente ou no cluster Kubernetes, e ele irá copiar seu código de aplicação Laravel a partir do diretório /var/www/tmp para /var/www/html onde o Apache será capaz de apresentá-lo.

nano ./docker-entrypoint.sh

Agora adicione o seguinte script:

#!/bin/bash

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

exec "$@"

A linha final, exec "$@" instrui o shell a executar qualquer comando que seja passado como um argumento de entrada a seguir. Isso é importante porque você quer que o Docker continue executando o comando Apache run (apache2-foreground) após este script ser executado. Salve e feche o arquivo.

Em seguida, crie um arquivo .dockerignore no diretório raiz da sua aplicação. Este arquivo irá garantir que quando você compilar sua imagem Docker ela não ficará poluída com pacotes ou arquivos de ambiente que não devem ser copiados para ela:

nano ./.dockerignore

.env
/vendor

Salve e feche o arquivo.

O último arquivo que você precisa criar antes que você possa executar sua aplicação localmente usando o Docker Compose é um arquivo docker-compose.yml. No entanto, durante a configuração deste arquivo YAML, você precisará inserir o APP_KEY que o Laravel gerou durante a instalação. Encontre isso abrindo e pesquisando o arquivo . /.env, ou executando os seguintes comandos cat e grep:

cat .env | grep ^APP_KEY

Você verá uma saída como esta:

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

Copie sua chave para sua área de transferência. Certifique-se de incluir o prefixo base64: Agora crie o arquivo docker-compose.yml no diretório raiz da sua aplicação:

nano ./docker-compose.yml

Aqui incluiremos a imagem PHP da sua aplicação Laravel, bem como um contêiner MySQL para executar o seu banco de dados. Adicione o conteúdo a seguir:

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}

Use a variável APP_KEY que você copiou para sua área de transferência para a variável your_laravel_app_key e use seu nome de usuário do Docker Hub para a variável your_docker_hub_username. Salve e feche o arquivo.

Você irá criar a primeira imagem localmente usando o docker build. A segunda imagem é a imagem Docker oficial do MySQL disponível no Docker Hub. Ambos exigem várias variáveis de ambiente, que você irá incluir quando você executar os contêineres.

Para compilar a imagem Docker que contém sua aplicação Laravel, execute o seguinte comando. Certifique-se de substituir your_docker_hub_username pelo nome de usuário ou nome de sua equipe no Docker Hub onde essa imagem será armazenada:

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

Em seguida, você pode executar os dois contêineres com o Docker Compose com as credenciais de banco de dados necessárias:

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

As quatro variáveis de ambiente usadas aqui (DB_ROOT_PASSWORD, DB_DATABASE, DB_USERNAME, DB_PASSWORD) podem ser modificadas se você quiser, mas uma vez que você está testando sua aplicação somente localmente, você não precisa se preocupar em protegê-las ainda.

Pode demorar até 30 segundos para que seu banco de dados MySQL inicialize e os contêineres estejam prontos. Depois que eles etiverem prontos, você pode visualizar sua aplicação Laravel em sua máquina em localhost:8000.

Sua aplicação PHP irá se conectar ao seu banco de dados MySQL. Após uma conexão bem-sucedida, o texto “Database Connected: local_db” irá aparecer sob o logotipo do Laravel.

Agora que você testou sua imagem Docker localmente usando o Docker Compose, você pode desligar os contêineres executando docker-compose down:

docker-compose down

Na próxima seção, você irá enviar sua imagem Docker para o Docker Hub para que seu Helm chart possa utilizá-la para implantar a aplicação no cluster Kubernetes.

Passo 3 — Enviando sua imagem Docker para o Docker Hub

O LAMP Helm Chart que você irá usar para implantar seu código no Kubernetes requer que seu código esteja disponível em um registro de contêiner. Embora você possa enviar sua imagem para um registro privado ou auto-hospedado, para os propósitos deste tutorial, você irá usar um registro Docker gratuito e disponível publicamente no Docker Hub.

Acesse sua conta no Docker Hub usando seu navegador Web e então crie um novo repositório chamado laravel-kubernetes.

Em seguida, se você não tiver conectado ao Docker Hub a partir de sua máquina local, você precisará fazer login no Docker Hub. Você pode fazer isso através da linha de comando:

docker login -u your_docker_hub_username

Digite suas credenciais de login quando solicitado. Isso normalmente só precisa ser feito uma vez por máquina, pois o Docker irá salvar suas credenciais em ~/.docker/config.json em seu diretório home.

Finalmente, envie sua imagem para o Docker Hub:

docker push your_docker_hub_username/laravel-kubernetes:latest

Pode demorar alguns minutos para fazer upload da sua aplicação dependendo da velocidade da sua conexão, mas uma vez que o Docker tiver feito, você verá um digest hash final e o tamanho da sua imagem no terminal. Eles se parecerão com isso:

Output
latest: digest: sha256:df4bdeda91484c8c26a989b13b8f27ab14d93ab2e676e3c396714cb3811c4086 size: 4918

Agora que sua aplicação Laravel está conteinerizada e você enviou uma imagem para o Docker Hub, use a imagem em uma implantação do Helm Chart ou do Kubernetes. No próximo passo, você irá definir valores personalizados com base no LAMP Helm Chart e implantá-los em seu cluster Kubernetes.na DigitalOcean.

Passo 4 — Configurando e implantando a aplicação com o LAMP Helm Chart

O Helm fornece uma variedade de Charts para ajudá-lo a configurar aplicações Kubernetes usando combinações predefinidas de ferramentas. Embora você possa escrever seus próprios arquivos de serviço do Kubernetes para realizar uma implantação semelhante, você verá nesta seção que usar um Helm Chart irá exigir muito menos configuração.

Primeiro, você precisará de um diretório para armazenar todos os seus arquivos de configuração do Helm. Crie um novo diretório na raiz do seu projeto Laravel chamado helm/:

mkdir ./helm

Dentro do diretório helm/, você irá criar dois novos arquivos: values.yml e secrets.yml. Primeiro, crie e abra values.yml:

nano ./helm/values.yml

O arquivo values.yml irá incluir opções de configuração não secretas que irão substituir os valores padrão no LAMP Helm chart. Adicione as seguintes configurações, certificando-se de substituir your_docker_hub_username pelo seu próprio nome de usuário:

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

Salve e feche o arquivo.

Agora crie um arquivo secrets.yml:

nano ./helm/secrets.yml

secrets.yml não será verificado no controle de versão. Ele irá conter informações de configuração confidenciais como a senha do seu banco de dados e a chave da aplicação Laravel. Adicione as seguintes configurações, ajustando-as conforme necessário para corresponder às suas credenciais:

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"

Certifique-se de usar combinações de nome de usuário e senha fortes para seu banco de dados de produção, e use a mesma your_laravel_app_key como acima, ou abra uma nova janela de terminal e gere uma nova chave executando o seguinte comando. Você pode então copiar o novo valor que o Laravel definir em seu arquivo .env:

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

Salve e feche o arquivo secrets.yml.

Em seguida, para evitar que seu arquivo secrets.yml seja incorporado na imagem Docker ou salvo no controle de versão, certifique-se de adicionar a seguinte linha a ambos os arquivos .dockerignore e .gitignore. Abra e acrescente /helm/secrets.yml a cada arquivo, ou execute o seguinte comando para adicionar ambos:

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

Agora que você criou arquivos de configuração do Helm para sua aplicação e a imagem Docker, você pode instalar este Helm chart como uma nova versão em seu cluster Kubernetes. Instale seu chart a partir do diretório raiz da sua aplicação:

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

Você verá uma saída como esta:

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

Sua aplicação irá demorar um ou dois minutos para se tornar disponível, mas você pode executar este comando para monitorar os serviços Kubernetes em seu cluster:

kubectl get services -w

Procure pelo nome da sua aplicação:

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

Quando seu novo serviço laravel-kubernetes-lamp exibir um endereço IP sob EXTERNAL-IP, você pode visitar your_external_ip para ver a aplicação em execução no seu cluster Kubernetes. Sua aplicação irá se conectar ao seu banco de dados e você verá o nome do banco de dados abaixo do logotipo do Laravel, como você fez ao executar sua aplicação localmente no Docker Compose.

Executar uma aplicação Web em um endereço IP desprotegido pode não ser um problema para uma prova de conceito, mas seu site não está pronto para a produção sem um certificado SSL e um nome de domínio personalizado. Antes de configurar isso no próximo passo, desinstale seu release através da linha de comando:

helm delete laravel-kubernetes

No próximo passo, você irá expandir esta primeira configuração do Helm para adicionar um controlador Ingress, um certificado SSL e um domínio personalizado à sua aplicação Laravel.

Passo 5 — Adicionando um controlador Ingress e SSL ao seu cluster Kubernetes

No Kubernetes, um controlador Ingress é responsável por expor os serviços da sua aplicação à internet. No passo anterior, o LAMP Helm chart criou um balanceador de carga da DigitalOcean e expôs sua aplicação diretamente através do endereço IP do balanceador.

Você pode terminar o SSL e seu nome de domínio diretamente no balanceador de carga, mas como você está trabalhando no Kubernetes, pode ser mais conveniente gerenciar tudo isso no mesmo lugar. Para saber muito mais sobre controladores Ingress e detalhes sobre os seguintes passos, leia o tutorial How To Set Up an Nginx Ingress on DigitalOcean Kubernetes Using Helm.

O LAMP Helm chart inclui uma opção de configuração para suportar o Ingress. Abra seu arquivo helm/values.yml:

nano ./helm/values.yml

Agora, adicione as linhas a seguir:

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

Isso instrui sua implantação a não instalar um balanceador de carga e, em vez disso, expor a aplicação à porta 80 do cluster Kubernetes, onde o controlador Ingress irá expô-la à internet. Salve e feche o arquivo values.yml.

Agora, execute o comando helm install que você executou anteriormente para que sua aplicação Laravel seja executada novamente. Certifique-se de executar o comando a partir do diretório raiz da sua aplicação:

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

Em seguida, instale o controlador nginx-ingress em seu cluster Kubernetes usando o controlador Ingress Nginx mantido pelo Kubernetes:

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

Depois da instalação, você verá uma saída como esta:

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

Você também precisa de um recurso ou Resource Ingress para expor sua implantação da aplicação Laravel. Crie um novo arquivo no diretório raiz da sua aplicação chamado ingress.yml:

nano ./ingress.yml

Este arquivo define o host da sua aplicação, o gerenciador de certificados SSL e o serviço de backend e o nome da porta. Adicione as seguintes configurações, substituindo your_domain pelo domínio da sua escolha:

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

Salve e feche o arquivo.

Em seguida, você deve instalar o Cert-Manager e criar um emissor que lhe permitirá criar certificados SSL de produção usando o Let’s Encrypt. O Cert-Manager requer Definições de Recursos Personalizadas que você pode aplicar a partir do repositório Cert-Manager usando a linha de comando:

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

Isto irá criar uma série de recursos do Kubernetes que serão exibidos na linha de comando:

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

O Cert-Manager também requer um namespace para isolá-lo em seu cluster Kubernetes:

kubectl create namespace cert-manager

Você verá esta saída:

Output
namespace/cert-manager created

Como o Cert-Manager do Jetstack não é um dos charts mantidos pelo Kubernetes, você precisará adicionar o repositório Helm do Jetstack também. Execute o seguinte comando para torná-lo disponível no Helm:

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

Uma adição bem sucedida irá exibir o seguinte:

Output
"jetstack" has been added to your repositories

Agora você está pronto para instalar o Cert-Manager no namespace cert-manager em seu cluster Kubernetes:

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

Quando terminar, você verá um resumo da implantação como este:

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

O último arquivo que você precisará adicionar ao diretório raiz da sua aplicação Laravel é um arquivo de configuração do Kubernetes production_issuer.yml. Crie o arquivo:

nano ./production_issuer.yml

Agora, adicione o seguinte:

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

Salve e feche o arquivo.

O Let’s Encrypt irá enviar para your_email_address quaisquer avisos importantes e avisos de expiração, então certifique-se de adicionar um endereço que você irá verificar regularmente. Salve este arquivo e crie um novo recurso tanto para o seu recurso Ingress quanto para o emissor de produção em seu cluster Kubernetes:

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

Finalmente, atualize os registros DNS do seu nome de domínio para apontar um registro A para o endereço IP do seu balanceador de carga. Para encontrar o endereço IP para seu controlador Ingress digite:

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

Use o endereço your_external_ip como o endereço IP para seu registro A no DNS. O processo para atualizar seus registros DNS varia dependendo do local onde você gerencia seus nomes de domínio e hospedagem DNS, mas se você estiver usando a DigitalOcean você pode buscar referência em nosso guia How to Manage DNS Records.

Depois que seus registros de DNS atualizarem e seu certificado SSL for gerado, sua aplicação estará disponível em your_domain e o SSL estará habilitado.

Embora sua aplicação PHP e seu banco de dados já estejam conectados, você ainda precisará executar as migrações de banco de dados. No último passo, você verá como executar comandos Artisan em seu pod Kubernetes para realizar migrações de banco de dados e outras tarefas comuns de manutenção.

Passo 6 — Executando comandos remotos

Embora sua aplicação Laravel esteja executando e esteja conectada ao banco de dados MySQL no Kubernetes, há várias operações comuns que você deve executar em uma nova instalação do Laravel. Uma tarefa comum que você deve realizar são as migrações de banco de dados.

Antes que você possa executar um comando Artisan em sua aplicação Laravel, você precisa saber o nome do pod que está executando seu contêiner da aplicação Laravel. Usando a linha de comando, você pode visualizar todos os pods em seu cluster Kubernetes:

kubectl get pods

Você verá uma saída como esta:

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

Selecione o pod para sua implantação laravel-kubernetes-lamp-.... Certifique-se de usar o nome em sua saída e não o que está listado acima. Agora, você pode executar o kubectl exec nele. Por exemplo, execute uma migração de banco de dados usando o comando artisan migrate. Você irá adicionar a flag --force porque você está executando o pod em produção:

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

Este comando irá produzir uma saída:

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)

Agora, você implantou com sucesso o Laravel 7 e o MySQL no Kubernetes e realizou uma tarefa essencial de manutenção de banco de dados.

Conclusão

Neste tutorial, você aprendeu como conteinerizar uma aplicação PHP Laravel, conectar-se a um banco de dados MySQL, enviar uma imagem Docker contendo o seu código para o Docker Hub, e então usar um Helm chart para implantar essa imagem em um cluster Kubernetes da DigitalOcean. Finalmente, você adicionou SSL e um nome de domínio personalizado e aprendeu como executar ferramentas de linha de comando em seus pods em execução.

O Kubernetes e o Helm lhe oferecem uma série de vantagens em relação à tradicional hospedagem de pilhas LAMP: escalabilidade, a capacidade de alternar serviços sem precisar fazer login diretamente no seu servidor, ferramentas para realizar atualizações contínuas e controlar seu ambiente de hospedagem. Dito isso, a complexidade de inicialmente conteinerizar e configurar sua aplicação torna a barreira para começar bastante alta. Com este guia como ponto de partida, implantar o Laravel no Kubernetes torna-se mais acessível. A partir daqui você pode considerar aprender mais sobre o poder do Laravel ou adicionar ferramentas de monitoramento ao Kubernetes como o Linkerd, que você pode instalar manualmente com nosso guia ou com um droplet 1-Click da DigitalOcean.