One place for hosting & domains

      implantar

      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

      Como implantar e gerenciar seu DNS usando o DNSControl no Debian 10


      O autor selecionou a Electronic Frontier Foundation, Inc para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O DNSControl é uma ferramenta de infraestrutura como código que permite a implantação e gerenciamento de suas zonas DNS (Sistema de Nomes de Domínios, do inglês Domain Name System) usando princípios de desenvolvimento de software padrão, incluindo o controle, teste e implantação automática de versão. O DNSControl foi criado pelo Stack Exchange e foi escrito em Go.

      O DNSControl elimina muitas das armadilhas do gerenciamento manual de DNS, considerando que os arquivos da zona ficam armazenados em um formato programável. Isso permite que você implante zonas para vários provedores de DNS simultaneamente, identifique erros de sintaxe e envie a configuração DNS automaticamente, reduzindo o risco de erro humano. Outro uso comum do DNSControl é a migração rápida de seu DNS para um provedor diferente; por exemplo, no caso de um ataque DDoS ou uma interrupção do sistema.

      Neste tutorial, você instalará e configurará o DNSControl, criará uma configuração básica do DNS e começará a implantar registros DNS em um provedor ativo. Como parte deste tutorial, usaremos a DigitalOcean como o provedor DNS do exemplo. Se quiser usar um provedor diferente, a configuração é bastante parecida. Quando terminar, você conseguirá gerenciar e testar sua configuração de DNS em um ambiente seguro e offline e, depois, poderá implantá-lo para a produção.

      Pré-requisitos

      Antes de iniciar este guia, você precisará do seguinte:

      • Um servidor Debian 10 configurado de acordo com as instruções no artigo Configuração Inicial do servidor com o Debian 10, incluindo um usuário não raiz sudo e o firewall habilitado para bloquear portas não essenciais. O your-server-ipv4-address se refere ao endereço IP do servidor onde você estiver hospedando seu site ou domínio. O your-server-ipv6-address se refere ao endereço IPv6 do servidor onde você estiver hospedando seu site ou domínio.
      • Um nome de domínio devidamente registrado com o DNS hospedado por um provedor compatível. Este tutorial usará o your_domain durante todo o processo e a DigitalOcean como a provedora de serviço.
      • Uma chave de API para a DigitalOcean (Token de acesso pessoal), com permissões de leitura e gravação. Para criar uma chave, acesse a página Como criar um Token de acesso pessoal.

      Assim que estiver com tudo pronto, faça login no seu servidor como usuário não raiz para começar.

      Passo 1 — Como instalar o DNSControl

      O DNSControl foi escrito em Go, de modo que você começará este passo instalando o Go em seu servidor e configurando o seu GOPATH.

      O Go está disponível dentro dos repositórios padrão de software do Debian, possibilitando que ele seja instalado com as ferramentas de gerenciamento de pacotes convencionais.

      Também será necessário instalar o Git, pois ele é necessário para permitir que o Go baixe e instale o software DNSControl a partir de seu repositório no GitHub.

      Comece atualizando o índice local de pacotes para refletir quaisquer novas alterações feitas no pacote original (upstream):

      Em seguida, instale os pacotes golang-go e git:

      • sudo apt install golang-go git

      Após confirmar a instalação, a ferramenta apt irá baixar e instalar o Go e o Git, bem como todas as suas respectivas dependências.

      Em seguida, você irá configurar as variáveis de ambiente path necessárias para o Go. Se quiser saber mais sobre isso, leia o tutorial Entendendo o GOPATH. Comece editando o arquivo ~/.profile:

      Adicione as seguintes linhas ao final do seu arquivo:

      ~/.profile

      ...
      export GOPATH="$HOME/go"
      export PATH="$PATH:$GOPATH/bin"
      

      Assim que tiver adicionado essas linhas ao final do arquivo, salve e feche o arquivo. Em seguida, recarregue seu perfil - seja fazendo log-off e fazendo log-in de volta, ou fornecendo o arquivo novamente:

      Agora que você instalou e configurou o Go, instale o DNSControl.

      O comando go get pode ser usado para obter uma cópia do código, compilá-lo automaticamente e instalá-lo dentro do seu diretório Go:

      • go get github.com/StackExchange/dnscontrol

      Assim que terminar, verifique a versão instalada para garantir que tudo está funcionando:

      Sua saída será semelhante à seguinte:

      Output

      dnscontrol 2.9-dev

      Se ver um erro dnscontrol: command not found, verifique novamente sua configuração de caminho do Go.

      Agora que você instalou o DNSControl, você pode criar um diretório de configuração e conectar o DNSControl ao seu provedor de DNS, a fim de permitir que ele faça alterações em seus registros de DNS.

      Passo 2 — Configurando o DNSControl

      Neste passo, você criará os diretórios de configuração necessários para o DNSControl e o conectará ao seu provedor de DNS para que ele possa começar a fazer alterações dinâmicas (em tempo real) nos seus registros do DNS.

      Primeiro, crie um novo diretório no qual você possa armazenar sua configuração do DNSControl e, então, vá para ele:

      • mkdir ~/dnscontrol
      • cd ~/dnscontrol

      Nota: este tutorial se concentrará na configuração inicial do DNSControl; no entanto, para o uso na produção, é recomendável armazenar sua configuração do DNSControl em um sistema de controle de versão (VCS) como o Git. As vantagens de se usar um VCS incluem o controle total de versões, integração com CI/CD para teste, reverter implantações sem interrupções e assim por diante.

      Se quiser usar o DNSControl para escrever arquivos de zona no BIND, crie também o diretório zones:

      Os arquivos de zona do BIND são um método bruto e padronizado para armazenar zonas/registros do DNS em formato de texto simples. Eles foram originalmente usados para o software de servidor de DNS BIND, mas agora são amplamente adotados como o método padrão para armazenar zonas de DNS. Os arquivos de zona no BIND produzidos pelo DNSControl são úteis caso queira importá-los para um servidor DNS personalizado ou auto-hospedado, ou para fins de auditoria.

      No entanto, se quiser usar o DNSControl para forçar alterações do DNS em um provedor gerenciado, o diretório zones não será necessário.

      Em seguida, você precisa configurar o arquivo creds.json, que é o que permitirá que o DNSControl se autentique para seu provedor DNS e faça as alterações. O formato creds.json difere ligeiramente, dependendo do provedor de DNS que você estiver usando. Para encontrar a configuração do seu próprio provedor, consulte a Lista de provedores de serviço na documentação oficial do DNSControl.

      Crie o arquivo creds.json no diretório ~/dnscontrol:

      • cd ~/dnscontrol
      • nano creds.json

      Adicione a configuração do creds.json do exemplo para o seu provedor de DNS ao arquivo. Se estiver usando o DigitalOcean como seu provedor fr DNS, você pode usar o seguinte:

      ~/dnscontrol/creds.json

      {
      "digitalocean": {
        "token": "your-digitalocean-oauth-token"
      }
      }
      

      Esse arquivo diz ao DNSControl com quais provedores de DNS você quer que ele se conecte.

      Você precisará fornecer alguma forma de autenticação para seu provedor de DNS. Normalmente, essa autenticação consiste em uma chave de API ou token do OAuth, mas alguns provedores exigem informações extra, conforme documentado na Lista de provedores de serviço na documentação oficial do DNSControl.

      Aviso: esse token dará acesso à conta do seu provedor de DNS; dessa maneira, você deve protegê-lo, do mesmo modo que faria com uma senha. Além disso, se você estiver usando um sistema de controle de versão, certifique-se de que o arquivo que contém o token seja excluído (por exemplo, usando o .gitignore) ou criptografado de maneira segura.

      Se estiver usando o DigitalOcean como seu provedor de DNS, você pode usar o token do OAuth necessário em suas configurações de conta do DigitalOcean que você gerou como parte dos pré-requisitos.

      Se você tiver vários provedores de DNS — por exemplo, para nomes de domínios múltiplos, ou zonas de DNS delegadas—você pode definir todos eles no mesmo arquivo creds.json.

      Você definiu os diretórios de configuração inicial do DNSControl e configurou o creds.json para permitir que o DNSControl autentique seu provedor de DNS e faça alterações. Em seguida, você criará a configuração para suas zonas de DNS.

      Passo 3 — Criando um arquivo de configuração de DNS

      Neste passo, você criará um arquivo de configuração inicial do DNS, o qual terá os registros de DNS relacionados ao seu nome de domínio ou à zona de DNS delegada.

      O dnsconfig.js é o arquivo principal de configuração de DNS para o DNSControl. Neste arquivo, as zonas de DNS e seus registros correspondentes são definidos usando a sintaxe do JavaScript. Isso é conhecido como DSL, ou Linguagem Específica de Domínio. A página de DSL do JavaScript - na documentação oficial do DNSControl, fornece mais detalhes.

      Para começar, crie o arquivo de configuração do DNS no diretório ~/dnscontrol:

      • cd ~/dnscontrol
      • nano dnsconfig.js

      Então, adicione a seguinte configuração de exemplo ao arquivo:

      ~/dnscontrol/dnsconfig.js

      // Providers:
      
      var REG_NONE = NewRegistrar('none', 'NONE');
      var DNS_DIGITALOCEAN = NewDnsProvider('digitalocean', 'DIGITALOCEAN');
      
      // Domains:
      
      D('your_domain', REG_NONE, DnsProvider(DNS_DIGITALOCEAN),
        A('@', 'your-server-ipv4-address')
      );
      

      Esse arquivo de exemplo define um nome de domínio ou uma zona de DNS em um provedor em particular que, neste caso, é o your_domain, hospedado pelo DigitalOcean. Um registro de exemplo A também é definido para a zona raiz (@), que aponta para o endereço de IPv4 do servidor no qual você está hospedando seu domínio/site.

      Existem três funções principais que constituem um arquivo de configuração básica de DNSControl:

      • NewRegistrar(name, type, metadata): define o registrador de domínios para o seu nome de domínio. O DNSControl pode usar esse registrador para fazer as alterações necessárias, como modificar os servidores de nomes autorizados. Se quiser usar o DNSControl somente para gerenciar suas zonas de DNS, isso geralmente pode ser deixado como NONE.

      • NewDnsProvider(name, type, metadata)​​​: define um provedor de serviços de DNS para seu nome de domínio ou zona delegada. É aqui que o DNSControl irá forçar as alterações do DNS que você fez.

      • D(name, registrar, modifiers): define um nome de domínio ou zona de DNS delegada para o DNSControl gerenciar, além dos registros de DNS presentes na zona.

      Você deve configurar o NewRegistrar(), o NewDnsProvider() e o D(), conforme for o caso, usando a Lista de provedores de serviços da documentação oficial do DNSControl.

      Se você está usando o DigitalOcean como seu provedor de DNS e precisa ter a capacidade de fazer alterações no DNS (e não em servidores de nome autorizados), o exemplo do bloco de código anterior já está correto.

      Assim que terminar, salve e feche o arquivo.

      Neste passo, você definiu um arquivo de configuração de DNS para o DNSControl, com os fornecedores relevantes definidos. Em seguida, você irá preencher o arquivo com alguns registros úteis de DNS.

      Passo 4 — Preenchendo seu arquivo de configuração de DNS

      Na sequência, você pode preencher o arquivo de configuração de DNS com registros de DNS úteis para o seu site ou serviço, usando a sintaxe do DNSControl.

      Ao contrário dos arquivos tradicionais de zona no BIND, nos quais os registros de DNS são escritos em um formato bruto, linha por linha, os registros DNS dentro do DNSControl são definidos como um parâmetro de função (modificador de domínio) para a função D(), como mostrado brevemente no Passo 3.

      Existe um modificador de domínio para cada um dos tipos de registro padrão de DNS, incluindo A, AAAA, MX, TXT, NS, CAA e assim por diante. Na seção de Modificadores de domínios, da documentação sobre o DNSControl, você encontra uma lista completa dos tipos de registro disponíveis.

      Os modificadores de registros individuais também estão disponíveis (modificadores de registro). Atualmente, eles são usados principalmente para definir a vida útil (TTL ou time to live) de registros individuais. Você encontra a lista completa dos modificadores de registros disponíveis na seção de Modificadores de registro da documentação sobre o DNSControl. Os modifiers de registro são opcionais e, na maioria dos casos de uso básico, podem ser deixados de fora.

      A sintaxe para definir registros de DNS varia ligeiramente em relação a cada tipo de registro. Em seguida, temos alguns exemplos dos tipos de registros mais comuns:

      • Registros do tipo A:

        • Objetivo: apontar para um endereço de IPv4.
        • Sintaxe: A('name', 'address', optional record modifiers)​​​
        • Exemplo: A('@', 'your-server-ipv4-address', TTL(30))
      • Registros do tipo AAAA:

        • Objetivo: apontar para um endereço de IPv6.
        • Sintaxe: AAAA('name', 'address', optional record modifiers)
        • Exemplo: AAAA('@', 'your-server-ipv6-address') (modificador de registro deixado de lado para que a vida útil (TTL) padrão seja usada)
      • Registros do tipo CNAME:

        • Objetivo: transformar o seu domínio/subdomínio em alias de outro.
        • Sintaxe: CNAME('name', 'target', optional record modifiers)
        • Exemplo: CNAME('subdomain1', 'example.org.') (note que um ponto final, ., deve ser incluído se houver pontos no valor)
      • Registros do tipo MX:

        • Objetivo: direcionar e-mails para servidores/endereços específicos.
        • Sintaxe: MX('name', 'priority', 'target', optional record modifiers)
        • Exemplo: MX('@', 10, 'mail.example.net') (note que um ponto final, ., deve ser incluído se houver pontos no valor)
      • Registros do tipo TXT:

        • Objetivo: adicionar texto simples arbitrário, frequentemente usado para configurações sem seu próprio tipo de registro dedicado.
        • Sintaxe: TXT('name', 'content', optional record modifiers)
        • Exemplo: TXT('@', 'This is a TXT record. ')​​​
      • Registros do tipo CAA:

        • Objetivo: restringir e informar sobre as Autoridades de Certificação (CAs) que poderão emitir os certificados de TLS para os seus domínios/subdomínios.
        • Sintaxe: CAA('name', 'tag', 'value', optional record modifiers)
        • Exemplo: CAA('@', 'issue', 'letsencrypt.org')

      Para começar a adicionar registros de DNS ao seu domínio ou zona de DNS delegada, edite seu arquivo de configuração de DNS:

      Em seguida, você pode começar a preencher os parâmetros da função D() existente, usando a sintaxe descrita na lista anterior, além da seção de Modificadores de domínios da documentação oficial sobre DNSControl. Uma vírgula (,) deve ser usada entre cada registro.

      A título de referência, este bloco de código contém um exemplo da configuração completa de uma definição básica, inicial do DNS:

      ~/dnscontrol/dnsconfig.js

      ...
      
      D('your_domain', REG_NONE, DnsProvider(DNS_DIGITALOCEAN),
        A('@', 'your-server-ipv4-address'),
        A('www', 'your-server-ipv4-address'),
        A('mail', 'your-server-ipv4-address'),
        AAAA('@', 'your-server-ipv6-address'),
        AAAA('www', 'your-server-ipv6-address'),
        AAAA('mail', 'your-server-ipv6-address'),
        MX('@', 10, 'mail.your_domain.'),
        TXT('@', 'v=spf1 -all'),
        TXT('_dmarc', 'v=DMARC1; p=reject; rua=mailto:abuse@your_domain; aspf=s; adkim=s;')
      );
      

      Assim que tiver completado sua configuração inicial do DNS, salve e feche o arquivo.

      Neste passo, você configurou o arquivo de configuração inicial do DNS, contendo seus registros de DNS. Em seguida, você testará a configuração e a implantará.

      Passo 5 — Testando e implantando sua configuração de DNS

      Neste passo, você executará uma verificação local da sintaxe em sua configuração de DNS e, em seguida, implantará as alterações no servidor/provedor ativo de DNS.

      Primeiro, vá até seu diretório dnscontrol:

      Em seguida, utilize a função preview do DNSControl para verificar a sintaxe do seu arquivo e mostrar quais alterações ele irá fazer (sem realmente fazer as alterações):

      Se a sintaxe do seu arquivo de configuração do DNS estiver correta, o DNSControl mostrará um panorama das alterações que ele irá fazer. Isso deve ser semelhante ao seguinte:

      Output

      ******************** Domain: your_domain ----- Getting nameservers from: digitalocean ----- DNS Provider: digitalocean...8 corrections #1: CREATE A your_domain your-server-ipv4-address ttl=300 #2: CREATE A www.your_domain your-server-ipv4-address ttl=300 #3: CREATE A mail.your_domain your-server-ipv4-address ttl=300 #4: CREATE AAAA your_domain your-server-ipv6-address ttl=300 #5: CREATE TXT _dmarc.your_domain "v=DMARC1; p=reject; rua=mailto:abuse@your_domain; aspf=s; adkim=s;" ttl=300 #6: CREATE AAAA www.your_domain your-server-ipv6-address ttl=300 #7: CREATE AAAA mail.your_domain your-server-ipv6-address ttl=300 #8: CREATE MX your_domain 10 mail.your_domain. ttl=300 ----- Registrar: none...0 corrections Done. 8 corrections.

      Se ver um aviso de erro em sua saída, o DNSControl dará detalhes sobre o que está errado e onde o erro está localizado dentro do seu arquivo.

      Aviso: o próximo comando fará alterações dinâmicas nos seus registros do DNS e possivelmente em outras configurações. Certifique-se de que esteja preparado para isso, incluindo fazendo um um backup da sua configuração de DNS existente, além de garantir que tenha os meios para reverter o processo, se necessário.

      Por fim, você pode enviar as alterações para seu provedor de DNS ativo:

      Você verá uma saída similar à seguinte:

      Output

      ******************** Domain: your_domain ----- Getting nameservers from: digitalocean ----- DNS Provider: digitalocean...8 corrections #1: CREATE TXT _dmarc.your_domain "v=DMARC1; p=reject; rua=mailto:abuse@your_domain; aspf=s; adkim=s;" ttl=300 SUCCESS! #2: CREATE A your_domain your-server-ipv4-address ttl=300 SUCCESS! #3: CREATE AAAA your_domain your-server-ipv6-address ttl=300 SUCCESS! #4: CREATE AAAA www.your_domain your-server-ipv6-address ttl=300 SUCCESS! #5: CREATE AAAA mail.your_domain your-server-ipv6-address ttl=300 SUCCESS! #6: CREATE A www.your_domain your-server-ipv4-address ttl=300 SUCCESS! #7: CREATE A mail.your_domain your-server-ipv4-address ttl=300 SUCCESS! #8: CREATE MX your_domain 10 mail.your_domain. ttl=300 SUCCESS! ----- Registrar: none...0 corrections Done. 8 corrections.

      Agora, se verificar as configurações de DNS do seu domínio no painel de controle do DigitalOcean, verá as alterações.

      Captura de tela do painel de controle do DigitalOcean, que mostra algumas alterações do DNS, feitas pelo DNSControl.

      Também é possível verificar a criação de registros, executando uma consulta de DNS em relação à sua zona de domínio/delegada usando o dig.

      Se não tiver o dig instalado, será necessário instalar o pacote dnsutils:

      • sudo apt install dnsutils

      Assim que instalar o dig, utilize-o para fazer uma pesquisa de DNS em relação ao seu domínio. Você verá que os registros foram atualizados de forma adequada:

      Você verá uma saída que mostra o endereço IP e o registro relevante de DNS da sua zona - que foi implantado usando o DNSControl. Os registros de DNS podem levar algum tempo para se propagarem, assim, talvez seja necessário esperar e executar esse comando novamente.

      Neste passo final, você executou uma verificação da sintaxe local do arquivo de configuração do DNS. Em seguida, implantou-a em seu provedor de DNS ativo e testou se as alterações foram feitas com êxito.

      Conclusão

      Neste artigo, você configurou o DNSControl e implantou uma configuração de DNS em um provedor ativo. Agora, você pode gerenciar e testar suas alterações de configuração do DNS em um ambiente seguro e offline, antes de implantá-las na produção.

      Se quiser explorar mais esse assunto, o DNSControl foi criado para se integrar ao seu pipeline de CI/CD (Integração Contínua/Entrega Contínua), o que lhe permite executar testes em profundidade e ter mais controle sobre sua implantação na produção. Você também pode pesquisar sobre a integração do DNSControl aos seus processos de compilação/implantação de infraestrutura, o que permite implantar servidores e adicioná-los ao DNS de maneira completamente automática.

      Se quiser avançar ainda mais com o DNSControl, os artigos do DigitalOcean, a seguir, apresentam alguns passos subsequentes interessantes para ajudar a integrar o DNSControl aos fluxos de trabalho de gerenciamento de alterações e implantação de infraestrutura:



      Source link

      Como implantar e gerenciar seu DNS usando o OctoDNS no Debian 10


      O autor selecionou a Fundação Electronic Frontier para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O OctoDNS é uma ferramenta de infraestrutura como código que permite que você implante e gerencie suas zonas de DNS usando princípios de desenvolvimento de software padrão, incluindo o controle, teste e implantação automatizada de versões. O OctoDNS foi criado pelo GitHub e está escrito em Python.

      O OctoDNS elimina muitas das armadilhas do gerenciamento manual de DNS, já que os arquivos da zona ficam armazenados em um formato estruturado (YAML). Isso permite que você implante zonas para vários provedores de DNS simultaneamente, identifique erros de sintaxe e envie a configuração do DNS automaticamente, reduzindo o risco de erro humano. Outro uso comum do OctoDNS é o de sincronizar sua configuração do DNS entre diferentes provedores, como um sistema de teste e de produção, ou entre ambientes ativos e de failover.

      O OctoDNS é parecido com o DNSControl, que é uma ferramenta equivalente criada pelo Stack Exchange e escrita em Go. Diferente do OctoDNS, o DNSControl utiliza uma linguagem de configuração baseada em JavaScript para definir as zonas de DNS, o que permite que você utilize recursos de programação avançados, tais como os loops para especificar vários registros semelhantes dentro da mesma zona. O artigo Como implantar e gerenciar seu DNS usando o DNSControl no Debian 10 aborda a instalação e configuração básicas do DNSControl.

      Neste tutorial, você instalará e configurará o OctoDNS, criará uma configuração básica do DNS e começará a implantar os registros do DNS em um provedor ativo. Como parte deste tutorial, usaremos a DigitalOcean como a provedora de DNS do exemplo. Se quiser usar um provedor diferente, a configuração é bastante parecida. Quando tiver concluído a configuração, você conseguirá gerenciar e testar sua configuração de DNS em um ambiente seguro e off-line e, então, poderá implantá-lo na produção.

      Pré-requisitos

      Antes de iniciar este guia, será necessário o seguinte:

      • Um servidor Debian 10 configurado, de acordo com o artigo Configuração Inicial do servidor com o Debian 10, incluindo um usuário não raiz do comando sudo e um firewall habilitado para bloquear portas não essenciais. O your-server-ipv4-address e o your-server-ipv6-address referem-se ao endereço IP do servidor onde você estiver hospedando seu site ou domínio.
      • Um nome de domínio totalmente registrado com o DNS hospedado por um provedor compatível. Este tutorial usará o your-domain durante todo o processo e a DigitalOcean como a provedora de serviços.
      • Uma chave de API para a DigitalOcean (Token de acesso pessoal), com permissões de leitura e gravação. Para criar um chave, acesse a página do artigo sobre Como criar um Token de acesso pessoal.

      Assim que estiver com tudo pronto, faça login no seu servidor como usuário não raiz para começar.

      Passo 1 — Instalando o OctoDNS

      O OctoDNS é distribuído como um pacote pip (sistema de gerenciamento de pacotes) em Python e funciona em um Ambiente Virtual Python (virtualenv). Dessa maneira, você iniciará este passo instalando os pacotes necessários para isso. Um virtualenv é um ambiente Python isolado que pode ter suas próprias bibliotecas e configuração, separado da instalação de Python do sistema principal. O Python e o virtualenv estão disponíveis dentro dos repositórios padrão de software do Debian, possibilitando que eles sejam instalados com as ferramentas convencionais de gerenciamento de pacotes.

      Comece atualizando o índice de pacotes local para refletir quaisquer novas alterações feitas no pacote original:

      Então, instale os pacotes python e virtualenv:

      • sudo apt install python virtualenv

      Após confirmar a instalação, a ferramenta apt irá baixar e instalar o Python, o virtualenv e todas as suas dependências necessárias.

      Em seguida, você criará os diretórios necessários para o OctoDNS, onde sua configuração do DNS e do programa serão armazenados. Comece criando os diretórios ~/octodns e ~/octodns/config:

      • mkdir ~/octodns ~/octodns/config

      Agora, vá para ~/octodns:

      Em seguida, você precisará criar o Ambiente Virtual em Python — um ambiente Python isolado com suas próprias bibliotecas e configuração no qual irá executar o OctoDNS:

      Ative seu ambiente com o seguinte comando:

      Isso irá gerar algo parecido com o seguinte:

      Output

      Running virtualenv with interpreter /usr/bin/python2 New python executable in /home/user/octodns/env/bin/python2 Also creating executable in /home/user/octodns/env/bin/python Installing setuptools, pkg_resources, pip, wheel...done.

      Agora, seu prompt de shell no Bash também será prefixado com o nome do ambiente virtual. Isso mostra que você está operando dentro do virtualenv no momento:

      (env) user@digitalocean:~/octodns$
      

      Se quiser sair do virtualenv, utilize o comando deactivate a qualquer momento. No entanto, para continuar com este tutorial, você deve permanecer em seu virtualenv.

      Agora que você instalou e configurou o Python e o virtualenv, instale o OctoDNS. O OctoDNS é distribuído como um pacote pip do Python, que é a ferramenta padrão de gerenciamento de pacotes para pacotes e bibliotecas do Python.

      Você pode instalar o pacote pip do OctoDNS usando o seguinte comando dentro do seu virtualenv:

      Assim que terminar, verifique a versão instalada para garantir que tudo está funcionando:

      Sua saída será semelhante à seguinte:

      Output

      octoDNS 0.9.9

      Caso veja um erro octodns-sync: command not found, verifique novamente se você ainda está dentro do seu virtualenv.

      Agora que você instalou o OctoDNS, você pode criar os arquivos de configuração necessários para conectar o OctoDNS ao seu provedor de DNS para permitir que ele faça alterações nos seus registros de DNS.

      Passo 2 — Configurando o OctoDNS

      Neste passo, você criará os arquivos de configuração necessários para o OctoDNS e conectará ele ao seu provedor DNS, de modo que ele possa começar a fazer alterações em tempo real nos seus registros de DNS.

      Nota: este tutorial se concentrará na configuração inicial do OctoDNS; no entanto, para o uso na produção, é recomendável armazenar sua configuração do OctoDNS em um sistema de controle de versão (VCS) como o Git. As vantagens de se usar um VCS incluem o controle total de versões, integração com CI/CD para teste, reverter implantações sem interrupções e assim por diante.

      Primeiro, você precisa configurar o arquivo config.yaml, o qual define as zonas de DNS a serem gerenciadas pelo OctoDNS e permite que ele autentique seu provedor de DNS e faça alterações.

      Dependendo do provedor de DNS que você estiver usando o formado do arquivo config.yaml será ligeiramente diferente. Para encontrar a configuração para o seu provedor, consulte a Lista de provedores compatíveis na documentação oficial do OctoDNS. Ao visualizar esse hiperlink, os detalhes da configuração serão apresentados como comentários de código no código Python em si, que está vinculado na coluna ‘Provedor’ da tabela. Assim que tiver encontrado o código Python para o seu provedor, como o cloudflare.py ou o route53.py, o comentário de código relevante poderá ser encontrado diretamente sob a class ProviderNameProvider. Por exemplo:

      Excerpt of octodns/provider/route53.py

      class Route53Provider(BaseProvider):
        '''
        AWS Route53 Provider
        route53:
            class: octodns.provider.route53.Route53Provider
            # The AWS access key id
            access_key_id:
            # The AWS secret access key
            secret_access_key:
            # The AWS session token (optional)
            # Only needed if using temporary security credentials
            session_token:
      

      Vá para o diretório ~/octodns/config:

      Então, crie e abra o config.yaml para a edição:

      Adicione a configuração de exemplo do arquivo config.yaml do seu provedor de DNS ao arquivo. Se estiver usando a DigitalOcean como sua provedora de DNS, você pode usar o seguinte:

      ~/octodns/config/config.yaml

      ---
      providers:
        config:
          class: octodns.provider.yaml.YamlProvider
          directory: ./config
          default_ttl: 300
          enforce_order: True
        digitalocean:
          class: octodns.provider.digitalocean.DigitalOceanProvider
          token: your-digitalocean-oauth-token
      
      zones:
        your-domain.:
          sources:
            - config
          targets:
            - digitalocean
      

      Esse arquivo diz ao OctoDNS a quais provedores de DNS você quer que ele se conecte e quais zonas do DNS ele deve gerenciar em relação a esses provedores.

      Você precisará fornecer alguma forma de autenticação para seu provedor de DNS. Normalmente, trata-se de uma chave de API ou de token do OAth.

      Se não quiser armazenar seu token de acesso em texto simples no arquivo de configuração, em vez disso, você pode enviá-lo como uma variável de ambiente quando o programa for executado. Para fazer isso, você deve usar a seguinte linha de token: em vez de no arquivo config.yaml:

      ~/octodns/config/config.yaml

      token: env/DIGITALOCEAN_OAUTH_TOKEN
      

      Em seguida, antes de executar o OctoDNS, defina a variável de ambiente relevante para o seu token de acesso e o OctoDNS o lerá a partir daí quando for executado:

      • export DIGITALOCEAN_OAUTH_TOKEN=your-digitalocean-oauth-token

      Aviso: este token dará acesso à sua conta do provedor de DNS; portanto, você deve protegê-lo, assim como faria com uma senha. Além disso, se você estiver usando um sistema de controle de versão, certifique-se de que o arquivo que contém o token seja excluído (por exemplo, usando o .gitignore) ou criptografado de maneira segura.

      Se estiver usando a DigitalOcean como sua provedora de DNS, você pode usar o token do OAuth necessário - gerado como parte dos pré-requisitos - em suas configurações de conta da DigitalOcean.

      Se você tiver vários provedores de DNS — por exemplo, para vários nomes de domínios, ou zonas de DNS delegadas — você pode definir todos eles no mesmo arquivo config.yaml.

      Você configurou o arquivo de configuração inicial do OctoDNS para permitir que o programa autentique o seu provedor de DNS e faça alterações. Em seguida, você criará a configuração para suas zonas de DNS.

      Passo 3 — Criando um arquivo de configuração de DNS

      Neste passo, você criará um arquivo de configuração inicial do DNS, que terá os registros de DNS para seu nome de domínio ou zona de DNS delegada.

      Cada zona de DNS que você quiser gerenciar usando o OctoDNS tem seu próprio arquivo, por exemplo your-domain.yaml​​​​. Nesse arquivo, os registros de DNS para a zona são definidos com o YAML.

      Para começar, vá para o diretório ~/octodns/config:

      Então, crie e abra o your-domain.yaml para a edição:

      Adicione a seguinte configuração de exemplo ao arquivo:

      ~/octodns/config/your-domain.yaml

      ---
      '':
        - type: A
          value: your-server-ipv4-address
      
      www:
        - type: A
          value: your-server-ipv4-address
      

      Esse arquivo de exemplo define uma zona de DNS para o your-domain com dois registros do tipo A, apontando para o endereço IPv4 em que você está hospedando seu domínio ou site. Um registro do tipo A é para o domínio raiz (por exemplo, your-domain) e o outro registro A é para o subdomínio www (por exemplo, www.your-domain).

      Assim que terminar, salve e feche o arquivo.

      Você configurou um arquivo básico de configuração de zona de DNS para o OctoDNS, com dois registros tipo A básicos apontando para o endereço IPv4 do seu domínio ou site. Em seguida, você irá expandir arquivo com alguns registros úteis de DNS.

      Passo 4 — Preenchendo seu arquivo de configuração de DNS

      Em seguida, você pode preencher o arquivo de configuração do DNS com um conjunto prático de registros de DNS para o seu site ou serviço, usando a linguagem de configuração estruturada YAML.

      Diferente dos arquivos da zona BIND tradicionais, onde os registros DNS estão escritos em um formato bruto, linha a linha, os registros de DNS dentro do OctoDNS são definidos como chaves e subchaves em YAML, com um número de valores associados, como mostrado rapidamente no Passo 3.

      Normalmente, a chave de nível superior é a 'name', que é essencialmente, o identificador do registro. www, subdomain1 e mail são todos exemplos do DNS 'name'. No OctoDNS, existem dois nomes para uso especial, que são '', para o registro raiz (geralmente referido como @) e '*', para registros curinga. O type é um valor necessário de cada chave (registro de DNS). Isso define qual tipo de registro de DNS você está definindo dentro daquela chave de nível superior em YAML. Existe um type para cada um dos tipos padrão de registro de DNS, incluindo A, AAAA, MX, TXT, NS, CNAME e assim por diante. Na seção de Registros da documentação do OctoDNS, você encontra uma lista completa dos tipos de registro disponíveis.

      Os valores dos seus registros de DNS são definidos diretamente - como valores para as chaves de nível superior (se tiver apenas um valor), ou como uma lista (se tiver vários valores como, por exemplo, múltiplos endereços IP ou MX).

      Por exemplo, para definir um único valor, você poderia usar a seguinte configuração:

      ~/octodns/config/your-domain.yaml

      'www':
        type: A
        value: 203.0.113.1
      

      Como alternativa, para definir vários valores para um único registro:

      ~/octodns/config/your-domain.yaml

      'www':
        type: A
        values:
        - 203.0.113.1
        - 203.0.113.2
      

      A sintaxe para definir registros de DNS varia ligeiramente para cada tipo de registro. Em seguida, temos alguns exemplos dos tipos de registro mais comuns:

      Registros do tipo A:

      Objetivo: apontar para um endereço IPv4.

      Sintaxe:

      'name':
        type: A
        value: ipv4-address
      

      Exemplo:

      'www':
        type: A
        value: your-server-ipv4-address
      

      Registros do tipo AAAA:

      Objetivo: apontar para um endereço IPv6.

      Sintaxe:

      'name':
        type: AAAA
        value: ipv6-address
      

      Exemplo:

      'www':
        type: AAAA
        value: your-server-ipv6-address
      

      Registros do tipo CNAME:

      Objetivo: transformar o seu domínio/subdomínio em alias de outro.

      Sintaxe:

      'name':
        type: CNAME
        value: fully-qualified-domain-name
      

      Exemplo:

      'www':
        type: CNAME
        value: www.example.org
      

      Registros do tipo MX:

      Objetivo: direcionar e-mails para servidores/endereços específicos.

      Sintaxe:

      'name':
        type: MX
        value:
          exchange: mail-server
          preference: priority-value
      

      Note que um ponto final, ., *deve *ser incluído se houver quaisquer pontos no valor do registro tipo MX.

      Exemplo:

      '':
        type: MX
        value:
          exchange: mail.your-domain.
          preference: 10
      

      Registros do tipo TXT:

      Objetivo: adicionar texto simples arbitrário, frequentemente usado para configurações sem seu próprio tipo de registro dedicado.

      Sintaxe:

      'name':
        type: TXT
        value: content
      

      Exemplo:

      '':
        type: TXT
        value: This is a TXT record.
      

      Para começar a adicionar registros de DNS ao seu domínio ou zona de DNS delegada, edite seu arquivo de configuração de DNS:

      • cd ~/octodns/config
      • nano your-domain.yaml

      Na sequência, você pode começar a preencher sua zona de DNS, usando a sintaxe descrita na lista anterior, bem como a seção de Registros da documentação oficial do OctoDNS.

      A título de referência, este bloco de código contém um exemplo da configuração completa de uma definição básica, inicial do DNS:

      ~/octodns/config/your-domain.yaml

      ---
      '':
        - type: A
          value: your-server-ipv4-address
      
        - type: AAAA
          value: your-server-ipv6-address
      
        - type: MX
          value:
            exchange: mail.your-domain.
            preference: 10
      
        - type: TXT
          value: v=spf1 -all
      
      _dmarc:
        type: TXT
        value: v=DMARC1; p=reject; rua=mailto:abuse@your-domain; aspf=s; adkim=s;
      
      mail:
        - type: A
          value: your-server-ipv4-address
      
        - type: AAAA
          value: your-server-ipv6-address
      
      www:
        - type: A
          value: your-server-ipv4-address
      
        - type: AAAA
          value: your-server-ipv6-address
      

      Assim que tiver completado sua configuração inicial de DNS, salve e feche o arquivo.

      Neste passo, você configurou o arquivo de configuração inicial do DNS, contendo seus registros de DNS. Em seguida, você testará a configuração e a implantará.

      Passo 5 — Testando e implantando sua configuração de DNS

      Neste passo, você executará uma verificação local da sintaxe em sua configuração de DNS e, em seguida, implantará as alterações no servidor/provedor ativo de DNS.

      Primeiro, vá até seu diretório octodns:

      Verifique novamente se você ainda está operando dentro do seu virtualenv em Python, procurando por seu nome, antes do prompt do Bash:

      (env) user@digitalocean:~/octodns$
      

      Em seguida, utilize o comando octodns-validate para verificar a sintaxe do(s) seu(s) arquivo(s) de configuração. Você precisará especificar o caminho para seu arquivo de configuração:

      • octodns-validate --config=./config/config.yaml

      Se a sintaxe YAML do seu arquivo de configuração DNS estiver correta, o OctoDNS não retornará nenhum resultado. Se ver um erro ou um aviso em seu resultado, o OctoDNS dará detalhes sobre o que está errado e onde o erro está localizado dentro do seu arquivo YAML.

      Em seguida, você pode realizar um push de simulação da configuração do DNS, que irá exibir quais alterações serão feitas, sem, de fato, fazê-las:

      • octodns-sync --config=./config/config.yaml

      Isso deve gerar uma saída parecida com esta:

      Output

      ******************************************************************************** * your-domain. ******************************************************************************** * digitalocean (DigitalOceanProvider) * Create <ARecord A 300, mail.your-domain., ['your-server-ipv4-address']> (config) * Create <AaaaRecord AAAA 300, mail.your-domain., ['your-server-ipv6-address']> (config) * Create <TxtRecord TXT 300, your-domain., ['v=spf1 -all']> (config) * Create <AaaaRecord AAAA 300, your-domain., ['your-server-ipv6-address']> (config) * Create <ARecord A 300, your-domain., ['your-server-ipv4-address']> (config) * Create <ARecord A 300, www.your-domain., ['your-server-ipv4-address']> (config) * Create <MxRecord MX 300, your-domain., [''10 mail.your-domain.'']> (config) * Create <TxtRecord TXT 300, _dmarc.your-domain., ['v=DMARC1; p=reject; rua=mailto:abuse@your-domain; aspf=s; adkim=s;']> (config) * Create <AaaaRecord AAAA 300, www.your-domain., ['your-server-ipv6-address']> (config) * Summary: Creates=9, Updates=0, Deletes=0, Existing Records=2 ********************************************************************************

      Aviso: o próximo comando fará alterações em tempo real nos seus registros de DNS e, possivelmente, em outras configurações. Certifique-se de que esteja preparado para isso, incluindo a realização de um backup da sua configuração de DNS existente, além de garantir que tenha os meios para reverter o processo, se necessário.

      Por fim, você pode enviar as alterações para seu provedor de DNS ativo:

      • octodns-sync --config=./config/config.yaml --doit

      Nota: em alguns casos, o OctoDNS se recusará a forçar alterações se estiver fazendo um número significativo de ajustes. Trata-se de um recurso de proteção automático feito para evitar erros de configuração acidentais. Se ocorrer essa recusa, tente executar novamente o octodns-sync usando a opção --force, mas certifique-se de que esteja pronto para fazer isso.

      Neste passo, você verá uma saída similar à simulação anterior, mas com a adição de algo parecido com o seguinte:

      Output

      2019-07-07T23:17:27 INFO DigitalOceanProvider[digitalocean] apply: making changes 2019-07-07T23:17:30 INFO Manager sync: 9 total changes

      Agora, se verificar as configurações de DNS do seu domínio no painel de controle da DigitalOcean, verá as alterações.

      Captura de tela do painel de controle da DigitalOcean, que mostra algumas alterações do DNS, feitas pelo OctoDNS.

      Também é possível verificar a criação de registros, executando uma consulta de DNS em relação à sua zona de domínio/delegada usando o dig.

      Se não tiver o dig instalado, será necessário instalar o pacote dnsutils:

      • sudo apt install dnsutils

      Assim que instalar o dig, utilize-o para fazer uma pesquisa de DNS em relação ao seu domínio. Você verá que os registros foram devidamente atualizados:

      Você verá uma saída que mostra o endereço IP e o registro relevante de DNS da sua zona - que foi implantado usando o OctoDNS. Os registros de DNS podem levar algum tempo para se propagarem; assim, talvez seja necessário esperar e executar esse comando novamente.

      Neste passo final, você executou uma verificação da sintaxe local do arquivo de configuração do DNS. Em seguida, implantou-a em seu provedor de DNS ativo e testou se as alterações foram feitas com êxito.

      Conclusão

      Neste artigo, você configurou o OctoDNS e implantou uma configuração de DNS em um provedor ativo. Agora, você pode gerenciar e testar suas alterações de configuração do DNS em um ambiente seguro e off-line, antes de implantá-las na produção.

      Se quiser explorar mais esse assunto, o OctoDNS foi criado para se integrar ao seu pipeline de CI/CD (Integração Contínua/Entrega Contínua), o que lhe permite executar testes em profundidade e ter mais controle sobre sua implantação na produção. Você também pode pesquisar sobre a integração do OctoDNS aos seus processos de compilação/implantação de infraestrutura, o que permite implantar servidores e adicioná-los ao DNS de maneira completamente automática.

      Se quiser saber mais sobre o OctoDNS, os artigos da DigitalOcean a seguir fornecem alguns passos interessantes para ajudar a integrar o OctoDNS em seus fluxos de trabalho de gerenciamento de mudanças e implantação de infraestrutura:



      Source link