Este lab se desarrolló junto con nuestro socio HashiCorp. Es posible que tu información personal se comparta con HashiCorp, el patrocinador del lab, si aceptaste recibir actualizaciones, anuncios y ofertas de productos en el perfil de tu cuenta.

GSP750

Descripción general

Terraform es la oferta de infraestructura como código de HashiCorp. Es una herramienta para crear, cambiar y administrar infraestructuras de forma segura y repetible. Los operadores y equipos de infraestructura pueden usar Terraform para administrar entornos con el lenguaje de configuración de HashiCorp (HCL) y lograr implementaciones automatizadas y legibles por humanos.

La infraestructura como código es el proceso de administrar infraestructura en uno o varios archivos, en lugar de configurar recursos manualmente en una interfaz de usuario. En este caso, un recurso es cualquier elemento de infraestructura en un entorno específico, como una máquina virtual, un grupo de seguridad, una interfaz de red, etc. En general, Terraform permite a los operadores usar HCL para crear archivos que contengan definiciones de los recursos que deseen en casi cualquier proveedor (AWS, Google Cloud, GitHub, Docker, etc.) y automatiza la creación de estos recursos en el momento de su aplicación.

Un flujo de trabajo sencillo para implementación será muy similar a estos pasos:

• Determinar el alcance. Confirma qué recursos se deben crear para un proyecto específico.
• Crear. Crea el archivo de configuración en el HCL según los parámetros del alcance.
• Inicializar. Ejecuta terraform init en el directorio del proyecto con los archivos de configuración para descargar los complementos correctos del proveedor para el proyecto.
• Planificar y aplicar. Ejecuta terraform plan para verificar el proceso de creación y, luego, terraform apply para crear recursos reales y el archivo de estado, que compara los cambios futuros en tus archivos de configuración con lo que existe realmente en tu entorno de implementación.

Objetivos

En este lab, aprenderás a realizar las siguientes tareas:

• Crear, cambiar y destruir infraestructuras con Terraform
• Crear dependencias de recursos con Terraform
• Aprovisionar infraestructuras con Terraform

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs cuentan con un temporizador que no se puede pausar. El temporizador, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.

Este lab práctico te permitirá realizar las actividades correspondientes en un entorno de nube real, no en uno de simulación o demostración. Para ello, se te proporcionan credenciales temporales nuevas que utilizarás para acceder a Google Cloud durante todo el lab.

Para completar este lab, necesitarás lo siguiente:

• Acceso a un navegador de Internet estándar. Se recomienda el navegador Chrome.

Nota: Usa una ventana del navegador privada o de incógnito (opción recomendada) para ejecutar el lab. Así evitarás conflictos entre tu cuenta personal y la cuenta de estudiante, lo que podría generar cargos adicionales en tu cuenta personal.

• Tiempo para completar el lab (recuerda que, una vez que comienzas un lab, no puedes pausarlo).

Nota: Usa solo la cuenta de estudiante para este lab. Si usas otra cuenta de Google Cloud, es posible que se apliquen cargos a esa cuenta.

Cómo iniciar tu lab y acceder a la consola de Google Cloud

1. Haz clic en el botón Comenzar lab. Si debes pagar por el lab, se abrirá un diálogo para que selecciones la forma de pago. A la derecha, se encuentra el panel Configuración del lab y acceso, que tiene los siguientes elementos:

   • El botón Abrir la consola de Google Cloud
   • Las credenciales temporales (nombre de usuario y contraseña) que debes usar para este lab
   • Otra información para completar el lab (si es necesaria)

   Ten en cuenta que el cronómetro del lab se encuentra cerca de la parte superior de la página y muestra el tiempo restante.

2. Haz clic en Abrir la consola de Google Cloud (o haz clic con el botón derecho y selecciona Abrir el vínculo en una ventana de incógnito si ejecutas el navegador Chrome).

   El lab inicia los recursos y abre otra pestaña, en la que se muestra la página de acceso.

   Sugerencia: Ordena las pestañas en ventanas separadas, una junto a la otra.

   Nota: Si ves el diálogo Elegir una cuenta, haz clic en Usa otra cuenta.

3. De ser necesario, copia el nombre de usuario a continuación y pégalo en el diálogo Acceder.

   {{{user_0.username | "Username"}}}

   También puedes encontrar el nombre de usuario en el panel Configuración del lab y acceso.

4. Haz clic en Siguiente.

5. Copia la contraseña que aparece a continuación y pégala en el diálogo Te damos la bienvenida.

   {{{user_0.password | "Password"}}}

   También puedes encontrar la contraseña en el panel Configuración del lab y acceso.

6. Haz clic en Siguiente.

   Importante: Debes usar las credenciales que te proporciona el lab. No uses las credenciales de tu cuenta de Google Cloud. Nota: Usar tu propia cuenta de Google Cloud para este lab podría generar cargos adicionales.

7. Haz clic para avanzar por las páginas siguientes:

   • Acepta los Términos y Condiciones.
   • No agregues opciones de recuperación ni autenticación de dos factores, ya que esta cuenta es temporal.
   • No te registres para obtener pruebas gratuitas.

Después de un momento, se abrirá la consola de Google Cloud en esta pestaña.

Nota: Para acceder a los productos y servicios de Google Cloud, haz clic en el menú de navegación o escribe el nombre del servicio o producto en el campo Buscar.

Activa Cloud Shell

Cloud Shell es una máquina virtual que cuenta con herramientas para desarrolladores. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud. Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.

1. Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.

2. Haz clic para avanzar por las siguientes ventanas:

   • Continúa en la ventana de información de Cloud Shell.
   • Autoriza a Cloud Shell para que use tus credenciales para realizar llamadas a la API de Google Cloud.

Cuando te conectes, habrás completado la autenticación, y el proyecto estará configurado con tu Project_ID, . El resultado contiene una línea que declara el Project_ID para esta sesión:

Your Cloud Platform project in this session is set to {{{project_0.project_id | "PROJECT_ID"}}}

gcloud es la herramienta de línea de comandos de Google Cloud. Viene preinstalada en Cloud Shell y es compatible con la función de autocompletado con tabulador.

3. Puedes solicitar el nombre de la cuenta activa con este comando (opcional):

gcloud auth list

4. Haz clic en Autorizar.

Resultado:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} To set the active account, run: $ gcloud config set account `ACCOUNT`

5. Puedes solicitar el ID del proyecto con este comando (opcional):

gcloud config list project

Resultado:

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Nota: Para obtener toda la documentación de gcloud, en Google Cloud, consulta la guía con la descripción general de gcloud CLI.

Instala Terraform

Terraform no está preinstalado en Cloud Shell. Debes instalar la CLI de Terraform y configurarla para que persista en tus sesiones de Cloud Shell.

1. Para configurar el repositorio de HashiCorp y, luego, instalar Terraform, y para asegurarte de que esta instalación persista en sesiones futuras, ejecuta los siguientes comandos en la terminal de Cloud Shell:

cat <<'EOF' > ~/.customize_environment # Configura el repositorio de HashiCorp e instala Terraform wget -O - https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(grep -oP '(?<=UBUNTU_CODENAME=).*' /etc/os-release || lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list sudo apt update && sudo apt install -y terraform EOF bash ~/.customize_environment

2. Para verificar que Terraform se haya instalado correctamente, ejecuta el siguiente comando:

terraform --version

En el resultado se debería mostrar la versión instalada (v1.5.7 o posterior):

Terraform v1.9.0

Tarea 1: Crea la infraestructura

Primero, crea tu configuración de ejemplo en un archivo llamado main.tf. Terraform reconoce los archivos que terminan en .tf o .tf.json como archivos de configuración y los carga cuando se ejecuta.

1. Crea el archivo main.tf:

touch main.tf

2. Haz clic en el botón Abrir editor en la barra de herramientas de Cloud Shell. Puedes cambiar entre Cloud Shell y el editor de código con los íconos Abrir editor y Abrir terminal según sea necesario. También puedes hacer clic en el botón Abrir en una ventana nueva para dejar el editor abierto en una pestaña aparte.

3. En el editor, agrega el siguiente contenido al archivo main.tf.

terraform { required_providers { google = { source = "hashicorp/google" version = "3.5.0" } } } provider "google" { project = "{{{project_0.project_id | PROJECT ID}}}" region = "{{{project_0.default_region | REGION}}}" zone = "{{{project_0.default_zone | ZONE}}}" } resource "google_compute_network" "vpc_network" { name = "terraform-network" }

Bloque de Terraform

Se requiere el bloque terraform {}, que le permite a Terraform saber cuál proveedor descargar desde Terraform Registry. En la configuración anterior, la fuente del proveedor google se definió como hashicorp/google, que es la abreviatura de registry.terraform.io/hashicorp/google.

También puedes asignar una versión a cada proveedor definido en el bloque required_providers. El argumento version es opcional, pero se recomienda incluirlo. Se utiliza para limitar el proveedor a una versión específica o a un rango de versiones para evitar que se descargue un proveedor nuevo que tal vez contenga cambios rotundos. Si no se especifica la versión, Terraform descargará automáticamente el proveedor más reciente cuando se inicialice.

Para obtener más información, consulta los requisitos para proveedores en el sitio web de HashiCorp Terraform.

Proveedores

El bloque provider se usa para configurar el proveedor nombrado, en este caso, google. Los proveedores son responsables de crear y administrar recursos. Pueden existir varios bloques "provider" si una configuración de Terraform administra recursos de diferentes proveedores.

Inicialización

El primer comando que se debe ejecutar después de crear una nueva configuración (o clonar una existente desde el sistema de control de versiones) es terraform init, que inicializa diversos parámetros de configuración y datos locales que se usarán en comandos posteriores.

• En la terminal de Cloud Shell (haz clic en Abrir terminal si es necesario), inicializa tu nueva configuración de Terraform:

terraform init

Crea recursos

1. Ahora aplica tu configuración ejecutando el comando terraform apply:

terraform apply

El resultado tiene un signo + junto al recurso "google_compute_network" "vpc_network", lo que significa que Terraform creará el recurso. Debajo se muestran los atributos que se establecerán. Cuando el valor que se muestra es (known after apply), significa que no se conocerá el valor hasta que se cree el recurso.

Si se creó correctamente el plan, Terraform se pausará y esperará a obtener la aprobación antes de continuar. Si cualquier parte del plan parece incorrecta o peligrosa, es seguro anular el proceso aquí sin que se realicen cambios en tu infraestructura.

Si terraform apply falla y muestra un mensaje de error, léelo y corrígelo.

2. En este punto, el plan parece aceptable, así que escribe yes en la solicitud de confirmación y presiona INTRO para continuar.

El plan tardará algunos minutos en ejecutarse porque Terraform esperará a que la red se cree correctamente:

# ... Enter a value: yes google_compute_network.vpc_network: Creating... google_compute_network.vpc_network: Still creating... [10s elapsed] google_compute_network.vpc_network: Still creating... [20s elapsed] google_compute_network.vpc_network: Still creating... [30s elapsed] google_compute_network.vpc_network: Still creating... [40s elapsed] google_compute_network.vpc_network: Still creating... [50s elapsed] google_compute_network.vpc_network: Creation complete after 58s [id=terraform-network] Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Después de eso, Terraform habrá terminado. Puedes ir a la consola de Cloud para ver la red que aprovisionaste.

3. En el menú de navegación de la consola de Google Cloud, ve a Red de VPC. Verás que se aprovisionó terraform-network.

4. En Cloud Shell, ejecuta el comando terraform show para inspeccionar el estado actual:

terraform show

Estos valores podrán tomarse como referencia para configurar otros recursos o resultados que se mencionarán más adelante en este lab.

Haz clic en Revisar mi progreso para verificar el objetivo. Crear recursos en Terraform

Tarea 2: Cambia la infraestructura

En la sección anterior, creaste una infraestructura básica con Terraform: una red de VPC. En esta sección, modificarás tu configuración y verás cómo Terraform maneja el cambio.

La infraestructura está evolucionando continuamente, y Terraform se creó para administrar y aplicar esos cambios. A medida que cambias la configuración de Terraform, el servicio crea un plan de ejecución que solo modifica lo que es necesario para alcanzar el estado deseado.

Cuando usas Terraform para cambiar la infraestructura, puedes controlar las versiones no solo de las configuraciones, sino también del estado, de manera que puedes ver la forma en que la infraestructura evoluciona con el paso del tiempo.

Agrega recursos

Para incluir recursos nuevos, agrégalos a tu configuración de Terraform y ejecuta terraform apply para aprovisionarlos.

1. En el editor, agrega un recurso de instancia de procesamiento a main.tf:

resource "google_compute_instance" "vm_instance" { name = "terraform-instance" machine_type = "e2-micro" boot_disk { initialize_params { image = "debian-cloud/{{{project_0.startup_script.debian_image_id_short | debian-12}}}" } } network_interface { network = google_compute_network.vpc_network.name access_config { } } }

Este recurso incluye argumentos adicionales. El nombre y el tipo de máquina son cadenas sencillas, pero boot_disk y network_interface son bloques más complejos. Puedes ver todas las opciones disponibles en la documentación de google_compute_instance.

Por ejemplo, tu instancia de procesamiento usará un sistema operativo Debian y se conectará a la red de VPC que creaste antes. Observa la forma en que esta configuración hace referencia a la propiedad del nombre de la red con google_compute_network.vpc_network.name. google_compute_network.vpc_network es el ID, que coincide con los valores del bloque que define la red, y name es una propiedad de ese recurso.

La presencia del bloque access_config, incluso sin ningún argumento, garantiza que se podrá acceder a la instancia a través de Internet.

2. Ahora ejecuta terraform apply para crear la instancia de procesamiento:

terraform apply

3. Una vez más, responde yes a la solicitud de confirmación.

Este es un cambio bastante sencillo: agregaste un recurso “google_compute_instance” llamado “vm_instance” a tu configuración, y Terraform creó el recurso en Google Cloud.

Cambia los recursos

Además de crear recursos, Terraform también puede realizar cambios en ellos.

1. Agrega un argumento tags a tu recurso vm_instance en el archivo main.tf para que se vea así:

resource "google_compute_instance" "vm_instance" { name = "terraform-instance" machine_type = "e2-micro" tags = ["web", "dev"] # Add this line # ... }

2. Ejecuta terraform apply nuevamente para actualizar la instancia:

terraform apply

3. El prefijo ~ indica que Terraform actualiza el recurso implementado. Para aplicar el cambio, responde yes, y Terraform agregará las etiquetas a tu instancia.

Haz clic en Revisar mi progreso para verificar el objetivo. Cambiar la infraestructura

Cambios destructivos

Un cambio destructivo es uno que requiere que el proveedor reemplace el recurso existente en lugar de actualizarlo. Por lo general, esto sucede porque el proveedor de servicios en la nube no admite actualizar el recurso como se describe en tu configuración.

Un ejemplo de cambio destructivo es modificar la imagen de disco de tu instancia.

1. Edita el bloque boot_disk dentro del recurso vm_instance en tu archivo de configuración main.tf y cámbialo por lo siguiente:

boot_disk { initialize_params { image = "cos-cloud/cos-stable" } }

2. Ahora ejecuta terraform apply nuevamente para explorar cómo Terraform aplica el cambio a los recursos existentes:

terraform apply

El prefijo -/+ indica que Terraform destruirá y volverá a crear el recurso, en lugar de actualizarlo localmente. Si bien algunos atributos se pueden actualizar localmente (los que se muestran con el prefijo ~), cambiar la imagen del disco de arranque de una instancia requiere volver a crearla. Terraform y el proveedor de Google Cloud controlan estos detalles por ti, y el plan de ejecución deja en claro lo que hará Terraform.

Además, el plan de ejecución muestra que el reemplazo de tu instancia se debe al cambio de la imagen de disco. Con esta información, puedes ajustar los cambios para evitar destruir o crear actualizaciones si no son aceptables en algunas situaciones.

3. Una vez más, Terraform te solicitará que apruebes el plan de ejecución antes de continuar. Responde yes para ejecutar los pasos planificados.

Como lo indica el plan de ejecución, Terraform primero destruyó la instancia existente y, luego, creó una nueva. Puedes usar terraform show otra vez para ver los valores nuevos asociados a esta instancia.

Destruye la infraestructura

Ya aprendiste a crear y cambiar la infraestructura. Antes de crear varios recursos y mostrar sus dependencias, verás cómo destruir completamente tu infraestructura administrada por Terraform.

Destruir la infraestructura es un evento poco común en los entornos de producción. Pero si utilizas Terraform para iniciar varios entornos como desarrollo, pruebas y etapa de pruebas, es con frecuencia una acción útil.

Los recursos se pueden destruir con el comando terraform destroy, que es similar a terraform apply, pero se comporta como si todos los recursos se hubieran quitado de la configuración.

• Prueba el comando terraform destroy. Responde yes cuando se te solicite ejecutar este plan y destruir la infraestructura:

terraform destroy

El prefijo - indica que se destruirán la instancia y la red. Tal como sucede con apply, Terraform muestra su plan de ejecución y espera a que se apruebe antes de realizar cualquier cambio.

Al igual que con terraform apply, Terraform determina el orden en que deben destruirse los elementos. Google Cloud no permitirá que se borre una red de VPC si aún hay recursos en ella. Por esto, Terraform espera hasta que se destruya la instancia antes de destruir la red. Cuando Terraform realiza operaciones, crea un gráfico de dependencias para determinar el orden correcto de las operaciones. En casos más complicados con varios recursos, Terraform realizará operaciones en paralelo cuando sea seguro hacerlo.

Haz clic en Revisar mi progreso para verificar el objetivo. Realizar cambios destructivos

Tarea 3: Crea dependencias de recursos

En esta sección, aprenderás más sobre las dependencias de recursos y cómo usar parámetros de recursos para compartir información acerca de un recurso con otros recursos.

Las infraestructuras reales tienen un conjunto diverso de recursos y tipos de recursos. La configuración de Terraform puede contener muchos recursos y varios tipos de ellos, los cuales pueden incluso abarcar varios proveedores.

En esta sección, se mostrará un ejemplo básico para configurar varios recursos y cómo usar los atributos de recursos para configurar otros recursos.

• Ejecuta el siguiente comando para volver a crear tu red y tu instancia:

terraform apply

Después de responder yes a la solicitud, se crearán los recursos.

Asigna una dirección IP estática

1. Agrega lo siguiente al archivo de configuración main.tf para asignar una IP estática a la instancia de VM:

resource "google_compute_address" "vm_static_ip" { name = "terraform-static-ip" }

Te parecerá similar al ejemplo anterior de adición de un recurso de instancia de VM, salvo que esta vez crearás un tipo de recurso "google_compute_address", que asigna una dirección IP reservada a tu proyecto.

2. A continuación, ejecuta terraform plan:

terraform plan

Puedes ver lo que se creará con terraform plan:

$ terraform plan Refreshing Terraform state in-memory prior to plan... The refreshed state will be used to calculate this plan, but will not be persisted to local or remote state storage. google_compute_network.vpc_network: Refreshing state... [id=terraform-network] google_compute_instance.vm_instance: Refreshing state... [id=terraform-instance] ------------------------------------------------------------------------ An execution plan has been generated and is shown below. Resource actions are indicated with the following symbols: + create Terraform will perform the following actions: # google_compute_address.vm_static_ip will be created + resource "google_compute_address" "vm_static_ip" { + address = (known after apply) + address_type = "EXTERNAL" + creation_timestamp = (known after apply) + id = (known after apply) + name = "terraform-static-ip" + network_tier = (known after apply) + project = (known after apply) + region = (known after apply) + self_link = (known after apply) + subnetwork = (known after apply) + users = (known after apply) } Plan: 1 to add, 0 to change, 0 to destroy. ------------------------------------------------------------------------ Note: You didn't specify an "-out" parameter to save this plan, so Terraform can't guarantee that exactly these actions will be performed if "terraform apply" is subsequently run.

A diferencia de terraform apply, el comando plan solo mostrará lo que cambiará y nunca aplicará los cambios directamente. Observa que el único cambio que hiciste hasta ahora fue agregar una IP estática. A continuación, debes conectarla a tu instancia.

3. Actualiza la configuración de network_interface para tu instancia:

network_interface { network = google_compute_network.vpc_network.self_link access_config { nat_ip = google_compute_address.vm_static_ip.address } }

El bloque access_config tiene varios argumentos opcionales y, en este caso, definirás nat_ip como la dirección IP estática. Cuando Terraform lea esta configuración, hará lo siguiente:

• Se asegurará de que vm_static_ip se cree antes que vm_instance.
• Guardará las propiedades de vm_static_ip en el estado.
• Definirá nat_ip en el valor de la propiedad vm_static_ip.address.

4. Ejecutará de nuevo terraform plan, pero esta vez lo guardará:

terraform plan -out static_ip

Guardar el plan de este modo garantizará que puedas aplicarlo de forma idéntica en el futuro. Si tratas de aplicar el archivo que crea el plan, Terraform se asegurará de que se realice exactamente el mismo conjunto de cambios antes de aplicar el plan.

En este caso, verás que Terraform creará un nuevo recurso google_compute_address y actualizará la VM existente para usarlo.

5. Ejecuta terraform apply "static_ip" para ver cómo Terraform planifica aplicar este cambio:

terraform apply "static_ip"

Como se mostró anteriormente, Terraform creó la IP estática antes de modificar la instancia de VM. Debido a la expresión de interpolación que pasa la dirección IP a la configuración de la interfaz de red de la instancia, Terraform puede inferir una dependencia y sabe que esta debe crear la IP estática antes de actualizar la instancia.

Haz clic en Revisar mi progreso para verificar el objetivo. Crear dependencias de recursos

Explora dependencias implícitas y explícitas

A través del análisis de los atributos de recursos utilizados en expresiones de interpolación, Terraform puede inferir automáticamente cuándo un recurso depende de otro. En el ejemplo anterior, la referencia a google_compute_address.vm_static_ip.address crea una dependencia implícita en el recurso google_compute_address con el nombre vm_static_ip.

Terraform usa esta información para determinar el orden correcto en el que crear y actualizar diferentes recursos. En el ejemplo anterior, Terraform sabe que vm_static_ip debe crearse antes de que se actualice el recurso vm_instance para usarlo.

Las dependencias implícitas a través de expresiones de interpolación son la forma principal de informar a Terraform acerca de estas relaciones y deberían utilizarse siempre que sea posible.

A veces, hay dependencias entre los recursos que no son visibles para Terraform. El argumento depends_on puede agregarse a cualquier recurso y acepta una lista de recursos para los cuales creará dependencias explícitas.

Por ejemplo, es posible que una aplicación que se ejecutará en tu instancia espere usar un bucket de Cloud Storage específico, pero esa dependencia está configurada dentro del código de la aplicación y, por lo tanto, no es visible para Terraform. En ese caso, puedes usar depends_on para declarar explícitamente la dependencia.

1. Incluye un bucket de Cloud Storage y una instancia con una dependencia explícita en el bucket. Para ello, agrega el siguiente código a main.tf:

# New resource for the storage bucket our application will use. resource "google_storage_bucket" "example_bucket" { name = "{{{project_0.project_id | PROJECT_ID}}}" location = "US" website { main_page_suffix = "index.html" not_found_page = "404.html" } } # Create a new instance that uses the bucket resource "google_compute_instance" "another_instance" { # Tells Terraform that this VM instance must be created only after the # storage bucket has been created. depends_on = [google_storage_bucket.example_bucket] name = "terraform-instance-2" machine_type = "e2-micro" boot_disk { initialize_params { image = "cos-cloud/cos-stable" } } network_interface { network = google_compute_network.vpc_network.self_link access_config { } } } Nota: Los buckets de almacenamiento deben ser globalmente únicos. Por este motivo, el nombre del bucket está configurado para usar tu ID de proyecto único: {{{project_0.project_id | PROJECT_ID}}}.

Tal vez te preguntes a qué parte de tu configuración deberían ir estos recursos. El orden en que se definen los recursos en un archivo de configuración de Terraform no afecta la forma en que este aplica tus cambios. Organiza los archivos de configuración de la manera que tenga más sentido para ti y tu equipo.

2. Ahora ejecuta terraform plan y terraform apply para ver los cambios en acción:

terraform plan terraform apply

Haz clic en Revisar mi progreso para verificar el objetivo. Crear una instancia dependiente de un bucket

3. Antes de continuar, borra los bloques de recursos google_storage_bucket.example_bucket y google_compute_instance.another_instance del archivo main.tf y vuelve a ejecutar terraform apply para destruirlos. No usarás más el bucket ni la segunda instancia en este lab.

Tarea 4: Aprovisiona la infraestructura

La instancia de procesamiento que iniciaste en este punto se basa en la imagen de Google especificada, pero no tiene software adicional instalado ni una configuración aplicada.

Google Cloud permite que los clientes administren sus propias imágenes personalizadas de sistema operativo. Esta puede ser una excelente manera de asegurarte de que las instancias que aprovisiones con Terraform se configuren previamente según tus necesidades. Packer es la herramienta perfecta para esto que, además, incluye un compilador para Google Cloud.

Terraform usa aprovisionadores para subir archivos, ejecutar secuencias de comandos de shell o instalar y activar otros software, como herramientas de administración de configuraciones.

Define un aprovisionador

1. Para definir un aprovisionador, modifica el bloque de recursos que define el primer recurso vm_instance en tu configuración para que se vea de la siguiente forma:

resource "google_compute_instance" "vm_instance" { name = "terraform-instance" machine_type = "e2-micro" tags = ["web", "dev"] provisioner "local-exec" { command = "echo ${self.name}: ${self.network_interface[0].access_config[0].nat_ip} >> ip_address.txt" } # ... }

Se agregará un bloque provisioner en el bloque resource. Se pueden agregar diferentes bloques provisioner para definir varios pasos de aprovisionamiento. Terraform admite muchos aprovisionadores, pero, en este ejemplo, se utilizará el aprovisionador local-exec.

El aprovisionador local-exec ejecuta un comando localmente en la máquina que ejecuta Terraform, no en la instancia de VM. Dado que usarás este aprovisionador en lugar de los otros, no tenemos que preocuparnos de especificar información de conexión por ahora.

Esto también muestra un ejemplo más complejo de interpolación de cadena que los que viste antes. Cada instancia de VM puede tener varias interfaces de red, así que haz referencia a la primera con network_interface[0]. El recuento comienza desde 0, como lo hace la mayoría de los lenguajes de programación, y cada interfaz de red también puede tener varios bloques access_config, por lo que una vez más debes especificar el primero.

2. Ejecuta terraform apply:

terraform apply

En este punto, el resultado puede ser confuso, en un principio.

Terraform no encontró nada que hacer y, si revisas el resultado, descubrirás que no hay un archivo ip_address.txt en tu máquina local.

Terraform trata los aprovisionadores de forma diferente a otros argumentos. Los aprovisionadores solo se ejecutan cuando se crea un recurso, pero agregar un aprovisionador no obliga a destruir y volver a crear el recurso en cuestión.

3. Utiliza terraform taint para indicarle a Terraform que recree la instancia:

terraform taint google_compute_instance.vm_instance

Durante la siguiente ejecución de apply, se destruirá y se volverá a crear un recurso con fallas.

4. Ejecuta terraform apply ahora:

terraform apply

5. Para verificar que todo funcione correctamente, examina el contenido del archivo ip_address.txt.

Este contiene la dirección IP como la solicitaste.

Aprovisionadores con errores y recursos con fallas

Si un recurso se crea correctamente, pero falla en un paso del aprovisionamiento, Terraform generará un error y marcará el recurso como con fallas. Un recurso con fallas sigue existiendo, pero no es seguro para usarlo, ya que el aprovisionamiento falló.

Cuando generes tu siguiente plan de ejecución, Terraform quitará los recursos con fallas y creará recursos nuevos, y tratará de aprovisionarlos nuevamente apenas se creen.

Aprovisionadores de destrucción

Los aprovisionadores también se pueden definir para que se ejecuten solo durante una operación de destrucción. Estos son útiles para limpiar el sistema y extraer datos, entre otras acciones.

Para muchos recursos, se recomienda usar mecanismos de limpieza incorporados (como las secuencias de comandos init) si es posible, pero se pueden utilizar aprovisionadores si es necesario.

En este lab, no se mostrarán ejemplos de aprovisionadores de destrucción. Si necesitas usarlos, consulta la documentación sobre aprovisionadores.

¡Felicitaciones!

En este lab, aprendiste a crear, cambiar y destruir infraestructura con Terraform. Luego, creaste dependencias de recursos y aprovisionaste infraestructura básica con archivos de configuración de Terraform.

Próximos pasos y más información

Asegúrate de consultar los siguientes recursos para adquirir más práctica con Terraform:

• HashiCorp en Google Cloud Marketplace
• HashiCorp Learn
• Comunidad de Terraform
• Ejemplos de Google con Terraform

Capacitación y certificación de Google Cloud

Recibe la formación que necesitas para aprovechar al máximo las tecnologías de Google Cloud. Nuestras clases incluyen habilidades técnicas y recomendaciones para ayudarte a avanzar rápidamente y a seguir aprendiendo. Para que puedas realizar nuestros cursos cuando más te convenga, ofrecemos distintos tipos de capacitación de nivel básico a avanzado: a pedido, presenciales y virtuales. Las certificaciones te ayudan a validar y demostrar tus habilidades y tu conocimiento técnico respecto a las tecnologías de Google Cloud.

Última actualización del manual: 14 de julio de 2026

Prueba más reciente del lab: 14 de julio de 2026

Copyright 2026 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.