Cómo ejecutar Terraform en DigitalOcean

Introducción

Terraform es una herramienta para crear y gestionar infraestructura de forma organizada. Puede usarla para administrar Droplets de DigitalOcean, Balanceadores de Carga e incluso entradas DNS, además de una amplia gama de servicios ofrecidos por otros proveedores. Terraform utiliza una interfaz de línea de comandos y puede ejecutarse desde su escritorio o un servidor remoto.

Terraform funciona leyendo archivos de configuración que describen los componentes de su entorno de aplicaciones o centro de datos. Con base en la configuración, crea un plan ejecutable que describe cómo lograr el estado deseado. Posteriormente, Terraform ejecuta este plan para construir su infraestructura. Cuando se producen cambios en la configuración, Terraform puede crear y ejecutar planes incrementales para actualizar la infraestructura existente al nuevo estado descrito.

En este tutorial, instalará Terraform y lo usará para crear una infraestructura en DigitalOcean compuesta por dos servidores Nginx con balanceo de carga mediante un balanceador de carga de DigitalOcean. A continuación, usará Terraform para agregar una entrada DNS en DigitalOcean que apunte al balanceador de carga. Esto le ayudará a comenzar a usar Terraform y le dará una idea de cómo puede usarlo para administrar e implementar una infraestructura basada en DigitalOcean que se ajuste a sus necesidades.

Requisitos previos

• Una cuenta de DigitalOcean
• Un código de acceso personal de DigitalOcean que puede crear a través del panel de control de DigitalOcean.
• Se ha agregado una clave SSH sin contraseña a su cuenta de DigitalOcean.
• Un dominio personal que apunta a un servidor llamado DigitalOcean.

Paso 1: Instalación de Terraform

Terraform es una herramienta de línea de comandos que se ejecuta en un escritorio o servidor remoto. Para instalarla, descárgala y colócala en tu PATH para que puedas ejecutarla en cualquier directorio en el que estés trabajando.

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

En macOS, use este comando para descargar Terraform y colocarlo en su directorio de inicio:

curl -o ~/terraform.zip https://releases.hashicorp.com/terraform/1.7.2/terraform_1.7.2_darwin_amd64.zip

En Linux, use este comando:

curl -o ~/terraform.zip https://releases.hashicorp.com/terraform/1.7.2/terraform_1.7.2_linux_amd64.zip

Cree la carpeta ~/opt/terraform:

mkdir -p ~/opt/terraform

Luego, descomprima Terraform en ~/opt/terraform con el comando unzip. En Ubuntu, puede instalar unzip con apt:

sudo apt install unzip

Úselo para extraer el archivo descargado a la carpeta ~/opt/terraform ejecutando:

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

Por último, agregue ~/opt/terraform a su variable de entorno PATH para que pueda ejecutar el comando terraform sin especificar la ruta completa al archivo ejecutable.

En Linux, debe definir PATH en bashrc., que se ejecuta al abrir un nuevo shell. Para editarlo, ejecute lo siguiente:

nano ~/.bashrc

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

export PATH=$PATH:~/opt/terraform

Cuando termine, guarde y cierre el archivo.

Ahora todas tus nuevas sesiones de shell podrán encontrar el comando terraform. Para cargar la nueva ruta en tu sesión actual, si usas Bash en un sistema Linux, ejecuta el siguiente comando:

. ~/.bashrc

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

. .bash_profile

Si está utilizando ZSH, ejecute este comando:

. .zshrc

Para verificar que ha instalado Terraform correctamente, ejecute el comando terraform sin argumentos:

terraform

Verá un resultado similar al siguiente:

OutputUsage: 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. El resultado le ofrecerá una breve explicación y aprenderá más sobre ellos a lo largo de este tutorial.

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

Paso 2: Configurar Terraform para DigitalOcean

Terraform admite diversos proveedores de servicios que puedes instalar. Cada proveedor tiene sus propias especificaciones que generalmente exponen su API correspondiente.

El proveedor de DigitalOcean permite a Terraform interactuar con la API de DigitalOcean para crear infraestructura. Este proveedor facilita la creación de diversos recursos de DigitalOcean, entre ellos:

• digitalocean_droplet: Droplets (servidores)
• digitalocean_loadbalancer: Balanceador de carga
• digitalocean_domain: entradas de dominio DNS
• digitalocean_record: registros DNS

Terraform utiliza su clave de acceso personal de DigitalOcean para comunicarse con la API de DigitalOcean y administrar los recursos de su cuenta. No comparta esta clave con otros y manténgala fuera del control de scripts y versiones. Exporte su clave de acceso personal de DigitalOcean a una variable de entorno llamada DO_PAT ejecutando lo siguiente:

export DO_PAT="your_personal_access_token"

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

mkdir ~/loadbalance

Vaya al directorio recién creado:

cd ~/loadbalance

Las configuraciones de Terraform son archivos de texto con la extensión .tf. Son legibles y admiten comentarios. (Terraform también admite archivos de configuración en formato JSON, pero no se tratan aquí). Terraform lee todos los archivos de configuración de su directorio de trabajo de forma declarativa, por lo que el orden de las definiciones de recursos y variables es irrelevante. Toda su infraestructura puede constar en un único archivo de configuración, pero para mayor claridad, conviene separar los archivos de configuración por tipo de recurso.

El primer paso para crear infraestructura con Terraform es definir el proveedor que vas a utilizar.

Para usar un proveedor de DigitalOcean con Terraform, debe informar a Terraform sobre él y configurar el complemento con las variables de credenciales adecuadas. Cree un archivo llamado provider.tf que almacene la configuración del proveedor:

nano provider.tf

Agregue las siguientes líneas al archivo para indicarle a Terraform que desea utilizar el proveedor DigitalOcean e indicarle dónde encontrarlo:

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

Luego, defina las siguientes variables en el archivo para que pueda referenciarlas en el resto de sus archivos de configuración:

• hacer_token:Su contraseña personal de acceso a DigitalOcean.
• clave privada:La ubicación de la clave privada, para que Terraform pueda usarla para iniciar sesión en nuevos Droplets e instalar Nginx.

Se pasan los valores de estas variables a Terraform durante su ejecución, en lugar de codificarlos directamente. Esto facilita la portabilidad de la configuración.

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

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

Luego, agregue estas líneas para configurar el proveedor de DigitalOcean y asignar las credenciales de su cuenta de DigitalOcean mediante hacer_token Al argumento Simbólico Especifique el proveedor:

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

Finalmente, desea que Terraform agregue automáticamente su clave SSH a cualquier droplet nuevo que cree. Al agregar su clave SSH a DigitalOcean, le asignó un nombre. Terraform puede usar este nombre para recuperar la clave pública. Agregue estas líneas, reemplazando el nombre de la clave que proporcionó en su cuenta de DigitalOcean. terraformar Hacer:

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

Archivo proveedor.tf El formulario 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"
}

Inicialice Terraform para su proyecto ejecutando:

terraform init

Esto leerá tu configuración e instalará los complementos de tu proveedor. Verás esto en el resultado:

OutputInitializing the backend...
Initializing provider plugins...
- Finding digitalocean/digitalocean versions matching "~> 2.0"...
- Installing digitalocean/digitalocean v2.34.1...
- Installed digitalocean/digitalocean v2.34.1 (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 solucionarlo eliminando el archivo terraform.tfstate Y elimine manualmente los recursos creados (por ejemplo, a través del Panel de control) y comience de nuevo.

Terraform ya está configurado y puede conectarse a su cuenta de DigitalOcean. A continuación, usará Terraform para definir un droplet que ejecutará el servidor Nginx.

Paso 3: Definir el primer servidor Nginx

Puedes usar Terraform para crear un Droplet de DigitalOcean, iniciarlo e instalar el software en él. En este paso, aprovisionarás Ubuntu 20.04 e instalarás el servidor web Nginx con Terraform.

Un nuevo archivo de configuración de Terraform llamado www-1.tf Cree un archivo que contenga la configuración de Droplet:

nano www-1.tf

Introduzca las siguientes líneas para definir la fuente del 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 anterior, la primera línea define un recurso digitalocean_droplet llamado www-1. Las líneas restantes especifican las propiedades del Droplet, incluyendo el centro de datos donde se encuentra y el Slug que especifica el tamaño del Droplet que desea configurar. En este caso, se utiliza s-1vcpu-1gb, que crea un Droplet con una CPU y 1 GB de RAM. (Consulte esta tabla de tamaños de slugs para ver los slugs disponibles).

Sección claves ssh Especifica una lista de claves públicas que desea agregar al Droplet. En este caso, especifique la clave que se encuentra en proveedor.tf Asegúrese de que el nombre aquí coincida con el nombre que definió en proveedor.tf Has especificado que debe coincidir.

Al ejecutar Terraform contra la API de DigitalOcean, se recopila información diversa sobre el Droplet, como sus direcciones IP públicas y privadas. Esta información puede ser utilizada por otros recursos de su configuración.

Si no sabe qué argumentos son obligatorios u opcionales para una fuente Droplet, consulte la documentación oficial de Terraform: Especificación de gotas de DigitalOcean

Para configurar una conexión que Terraform pueda usar 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 explican cómo Terraform debe conectarse al servidor para que pueda conectarse vía SSH e instalar Nginx. Uso de la variable de clave privada. var.pvt_key Preste atención: pasa el valor a Terraform cuando lo ejecuta.

Ahora que tiene la conexión configurada, configure el proveedor de ejecución remota que usará para instalar Nginx. Para ello, agregue las siguientes líneas a la configuración:

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

Tenga en cuenta que las cadenas en la matriz en línea son los comandos que el usuario root ejecuta 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",
# install nginx
"sudo apt update",
"sudo apt install -y nginx"
]
}
}

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

Paso 4: Usar Terraform para crear un servidor Nginx

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

Orden plan de terraformación Ejecute para ver el plan de ejecución o lo que Terraform hará para construir la infraestructura que describió. Debe especificar los valores del token de acceso de DigitalOcean y la ruta a su clave privada, ya que su configuración utilizará esta información para acceder al droplet de la instalación de Nginx. Para crear un plan, ejecute el siguiente comando:

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

Verá un resultado similar a este:

OutputTerraform 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 + recurso “digitalocean_droplet” “www-1” significa que Terraform creará un nuevo recurso Droplet llamado www-1 con la siguiente información. Esto es exactamente lo que debería suceder, así que ejecute el comando de la aplicación Terraform para ejecutar la aplicación actual:

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

Obtendrá el mismo resultado que antes, pero esta vez Terraform le preguntará si desea 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

Ingrese "Sí" y presione ENTER. Terraform Droplet le proporciona:

Outputdigitalocean_droplet.www-1: Creating...

Después de un tiempo, verá que Terraform instala Nginx con el proveedor de ejecución remota 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. Si visita la dirección IP pública de su nuevo Droplet, verá la página de bienvenida de Nginx. La IP pública se muestra al crear el Droplet, pero siempre puede verla consultando 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 su entorno, utilice el siguiente comando:

terraform show terraform.tfstate

Esto muestra la dirección IP pública de su Droplet.

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

Para verificar que su servidor Nginx esté funcionando, vaya a http://your_www-1_server_ip en su navegador.

En este punto, ya has implementado el Droplet que describiste en Terraform. Ahora crearás uno segundo.

Paso 5: Crear un segundo servidor Nginx

Ahora que tiene un servidor Nginx configurado, puede agregar rápidamente un segundo copiando el archivo de configuración del servidor existente y reemplazando el nombre de origen y el nombre de host del Droplet.

Puedes hacerlo manualmente, pero usando el comando sed Para leer el archivo www-1.tf, reemplazando todas las instancias www-1 Con www-2 y crea un nuevo archivo llamado www-2.tf Es más rápido. Aquí está el comando. sed Para ello hay:

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

Puede obtener más información sobre el uso de sed visitando Uso de sed. sed Más información.

Para obtener una vista previa de los cambios que realizará Terraform, ejecute el programa Terraform nuevamente:

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

El resultado muestra que Terraform creará un segundo servidor www-2:

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

Ejecute la aplicación Terraform nuevamente para crear la segunda gota:

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

Como antes, Terraform te pedirá que confirmes que deseas continuar. Revisa el plan de nuevo y pulsa "Sí" para continuar.

Después de un tiempo, Terraform crea el nuevo servidor y muestra los resultados:

Outputdigitalocean_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 modificar el existente. Puede repetir este paso para agregar más servidores Nginx.

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

Paso 6 – Equilibrio de carga

Utilizará DigitalOcean Load Balancer, que es compatible con el proveedor oficial Terraform, para enrutar el tráfico entre los dos servidores web.

Un nuevo archivo de configuración de Terraform llamado balanceador de carga.tf Crear:

nano loadbalancer.tf

Agregue 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 de Load Balancer especifica su nombre, el centro de datos en el que estará ubicado, los puertos que debe escuchar para equilibrar el tráfico, la configuración para los controles de estado y los identificadores de las estaciones que debe equilibrar, que se obtienen mediante variables de Terraform.

A continuación, defina una verificación de estado para asegurarse de que el balanceador de carga esté realmente disponible después de la implementación:

check "health_check" {
data "http" "lb_check" {
url = "http://${digitalocean_loadbalancer.www-lb.ip}"
}
assert {
condition = data.http.lb_check.status_code == 200
error_message = "${data.http.lb_check.url} returned an unhealthy status code"
}
}

Esta comprobación solicita el estado de la dirección IP del balanceador de carga mediante HTTP y verifica que el código de retorno sea 200, lo que indica que los droplets están en buen estado y disponibles. Si hay algún error o un código de retorno diferente, se mostrará una advertencia después de los pasos de implementación. Al finalizar, guarde y cierre el archivo.

Ordenar nuevamente plan de terraformación Ejecutar para revisar el nuevo ejecutable:

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

Verá varias líneas de salida, incluidas las siguientes:

Output...
Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
+ create
<= read (data resources)
Terraform will perform the following actions:
# data.http.lb_check will be read during apply
# (config refers to values not yet known)
<= data "http" "lb_check" {
+ body = (known after apply)
+ id = (known after apply)
+ response_body = (known after apply)
+ response_body_base64 = (known after apply)
+ response_headers = (known after apply)
+ status_code = (known after apply)
+ url = (known after apply)
}
# 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
+ http_idle_timeout_seconds = (known after apply)
+ id = (known after apply)
+ ip = (known after apply)
+ name = "www-lb"
+ project_id = (known after apply)
+ 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
}
}
Plan: 1 to add, 0 to change, 0 to destroy.
│ Warning: Check block assertion known after apply
│ on loadbalancer.tf line 27, in check "health_check":
│ 27: condition = data.http.lb_check.status_code == 200
│ ├────────────────
│ │ data.http.lb_check.status_code is a number
│
│ The condition could not be evaluated at this time, a result will be known when this plan is applied.
╵
...

Desde las gotitas www-1 y www-2 Ya existen, Terraform Load Balancer crea www-lb y lo verifica después de aprovisionarlo.

Antes de implementar, debe reiniciar el proyecto para agregar la dependencia http utilizada en health_check:

terraform init -upgrade

Luego, ejecute la aplicación Terraform para crear el balanceador de carga:

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

Terraform te pedirá nuevamente que revises el plan. Confirma el plan presionando "Sí" para continuar.

Después de hacer esto, verá la salida que contiene las siguientes líneas, truncadas para abreviar:

Output...
digitalocean_loadbalancer.www-lb: Creating...
...
digitalocean_loadbalancer.www-lb: Creation complete after 1m18s [id=your_load_balancer_id]
data.http.lb_check: Reading...
data.http.lb_check: Read complete after 0s [id=http://lb-ip]
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
...

Tenga en cuenta que lb_check se completó correctamente.

De terraform muestra terraform.tfstate Para encontrar la dirección IP de su balanceador de carga, utilice:

terraform show terraform.tfstate

Encontrarás la IP en 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"
...

Vaya a http://your_load_balancer_ip en su navegador y verá la página de bienvenida de Nginx mientras el balanceador de carga reenvía tráfico a uno de los dos servidores Nginx.

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

Paso 7 – Crear dominios y registros DNS

Además de Droplets y Balanceadores de Carga, Terraform también puede crear y registrar dominios DNS. Por ejemplo, si desea apuntar su dominio a su Balanceador de Carga, puede crear una configuración que describa esa relación.

Crea un nuevo archivo para describir tu DNS:

nano domain_root.tf

Agregue la siguiente fuente de dominio, reemplazando your_domain con su nombre de dominio:

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

Cuando termine, guarde y cierre el archivo.

También puede agregar un registro CNAME que www.tu_dominio a tu_dominio Cree un nuevo archivo para el registro CNAME:

nano domain_cname.tf

Añade estas líneas al archivo:

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

Cuando termine, guarde y cierre el archivo.

Para agregar entradas DNS, la aplicación terraformar Y luego aplicación terraform Ejecútelo como cualquier otro recurso.

Vaya a su nombre de dominio y verá la página de bienvenida de Nginx porque el dominio apunta al Load Balancer que envía tráfico a uno de los dos servidores Nginx.

Paso 8 – Destruye tu infraestructura

Aunque Terraform no se suele usar en entornos de producción, también puede destruir la infraestructura existente. Esto es especialmente útil en entornos de desarrollo que se implementan y destruyen varias veces.

Primero, usando plan terraform -destruir Crear un plan de implementación para la destrucción de infraestructura:

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

Terraform genera un plan con recursos resaltados en rojo, precedido por un signo menos, lo que indica que eliminará sus recursos de infraestructura.

Luego desde aplicación terraform Para implementar el plan, utilice:

terraform apply terraform.tfplan

Terraform continuará destruyendo recursos según lo especificado en el plan generado.

Resultado

En este tutorial, usaste Terraform para crear una infraestructura web con balanceo de carga en DigitalOcean, con dos servidores web Nginx ejecutándose detrás de un balanceador de carga de DigitalOcean. Aprendiste a crear y destruir recursos, ver el estado actual y usar Terraform para configurar entradas DNS.

Ahora que comprende el funcionamiento de Terraform, puede crear archivos de configuración que describan la infraestructura del servidor para sus proyectos. El ejemplo de este tutorial es un buen punto de partida para mostrar cómo automatizar la implementación de servidores. Si ya utiliza herramientas de aprovisionamiento, puede integrarlas con Terraform para configurar servidores durante el proceso de creación, en lugar de usar el método de aprovisionamiento de este tutorial.

Terraform ofrece muchas más funciones y es compatible con otros proveedores. Para obtener más información sobre cómo usar Terraform para mejorar su infraestructura, consulte la documentación oficial de Terraform. Este tutorial forma parte de la serie "Cómo administrar la infraestructura con Terraform". Esta serie abarca diversos temas relacionados con Terraform, desde su instalación inicial hasta la gestión de proyectos complejos.