Cómo estructurar un proyecto de Terraform

Introducción

Organizar proyectos de Terraform de manera apropiada en función de su caso de uso y complejidad es fundamental para asegurarse de su mantenibilidad y extensibilidad durante las operaciones diarias. Es necesario adoptar un enfoque sistemático para organizar correctamente los archivos de código para garantizar que el proyecto sea escalable durante la implementación y útil para tú y tu equipo. Se necesita un enfoque adecuado para organizar correctamente los archivos de código para asegurarse de que el proyecto sea escalable durante la implementación y útil para ti y tu equipo. En este tutorial, aprenderás sobre la estructuración de proyectos de Terraform según su propósito general y complejidad percibida. Luego, crearás un proyecto con una estructura simple utilizando las características más comunes de Terraform: variables, locales, fuentes de datos y provisionadores. Al final, tu proyecto se desplegará un servidor Ubuntu 20.04 en DigitalOcean, instalará un servidor web Apache, y dirigirá tu dominio al servidor web.

Requisitos previos

• Una clave de acceso personal de DigitalOcean, que puedes crear a través del panel de control de DigitalOcean. Puedes encontrar instrucciones en los documentos de productos de DigitalOcean, Cómo Crear una Clave de Acceso Personal.

• Una clave SSH sin contraseña agregada a tu cuenta de DigitalOcean, que puedes crear siguiendo la guía Cómo Usar Claves SSH con Dropletas de DigitalOcean.

• Terraform instalado en tu máquina local. Para instrucciones según tu sistema operativo, vea Step 1 del tutorial Cómo Usar Terraform con DigitalOcean.

• Se ha instalado Python 3 en su máquina local. Puede completar Paso 1 de Cómo instalar y configurar un entorno de programación local para Python 3 según su SO.

• Se ha añadido un dominio registrado completamente a su cuenta de DigitalOcean. Para obtener instrucciones sobre cómo hacer esto, visita las documentaciones oficiales.

Comprensión de la estructura de un proyecto de Terraform

En esta sección, aprenderás qué considera Terraform un proyecto, cómo puedes estructurar el código de infraestructura, y cuándo elegir cualquier otra opción. También aprenderás sobre espacios de trabajo de Terraform, lo que hacen, y cómo Terraform almacena estado.

Un recurso es una entidad de un servicio en la nube (como un Dropleton DigitalOcean) declarada en el código de Terraform que se crea según propiedades especificadas e inferidas. Múltiples recursos forman infraestructura con sus conexiones mutuas.

Terraform usa un lenguaje de programación especializado para definir infraestructura, llamado Lenguaje de configuración de Hashicorp (HCL). El código de HCL se guarda generalmente en archivos con la extensión tf. Un proyecto de Terraform es cualquier directorio que contenga archivos tf y que ha sido inicializado utilizando el comando init, el cual establece las cachés de Terraform y el estado local predeterminado.

El estado de Terraform es el mecanismo por el cual mantiene la ruta de acceso a los recursos que se han deployeado realmente en la nube. Se almacena en repositorios (localmente en disco duro o remotamente en un servicio de almacenamiento de archivos en la nube o software específico de gestión de estado). Puedes leer más sobre diferentes repositorios en la documentación de Terraform.

Proyectos de espacios de trabajo permiten tener múltiples estados en la misma infraestructura detrás, vinculados a la misma configuración. Esto le permite desplegar múltiples instancias distintas de la misma infraestructura. Cada proyecto comienza con un espacio de trabajo llamado default. Este será usado si no crea o cambia alguno explícitamente.

Módulos en Terraform (como bibliotecas en otros lenguajes de programación) son contenedores de código parametrizados que encapsulan varias declaraciones de recursos. Permiten abstraer una parte común de su infraestructura y reutilizarla más tarde con diferentes entradas.

Un proyecto de Terraform también puede incluir archivos de código externos para usar con datos de entrada dinámicos, que pueden analizar la salida JSON de una orden de la CLI y ofrecerla para usar en declaraciones de recursos. En este tutorial, lo hará con un script de Python.

Ahora que sabéis qué constituye un proyecto de Terraform, reviemos dos enfoques generales para la estructurización de proyectos de Terraform.

Estructura simple

Una estructura simple es adecuada para proyectos pequeños y de prueba, con unos pocos recursos de diferentes tipos y variables. Tiene unos pocos archivos de configuración, normalmente uno por tipo de recurso (o más auxiliares juntos con uno principal), y no hay módulos personalizados, ya que la mayoría de los recursos son únicos y no hay suficientes para generalizar y reutilizar. Siguiendo esto, la mayor parte del código está almacenado en el mismo directorio, uno al lado del otro. Estos proyectos a menudo tienen unas pocas variables (como una clave de API para acceder a la nube) y pueden utilizar entradas de datos dinámicos y otras características de Terraform y HCL, aunque no destacadamente.

Como ejemplo de la estructura de archivos de este enfoque, este es cómo se verá el proyecto que construirá en este tutorial al final:

.
└── tf/
    ├── versions.tf
    ├── variables.tf
    ├── provider.tf
    ├── droplets.tf
    ├── dns.tf
    ├── data-sources.tf
    └── external/
        └── name-generator.py

Como este proyecto desplegará un servidor web Apache Droplet y configurará registros DNS, las definiciones de variables de proyecto, el proveedor de Terraform de DigitalOcean, el Droplet y los registros DNS se almacenarán en sus respectivos archivos. Se especificarán las versiones mínimas requeridas de Terraform y el proveedor de DigitalOcean en versions.tf, mientras que el script de Python que generará un nombre para el Droplet (y será utilizado como fuente de datos dinámica en data-sources.tf) se almacenará en la carpeta external, para separarlo del código en HCL.

Estructura compleja

En comparación con la estructura simple, este enfoque es adecuado para proyectos grandes, que incluyen estructuras de subdirectorios claramente definidas que contienen módulos multiples de distintos niveles de complejidad, además del código habitual. Estos módulos pueden depender uno de otro. En conjunto con los sistemas de control de versiones, estos proyectos pueden hacer un uso extensivo de áreas de trabajo. Este enfoque es adecuado para proyectos mayores que gestionan múltiples aplicaciones, mientras reutilizan el código en la medida de lo posible.

Las instancias de infraestructura de desarrollo, producción, pruebas de calidad y staging también pueden alojarse en el mismo proyecto en directorios diferentes, dependiendo de módulos comunes, eliminando así el código duplicado y haciendo del proyecto la fuente central de la verdad. Aquí se muestra la estructura de archivos de un proyecto de ejemplo con una estructura más compleja, que contiene múltiples aplicaciones de implementación, módulos de Terraform y entornos de nube de destino:

.
└── tf/
    ├── modules/
    │   ├── network/
    │   │   ├── main.tf
    │   │   ├── dns.tf
    │   │   ├── outputs.tf
    │   │   └── variables.tf
    │   └── spaces/
    │       ├── main.tf
    │       ├── outputs.tf
    │       └── variables.tf
    └── applications/
        ├── backend-app/
        │   ├── env/
        │   │   ├── dev.tfvars
        │   │   ├── staging.tfvars
        │   │   ├── qa.tfvars
        │   │   └── production.tfvars
        │   └── main.tf
        └── frontend-app/
            ├── env/
            │   ├── dev.tfvars
            │   ├── staging.tfvars
            │   ├── qa.tfvars
            │   └── production.tfvars
            └── main.tf

Este enfoque se explora más a fondo en la serie Cómo Gestionar Infraestructuras con Terraform.

Ahora sabes qué es un proyecto de Terraform, cómo estructurarlo de mejor manera según la complejidad percibida y qué función sirven las áreas de trabajo de Terraform. En los próximos pasos, crearás un proyecto con una estructura simple que provisionará un Droplet con un servidor web Apache instalado y registros DNS configurados para tu dominio. Primero inicializarás tu proyecto con el proveedor de DigitalOcean y variables, y luego definirás el Droplet, un origen de datos dinámico para proporcionar su nombre, y un registro DNS para la implementación.

Primer paso — Configuración de tu proyecto inicial

En esta sección, agregarás el proveedor de DigitalOcean de Terraform al proyecto, definirá las variables del proyecto y declarará una instancia del proveedor de DigitalOcean, de manera que Terraform pueda conectarse a su cuenta.

Comience creando un directorio para su proyecto de Terraform con la siguiente orden:

mkdir ~/apache-droplet-terraform

Muevase a él:

cd ~/apache-droplet-terraform

Puesque este proyecto se adhiere al enfoque de estructuración sencilla, guardará el código del proveedor, las variables, la instancia de Droplets y registros DNS en archivos separados, según la estructura de archivos de la sección anterior. Primero, necesitará agregar el proveedor de DigitalOcean de Terraform al proyecto como proveedor requerido.

Cree un archivo llamado versiones.tf y abrelo para edición ejecutando:

nano versions.tf

Agregue las siguientes líneas:

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

En esta terraform bloque, lista los proveedores requeridos (DigitalOcean, versión 2.x). Cuando lo haya hecho, guarde y cierre el archivo.

Luego, defina las variables que expondrá el proyecto en el archivo variables.tf siguiendo el enfoque de almacenar diferentes tipos de recursos en archivos separados de código:

nano variables.tf

Agregue las siguientes variables:

variable "do_token" {}
variable "domain_name" {}

Guarde y cierre el archivo.

La variable do_token contendrá su Token de Acceso Personal de DigitalOcean y domain_name especificará el nombre de dominio deseado. La Droplet desplegada tendrá la clave SSH, identificada por la huella digital SSH, instalada automáticamente.

A continuación, vamos a definir la instancia del proveedor de DigitalOcean para este proyecto. Lo almacenará en un archivo llamado provider.tf. Cree y abra para edición ejecutando:

nano provider.tf

Agregue el proveedor:

provider "digitalocean" {
  token = var.do_token
}

Guarde y salga cuando haya terminado. Ha definido el proveedor digitalocean, que corresponde al proveedor requerido que especificó anteriormente en provider.tf, y ha establecido su token en el valor de la variable, que será proporcionado durante el tiempo de ejecución.

En este paso, ha creado un directorio para su proyecto, solicitado que el proveedor de DigitalOcean esté disponible, declarado variables de proyecto y configurado la conexión a una instancia de proveedor de DigitalOcean para usar un token de autenticación que será proporcionado más adelante. Ahora escribirá un script que generará datos dinámicos para las definiciones de su proyecto.

Paso 2 — Creando un Script de Python para Datos Dinámicos

Antes de continuar con la definición del Dropleton, creará un guión de Python que genere el nombre del Droplet dinámica y declare una fuente de recursos de datos para analizarlo. El nombre será generado concatenando una cadena constante (web) con el tiempo actual de la máquina local, expresado en formato UNIX épocas. Un guión de nombres puede ser útil cuando se generan varios Dropleton según un esquema de nombres, para diferenciarlos fácilmente entre sí.

El guión lo guardarás en un archivo llamado name-generator.py, en un directorio llamado external. Primero, cree el directorio mediante la ejecución:

mkdir external

El directorio external reside en la raíz del proyecto y almacenará archivos de código de Python no HCL, como el guión que escribirás.

Cree name-generator.py bajo external y abrirlo para editar:

nano external/name-generator.py

Agregue el siguiente código:

import json, time

fixed_name = "web"
result = {
  "name": f"{fixed_name}-{int(time.time())}",
}

print(json.dumps(result))

Este guión de Python importa los módulos json y time, declara un diccionario llamado result, y establece el valor de la clave name a una cadena interpolada que combina fixed_name con el tiempo actual de la máquina en la que se ejecuta. Luego, result se convierte en JSON y se muestra en stdout. La salida será diferente cada vez que se ejecute el guión:

Output
{"name": "web-1597747959"}

Cuando lo hayas hecho, guarda y cierra el archivo.

Ahora que está listo el script, puedes definir la fuente de datos, la cual extraerá los datos del script. Lo almacenarás en un archivo llamado data-sources.tf en la raíz de tu proyecto según la aproximación de estructuración sencilla.

Cree para editarlo mediante la ejecución:

nano data-sources.tf

Agregue la siguiente definición:

data "external" "droplet_name" {
  program = ["python3", "${path.module}/external/name-generator.py"]
}

Guarde y cierre el archivo.

Esta fuente de datos se llama droplet_name y ejecuta el script name-generator.py utilizando Python 3, el cual reside en la dirección external que acabas de crear. Automáticamente analiza su salida y proporciona los datos deserializados bajo su atributo result.

Con la fuente de datos ahora declarada, puedes definir el Dropletto en el que Apache se ejecutará.

Paso 3 — Definición de la gota

En este paso, escribirás la definición de la gota y la guardarás en un archivo de código dedicado a las gotas, de acuerdo con el enfoque de estructuración simple. Su nombre será diferente cada vez que se deploye. Su nombre provendrá de la fuente de datos dinámica que acabas de crear y será distinto cada vez.

Cree y abra el archivo droplets.tf para editar:

nano droplets.tf

Agregue la siguiente definición de recurso de gota:

data "digitalocean_ssh_key" "ssh_key" {
  name = "your_ssh_key_name"
}

resource "digitalocean_droplet" "web" {
  image  = "ubuntu-20-04-x64"
  name   = data.external.droplet_name.result.name
  region = "fra1"
  size   = "s-1vcpu-1gb"
  ssh_keys = [
    data.digitalocean_ssh_key.ssh_key.id
  ]
}

Primero declaras una instancia de clave SSH de DigitalOcean llamada ssh_key, la cual obtendrá una clave de tu cuenta por su nombre. Asegúrate de reemplazar el código resaltado con el nombre de tu clave SSH.

Luego, declara un recurso de gota llamado web. Su nombre real en la nube será diferente, ya que se solicita desde la fuente de datos externa droplet_name. Para iniciar la gota con una clave SSH cada vez que se deploye, se pasa el ID de la ssh_key al parámetro ssh_keys, de manera que DigitalOcean sepa a qué clave aplicar.

Por ahora, eso es todo lo que necesitas configurar en relación con droplet.tf, así que guarde y cierre el archivo cuando lo haya terminado.

Ahora escribirás la configuración del registro DNS que apuntará tu dominio a la gota declarada anteriormente.

Paso 4 — Definición de registros DNS

El último paso en el proceso es configurar un registro DNS que apunte al Droplets de tu dominio.

Vas a guardar la configuración de DNS en un archivo llamado dns.tf, porque es una entidad de recursos diferente de las otras que has creado en los pasos anteriores. Crea y abre para editar:

nano dns.tf

Anade las siguientes líneas:

resource "digitalocean_record" "www" {
  domain = var.domain_name
  type   = "A"
  name   = "@"
  value  = digitalocean_droplet.web.ipv4_address
}

Este código declara un registro de DigitalOcean en tu nombre de dominio (proporcionado usando la variable), de tipo A. El registro tiene un nombre de @, que es un lugar común para dirigirse al propio dominio y con la dirección IP del Droplet como su valor. Puedes reemplazar el valor de name con algo más, lo cual resultará en la creación de un subdominio.

Cuando lo hagas, guarda y cierra el archivo.

Ahora que haz configurado el Droplet, la fuente de datos generadores y un registro DNS, procederás a desplegar el proyecto en la nube.

Paso 5 — Planificación y Aplicación de la Configuración

En esta sección, inicializarás tu proyecto de Terraform, lo desplegará en la nube y verificará que todo fue provisto correctamente.

Ahora que la infraestructura del proyecto está definida completamente, lo único que queda antes de desplegarlo es iniciar el proyecto de Terraform. Haga lo siguiente: ejecute el comando siguiente:

terraform init

Recibirá la siguiente salida:

Output
Initializing the backend...

Initializing provider plugins...
- Finding digitalocean/digitalocean versions matching "~> 2.0"...
- Finding latest version of hashicorp/external...
- Installing digitalocean/digitalocean v2.10.1...
- Installed digitalocean/digitalocean v2.10.1 (signed by a HashiCorp partner, key ID F82037E524B9C0E8)
- Installing hashicorp/external v2.1.0...
- Installed hashicorp/external v2.1.0 (signed by HashiCorp)

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.

Ahora puede desplegar su Dropletto con un nombre dinámico generado y una correspondiente dirección de dominio en su cuenta de DigitalOcean.

Comience definiendo el nombre del dominio, la impresión de la firma del clave SSH, y su token de acceso personal como variables de entorno, de manera que no tenga que copiar los valores cada vez que ejecute Terraform. Ejecute los siguientes comandos, reemplazando los valores resaltados:

export DO_PAT="your_do_api_token"
export DO_DOMAIN_NAME="your_domain"

Puede encontrar su token de API en su panel de control de DigitalOcean.

Ejecute el comando plan con los valores de las variables pasadas para ver qué pasos Terraform tomaría para desplegar su proyecto:

terraform plan -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}"

La salida será similar a la siguiente:

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.web será creado
  + resource "digitalocean_droplet" "web" {
      + 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                 = "web-1625908814"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = (known after apply)
      + region               = "fra1"
      + 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)
    }

  # digitalocean_record.www será creado
  + resource "digitalocean_record" "www" {
      + domain = "your_domain'"
      + fqdn   = (known after apply)
      + id     = (known after apply)
      + name   = "@"
      + ttl    = (known after apply)
      + type   = "A"
      + value  = (known after apply)
    }

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

Las líneas que comienzan con una marca + significan que Terraform creará cada uno de los recursos que siguen después de que lo hagas—lo cual es exactamente lo que debería ocurrir, por lo que puede aplicar la configuración:

terraform apply -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}"

El output será el mismo que antes, pero esta vez le preguntarán para confirmar:

Output
Plan: 2 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`

Entre si. Y Terraform proporcionará su Dropletto y la entrada DNS:

Output
digitalocean_droplet.web: Creating...
...
digitalocean_droplet.web: Creation complete after 33s [id=204432105]
digitalocean_record.www: Creating...
digitalocean_record.www: Creation complete after 1s [id=110657456]

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

Terraform ha registrado ahora las recursos implementados en su estado. Para confirmar que los registros de DNS y la instancia de la nube se conectaron correctamente, puede extraer el puerto de acceso de la instancia de la nube de la información estática local y verificar si coincide con los registros públicos de DNS para su dominio. Ejecute el siguiente comando para obtener la dirección IP de la instancia de la nube:

terraform show | grep "ipv4"

Recibirá la dirección IP de la instancia de la nube:

Output
ipv4_address       = "your_Droplet_IP"
...

Puede verificar los registros públicos A ejecutando:

nslookup -type=a your_domain | grep "Address" | tail -1

El resultado mostrará la dirección IP a la que apunta el registro A:

Output
Address: your_Droplet_IP

Es lo mismo, como debería ser, lo que significa que la instancia de la nube y el registro DNS fueron proporcionados exitosamente.

Para que los cambios en la siguiente paso se lleven a cabo, destruya los recursos implementados ejecutando:

terraform destroy -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}"

Cuando se le pregunte, escriba sí para continuar.

En este paso, ha creado su infraestructura y la aplicó a su cuenta de DigitalOcean. Ahora modifique para que se instale automáticamente el servidor web Apache en la instancia proporcionada usando proveedores de configuración de Terraform.

Paso 6: Ejecutando Código Usando Proveedores

Ahora establecerá la instalación del servidor web Apache en su instancia implementada utilizando el proveedor remote-exec para ejecutar comandos personalizados.

Los provisionales de Terraform se pueden utilizar para ejecutar acciones específicas sobre los recursos remotos creados (el proveedor remote-exec) o la máquina local en la que se ejecute el código (utilizando el proveedor local-exec). Si falla un procesador, se marcará el nodo como corruptido en el estado actual, lo que significa que será eliminado y recreado durante la prueba siguiente.

Para conectarse a una nube Droplet proporcionada, Terraform necesita la clave privada SSH del Droplet configurado. La mejor manera de pasar la ubicación de la clave privada es utilizando variables, por lo que abrir variables.tf para editar:

nano variables.tf

Agregue la línea resaltada:

variable "do_token" {}
variable "domain_name" {}
variable "private_key" {}

Ahora ha agregado una nueva variable, llamada private_key , al proyecto. Guarde y cierre el archivo.

Entonces, agregará las declaraciones de datos de conexión y provisionales declarativos para su configuración de Droplet. Abra droplets.tf para editar mediante el comando:

nano droplets.tf

Ampliar el bloque existente con las líneas resaltadas:

data "digitalocean_ssh_key" "ssh_key" {
  name = "your_ssh_key_name"
}

resource "digitalocean_droplet" "web" {
  image  = "ubuntu-20-04-x64"
  name   = data.external.droplet_name.result.name
  region = "fra1"
  size   = "s-1vcpu-1gb"
  ssh_keys = [
    data.digitalocean_ssh_key.ssh_key.id
  ]

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

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

El bloque connection especifica cómo Terraform debe conectarse al objetivo Droplet. El bloque provisioner contiene la matriz de comandos, dentro del parámetro inline, que ejecutará después de la provisión. Es decir, actualizar la caché del gestor de paquetes y instalar Apache. Guarde y salga cuando haya terminado.

También puede crear una variable de entorno temporal para la ruta de la clave privada:

export DO_PRIVATE_KEY="private_key_location"

Intenta aplicar la configuración de nuevo:

terraform apply -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}" -var "private_key=${DO_PRIVATE_KEY}"

Escribe sí cuando se te pregunte. Recibirás una salida similar a la anterior, pero seguida por una salida larga proveniente del proveedor de ejecución remota:

Output
digitalocean_droplet.web: Creating...
digitalocean_droplet.web: Still creating... [10s elapsed]
digitalocean_droplet.web: Still creating... [20s elapsed]
digitalocean_droplet.web: Still creating... [30s elapsed]
digitalocean_droplet.web: Provisioning with 'remote-exec'...
digitalocean_droplet.web (remote-exec): Connecting to remote host via SSH...
digitalocean_droplet.web (remote-exec):   Host: ...
digitalocean_droplet.web (remote-exec):   User: root
digitalocean_droplet.web (remote-exec):   Password: false
digitalocean_droplet.web (remote-exec):   Private key: true
digitalocean_droplet.web (remote-exec):   Certificate: false
digitalocean_droplet.web (remote-exec):   SSH Agent: false
digitalocean_droplet.web (remote-exec):   Checking Host Key: false
digitalocean_droplet.web (remote-exec): Connected!
...
digitalocean_droplet.web: Creation complete after 1m5s [id=204442200]
digitalocean_record.www: Creating...
digitalocean_record.www: Creation complete after 1s [id=110666268]

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

Ahora puedes navegar a tu dominio en un navegador web. Verás una página de bienvenida estándar de Apache.

Esto significa que Apache fue instalado correctamente y que Terraform provisionalizó todos los recursos correctamente.

Para destruir los recursos implementados, ejecuta el siguiente comando y escribe sí cuando se te pregunte:

terraform destroy -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}" -var "private_key=${DO_PRIVATE_KEY}"

Ya has completado un pequeño proyecto de Terraform con estructura sencilla que desplecha el servidor Web de Apache en una Dropleta y establece registros DNS para el dominio deseado.

Conclusión

Ha aprendido acerca de dos enfoques generales para estructurar sus proyectos de Terraform, según su complejidad. Siguiendo el enfoque de estructuración simple, y utilizando el proveedor remote-exec para ejecutar comandos, entonces desplegó una Droplet que ejecuta Apache con registros de DNS para su dominio.

Para referencia, aquí está la estructura de archivos del proyecto que creó en este tutorial:

.
└── tf/
    ├── versions.tf
    ├── variables.tf
    ├── provider.tf
    ├── droplets.tf
    ├── dns.tf
    ├── data-sources.tf
    └── external/
        └── name-generator.py

Los recursos que definió (la Droplet, el registro de DNS y la fuente de datos dinámica, el proveedor DigitalOcean y las variables) están almacenados cada uno en su propio archivo separado, de acuerdo con la estructura de proyecto simple descrita en la primera sección de este tutorial.

Para obtener más información sobre los proveedores de Terraform y sus parámetros, visita la documentación oficial.

Este tutorial es parte de la serie Cómo Gestionar Infraestructuras con Terraform. La serie cubre una variedad de temas de Terraform, desde la instalación de Terraform por primera vez hasta la gestión de proyectos complejos.