One place for hosting & domains

      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:

      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:

      ./resources/views/welcome.blade.php

      ...
      <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:

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

      ./Dockerfile

      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:

      ./docker-entrypoint.sh

      #!/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:

      ./.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:

      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:

      ./docker-compose.yml

      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.

      The Laravel application running locally using Docker Compose

      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:

      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.

      Creating a new repository on Docker Hub

      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.

      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/:

      Dentro do diretório helm/, você irá criar dois novos arquivos: values.yml e secrets.yml. Primeiro, crie e abra 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:

      ./helm/values.yml

      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:

      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:

      ./helm/secrets.yml

      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:

      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.

      The Laravel application running on Kubernetes using the LAMP Helm chart

      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:

      Agora, adicione as linhas a seguir:

      ./helm/values.yml

      ...
      # 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:

      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:

      ./ingress.yml

      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.

      The Laravel application with SSL termination and a custom domain name

      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:

      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.



      Source link