Cómo usar Terraform con DigitalOcean

Introducción

Terraform es una herramienta para construir y gestionar infraestructuras de manera organizada. Puedes usarlo para gestionar Droplets de DigitalOcean, Balanceadores de Carga e incluso entradas DNS, además de una amplia variedad de servicios ofrecidos por otros proveedores. Terraform utiliza una interfaz de línea de comandos y puede ejecutarse desde tu escritorio o un servidor remoto.

Terraform funciona leyendo archivos de configuración que describen los componentes que conforman el entorno de aplicación o el centro de datos. Con base 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 utilizarás para crear una infraestructura en DigitalOcean que consta de dos servidores Nginx balanceados por un Balanceador de Carga de DigitalOcean. Luego, utilizará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 gestionar e implementar una infraestructura basada en DigitalOcean que satisfaga tus propias necesidades.

Prerrequisitos

Para completar este tutorial, necesitarás:

• A DigitalOcean account. If you do not have one, sign up for a new account.
• A DigitalOcean Personal Access Token, which you can create via the DigitalOcean control panel. Instructions to do that can be found at: How to Create a Personal Access Token.
• A password-less SSH key added to your DigitalOcean account, which you can create by following How To Use SSH Keys with DigitalOcean Droplets. When you add the key to your account, remember the name you give it, as you’ll need it in this tutorial. (For Terraform to accept the name of your key, it must start with a letter or underscore and may contain only letters, digits, underscores, and dashes.)
• A personal domain pointed to DigitalOcean’s nameserver, which you can do by following the tutorial, How To Point to DigitalOcean Nameservers From Common Domain Registrars.

Paso 1: Instalación de Terraform

Terraform es una herramienta de línea de comandos que se ejecuta 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.

Primero, descarga el paquete apropiado 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, utiliza este comando para descargar Terraform y colocarlo en tu directorio principal:

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

En Linux, utiliza 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 utilizando el comando unzip. En Ubuntu, puedes instalar unzip utilizando 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, necesitarás redefinir PATH en .bashrc, el cual se ejecuta cuando se abre una nueva terminal. Ábrelo para editarlo ejecutando:

nano ~/.bashrc

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 terminal podrán encontrar el comando terraform. Para cargar el nuevo PATH en tu sesión actual, ejecuta el siguiente comando si estás utilizando Bash en un sistema Linux:

. ~/.bashrc

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

. .bash_profile

Si estás utilizando ZSH, ejecuta este comando:

. .zshrc

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

terraform

Verás una salida 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 proporciona una breve descripción, y aprenderás más sobre ellos a lo largo de este tutorial.

Ahora que Terraform está instalado, configuremos para que funcione con los recursos de DigitalOcean.

Paso 2 — Configuración de Terraform para DigitalOcean

Terraform soporta 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 crear 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="your_personal_access_token"

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

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

mkdir ~/loadbalance

Navega al directorio recién creado:

cd ~/loadbalance

Las configuraciones de Terraform son archivos de texto que terminan con la extensión de archivo .tf. Son legibles para humanos y admiten comentarios. (Terraform también admite archivos de configuración en formato JSON, pero no se tratarán aquí). Terraform leerá todos los archivos de configuración en tu directorio de trabajo de manera declarativa, por lo que el orden de las definiciones de recursos y variables no importa. Toda tu infraestructura puede existir en un solo archivo de configuración, pero deberías 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 utilizar.

Para usar el proveedor de DigitalOcean con Terraform, debes informar 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 indicar a Terraform que quieres usar el proveedor de DigitalOcean e instruir a Terraform dónde encontrarlo:

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ás 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 portable.

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

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

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

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

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

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.

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 encuentras atascado y Terraform no está funcionando como esperas, puedes empezar 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 está ahora configurado y puede conectarse a tu cuenta de DigitalOcean. En el próximo paso, utilizarás Terraform para definir un Droplet que ejecutará un servidor Nginx.

Paso 3 — 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, aprovisionará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:

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 precedente, la primera línea define un recurso digitalocean_droplet nombrado www-1. El resto de las líneas especifican los atributos del Droplet, incluyendo 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 utilizando s-1vcpu-1gb, que creará un Droplet con un CPU y 1GB de RAM. (Visita esta tabla de tamaños de slug para ver los slugs disponibles que puedes usar.)

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

Cuando ejecute 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 su configuración.

Si se pregunta qué argumentos son requeridos u opcionales para un recurso de Droplet, consulte la documentación oficial de Terraform: Especificación de Droplet de DigitalOcean.

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

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

Estas líneas describen cómo Terraform debería conectarse al servidor, para que Terraform pueda conectarse a través de SSH para instalar Nginx. Note el uso de la variable de clave privada var.pvt_key—pasará su valor cuando ejecute Terraform.

Ahora que tiene la conexión configurada, configure el aprovisionador remote-exec, que utilizará para instalar Nginx. Agregue las siguientes líneas a la configuración para hacer eso:

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

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

El archivo completo se ve así:

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",
      # instalar nginx
      "sudo apt update",
      "sudo apt install -y nginx"
    ]
  }
}

Guarde el archivo y salga del editor. Ha definido el servidor y está listo para implementarlo, lo cual hará ahora.

Paso 4 — Usando Terraform para Crear el Servidor Nginx

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

Ejecute el comando terraform plan para ver el plan de ejecución, o lo que Terraform intentará hacer para construir la infraestructura que describió. Deberá especificar los valores para su Token de Acceso de DigitalOcean y la ruta de su clave privada, ya que su configuración utiliza esta información para acceder a su Droplet e instalar Nginx. Ejecute el siguiente comando para crear un plan:

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

Verá 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 se creará
  + 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://tu_www-1_dirección_ip_del_servidor en tu navegador para verificar que tu servidor Nginx esté en funcionamiento.

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.

Paso 5 — Creando el Segundo Servidor Nginx

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

Esto se puede hacer manualmente, pero es más rápido utilizar el comando sed para leer el archivo www-1.tf, sustituir todas las instancias de www-1 con 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

Puedes aprender más sobre sed visitando Usando sed.

Ejecuta terraform plan de nuevo para previsualizar los cambios que Terraform hará:

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 será creado
  + 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 terraform apply nuevamente 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 el plan nuevamente 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 creó 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.

Paso 6: Crear el Balanceador de Carga

Utilizarás un Balanceador de Carga de DigitalOcean, el cual es compatible con el proveedor oficial de Terraform, para enrutar 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:

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 centro de datos en el que estará, los puertos en los que debe escuchar para equilibrar el tráfico, la configuración para la comprobación de salud y los IDs de los Droplets que debe equilibrar, los cuales se obtienen utilizando variables de Terraform. Guarda y cierra el archivo.

Ejecuta el comando terraform plan nuevamente 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 salida, incluyendo las siguientes líneas:

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:

  # Se creará digitalocean_loadbalancer.www-lb
  + 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)
      + vpc_uuid                         = (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"

Nuevamente, Terraform te pedirá que revises el plan. Aprueba el plan ingresando yes para continuar.

Una vez que lo hagas, verás una salida 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.
...

Utiliza terraform show terraform.tfstate para localizar la dirección IP de tu Balanceador de Carga:

terraform show terraform.tfstate

Encontrarás la IP bajo la entrada 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 tráfico a uno de los dos servidores Nginx.

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

Paso 7 — 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 quieres apuntar tu dominio a tu Balanceador de Carga, puedes escribir la configuración que describe esa relación.

Crea un nuevo archivo para describir tu DNS:

nano domain_root.tf

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

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_dominio a tu_dominio. Crea un nuevo archivo para el registro CNAME:

nano domain_cname.tf

Agrega estas líneas al archivo:

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, como 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 tráfico a uno de los dos servidores Nginx.

Paso 8 — Destrucción de tu Infraestructura

Aunque no se utiliza 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 varias veces.

Primero, cree 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 emitirá un plan con recursos marcados en rojo y precedidos por un signo menos, lo que indica que eliminará los recursos de su infraestructura.

Luego, utilice 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. Sabes cómo crear y destruir recursos, ver el estado actual y utilizar 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 utilizas 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 utilizar Terraform para mejorar tu propia infraestructura.

Este tutorial es parte de la serie Cómo gestionar la infraestructura con Terraform. La serie cubre varios temas de Terraform, desde instalar Terraform por primera vez hasta gestionar proyectos complejos.