Solucionar problemas de hora y zona horaria en Docker

Terraform con DigitalOcean

Terraform con DigitalOcean

Utilizando Terraform en DigitalOcean podrás gestionar Droplets, Balanceadores de Carga e incluso las entradas DNS, además de una gran variedad de servicios ofrecidos por otros proveedores. Terraform es una herramienta para construir y administrar la infraestructura de manera organizada. Utiliza una interfaz de línea de comandos y puede ejecutarse desde tu escritorio o un servidor remoto.

Infraestructura como código vs gestión de configuración vs aprovisionamiento de infraestructura

Terraform funciona leyendo archivos de configuración que describen los componentes que conforman tu entorno de aplicación o centro de datos. Basado en la configuración, genera un plan de ejecución que describe lo que hará para alcanzar el estado deseado. Luego, utilizas Terraform para ejecutar este plan y construir la infraestructura. Cuando ocurren cambios en la configuración, Terraform puede generar y ejecutar planes incrementales para actualizar la infraestructura existente al estado recién descrito.

En este tutorial, instalarás Terraform y lo usarás para crear una infraestructura en DigitalOcean que consta de dos servidores Nginx equilibrados por un Balanceador de Carga de DigitalOcean. Luego, usarás Terraform para agregar una entrada DNS en DigitalOcean que apunte a tu Balanceador de Carga. Esto te ayudará a comenzar a usar Terraform y te dará una idea de cómo puedes usarlo para administrar e implementar una infraestructura basada en DigitalOcean que satisfaga tus propias necesidades.

Prerrequisitos

Para completar este tutorial, necesitarás:

  • Una cuenta de DigitalOcean. Si no tienes una, regístrate para obtener una cuenta nueva. Con ese enlace te darán $100 si pagas $5 dolares.
  • Un Token de Acceso Personal de DigitalOcean, que puedes crear a través del panel de control de DigitalOcean.
  • Una clave SSH sin contraseña agregada a tu cuenta de DigitalOcean. Cuando agregues la clave a tu cuenta, recuerda el nombre que le das, ya que lo necesitarás en este tutorial. (Para que Terraform acepte el nombre de tu clave, debe comenzar con una letra o guión bajo y solo puede contener letras, dígitos, guiones bajos y guiones).
  • Un dominio personal apuntado a los servidores de nombres de DigitalOcean.

Instalación de Terraform

Terraform es una herramienta de línea de comandos que ejecutas en tu escritorio o en un servidor remoto. Para instalarlo, lo descargarás y lo colocarás en tu PATH para que puedas ejecutarlo en cualquier directorio en el que estés trabajando. También puedes usar asdf para controlar las versiones, ya que según el código que tengas que gestionar, puedes encontrar que se requiera el uso de versiones anteriores.

Primero, descarga el paquete adecuado para tu sistema operativo y arquitectura desde la página oficial de Descargas. Si estás en macOS o Linux, puedes descargar Terraform con curl.

En macOS, usa este comando para descargar Terraform y colocarlo en tu directorio de inicio:

curl -o ~/terraform.zip https://releases.hashicorp.com/terraform/1.1.3/terraform_1.1.3_darwin_amd64.zip 

En Linux, usa este comando:

curl -o ~/terraform.zip https://releases.hashicorp.com/terraform/1.1.3/terraform_1.1.3_linux_amd64.zip 

Crea el directorio ~/opt/terraform:

mkdir -p ~/opt/terraform

Luego, descomprime Terraform en ~/opt/terraform usando el comando unzip. En Ubuntu, puedes instalar unzip usando apt:

sudo apt install unzip

Úsalo para extraer el archivo descargado en el directorio ~/opt/terraform ejecutando:

unzip ~/terraform.zip -d ~/opt/terraform

Finalmente, agrega ~/opt/terraform a tu variable de entorno PATH para que puedas ejecutar el comando terraform sin especificar la ruta completa al ejecutable.

En Linux, deberás redefinir PATH en .bashrc, que se ejecuta cuando se abre un nuevo shell. Ábrelo para editarlo ejecutando:

nano ~/.bashrc

Nota: En macOS, agrega la ruta al archivo .bash_profile si estás usando Bash, o a .zshrc si estás usando ZSH.

Para agregar la ruta de Terraform a tu PATH, agrega la siguiente línea al final del archivo:

export PATH=$PATH:~/opt/terraform

Guarda y cierra el archivo cuando hayas terminado.

Ahora todas tus nuevas sesiones de shell podrán encontrar el comando terraform. Para cargar el nuevo PATH en tu sesión actual, ejecuta el siguiente comando si estás usando Bash en un sistema Linux:

. ~/.bashrc

Si estás usando Bash en macOS, ejecuta este comando en su lugar:

. .bash_profile

Si estás usando ZSH, ejecuta este comando:

. .zshrc

Para verificar que has instalado Terraform correctamente, ejecuta el comando terraform sin argumentos:

terraform

Verás una output similar a la siguiente:

Output
Usage: terraform [global options] <subcommand> [args]

The available commands for execution are listed below.
The primary workflow commands are given first, followed by
less common or more advanced commands.

Main commands:
  init          Prepare your working directory for other commands
  validate      Check whether the configuration is valid
  plan          Show changes required by the current configuration
  apply         Create or update infrastructure
  destroy       Destroy previously-created infrastructure

All other commands:
  console       Try Terraform expressions at an interactive command prompt
  fmt           Reformat your configuration in the standard style
  force-unlock  Release a stuck lock on the current workspace
  get           Install or upgrade remote Terraform modules
  graph         Generate a Graphviz graph of the steps in an operation
  import        Associate existing infrastructure with a Terraform resource
  login         Obtain and save credentials for a remote host
  logout        Remove locally-stored credentials for a remote host
  output        Show output values from your root module
  providers     Show the providers required for this configuration
  refresh       Update the state to match remote systems
  show          Show the current state or a saved plan
  state         Advanced state management
  taint         Mark a resource instance as not fully functional
  test          Experimental support for module integration testing
  untaint       Remove the 'tainted' state from a resource instance
  version       Show the current Terraform version
  workspace     Workspace management

Global options (use these before the subcommand, if any):
  -chdir=DIR    Switch to a different working directory before executing the

                given subcommand.
  -help         Show this help output, or the help for a specified subcommand.
  -version      An alias for the "version" subcommand.

Estos son los comandos que acepta Terraform. La salida te da una breve descripción, y aprenderás más sobre ellos a lo largo de este tutorial.

Ahora que Terraform está instalado, configurémoslo para trabajar con los recursos de DigitalOcean.

Configurando Terraform para DigitalOcean

Terraform admite una variedad de proveedores de servicios a través de proveedores que puedes instalar. Cada proveedor tiene sus propias especificaciones, que generalmente se corresponden con la API de su respectivo proveedor de servicios.

El proveedor de DigitalOcean permite a Terraform interactuar con la API de DigitalOcean para construir infraestructura. Este proveedor admite la creación de varios recursos de DigitalOcean, incluidos los siguientes:

  • digitalocean_droplet: Droplets (servidores)
  • digitalocean_loadbalancer: Balanceadores de Carga
  • digitalocean_domain: Entradas de dominio DNS
  • digitalocean_record: Registros DNS

Terraform utilizará tu Token de Acceso Personal de DigitalOcean para comunicarse con la API de DigitalOcean y administrar recursos en tu cuenta. No compartas esta clave con otros y mantenla fuera de scripts y control de versiones. Exporta tu Token de Acceso Personal de DigitalOcean a una variable de entorno llamada DO_PAT ejecutando:

export DO_PAT="tu_token_de_acceso_personal"

Esto facilitará su uso en comandos posteriores y lo mantendrá separado de tu código.

Nota: Si trabajarás con Terraform y DigitalOcean con frecuencia, agrega esta línea a tus archivos de configuración de shell utilizando el mismo enfoque que usaste para modificar tu variable de entorno PATH en el paso anterior.

Crea un directorio que almacenará la configuración de tu infraestructura ejecutando el siguiente comando:

mkdir ~/balanceadorcarga

Navega al directorio recién creado:

cd ~/balanceadorcarga

Las configuraciones de Terraform son archivos de texto que terminan con la extensión de archivo .tf. Son legibles por humanos y admiten comentarios. (Terraform también admite archivos de configuración en formato JSON, pero no se cubrirán aquí). Terraform leerá todos los archivos de configuración en tu directorio de trabajo de manera declarativa, por lo que el orden de definiciones de recursos y variables no importa. Toda tu infraestructura puede existir en un solo archivo de configuración, pero debes separar los archivos de configuración por tipo de recurso para mantener la claridad.

El primer paso para construir una infraestructura con Terraform es definir el proveedor que vas a usar.

Para usar el proveedor de DigitalOcean con Terraform, debes informarle a Terraform al respecto y configurar el complemento con las variables de credenciales adecuadas. Crea un archivo llamado provider.tf, que almacenará la configuración para el proveedor:

nano provider.tf

Agrega las siguientes líneas al archivo para indicarle a Terraform que deseas usar el proveedor de DigitalOcean e instruir a Terraform dónde encontrarlo:

~/balanceadorcarga/provider.tf

terraform {
  required_providers {
    digitalocean = {
      source = "digitalocean/digitalocean"
      version = "~> 2.0"
    }
  }
}

Luego, define las siguientes variables en el archivo para que puedas hacer referencia a ellas en el resto de tus archivos de configuración:

  • do_token: tu Token de Acceso Personal de DigitalOcean.
  • pvt_key: ubicación de la clave privada, para que Terraform pueda usarla para iniciar sesión en nuevos Droplets e instalar Nginx.

Pasará los valores de estas variables a Terraform cuando lo ejecutes, en lugar de codificar los valores aquí. Esto hace que la configuración sea más portátil.

Para definir estas variables, agrega estas líneas al archivo:

~/balanceadorcarga/provider.tf

...
variable "do_token" {}
variable "pvt_key" {}

Luego, agrega estas líneas para configurar el proveedor de DigitalOcean y especificar las credenciales de tu cuenta de DigitalOcean asignando el do_token al argumento token del proveedor:

~/balanceadorcarga/provider.tf

...
provider "digitalocean" {
  token = var.do_token
}

Finalmente, querrás que Terraform agregue automáticamente tu clave SSH a cualquier nuevo Droplet que crees. Cuando agregaste tu clave SSH a DigitalOcean, le diste un nombre. Terraform puede usar este nombre para recuperar la clave pública. Agrega estas líneas, reemplazando terraform con el nombre de la clave que proporcionaste en tu cuenta de DigitalOcean:

~/balanceadorcarga/provider.tf

...
data "digitalocean_ssh_key" "terraform" {
  name = "terraform"
}

Tu archivo provider.tf completo se verá así:

~/balanceadorcarga/provider.tf

terraform {
  required_providers {
    digitalocean = {
      source = "digitalocean/digitalocean"
      version = "~> 2.0"
    }
  }
}

variable "do_token" {}
variable "pvt_key" {}

provider "digitalocean" {
  token = var.do_token
}

data "digitalocean_ssh_key" "terraform" {
  name = "terraform"
}

Cuando hayas terminado, guarda y cierra el archivo.

Nota: Configurar la variable de entorno TF_LOG en 1 permitirá un registro detallado de lo que Terraform está intentando hacer. Puedes configurarlo ejecutando:

export TF_LOG=1

Inicializa Terraform para tu proyecto ejecutando:

terraform init

Esto leerá tu configuración e instalará los complementos para tu proveedor. Verás eso registrado en la salida:

Output
Initializing the backend...

Initializing provider plugins...
- Finding digitalocean/digitalocean versions matching "~> 2.0"...
- Installing digitalocean/digitalocean v2.16.0...
- Installed digitalocean/digitalocean v2.16.0 (signed by a HashiCorp partner, key ID F82037E524B9C0E8)

Partner and community providers are signed by their developers.
If you'd like to know more about provider signing, you can read about it here:
https://www.terraform.io/docs/cli/plugins/signing.html

Terraform has created a lock file .terraform.lock.hcl to record the provider
selections it made above. Include this file in your version control repository
so that Terraform can guarantee to make the same selections by default when
you run "terraform init" in the future.

Terraform has been successfully initialized!

You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.

If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.

Si te quedas atascado y Terraform no funciona como esperas, puedes comenzar de nuevo eliminando el archivo terraform.tfstate y destruyendo manualmente los recursos que se crearon (por ejemplo, a través del panel de control).

Terraform ahora está configurado y puede conectarse a tu cuenta de DigitalOcean. En el próximo paso, usarás Terraform para definir un Droplet que ejecutará un servidor Nginx.

Definiendo el Primer Servidor Nginx

Puedes usar Terraform para crear un Droplet de DigitalOcean e instalar software en el Droplet una vez que esté en funcionamiento. En este paso, provisionarás un solo Droplet Ubuntu 20.04 e instalarás el servidor web Nginx usando Terraform.

Crea un nuevo archivo de configuración de Terraform llamado www-1.tf, que contendrá la configuración para el Droplet:

nano www-1.tf

Inserta las siguientes líneas para definir el recurso Droplet:

~/loadbalance/www-1.tf

resource "digitalocean_droplet" "www-1" {
    image = "ubuntu-20-04-x64"
    name = "www-1"
    region = "nyc3"
    size = "s-1vcpu-1gb"
    ssh_keys = [
      data.digitalocean_ssh_key.terraform.id
    ]

En la configuración anterior, la primera línea define un recurso digitalocean_droplet llamado www-1. El resto de las líneas especifican los atributos del Droplet, incluido el centro de datos en el que residirá y el slug que identifica el tamaño del Droplet que deseas configurar. En este caso, estás usando s-1vcpu-1gb, que creará un Droplet con una CPU y 1 GB de RAM. (Visita esta tabla de slugs de tamaño para ver los slugs disponibles que puedes usar).

La sección ssh_keys especifica una lista de claves públicas que deseas agregar al Droplet. En este caso, estás especificando la clave que definiste en provider.tf. Asegúrate de que el nombre aquí coincida con el nombre que especificaste en provider.tf.

Cuando ejecutes Terraform contra la API de DigitalOcean, recopilará una variedad de información sobre el Droplet, como sus direcciones IP pública y privada. Esta información puede ser utilizada por otros recursos en tu configuración.

Si te preguntas qué argumentos son obligatorios u opcionales para un recurso Droplet, consulta la documentación oficial de Terraform.

Para configurar una conexión que Terraform pueda usar para conectarse al servidor a través de SSH, agrega las siguientes líneas al final del archivo:

~/loadbalance/www-1.tf

...
connection {
    host = self.ipv4_address
    user = "root"
    type = "ssh"
    private_key = file(var.pvt_key)
    timeout = "2m"
  }

Estas líneas describen cómo Terraform debe conectarse al servidor, para que Terraform pueda conectarse por SSH para instalar Nginx. Observa el uso de la variable de clave privada var.pvt_key; pasarás su valor cuando ejecutes Terraform.

Ahora que tienes la conexión configurada, configura el aprovisionador remote-exec, que usarás para instalar Nginx. Agrega las siguientes líneas a la configuración para hacer eso:

~/loadbalance/www-1.tf

...
provisioner "remote-exec" {
    inline = [
      "export PATH=$PATH:/usr/bin",
      # install nginx
      "sudo apt update",
      "sudo apt install -y nginx"
    ]
  }
}

Ten en cuenta que las cadenas en la matriz inline son los comandos que ejecutará el usuario root para instalar Nginx.

El archivo completo se verá así:

~/loadbalance/www-1.tf

resource "digitalocean_droplet" "www-1" {
  image = "ubuntu-20-04-x64"
  name = "www-1"
  region = "nyc3"
  size = "s-1vcpu-1gb"
  ssh_keys = [
    data.digitalocean_ssh_key.terraform.id
  ]
  
  connection {
    host = self.ipv4_address
    user = "root"
    type = "ssh"
    private_key = file(var.pvt_key)
    timeout = "2m"
  }
  
  provisioner "remote-exec" {
    inline = [
      "export PATH=$PATH:/usr/bin",
      # install nginx
      "sudo apt update",
      "sudo apt install -y nginx"
    ]
  }
}

Guarda el archivo y sal del editor. Has definido el servidor y estás listo para implementarlo, lo que harás ahora.

Usando Terraform para Crear el Servidor Nginx

Tu configuración actual de Terraform describe un único servidor Nginx. Ahora implementarás el Droplet exactamente como está definido.

Ejecuta el comando terraform plan para ver el plan de ejecución, o lo que Terraform intentará hacer para construir la infraestructura que describiste. Tendrás que especificar los valores para tu Token de Acceso de DigitalOcean y la ruta de tu clave privada, ya que tu configuración usa esta información para acceder a tu Droplet para instalar Nginx. Ejecuta el siguiente comando para crear un plan:

terraform plan \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa" 

Advertencia: El comando terraform plan admite un parámetro -out para guardar el plan. Sin embargo, el plan almacenará claves API, y Terraform no encripta estos datos. Al usar esta opción, deberías explorar la encriptación de este archivo si planeas enviarlo a otros o dejarlo en reposo durante un período prolongado de tiempo.

Verás una salida similar a esta:

Output
Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # digitalocean_droplet.www-1 will be created
  + resource "digitalocean_droplet" "www-1" {
      + backups              = false
      + created_at           = (known after apply)
      + disk                 = (known after apply)
      + graceful_shutdown    = false
      + id                   = (known after apply)
      + image                = "ubuntu-20-04-x64"
      + ipv4_address         = (known after apply)
      + ipv4_address_private = (known after apply)
      + ipv6                 = false
      + ipv6_address         = (known after apply)
      + locked               = (known after apply)
      + memory               = (known after apply)
      + monitoring           = false
      + name                 = "www-1"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = (known after apply)
      + region               = "nyc3"
      + resize_disk          = true
      + size                 = "s-1vcpu-1gb"
      + ssh_keys             = [
          + "...",
        ]
      + status

               = (known after apply)
      + urn                  = (known after apply)
      + vcpus                = (known after apply)
      + volume_ids           = (known after apply)
      + vpc_uuid             = (known after apply)
    }

Plan: 1 to add, 0 to change, 0 to destroy.

───────────────────────────────────────────────────────────────

Note: You didn't use the -out option to save this plan, so Terraform can't guarantee to take exactly these actions if you run "terraform apply" now.

La línea + resource «digitalocean_droplet» «www-1» significa que Terraform creará un nuevo recurso Droplet llamado www-1, con los detalles que le siguen. Eso es exactamente lo que debería suceder, así que ejecuta el comando terraform apply para ejecutar el plan actual:

terraform apply \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Obtendrás la misma salida que antes, pero esta vez, Terraform te preguntará si deseas continuar:

Output
...
Plan: 1 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

Ingresa yes y presiona ENTER. Terraform aprovisionará tu Droplet:

Output
digitalocean_droplet.www-1: Creating...

Después de un tiempo, verás a Terraform instalando Nginx con el aprovisionador remote-exec, y luego el proceso se completará:

Output

digitalocean_droplet.www-1: Provisioning with 'remote-exec'...

....

digitalocean_droplet.www-1: Creation complete after 1m54s [id=your_www-1_droplet_id]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
...

Terraform ha creado un nuevo Droplet llamado www-1 e instalado Nginx en él. Si visitas la dirección IP pública de tu nuevo Droplet, verás la pantalla de bienvenida de Nginx. La dirección IP pública se mostró cuando se creó el Droplet, pero siempre puedes verla mirando el estado actual de Terraform. Terraform actualiza el archivo de estado terraform.tfstate cada vez que ejecuta un plan o actualiza su estado.

Para ver el estado actual de tu entorno, usa el siguiente comando:

terraform show terraform.tfstate

Esto te mostrará la dirección IP pública de tu Droplet.

Output
resource "digitalocean_droplet" "www-1" {
    backups              = false
    created_at           = "..."
    disk                 = 25
    id                   = "your_www-1_droplet_id"
    image                = "ubuntu-20-04-x64"
    ipv4_address         = "your_www-1_server_ip"
    ipv4_address_private = "10.128.0.2"
    ...

Navega a http://your_www-1_server_ip en tu navegador para verificar que tu servidor Nginx esté en funcionamiento.

Nota: Si modificas tu infraestructura fuera de Terraform, tu archivo de estado estará desactualizado. Si tus recursos se modifican fuera de Terraform, deberás actualizar el archivo de estado para ponerlo al día. Este comando extraerá la información de recursos actualizada de tus proveedores:

terraform refresh \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

En este paso, has implementado el Droplet que has descrito en Terraform. Ahora crearás un segundo.

Creando el Segundo Servidor Nginx

Ahora que has descrito un servidor Nginx, puedes agregar rápidamente un segundo copiando el archivo de configuración existente del servidor y reemplazando el nombre y el hostname del recurso Droplet.

Puedes hacerlo manualmente, pero es más rápido usar el comando sed para leer el archivo www-1.tf, sustituir todas las instancias de www-1 por www-2 y crear un nuevo archivo llamado www-2.tf. Aquí tienes el comando sed para hacerlo:

sed 's/www-1/www-2/g' www-1.tf > www-2.tf

Ejecuta nuevamente terraform plan para previsualizar los cambios que Terraform realizará:

terraform plan \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

La salida muestra que Terraform creará el segundo servidor, www-2:

Output
Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # digitalocean_droplet.www-2 will be created
  + resource "digitalocean_droplet" "www-2" {
      + backups              = false
      + created_at           = (known after apply)
      + disk                 = (known after apply)
      + id                   = (known after apply)
      + image                = "ubuntu-20-04-x64"
      + ipv4_address         = (known after apply)
      + ipv4_address_private = (known after apply)
      + ipv6                 = false
      + ipv6_address         = (known after apply)
      + locked               = (known after apply)
      + memory               = (known after apply)
      + monitoring           = false
      + name                 = "www-2"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = true
      + region               = "nyc3"
      + resize_disk          = true
      + size                 = "s-1vcpu-1gb"
      + ssh_keys             = [
          + "...",
        ]
      + status               = (known after apply)
      + urn                  = (known after apply)
      + vcpus                = (known after apply)
      + volume_ids           = (known after apply)
      + vpc_uuid             = (known after apply)
    }

Plan: 1 to add, 0 to change, 0 to destroy.
...

Ejecuta nuevamente terraform apply para crear el segundo Droplet:

terraform apply \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Como antes, Terraform te pedirá que confirmes si deseas continuar. Revisa nuevamente el plan y escribe yes para continuar.

Después de algún tiempo, Terraform creará el nuevo servidor y mostrará los resultados:

Output
digitalocean_droplet.www-2: Creation complete after 1m47s [id=your_www-2_droplet_id]
...
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Terraform ha creado el nuevo servidor, sin alterar el existente. Puedes repetir este paso para agregar servidores Nginx adicionales.

Ahora que tienes dos Droplets ejecutando Nginx, definirás e implementarás un balanceador de carga para dividir el tráfico entre ellos.

Creando el Balanceador de Carga

Utilizarás un Balanceador de Carga de DigitalOcean, compatible con el proveedor oficial de Terraform, para dirigir el tráfico entre los dos servidores web.

Crea un nuevo archivo de configuración de Terraform llamado loadbalancer.tf:

nano loadbalancer.tf

Agrega las siguientes líneas para definir el Balanceador de Carga:

~/loadbalance/loadbalancer.tf

resource "digitalocean_loadbalancer" "www-lb" {
  name = "www-lb"
  region = "nyc3"

  forwarding_rule {
    entry_port = 80
    entry_protocol = "http"

    target_port = 80
    target_protocol = "http"
  }

  healthcheck {
    port = 22
    protocol = "tcp"
  }

  droplet_ids = [digitalocean_droplet.www-1.id, digitalocean_droplet.www-2.id ]
}

La definición del Balanceador de Carga especifica su nombre, el datacenter en el que estará, los puertos en los que debe escuchar para equilibrar el tráfico, la configuración para la verificación de salud y los IDs de los Droplets que debería balancear, que se obtienen utilizando variables de Terraform. Guarda y cierra el archivo.

Ejecuta nuevamente el comando terraform plan para revisar el nuevo plan de ejecución:

terraform plan \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Verás varias líneas de output, incluyendo las siguientes:

Output
...
Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # digitalocean_loadbalancer.www-lb will be created
  + resource "digitalocean_loadbalancer" "www-lb" {
      + algorithm                        = "round_robin"
      + disable_lets_encrypt_dns_records = false
      + droplet_ids                      = [
          + ...,
          + ...,
        ]
      + enable_backend_keepalive         = false
      + enable_proxy_protocol            = false
      + id                               = (known after apply)
      + ip                               = (known after apply)
      + name                             = "www-lb"
      + redirect_http_to_https           = false
      + region                           = "nyc3"
      + size_unit                        = (known after apply)
      + status                           = (known after apply)
      + urn                              = (known after apply)

      + forwarding_rule {
          + certificate_id   = (known after apply)
          + certificate_name = (known after apply)
          + entry_port       = 80
          + entry_protocol   = "http"
          + target_port      = 80
          + target_protocol  = "http"
          + tls_passthrough  = false
        }

      + healthcheck {
          + check_interval_seconds   = 10
          + healthy_threshold        = 5
          + port                     = 22
          + protocol                 = "tcp"
          + response_timeout_seconds = 5
          + unhealthy_threshold      = 3
        }

      + sticky_sessions {
          + cookie_name        = (known after apply)
          + cookie_ttl_seconds = (known after apply)
          + type               = (known after apply)
        }
    }

Plan: 1 to add, 0 to change, 0 to destroy.
...

Esto significa que los Droplets www-1 y www-2 ya existen, y Terraform creará el Balanceador de Carga www-lb.

Ejecuta terraform apply para construir el Balanceador de Carga:

terraform apply \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Una vez más, Terraform te pedirá que revises el plan. Aprueba el plan ingresando yes para continuar.

Una vez que lo hagas, verás una Output que contiene las siguientes líneas, truncadas por brevedad:

Output
...
digitalocean_loadbalancer.www-lb: Creating...
...
digitalocean_loadbalancer.www-lb: Creation complete after 1m18s [id=your_load_balancer_id]
...
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
...

Usa terraform show terraform.tfstate para ubicar la dirección IP de tu Balanceador de Carga:

terraform show terraform.tfstate

Encontrarás la IP bajo la entrada de www-lb:

Output
...
# digitalocean_loadbalancer.www-lb:
resource "digitalocean_loadbalancer" "www-lb" {
    algorithm                = "round_robin"
    disable_lets_encrypt_dns_records = false
    droplet_ids              = [
        your_www-1_droplet_id,
        your_www-2_droplet_id,
    ]
    enable_backend_keepalive = false
    enable_proxy_protocol    = false
    id                       = "your_load_balancer_id"
    ip                       = "your_load_balancer_ip"
    name                     = "www-lb"
    ...

Navega a http://tu_dirección_ip_del_balanceador en tu navegador y verás una pantalla de bienvenida de Nginx porque el Balanceador de Carga está enviando el tráfico a uno de los dos servidores Nginx.

Ahora aprenderás cómo configurar DNS para tu cuenta de DigitalOcean usando Terraform.

Creando Dominios y Registros DNS

Además de Droplets y Balanceadores de Carga, Terraform también puede crear dominios DNS y registros de dominios. Por ejemplo, si deseas apuntar tu dominio a tu Balanceador de Carga, puedes escribir la configuración que describa esa relación.

Nota: Utiliza tu propio nombre de dominio único o Terraform no podrá implementar los recursos DNS. Asegúrate de que tu dominio esté apuntado a los servidores de nombres de DigitalOcean.

Crea un nuevo archivo para describir tu DNS:

nano domain_root.tf

Agrega el siguiente recurso de dominio, reemplazando your_domain con tu nombre de dominio:

~/loadbalance/domain_root.tf

resource "digitalocean_domain" "default" {
   name = "your_domain"
   ip_address = digitalocean_loadbalancer.www-lb.ip
}

Guarda y cierra el archivo cuando hayas terminado.

También puedes agregar un registro CNAME que apunte www.tu_domain a tu_domain. Crea un nuevo archivo para el registro CNAME:

nano domain_cname.tf

Agrega estas líneas al archivo:

domain_cname.tf

resource "digitalocean_record" "CNAME-www" {
  domain = digitalocean_domain.default.name
  type = "CNAME"
  name = "www"
  value = "@"
}

Guarda y cierra el archivo cuando hayas terminado.

Para agregar las entradas DNS, ejecuta terraform plan seguido de terraform apply, al igual que con los otros recursos.

Navega a tu nombre de dominio y verás una pantalla de bienvenida de Nginx porque el dominio está apuntando al Balanceador de Carga, que está enviando el tráfico a uno de los dos servidores Nginx.

Destruyendo tu Infraestructura

Aunque no se usa comúnmente en entornos de producción, Terraform también puede destruir la infraestructura que creó. Esto es principalmente útil en entornos de desarrollo que se implementan y destruyen múltiples veces.

Primero, crea un plan de ejecución para destruir la infraestructura usando terraform plan -destroy:

terraform plan -destroy -out=terraform.tfplan \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Terraform mostrará un plan con recursos marcados en rojo, y precedidos por un signo menos, indicando que eliminará los recursos en tu infraestructura.

Luego, utiliza terraform apply para ejecutar el plan:

terraform apply terraform.tfplan

Terraform procederá a destruir los recursos, como se indica en el plan generado.

Conclusión

En este tutorial, utilizaste Terraform para construir una infraestructura web balanceada en DigitalOcean, con dos servidores web Nginx ejecutándose detrás de un Balanceador de Carga de DigitalOcean. Ahora sabes cómo crear y destruir recursos, ver el estado actual y usar Terraform para configurar entradas DNS.

Ahora que comprendes cómo funciona Terraform, puedes crear archivos de configuración que describan una infraestructura de servidor para tus propios proyectos. El ejemplo en este tutorial es un buen punto de partida que demuestra cómo puedes automatizar la implementación de servidores. Si ya usas herramientas de aprovisionamiento, puedes integrarlas con Terraform para configurar servidores como parte de su proceso de creación en lugar de utilizar el método de aprovisionamiento utilizado en este tutorial.

Terraform tiene muchas más características y puede trabajar con otros proveedores. Consulta la Documentación Oficial de Terraform para aprender más sobre cómo puedes usar Terraform para mejorar tu propia infraestructura.

Traducción adaptada de «How To Use Terraform with DigitalOcean«

Más apuntes

Invítame a un café con bitcoins:
1QESjZDPxWtZ9sj3v5tvgfFn3ks13AxWVZ

Bitcoins para café
También puedes invitarme a algo para mojar...

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Rellena este campo
Rellena este campo
Por favor, introduce una dirección de correo electrónico válida.
Tienes que aprobar los términos para continuar