One place for hosting & domains

      implementar

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


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

      Introducción

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

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

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

      Requisitos previos

      Paso 1: Crear una nueva aplicación Laravel

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

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

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

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

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

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

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

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

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

      Guarde y cierre el archivo.

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

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

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

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

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

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

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

      Guarde y cierre el archivo.

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

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

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

      • nano ./docker-entrypoint.sh

      Ahora agregue la siguiente secuencia de comandos:

      ./docker-entrypoint.sh

      #!/bin/bash
      
      cp -R /var/www/tmp/. /var/www/html/
      chown -R www-data:www-data /var/www/html
      
      exec "$@"
      

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

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

      ./.dockerignore

      .env
      /vendor
      

      Guarde y cierre el archivo.

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

      Verá un resultado similar a este:

      Output

      APP_KEY=base64:0EHhVpgg ... UjGE=

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

      • nano ./docker-compose.yml

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

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

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

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

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

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

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

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

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

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

      La aplicación Laravel que ejecutándose de manera local con Docker Compose

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

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

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

      Paso 3: Introducir la imagen de Docker en Docker Hub

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

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

      Crear un nuevo repositorio en Docker Hub

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

      • docker login -u your_docker_hub_username

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

      Por último, transfiera la imagen a Docker Hub:

      • docker push your_docker_hub_username/laravel-kubernetes:latest

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

      Output

      latest: digest: sha256:df4bdeda91484c8c26a989b13b8f27ab14d93ab2e676e3c396714cb3811c4086 size: 4918

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

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

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

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

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

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

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

      Guarde y cierre el archivo.

      Ahora cree un archivo secrets.yml:

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

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

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

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

      Guarde y cierre secrets.yml.

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

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

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

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

      Verá un resultado similar a este:

      Output

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

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

      Busque el nombre de su aplicación:

      Output

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

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

      La aplicación de Laravel ejecutándose en Kubernetes con el chart de Helm de LAMP

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

      • helm delete laravel-kubernetes

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

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

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

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

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

      Ahora agregue las siguientes líneas:

      ./helm/values.yml

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

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

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

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

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

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

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

      Output

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

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

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

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

      Guarde y cierre el archivo.

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

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

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

      Output

      customresourcedefinition.apiextensions.k8s.io/certificaterequests.cert-manager.io created customresourcedefinition.apiextensions.k8s.io/certificates.cert-manager.io created customresourcedefinition.apiextensions.k8s.io/challenges.acme.cert-manager.io created customresourcedefinition.apiextensions.k8s.io/clusterissuers.cert-manager.io created customresourcedefinition.apiextensions.k8s.io/issuers.cert-manager.io created customresourcedefinition.apiextensions.k8s.io/orders.acme.cert-manager.io create

      Cert-Manager también requiere un espacio de nombres para aislarlo en el clúster de Kubernetes:

      • kubectl create namespace cert-manager

      Obtendrá el siguiente resultado:

      Output

      namespace/cert-manager created

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

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

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

      Output

      "jetstack" has been added to your repositories

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

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

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

      Output

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

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

      • nano ./production_issuer.yml

      Ahora, agregue lo siguiente:

      apiVersion: cert-manager.io/v1alpha2
      kind: ClusterIssuer
      metadata:
        name: letsencrypt-prod
      spec:
        acme:
          # Email address used for ACME registration
          email: your_email_address
          server: https://acme-v02.api.letsencrypt.org/directory
          privateKeySecretRef:
            # Name of a secret used to store the ACME account private key
            name: letsencrypt-prod-private-key
          # Add a single challenge solver, HTTP01 using nginx
          solvers:
            - http01:
                ingress:
                  class: nginx
      

      Guarde y cierre el archivo.

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

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

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

      • kubectl get service nginx-ingress-controller

      Output

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

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

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

      La aplicación de Laravel con terminación de SSL y un nombre de dominio personalizado

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

      Paso 6: Ejecutar comandos remotos

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

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

      Verá un resultado similar a este:

      Output

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

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

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

      Este comando arrojará un resultado como el siguiente:

      Output

      Migration table created successfully. Migrating: 2014_10_12_000000_create_users_table Migrated: 2014_10_12_000000_create_users_table (0.16 seconds) Migrating: 2019_08_19_000000_create_failed_jobs_table Migrated: 2019_08_19_000000_create_failed_jobs_table (0.05 seconds)

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

      Conclusión

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

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



      Source link

      Cómo implementar y administrar su DNS usando DNSControl en Debian 10


      El autor seleccionó la Electronic Frontier Foundation Inc para recibir una donación como parte del programa Write for DOnations.

      Introducción

      DNSControl es una herramienta de infraestructura como código que le permite implementar y administrar sus zonas de DNS usando principios de desarrollo de software estándar, el control de versiones, pruebas e implementaciones automatizadas. DNSControl es una creación de Stack Exchange y se escribió en Go.

      El uso de DNSControl elimina muchas de las dificultades de la administración manual de DNS, ya que los archivos de zona se almacenan en un formato programable. Esto le permite implementar zonas en varios proveedores de DNS de manera simultánea, identificar errores de sintaxis y aplicar su configuración de DNS de manera automática, lo que reduce el riesgo que representan los errores humanos. Otro uso frecuente de DNSControl tiene que ver con la migración rápida de su DNS a un proveedor diferente; por ejemplo, en caso de un ataque DDoS o una interrupción del sistema.

      A través de este tutorial, instalará y configurará DNSControl, creará una configuración de DNS básica y comenzará a implementar registros de DNS en un proveedor activo. Como parte de este tutorial, usaremos DigitalOcean como proveedor DNS de ejemplo. Si desea usar un proveedor diferente, la configuración es muy similar. Al finalizar, podrá administrar y probar su configuración de DNS en un entorno seguro y sin conexión, y luego implementarla de manera automática en la producción.

      Requisitos previos

      Para completar esta guía, necesitará lo siguiente:

      • Un servidor de Debian 10 preparado conforme a la configuración inicial para servidores con Debian 10, incluidos un usuario sudo no root y un firewall habilitado para bloquear los puertos no esenciales. your-server-ipv4-address hace referencia a la dirección IP del servidor en donde aloja su sitio web o dominio. your-server-ipv6-address hace referencia a la dirección IPv6 del servidor en donde aloja su sitio web o dominio.
      • Un nombre de dominio registrado por completo con DNS alojado por un proveedor compatible. En este tutorial, se utilizará your_domain en todo momento y DigitalOcean será el proveedor de servicio.
      • Una clave de API de DigitalOcean (Token de acceso personal) con permisos de lectura y escritura. Para crear uno, consulte Cómo crear un Token de acceso personal.

      Una vez que tenga todo esto listo, para comenzar inicie sesión en su servidor como usuario no root.

      Paso 1: Instalar DNSControl

      DNSControl está escrito en Go, por lo que comenzará este paso instalando Go en su servidor y configurando su GOPATH.

      Go está disponible en los repositorios de software predeterminados de Debian, lo que permite la instalación con las herramientas convencionales de administración de paquetes.

      También deberá instalar Git, ya que es necesario para que en Go se descargue e instale el software DNSControl desde su repositorio en GitHub.

      Comience actualizando el índice de paquetes locales de modo que se refleje cualquier cambio anterior:

      Luego, instale los paquetes golang-go y git:

      • sudo apt install golang-go git

      Una vez confirmada la instalación, apt descargará e instalará Go y Git, así como todas las dependencias necesarias de estos.

      A continuación, configurará las variables de entorno de ruta necesarias para Go. Si desea obtener más información sobre esto, puede leer el siguiente tutorial de información sobre GOPATH. Comience editando el archivo ~/.profile:

      Añada las siguientes líneas al final de su archivo:

      ~/.profile

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

      Una vez que añada estas líneas al final del archivo, guárdelo y ciérrelo. Luego vuelva a cargar su perfil cerrando y volviendo a abrir la sesión, o bien volviendo a obtener el archivo:

      Ahora que instaló y configuró Go, puede instalar DNSControl.

      El comando go get se puede usar para obtener una copia del código, compilarlo automáticamente e instalarlo en su directorio de Go:

      • go get github.com/StackExchange/dnscontrol

      Una vez completado esto, puede verificar la versión instalada para asegurar que todo funcione:

      El resultado debe tener un aspecto similar al siguiente:

      Output

      dnscontrol 2.9-dev

      Si ve un error dnscontrol: command not found, verifique bien la configuración de su ruta de Go.

      Ahora que instaló DNSControl, puede crear un directorio de configuración y conectar DNSControl a su proveedor DNS para permitir que haga cambios en sus registros de DNS.

      Paso 2: Configurar DNSControl

      En este paso, creará los directorios de configuración necesarios para DNSControl y lo conectará a su proveedor DNS para que pueda comenzar a realizar cambios en tiempo real en sus registros de DNS.

      Primero, cree un directorio nuevo en el que pueda almacenar su configuración de DNSControl y luego posiciónese en este:

      • mkdir ~/dnscontrol
      • cd ~/dnscontrol

      Nota: En este tutorial, nos enfocaremos en la configuración inicial de DNSControl. Sin embargo, para el uso en producción se le recomienda almacenar su configuración de DNSControl en un sistema de control de versiones (VCS) como Git. Entre las ventajas de esto se incluyen un control de versiones completo, la integración con CI/CD para pruebas y las implementaciones de versiones anteriores sin problemas.

      Si planea usar DNSControl para escribir archivos de zona BIND, también deberá crear el directorio zones:

      Los archivos de zona BIND son una alternativa básica estándar para almacenar zonas y registros de DNS en formato de texto simple. Originalmente se utilizaron para el software del servidor DNS BIND, pero ahora se han adoptado ampliamente como el método estándar para almacenar zonas de DNS. Los archivos de zona BIND producidos por DNSControl son útiles si quiere importarlos a un servidor DNS personalizado o con alojamiento propio, o bien para fines de auditoría.

      Sin embargo, si solo quiere usar DNSControl para aplicar cambios de DNS a un proveedor administrado, no se necesitará el directorio zones.

      A continuación, deberá configurar el archivo creds.json, lo cual permitirá la autenticación de DNSControl en su proveedor DNS y la aplicación de cambios. El formato de creds.json varia ligeramente dependiendo del proveedor DNS que utilice. Consulte la lista de proveedores de servicio en la documentación oficial de DNSControl para hallar la configuración de su propio proveedor.

      Cree el archivo creds.json en el directorio ~/dnscontrol:

      • cd ~/dnscontrol
      • nano creds.json

      Añada la configuración de muestra creds.json para su proveedor DNS al archivo. Si utiliza DigitalOcean como su proveedor DNS, puede recurrir a lo siguiente:

      ~/dnscontrol/creds.json

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

      En este archivo se indican a DNSControl los proveedores de DNS con los que desea establecer conexión.

      Deberá proporcionar alguna forma de autenticación para proveedor DNS. Normalmente, se utiliza una clave de API o un token de OAuth, pero algunos proveedores requieren información adicional, como se detalla en la lista de proveedores de servicio de la documentación oficial de DNSControl.

      Advertencia: Este token brindará acceso a la cuenta de su proveedor DNS, por lo que debe protegerlo como si se tratara de una contraseña. También compruebe que, si utiliza un sistema de control de versiones, el archivo que contenga el token esté excluido (por ejemplo, con .gitignore), o cifrado de forma segura de alguna manera.

      Si utiliza DigitalOcean como su proveedor DNS, puede usar el token de OAuth requerido en la configuración de su cuenta de DigitalOcean que generó como parte de los requisitos previos.

      Si tiene varios proveedores de DNS diferentes, por ejemplo, para diferentes nombres de dominio o zonas de DNS delegadas, puede definir todos estos en el mismo archivo creds.json.

      Con esto, estableció los directorios de configuración inicial de DNSControl y configuró creds.json para permitir que DNSControl se autentique en su proveedor DNS y realice cambios. A continuación, creará la configuración para sus zonas de DNS.

      Paso 3: Crear un archivo de configuración de DNS

      Durante este paso, creará un archivo de configuración de DNS inicial, que contendrá los registros de DNS para su nombre de dominio o zona de DNS delegada.

      dnsconfig.js es el archivo de configuración de DNS principal para DNSControl. En este archivo, las zonas de DNS y sus registros correspondientes se definen usando sintaxis de JavaScript. Esto se conoce como DS o lenguaje específico de dominio. En la página de DSL en JavaScript de la documentación oficial de DNSControl hay más información disponible.

      Para comenzar, cree el archivo de configuración de DNS en el directorio ~/dnscontrol:

      • cd ~/dnscontrol
      • nano dnsconfig.js

      Luego, añada la siguiente configuración de ejemplo al archivo:

      ~/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')
      );
      

      Mediante este archivo de ejemplo se define un nombre de dominio o una zona de DNS en un proveedor determinado, que en este caso es your_domain alojado en DigitalOcean. También se define un ejemplo de registro A para la zona root (@) con orientación hacia la dirección IPv4 del servidor en el que aloja su dominio y sitio web.

      Existen tres funciones principales que conforman un archivo básico de configuración de DNSControl

      • NewRegistrar(name, type, metadata): define el registrador de dominio para su nombre de dominio. DNSControl puede utilizar esto para realizar los cambios necesarios, como la modificación de los servidores de nombres autoritativos. Si solo quiere usar DNSControl para administrar sus zonas de DNS, generalmente puede dejar el valor NONE.

      • NewDnsProvider(name, type, metadata): define un proveedor de servicio de DNS para su nombre de dominio o zona delegada. Aquí es donde DNSControl aplicará los cambios de DNS que realice.

      • D(name, registrar, modifiers): define un nombre de dominio o una zona de DNS delegada para DNSControl se encargue de la administración, como también los registros de DNS presentes en la zona.

      Deberá configurar NewRegistrar(), NewDnsProvider() y D() respectivamente usando la lista de proveedores de servicio de la documentación oficial de DNSControl.

      Si utiliza DigitalOcean como su proveedor DNS y solo necesita poder realizar cambios en el DNS (en lugar de servidores de nombres autoritativos también), el ejemplo del bloque de código anterior ya es válido.

      Una vez que termine, guarde y cierre el archivo.

      En este paso, creó un archivo de configuración de DNS para DNSControl, con los proveedores correspondientes definidos. A continuación, completará el archivo con algunos registros de DNS útiles.

      Paso 4: Completar su archivo de configuración de DNS

      A continuación, podrá completar el archivo de configuración de DNS con registros de DNS útiles para su sitio web o servicio, con la sintaxis de DNSControl.

      A diferencia de los archivos de zona BIND tradicionales, en los cuales los registros DNS están escritos en un formato básico, línea por línea, los registros DNS dentro de DNSControl se definen como un parámetro de función (modificador de dominio) en la función D(), como se muestra en forma resumida en el paso 3.

      Existe un modificador de dominio para cada uno de los tipos de registro de DNS estándares, entre los que se incluyen A, AAAA, MX, TXT, NS y CAA. Se encuentra disponible una lista completa de los tipos de registro en la sección Modificadores de dominios de la documentación de DNSControl.

      También se encuentran disponibles los modificadores para los registros individuales (modificadores de registros). Actualmente, se utilizan principalmente para configurar el TTL (período de vida) de registros individuales. Se encuentra disponible una lista completa de los modificadores de registros en la sección Modificadores de registros de la documentación de DNSControl. Los modificadores de registros son opcionales y en la mayoría de los casos de uso básicos pueden quedar excluidos.

      La sintaxis para configurar registros DNS varía ligeramente según cada tipo de registro. A continuación, se muestran algunos ejemplos para los tipos de registro más comunes:

      • Registros A:

        • Propósito: apuntar a una dirección IPv4.
        • Sintaxis: A('name', 'address', optional record modifiers).
        • Ejemplo: A('@', 'your-server-ipv4-address', TTL(30)).
      • Registros AAAA:

        • Propósito: apuntar a una dirección IPv6.
        • Sintaxis: AAAA('name', 'address', optional record modifiers).
        • Ejemplo: AAAA('@', 'your-server-ipv6-address') (se omitió el modificador de registros, por lo que se utilizará el TTL predeterminado).
      • Registros CNAME:

        • Propósito: convertir su dominio o subdominio en un alias de otro.
        • Sintaxis: CNAME('name', 'target', optional record modifiers).
        • Ejemplo: CNAME('subdomain1', 'example.org.') (tenga en cuenta que se debe incluir un . al final si hay algún punto en el valor).
      • Registros MX:

        • Propósito: dirigir el correo electrónico hacía direcciones o servidores específicos.
        • Sintaxis: MX('name', 'priority', 'target', optional record modifiers).
        • Ejemplo: MX('@', 10, 'mail.example.net') (tenga en cuenta que se debe incluir un . “al final si hay algún punto en el valor).
      • Registros de TXT:

        • Propósito: agregar texto simple arbitrario, a menudo utilizado para las configuraciones sin su propio tipo de registro dedicado.
        • Sintaxis: TXT('name', 'content', optional record modifiers).
        • Ejemplo: TXT('@', 'This is a TXT record.').
      • Registros CAA:

        • Propósito: restringir las entidades de certificación (CA) que pueden emitir certificados TLS para su dominio y subdominios, y presentar informes sobre ellas.
        • Sintaxis: CAA('name', 'tag', 'value', optional record modifiers).
        • Ejemplo: CAA('@', 'issue', 'letsencrypt.org').

      Con el fin de comenzar a añadir registros de DNS para su dominio o zona de DNS delegada, edite su archivo de configuración DNS:

      A continuación, puede comenzar a completar los parámetros para la función D() existente usando la sintaxis descrita en la lista anterior, así como la sección Modificadores de dominio de la documentación oficial de DNSControl. Se debe utilizar una coma (,) entre cada registro.

      A modo de referencia, el bloque de código aquí contiene una configuración de ejemplo completa para una configuración básica e inicial de un 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;')
      );
      

      Una vez que haya completado su configuración inicial de DNS, guarde y cierre el archivo.

      Durante este paso, creó el archivo de configuración de DNS inicial que contiene sus registros de DNS. A continuación, probará la configuración y la implementará.

      Paso 5: Probar e implementar su configuración de DNS

      En este paso, ejecutará una verificación de sintaxis local en su configuración de DNS y luego implementará los cambios en el servidor y proveedor DNS activos.

      Primero, posiciónese en el directorio dnscontrol:

      Luego, utilice la función preview de DNSControl para verificar la sintaxis de su archivo y mostrar los cambios que se realizarán (sin efectuarlos realmente):

      Si la sintaxis de su archivo de configuración de DNS es correcta, en DNSControl se mostrará un resumen de los cambios que se realizarán. Esto debe tener un aspecto similar a lo siguiente:

      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.

      Si ve una advertencia de error en el resultado, DNSControl proporcionará detalles sobre el tipo de error y el punto en el que se encuentra dentro de su archivo.

      Advertencia: A través del siguiente comando se harán cambios en tiempo real en sus registros DNS y posiblemente en otras configuraciones. Asegúrese de estar preparado para esto; incluya una copia de seguridad de su configuración de DNS existente y verifique que disponga de los medios necesarios para revertir los cambios si es necesario.

      Por último, puede aplicar los cambios a su proveedor DNS activo:

      Verá un resultado similar al siguiente:

      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.

      Ahora, si revisa las configuraciones de DNS para su dominio en el panel de control de DigitalOcean, podrá visualizar los cambios.

      Captura de pantalla del panel de control de DigitalOcean; se muestran algunos de los cambios de DNS realizados en DNSControl.

      También puede verificar la creación de registros ejecutando una solicitud de DNS para su dominio o zona delegando usando dig.

      Si no instaló dig, deberá instalar el paquete dnsutils:

      • sudo apt install dnsutils

      Una vez que instale dig, podrá utilizarlo con el propósito de realizar una búsqueda de DNS para su dominio. Verá que los registros se actualizaron de forma correspondiente:

      Verá un resultado que muestra la dirección IP y los registros de DNS pertinentes de su zona implementada usando DNSControl. Los registros DNS pueden tardar tiempo en propagarse, por lo cual es posible que necesite esperar y ejecutar este comando de nuevo.

      En este último paso, realizó una verificación de sintaxis local del archivo de configuración de DNS, luego lo implementó en su proveedor DNS activo y verificó mediante pruebas que los cambios se realizaran correctamente.

      Conclusión

      A lo largo de este artículo, configuró DNSControl e implementó una configuración de DNS en un proveedor activo. Ahora podrá administrar y probar sus cambios de configuración de DNS en un entorno seguro y sin conexión antes de implementarlos en la producción.

      Si desea profundizar en este tema, DNSControl está diseñado para integrarse en su proceso de CI/CD, lo que le permite realizar pruebas exhaustivas y tener más control sobre su implementación en la producción. También podría considerar la integración de DNSControl en sus procesos de compilación e implementación de infraestructuras, lo que le permitirá implementar servidores y agregarlos al DNS de manera completamente automática.

      Si desea dar un paso más con DNSControl, en los siguientes artículos de DigitalOcean se ofrecen algunos pasos interesantes que puede seguir para contribuir a la integración de DNSControl en sus flujos de trabajo de administración de cambios e implementación de infraestructura:



      Source link

      Cómo implementar y administrar su DNS usando OctoDNS en Debian 10


      El autor seleccionó la Electronic Frontier Foundation para recibir una donación como parte del programa Write for DOnations.

      Introducción

      OctoDNS es una herramienta de infraestructura como código que le permite implementar y administrar sus zonas de DNS usando principios de desarrollo de software estándar, control de versiones, pruebas e implementaciones automatizadas. OctoDNS es una creación de GitHub y está escrito en Python.

      El uso de OctoDNS elimina muchas de las dificultades de la administración de DNS manual, ya que los archivos de zona se almacenan en un formato estructurado (YAML). Esto le permite implementar zonas en varios proveedores de DNS de manera simultánea, identificar errores de sintaxis y aplicar su configuración de DNS de manera automática, lo que reduce el riesgo que representan los errores humanos. Otro uso común de OctoDNS tiene que ver con la sincronización de su configuración de DNS entre diferentes proveedores, como en el caso de un sistema de pruebas y producción o entre entornos activos y de conmutación por error.

      OctoDNS es similar a DNSControl, una herramienta equivalente creada por Stack Exchange y escrita en Go. A diferencia de OctoDNS, DNSControl utiliza un lenguaje de configuración basado en JavaScript para definir las zonas de DNS, lo cual le permite usar funciones de programación avanzadas como los bucles para especificar varios registros similares dentro de la misma zona. En el artículo Cómo implementar y administrar su DNS utilizando DNSControl en Debian 10 se abarcan la instalación y configuración básicas de DNSControl.

      A través de este tutorial, instalará y configurará OctoDNS, creará una configuración de DNS básica y comenzará a implementar registros de DNS en un proveedor activo. Como parte de este tutorial, usaremos DigitalOcean como proveedor DNS de ejemplo. Si quiere utilizar un proveedor diferente, la configuración es muy similar. Al finalizar, podrá administrar y probar su configuración de DNS en un entorno seguro y sin conexión, y luego implementarla de manera automática en la producción.

      Requisitos previos

      Para completar esta guía, necesitará lo siguiente:

      • Un servidor de Debian 10 preparado conforme la Configuración inicial para servidores con Debian 10, incluidos un usuario sudo no root y un firewall habilitado para bloquear los puertos no esenciales. your-server-ipv4-adress y your-server-ipv6-address hacen referencia a las direcciones IP del servidor en el que aloja su sitio web o dominio.
      • Un nombre de dominio registrado por completo con DNS alojado por un proveedor compatible. En este tutorial, se utilizará your_domain en todo momento y DigitalOcean será el proveedor de servicio.
      • Una clave de API de DigitalOcean (Token de acceso personal) con permisos de lectura y escritura. Para crear uno, consulte Cómo crear un Token de acceso personal.

      Una vez que tenga todo esto listo, inicie sesión en su servidor como usuario no root.

      Paso 1: Instalar OctoDNS

      OctoDNS se distribuye como paquete pip en Python y se ejecuta en un entorno virtual de Python (virtualenv), por lo que iniciará este paso instalando los paquetes necesarios para esto. Un virtualenv es un entorno aislado de Python que puede contar con bibliotecas y configuración propias, independientes de la instalación principal de Python en todo el sistema. Python y ​​​virtualenv están disponibles dentro de los repositorios de software predeterminados de Debian, lo que permite la instalación con herramientas convencionales de administración de paquetes.

      Comience actualizando el índice de paquetes locales de modo que se refleje cualquier cambio anterior:

      A continuación, instale los paquetes python y virtualenv:

      • sudo apt install python virtualenv

      Después de confirmar la instalación, apt descargará e instalará Python, virtualenv y todas sus dependencias necesarias.

      A continuación, creará los directorios necesarios para OctoDNS, en los que se almacenará su configuración de DNS y del programa. Comience creando los directorios ~/octodns y ~/octodns/config:

      • mkdir ~/octodns ~/octodns/config

      Ahora, posiciónese en ~/octodns:

      A continuación, es necesario crear el entorno virtual de Python; un entorno aislado con bibliotecas y configuración propias para ejecutar OctoDNS:

      Active su entorno con el siguiente comando:

      Con esto, se mostrará algo similar a lo siguiente:

      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.

      Ahora, su intérprete de comandos de shell de Bash también llevará como prefijo el nombre de su entorno virtual. Esto indica que actualmente realiza operaciones dentro de virtualenv:

      (env) user@digitalocean:~/octodns$
      

      Si quiere cerrar virtualenv, puede usar el comando deactivate en cualquier momento. Sin embargo, debe permanecer en su virtualenv para continuar con este tutorial.

      Ahora que instaló y configuró Python y virtualenv, puede instalar OctoDNS. OctoDNS se distribuye como un paquete pip de Python, que es la herramienta estándar de administración de paquetes y bibliotecas de Python.

      Puede instalar el paquete de pip de OctoDNS utilizando el siguiente comando dentro de su virtualenv:

      Una vez completado esto, puede verificar la versión instalada para asegurar que todo funcione:

      El resultado debe tener un aspecto similar al siguiente:

      Output

      octoDNS 0.9.9

      Si ve un error octodns-sync: command not found, compruebe que aún se encuentre dentro de su virtualenv.

      Ahora que instaló OctoDNS, podrá crear los archivos de configuración necesarios para conectar OctoDNS con su proveedor DNS para permitir que se realicen cambios en sus registros de DNS.

      Paso 2: Configurar OctoDNS

      En este paso, creará los archivos de configuración necesarios para OctoDNS y los conectará con su proveedor DNS para que pueda comenzar a realizar cambios en tiempo real en sus registros DNS.

      Nota: En este tutorial, nos enfocaremos en la configuración inicial de OctoDNS. Sin embargo, para el uso en producción se le recomienda almacenar su configuración de OctoDNS en un sistema de control de versiones (VCS) como Git. Entre las ventajas de esto se incluyen un control de versiones completo, la integración con CI/CD para pruebas y las implementaciones de versiones anteriores sin problemas.

      Primero, debe configurar el archivo config.yaml, que define las zonas de DNS para la administración a través de OctoDNS, y permite que este se autentique en su proveedor DNS y realice cambios.

      El formato de config.yaml varía ligeramente dependiendo del proveedor DNS que está utilizando. Consulte la lista de proveedores compatibles en la documentación oficial de OctoDNS para hallar la configuración de su propio proveedor. Si se observa este hiperenlace, los detalles de configuración se presentan como comentarios de código en el código real de Python para su proveedor, que está vinculado en la columna de “Provider” de la tabla. Una vez que encuentre el código de Python para su proveedor, como cloudflare.py o route53.py, podrá hallar el comentario de código pertinente directamente en la class ProviderNameProvider. Por ejemplo:

      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:
      

      Posiciónese en el directorio ~/octodns/config:

      Luego, cree y abra config.yaml para la edición:

      Añada la configuración de muestra config.yaml para su proveedor DNS al archivo. Si utiliza DigitalOcean como su proveedor DNS, puede recurrir a lo siguiente:

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

      A través de este archivo se indican a OctoDNS los proveedores DNS con los que desea establecer conexión y las zonas de DNS que el software debe administrar para esos proveedores.

      Deberá proporcionar alguna forma de autenticación para proveedor DNS. Normalmente, se trata de una clave de API o un token de OAuth.

      Si no desea almacenar su token de acceso en texto simple en el archivo de configuración, como alternativa puede pasarlo como variable de entorno cuando se ejecute el programa. Para hacer esto, debe usar la siguiente línea token: en config.yaml:

      ~/octodns/config/config.yaml

      token: env/DIGITALOCEAN_OAUTH_TOKEN
      

      A continuación, antes de ejecutar OctoDNS, fije la variable de entorno pertinente en su token de acceso. OctoDNS la leerá de allí cuando se ejecute:

      • export DIGITALOCEAN_OAUTH_TOKEN=your-digitalocean-oauth-token

      Advertencia: Este token brindará acceso a la cuenta de su proveedor DNS, por lo que debe protegerlo como si se tratara de una contraseña. También compruebe que, si utiliza un sistema de control de versiones, el archivo que contenga el token esté excluido (por ejemplo, con .gitignore), o cifrado de forma segura de alguna manera.

      Si utiliza DigitalOcean como su proveedor DNS, puede usar el token de OAuth requerido en la configuración de su cuenta de DigitalOcean que generó como parte de los requisitos previos.

      Si tiene varios proveedores DNS diferentes, por ejemplo, para varios nombres de dominio o zonas de DNS delegadas, puede definirlos todos en el mismo archivo config.yaml.

      Con esto, estableció el archivo de configuración inicial de OctoDNS para permitir que el programa se autentique en su proveedor DNS y realice cambios. A continuación, creará la configuración para sus zonas de DNS.

      Paso 3: Crear un archivo de configuración de DNS

      Durante este paso, creará un archivo de configuración de DNS inicial, que contendrá los registros de DNS para su nombre de dominio o zona de DNS delegada.

      Cada zona de DNS que quiere administrar utilizando OctoDNS tiene su propio archivo; por ejemplo your-domain.yaml. En este archivo, los registros de DNS de la zona se definen usando YAML.

      Para comenzar, acceda al directorio ~/octodns/config:

      Luego, cree y abra your-domain.yaml para la edición:

      Añada la siguiente configuración de ejemplo al archivo:

      ~/octodns/config/your-domain.yaml

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

      En este archivo de muestra se define una zona de DNS para your-domain con dos registros A, con orientación hacia la dirección IPv4 en la que aloja su dominio o sitio web. Un registro A es para el dominio root (por ejemplo, your-domain) y el otro es para el subdominio www (por ejemplo, www.your-domain).

      Una vez que termine, guarde y cierre el archivo.

      De esta manera, preparó un archivo de configuración básico de zona de DNS para OctoDNS, con dos registros A básicos orientados a la dirección IPv4 de su dominio o sitio web. A continuación, ampliará el archivo con algunos registros de DNS útiles.

      Paso 4: Completar su archivo de configuración DNS

      A continuación, podrá completar el archivo de configuración de DNS con un conjunto práctico de registros de DNS para su sitio web o servicio usando el lenguaje de configuración estructurado YAML.

      A diferencia de los archivos de zona BIND tradicionales, en los cuales los registros de DNS se escriben en un formato básico línea por línea, los registros de DNS dentro de OctoDNS se definen como claves y subclaves YAML con varios valores asociados, como se muestra brevemente en el paso 3.

      La clave de nivel superior suele ser el 'name', que es básicamente el identificador de registros. www, subdomain1 y mail son ejemplos de 'name' de DNS. En OctoDNS, hay dos nombres de uso especial: ", para el registro root (por lo general citado como @) y '*', para los registros de comodín. Un valor obligatorio de cada clave (registro de DNS) es type. Esto especifica el tipo de registro DNS que define dentro de esa clave de nivel superior YAML. Existe un type para cada uno de los tipos de registros de DNS estándares, entre los que se incluyen A, AAAA, MX, TXT, NS y CNAME. Se encuentra disponible una lista completa de los tipos de registro en la sección de registros de la documentación de OctoDNS.

      Los valores para sus registros de DNS se definen directamente como valores en las claves de nivel superior (si solo tiene un valor) o como una lista (si tiene varios valores, como varias direcciones IP o direcciones MX).

      Por ejemplo, para definir un valor podría usar la siguiente configuración:

      ~/octodns/config/your-domain.yaml

      'www':
        type: A
        value: 203.0.113.1
      

      Asimismo, para definir varios valores para un registro único:

      ~/octodns/config/your-domain.yaml

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

      La sintaxis para configurar registros de DNS varía ligeramente según cada tipo de registro. Los siguientes son algunos ejemplos para los tipos de registro más comunes:

      Registros A:

      Propósito: apuntar a una dirección IPv4.

      Sintaxis:

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

      Ejemplo:

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

      Registros AAA:

      Propósito: apuntar a una dirección IPv6.

      Sintaxis:

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

      Ejemplo:

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

      Registros CNAME:

      Propósito: convertir su dominio o subdominio en un alias de otro.

      Sintaxis:

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

      Ejemplo:

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

      Registros MX:

      Propósito: dirigir el correo electrónico a direcciones o servidores específicos.

      Sintaxis:

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

      Tenga en cuenta que un . final se debe incluir si hay puntos en el valor de MX.

      Ejemplo:

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

      Registros TXT:

      Propósito: agregar texto simple arbitrario, a menudo utilizado para configuraciones sin su propio tipo de registro dedicado.

      Sintaxis:

      'name':
        type: TXT
        value: content
      

      Ejemplo:

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

      Para comenzar a añadir registros de DNS para su dominio o zona de DNS delegada, edite su archivo de configuración de DNS:

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

      A continuación, podrá comenzar a completar su zona de DNS usando la sintaxis descrita en la lista anterior y en la sección de registros de la documentación oficial de OctoDNS.

      A modo de referencia, el bloque de código aquí contiene una configuración de ejemplo completa para una configuración inicial de un 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
      

      Una vez que haya completado su configuración inicial de DNS, guarde y cierre el archivo.

      Durante este paso, creó el archivo de configuración de DNS inicial que contiene sus registros de DNS. A continuación, probará la configuración y la implementará.

      Paso 5: Probar e implementar su configuración de DNS

      En este paso, ejecutará una verificación de sintaxis local en su configuración de DNS y luego implementará los cambios en el servidor y proveedor DNS activos.

      Primero, acceda a su directorio octodns:

      Asegúrese de seguir operando dentro de su virtualenv de Python buscando el nombre de este delante de su mensaje de Bash:

      (env) user@digitalocean:~/octodns$
      

      A continuación, utilice el comando octodns-validate para verificar la sintaxis de sus archivos de configuración. Deberá especificar la ruta a su archivo de configuración:

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

      Si la sintaxis YAML de su archivo de configuración de DNS es correcta, OctoDNS no mostrará resultados. Si ve un error o una advertencia en el resultado, DNSControl proporcionará detalles sobre el tipo de error y el punto en el que se encuentra dentro de su archivo.

      A continuación, podrá realizar un simulacro de la implementación de la configuración de DNS, con lo cual se mostrarán los cambios que se realizarán sin aplicarlos:

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

      Con esto, debería aparecer un resultado similar al siguiente:

      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 ********************************************************************************

      Advertencia: A través del siguiente comando se harán cambios en tiempo real en sus registros DNS y posiblemente en otras configuraciones. Asegúrese de estar preparado para esto; incluya una copia de seguridad de su configuración de DNS existente y verifique que disponga de los medios necesarios para revertir los cambios si es necesario.

      Por último, puede aplicar los cambios en su proveedor DNS activo:

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

      Nota: En algunos casos, OctoDNS no permitirá la introducción de cambios si realiza un número de ajustes considerable. Este es un mecanismo de protección automática para evitar configuraciones accidentales. Si se produce este rechazo, puede volver a ejecutar octodns-sync utilizando la opción --force. Sin embargo, asegúrese de estar listo para hacerlo.

      Verá un resultado como el del simulacro anterior de este paso, pero se agregará algo similar a lo siguiente:

      Output

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

      Ahora, si revisa las configuraciones de DNS para su dominio en el panel de control de DigitalOcean, verá los cambios.

      Captura de pantalla del panel de control de DigitalOcean; se muestran algunos de los cambios de DNS realizados en OctoDNS.

      También puede verificar la creación de registros ejecutando una solicitud de DNS para su dominio o zona delegada usando dig.

      Si no instaló dig, deberá instalar el paquete dnsutils:

      • sudo apt install dnsutils

      Una vez que instale dig, podrá utilizarlo con el propósito de realizar una búsqueda de DNS para su dominio. Verá que los registros se actualizaron de forma correspondiente:

      Verá un resultado que muestra la dirección IP y los registros de DNS pertinentes de su zona implementada usando OctoDNS. Los registros DNS pueden tardar tiempo en propagarse, por lo que es posible que necesite esperar y ejecutar este comando de nuevo.

      En este último paso, realizó una verificación de sintaxis local del archivo de configuración de DNS, luego lo implementó en su proveedor DNS activo y verificó mediante pruebas que los cambios se realizaran correctamente.

      Conclusión

      A lo largo de este artículo, configuró OctoDNS e implementó una configuración de DNS en un proveedor activo. Ahora podrá administrar y probar sus cambios de configuración de DNS en un entorno seguro y sin conexión antes de implementarlos en la producción.

      Si desea profundizar en este tema, Octo DNS está diseñado para integrarse en su proceso de CI/CD, lo que le permite realizar pruebas exhaustivas y tener más control sobre su implementación en la producción. También podría considerar la integración de OctoDNS en sus procesos de compilación e implementación de infraestructuras, lo que le permitirá implementar servidores y agregarlos al DNS de manera completamente automática.

      Si desea profundizar en el uso de OctoDNS, en los siguientes artículos de DigitalOcean se ofrecen algunos pasos interesantes que podrá seguir para contribuir a la integración de OctoDNS en sus flujos de trabajo de administración de cambios e implementación de infraestructura:



      Source link