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.

GSP751

Descripción general

A medida que administres tu infraestructura con Terraform, se crearán configuraciones cada vez más complejas. La complejidad de un archivo o directorio de configuración de Terraform no cuenta con un límite intrínseco, por lo que puedes escribir y actualizar tus archivos de configuración en un único directorio. Sin embargo, si lo haces, es posible que experimentes uno o varios de los siguientes problemas:

• Comprender los archivos de configuración y navegar por ellos será cada vez más difícil.
• Actualizar la configuración será cada vez más riesgoso, ya que la actualización de un bloque podría traer consecuencias inesperadas a otros bloques de tu configuración.
• La duplicación de bloques de configuración similares podría aumentar, por ejemplo, cuando configure entornos independientes de desarrollo, etapa de pruebas o producción. Esto aumentará la carga cuando actualices esas partes de tu configuración.
• Si deseas compartir partes de tu configuración con otros proyectos y equipos, cortar y pegar los bloques de configuración en distintos proyectos podría provocar errores y sería una operación difícil de mantener.

En este lab, descubrirás cómo los módulos pueden encargarse de estos problemas, así como la estructura de un módulo de Terraform y las prácticas recomendadas para crearlos y usarlos.

¿Para qué sirven los módulos?

Estas son algunas de las maneras en que los módulos te permiten solucionar los problemas enumerados anteriormente:

• Organiza la configuración: Los módulos facilitan la navegación, comprensión y actualización de tu configuración, ya que agrupan las partes relacionadas. Incluso una infraestructura con una complejidad moderada puede requerir cientos o miles de líneas de configuración para implementarse. Sin embargo, si usas módulos, puedes organizar tu configuración en componentes lógicos.

• Encapsula la configuración: Otro beneficio de usar módulos es que puedes encapsular la configuración en componentes lógicos separados. La encapsulación permite evitar consecuencias inesperadas (por ejemplo, que un cambio en una parte de tu configuración modifique otra infraestructura por accidente) y reduce las probabilidades de que se produzcan errores sencillos, como usar el mismo nombre para dos recursos diferentes.

• Reutiliza la configuración: Escribir tu configuración completa sin usar el código existente puede tardar mucho y provocar errores. En cambio, si usas módulos puedes ahorrar tiempo y reducir los errores costosos, ya que se reutiliza la configuración escrita por ti, otros miembros de tu equipo, o bien otros profesionales de Terraform que publicaron módulos para que los utilices. También puedes compartir los módulos que escribas con tu equipo o el público general para que se beneficien de tu arduo trabajo.

• Proporciona coherencia y asegúrate de que se apliquen las prácticas recomendadas: Los módulos también te ayudan a proporcionar coherencia a tus configuraciones. La coherencia permite que los parámetros de configuración complejos sean más fáciles de comprender, y esto garantiza que se apliquen las prácticas recomendadas en toda tu configuración. Por ejemplo, los proveedores de servicios en la nube ofrecen varias opciones para configurar servicios de almacenamiento de objetos, como Amazon S3 (Simple Storage Service) o los buckets de Google Cloud Storage. Muchos incidentes de seguridad de alto perfil han implicado objetos almacenados sin una correcta protección. Debido a la cantidad de opciones complejas de configuración involucradas, es fácil configurar incorrectamente estos servicios de manera accidental.

Usar módulos ayuda a reducir estos errores. Por ejemplo, podrías crear un módulo para describir cómo se configurarán todos los buckets del sitio web público de tu organización, y otro módulo para los buckets privados que se usan en aplicaciones de registro. Además, si se debe actualizar una configuración para un tipo de recurso, usar módulos te permite hacerlo en un solo lugar y aplicar la actualización a todos los casos en los que uses ese módulo.

Objetivos

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

• Usar un módulo de Registry
• Compilar un módulo

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs son cronometrados y no se pueden pausar. El cronómetro, 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 de navegador privada o de Incógnito para ejecutar este lab. Así evitarás cualquier conflicto 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: Si ya tienes un proyecto o una cuenta personal de Google Cloud, no los uses en este lab para evitar cargos adicionales en tu cuenta.

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

1. Haga clic en el botón Comenzar lab. Si debe pagar por el lab, se abrirá una ventana emergente para que seleccione su forma de pago. A la izquierda, se encuentra el panel Detalles del lab, que tiene estos elementos:

   • El botón Abrir la consola de Google Cloud
   • El tiempo restante
   • Las credenciales temporales que debe usar para el lab
   • Otra información para completar el lab, si es necesaria

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 recursos y abre otra pestaña en la que se muestra la página de acceso.

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

   Nota: Si ves el diálogo Elegir una cuenta, haz clic en Usar 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 Detalles del lab.

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 Detalles del lab.

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 podría generar cargos adicionales.

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

   • Acepta los Términos y Condiciones.
   • No agregues opciones de recuperación o autenticación de dos factores (esta es una cuenta 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 ver un menú con una lista de productos y servicios de Google Cloud, haz clic en el menú de navegación que se encuentra en la parte superior izquierda.

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.

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

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

gcloud auth list

3. Haz clic en Autorizar.

4. Ahora, el resultado debería verse de la siguiente manera:

Resultado:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net 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_ID>

Resultado de ejemplo:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: Para obtener toda la documentación de gcloud, consulta la guía con la descripción general de gcloud CLI en Google Cloud.

¿Qué es un módulo de Terraform?

Un módulo de Terraform es un conjunto de archivos de configuración de Terraform en un solo directorio. Incluso una configuración simple que consista en un único directorio con uno o más archivos .tf es un módulo. Cuando ejecutas los comandos de Terraform directamente desde un directorio de este tipo, este se considera el módulo raíz. En ese sentido, cada configuración de Terraform es parte de un módulo. Podrías tener un conjunto sencillo de archivos de configuración de Terraform como el siguiente:

├── LICENSE ├── README.md ├── main.tf ├── variables.tf ├── outputs.tf

En este caso, cuando ejecutas comandos de Terraform desde el directorio minimal-module, el contenido de dicho directorio se considera como módulo raíz.

Llamadas a módulos

Los comandos de Terraform solo usan directamente los archivos de configuración en un directorio que, por lo general, es el directorio de trabajo actual. Sin embargo, tu configuración puede usar bloques de módulos para llamar módulos de otros directorios. Cuando Terraform encuentra un bloque de módulo, lo carga y procesa sus archivos de configuración.

En ocasiones, cuando otra configuración llama a un módulo, este último se denomina “módulo secundario” de la configuración.

Módulos locales y remotos

Puedes cargar módulos desde el sistema de archivos local o una fuente remota. Terraform es compatible con una variedad de fuentes remotas, entre las que se incluyen Terraform Registry, la mayoría de los sistemas de control de versión, URLs HTTP y los registros de módulos privados de Terraform Cloud o Terraform Enterprise.

Prácticas recomendadas de módulos

En muchos sentidos, los módulos de Terraform son similares a los conceptos de bibliotecas, paquetes o módulos presentes en la mayor parte de los lenguajes de programación, y proporcionan muchos de sus beneficios. De la misma manera que casi cualquier programa de cómputo no trivial, las configuraciones del mundo real de Terraform deberían usar módulos en la medida de lo posible para ofrecer los beneficios que se mencionan arriba.

Se sugiere que todos los usuarios de Terraform sigan estas prácticas recomendadas cuando usen módulos:

• Comienza a escribir tu configuración con un plan para los módulos. Incluso para configuraciones de Terraform poco complejas y administradas por una sola persona, los beneficios de usar los módulos superan el tiempo que toma usarlos de manera adecuada.

• Usa módulos locales para organizar y encapsular tu código. Incluso si no usas o publicas módulos remotos, organizar tu configuración en términos de módulos desde un inicio reduce significativamente la carga de mantener y actualizar tu configuración a medida que aumenta la complejidad de tu infraestructura.

• Usa Terraform Registry, un servicio público que te permite buscar módulos útiles. De esta manera, puedes implementar tu configuración rápidamente y con confianza, pues se vale del trabajo de otros usuarios.

• Publica y comparte módulos con tu equipo. La mayoría de las infraestructuras son administradas por un equipo, y los módulos son una herramienta importante que pueden usar para crear y mantener tus infraestructuras. Como se mencionó antes, puedes publicar módulos de manera pública o privada. Aprenderás a hacerlo en un lab posterior de esta serie.

Tarea 1. Usa módulos de Registry

En esta sección, usarás módulos de Terraform Registry para aprovisionar un entorno de ejemplo en Google Cloud. Los conceptos que usarás aquí aplican para los módulos de cualquier fuente.

• En una nueva pestaña o ventana del navegador, abre la página de Terraform Registry para el módulo de Terraform Network. La página debe verse de la siguiente manera:

La página incluye información sobre el módulo y un vínculo al repositorio de código fuente. En el lado derecho de la página, se incluye una interfaz desplegable para seleccionar la versión del módulo, así como instrucciones para usarlo para aprovisionar la infraestructura.

Cuando llamas a un módulo, se requiere el argumento source. En este ejemplo, Terraform buscará un módulo en Terraform Registry que coincida con la cadena dada. También puedes usar una URL o una ruta de archivo local para la fuente de tus módulos. Consulta la documentación de Terraform para obtener una lista de posibles fuentes de módulos.

El otro argumento que se muestra aquí es version. Para las fuentes compatibles, este argumento te permite definir la versión o versiones del módulo que se cargará. En este lab, especificarás un número de versión exacto para los módulos que usarás. Para obtener más información sobre las formas en que puedes especificar versiones, consulta la documentación sobre módulos.

Otros argumentos para los bloques de módulos se tratan como variables de entrada de los módulos.

Cómo crear una configuración de Terraform

1. Para comenzar, ejecuta los siguientes comandos en Cloud Shell para clonar un proyecto sencillo de muestra a partir del repositorio de GitHub de módulos de Terraform en Google y cambia a la rama v6.0.1:

git clone https://github.com/terraform-google-modules/terraform-google-network cd terraform-google-network git checkout tags/v6.0.1 -b v6.0.1

Esto garantiza que uses el número de versión correcto.

2. En la barra de herramientas de Cloud Shell, haz clic en Abrir editor. Para pasar de Cloud Shell al editor de código y viceversa, haz clic en Abrir editor o Abrir terminal según sea necesario, o bien haz clic en Abrir en una nueva ventana para dejar el editor abierto en una pestaña distinta.

3. En el editor, navega a terraform-google-network/examples/simple_project, y abre el archivo main.tf. Tu configuración main.tf se verá de la siguiente manera:

module "test-vpc-module" { source = "terraform-google-modules/network/google" version = "~> 6.0" project_id = var.project_id # Replace this with your project ID network_name = "my-custom-mode-network" mtu = 1460 subnets = [ { subnet_name = "subnet-01" subnet_ip = "10.10.10.0/24" subnet_region = "us-west1" }, { subnet_name = "subnet-02" subnet_ip = "10.10.20.0/24" subnet_region = "us-west1" subnet_private_access = "true" subnet_flow_logs = "true" }, { subnet_name = "subnet-03" subnet_ip = "10.10.30.0/24" subnet_region = "us-west1" subnet_flow_logs = "true" subnet_flow_logs_interval = "INTERVAL_10_MIN" subnet_flow_logs_sampling = 0.7 subnet_flow_logs_metadata = "INCLUDE_ALL_METADATA" subnet_flow_logs_filter = "false" } ] }

Esta configuración incluye un bloque importante:

• module "test-vpc-module" define una nube privada virtual (VPC), la cual proporcionará los servicios de redes para el resto de tu infraestructura.

Cómo establecer valores para las variables de entrada de los módulos

Algunas variables de entrada son obligatorias, lo que significa que el módulo no proporciona un valor predeterminado. Por el contrario, se debe proporcionar un valor explícito para que Terraform se ejecute correctamente.

• En el bloque de módulo "test-vpc-module", revisa las variables de entrada que configures. Cada una de estas variables de entrada se documenta en Terraform Registry. Estas son las entradas obligatorias para este módulo:

  • network_name: Es el nombre de la red que se creará.
  • project_id: Es el ID del proyecto en el que se creará esta VPC.
  • subnets: Es la lista de subredes que se crearán.

Para usar la mayoría de los módulos, deberás pasar variables de entrada a la configuración del módulo. La configuración que llama a un módulo es responsable de establecer sus valores de entrada, los cuales se pasan como argumentos al bloque de módulo. Además de source y version, la mayoría de los argumentos para un bloque de módulo establecen valores de variables.

En la página de Terraform Registry para el módulo de red de Google Cloud, la pestaña Entradas describe todas las variables de entrada que son compatibles con el módulo.

Cómo definir variables de entrada raíz

El uso de variables de entrada con módulos es muy similar a la manera en que las usarías en cualquier configuración de Terraform. Un patrón común es identificar las variables de entrada del módulo que quizá debas modificar en el futuro y, luego, crear variables coincidentes en el archivo variables.tf de tu configuración con valores predeterminados sensatos. Luego, esas variables se pueden pasar al bloque de módulo como argumentos.

1. Para recuperar el ID de tu proyecto, ejecuta el siguiente comando en Cloud Shell:

gcloud config list --format 'value(core.project)'

2. En el editor, navega a variables.tf del mismo directorio.

3. Ingresa la variable project_id con el resultado del comando anterior. Debes seguir el formato que se muestra a continuación y establecer el valor default para la variable:

variable "project_id" { description = "The project ID to host the network in" default = "FILL IN YOUR PROJECT ID HERE" }

4. En variables.tf, ingresa la variable network_name. Puedes usar el nombre example-vpc o cualquier otro que prefieras. Debes seguir el formato que se muestra a continuación y establecer el valor default para la variable:

variable "network_name" { description = "The name of the VPC network being created" default = "example-vpc" }

5. Regresa al archivo main.tf y actualiza el parámetro network_name para usar la variable que acabas de definir configurando el valor como var.network_name.

module "test-vpc-module" { ... project_id = var.project_id network_name = var.network_name ...

6. En el archivo main.tf, actualiza las regiones de subred en las líneas 35, 40 y 47 de us-west1 a . Esto garantizará que las subredes se creen en la región permitida de tu proyecto. Tu módulo debería verse de esta manera:

subnets = [ { subnet_name = "subnet-01" subnet_ip = "10.10.10.0/24" subnet_region = "{{{project_0.default_region | REGION}}}" }, { subnet_name = "subnet-02" subnet_ip = "10.10.20.0/24" subnet_region = "{{{project_0.default_region | REGION}}}" subnet_private_access = "true" subnet_flow_logs = "true" }, { subnet_name = "subnet-03" subnet_ip = "10.10.30.0/24" subnet_region = "{{{project_0.default_region | REGION}}}" ... .. }

Cómo definir valores de salida de raíz

Los módulos también tienen valores de salida, que se definen dentro del módulo con la palabra clave output. Puedes acceder a ellos consultando module.<MODULE NAME>.<OUTPUT NAME>. Al igual que las variables de entrada, las salidas del módulo se enumeran en la pestaña outputs de Terraform Registry.

Las salidas de los módulos usualmente se pasan a otras partes de tu configuración o se definen como salidas en tu módulo raíz. En este lab verás ambos usos.

• Navega al archivo outputs.tf dentro del directorio de tu configuración. Verifica que el archivo contenga lo siguiente:

output "network_name" { value = module.test-vpc-module.network_name description = "The name of the VPC being created" } output "network_self_link" { value = module.test-vpc-module.network_self_link description = "The URI of the VPC being created" } output "project_id" { value = module.test-vpc-module.project_id description = "VPC project id" } output "subnets_names" { value = module.test-vpc-module.subnets_names description = "The names of the subnets being created" } output "subnets_ips" { value = module.test-vpc-module.subnets_ips description = "The IP and cidrs of the subnets being created" } output "subnets_regions" { value = module.test-vpc-module.subnets_regions description = "The region where subnets will be created" } output "subnets_private_access" { value = module.test-vpc-module.subnets_private_access description = "Whether the subnets will have access to Google API's without a public IP" } output "subnets_flow_logs" { value = module.test-vpc-module.subnets_flow_logs description = "Whether the subnets will have VPC flow logs enabled" } output "subnets_secondary_ranges" { value = module.test-vpc-module.subnets_secondary_ranges description = "The secondary ranges associated with these subnets" } output "route_names" { value = module.test-vpc-module.route_names description = "The routes associated with this VPC" }

Cómo aprovisionar la infraestructura

1. En Cloud Shell, navega a tu directorio simple_project:

cd ~/terraform-google-network/examples/simple_project

2. Inicializa tu configuración de Terraform:

terraform init

3. Crea tu VPC:

terraform apply

4. Para aplicar los cambios y continuar, responde yes en el prompt.

¡Genial! Acabas de usar tu primer módulo. La salida de tu configuración debe ser similar a la siguiente:

Outputs: network_name = "example-vpc" network_self_link = "https://www.googleapis.com/compute/v1/projects/qwiklabs-gcp-01-a68489b0625b/global/networks/example-vpc" project_id = "" route_names = [] subnets_flow_logs = [ false, true, true, ] subnets_ips = [ "10.10.10.0/24", "10.10.20.0/24", "10.10.30.0/24", ] subnets_names = [ "subnet-01", "subnet-02", "subnet-03", ] .... ....

Cómo funcionan los módulos

Cuando uses un módulo nuevo por primera vez, debes ejecutar terraform init o terraform get para instalarlo. Con cualquiera de estos dos comandos, Terraform instala los módulos nuevos en el directorio .terraform/modules, que se encuentra en el directorio de trabajo de tu configuración. Para los módulos locales, Terraform crea un symlink al directorio del módulo. Por ello, cualquier cambio a los módulos locales se verá reflejado de inmediato, sin que debas volver a ejecutar terraform get.

Cómo borrar tu infraestructura

Hasta aquí, aprendiste a usar módulos desde Terraform Registry, a configurarlos con variables de entrada y a obtener valores de salida de ellos.

1. Ahora, destruye la infraestructura que creaste:

terraform destroy

2. Responde yes en el prompt. Terraform destruirá la infraestructura que creaste.

3. Una vez que hayas destruido tus recursos, borra la carpeta terraform-google-network.

cd ~ rm -rd terraform-google-network -f

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

Tarea 2. Compila un módulo

En la tarea anterior, usaste un módulo de Terraform Registry para crear una red de VPC en Google Cloud. Aunque el uso correcto de los módulos existentes de Terraform es una habilidad importante, los profesionales se beneficiarán además si aprenden cómo crearlos. Te recomendamos que crees todas tus configuraciones de Terraform con el supuesto de que podría usarse como un módulo, pues esto te ayudará a que el diseño de tus configuraciones sea flexible, reusable y componible.

Como ya sabes, Terraform trata cada configuración como un módulo. Cuando ejecutas los comandos terraform, o usas Terraform Cloud o Terraform Enterprise para ejecutar Terraform de manera remota, el directorio objetivo que contiene la configuración es tratado como el módulo raíz.

En esta tarea, crearás un módulo para administrar los buckets de Cloud Storage que se usan para alojar sitios web estáticos.

Estructura de módulos

Terraform trata todos los directorios locales a los que se hace referencia en el argumento source de un bloque module como un módulo. Esta es la estructura de archivos convencional de un módulo nuevo:

├── LICENSE ├── README.md ├── main.tf ├── variables.tf ├── outputs.tf Nota: Ninguno de estos archivos es obligatorio o tiene un significado especial para Terraform cuando usa tu módulo. Puedes crear un módulo con un solo archivo .tf o usar cualquier otra estructura de archivos que desees.

Cada uno de estos archivos cumple un propósito:

• LICENSE contiene la licencia bajo la cual se distribuirá tu módulo. Cuando lo compartes, el archivo LICENSE les informará a los usuarios los términos bajo los cuales está disponible. Terraform no usa este archivo.
• README.md contiene documentación en formato markdown, que describe cómo usar tu módulo. Terraform no usa este archivo, pero otros servicios como Terraform Registry y GitHub mostrarán el contenido de este archivo a los visitantes de las páginas de Terraform Registry o GitHub correspondientes a tu módulo.
• main.tf contiene el conjunto principal de parámetros de configuración para tu módulo. También puedes crear otros archivos de configuración y organizarlos de manera que tengan sentido para tu proyecto.
• variables.tf contiene las definiciones de variables para tu módulo. Cuando otras personas usan tu módulo, las variables se configurarán como argumentos en el bloque de módulo. Dado que debes definir todos los valores de Terraform, cualquier variable que no tenga un valor predeterminado se convertirá en un argumento obligatorio. También puedes proporcionar una variable con un valor predeterminado como si fuera un argumento del módulo, con lo que se anula el valor predeterminado.
• outputs.tf contiene las definiciones de salida para tu módulo. Estas salidas están disponibles para la configuración que usa el módulo, por lo que a menudo se usan para pasar información sobre las partes de tu infraestructura que define el módulo a otras partes de tu configuración.

Ten cuidado con estos archivos y asegúrate de no distribuirlos como parte de tu módulo.

• Los archivos terraform.tfstate y terraform.tfstate.backup contienen el estado y son la manera en que Terraform hace un seguimiento de la relación entre tu configuración y la infraestructura que esta aprovisiona.
• El directorio .terraform contiene los módulos y complementos que se usan para aprovisionar tu infraestructura. Estos archivos son específicos para cada instancia individual de Terraform cuando aprovisionas la infraestructura, no para la configuración de la infraestructura que se define en los archivos .tf.
• No es necesario distribuir los archivos *.tfvars con tu módulo, a menos que también lo uses como una configuración independiente de Terraform. Esto se debe a que las variables de entrada del módulo se establecen mediante argumentos para el bloque de módulo en tu configuración.

Nota: Si haces el seguimiento de los cambios de tu módulo en un sistema de control de versión como Git, te sugerimos que configures este sistema para que ignore estos archivos. Como ejemplo, consulta este archivo .gitignore en GitHub.

Cómo crear un módulo

Navega a tu directorio principal y crea tu módulo raíz. Para ello, construye un archivo de configuración main.tf nuevo. Luego, crea un directorio llamado modules que contenga otra carpeta llamada gcs-static-website-bucket. Trabajarás con tres archivos de configuración de Terraform dentro del directorio gcs-static-website-bucket: website.tf, variables.tf y outputs.tf.

1. Crea el directorio para tu módulo nuevo:

cd ~ touch main.tf mkdir -p modules/gcs-static-website-bucket

2. Navega al directorio del módulo y ejecuta los siguientes comandos para crear tres archivos vacíos:

cd modules/gcs-static-website-bucket touch website.tf variables.tf outputs.tf

3. Dentro del directorio gcs-static-website-bucket, ejecuta el siguiente comando para crear un archivo llamado README.md con este contenido:

tee -a README.md <<EOF # GCS static website bucket This module provisions Cloud Storage buckets configured for static website hosting. EOF Nota: Elegir la licencia correcta para tus módulos está fuera del alcance de este lab. En este caso, usarás la licencia de código abierto Apache 2.0.

4. Crea otro archivo llamado LICENSE con el siguiente contenido:

tee -a LICENSE <<EOF Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. EOF Nota: Ninguno de estos archivos es obligatorio ni los usa Terraform. Sin embargo, tenerlos es una práctica recomendada para el uso de módulos que se podrían compartir con otros usuarios.

La estructura actual de tu directorio de módulos debería ser similar a la siguiente:

main.tf modules/ └── gcs-static-website-bucket ├── LICENSE ├── README.md ├── website.tf ├── outputs.tf └── variables.tf

5. Agrega este recurso de bucket de Cloud Storage a tu archivo website.tf dentro del directorio modules/gcs-static-website-bucket:

resource "google_storage_bucket" "bucket" { name = var.name project = var.project_id location = var.location storage_class = var.storage_class labels = var.labels force_destroy = var.force_destroy uniform_bucket_level_access = true versioning { enabled = var.versioning } dynamic "retention_policy" { for_each = var.retention_policy == null ? [] : [var.retention_policy] content { is_locked = var.retention_policy.is_locked retention_period = var.retention_policy.retention_period } } dynamic "encryption" { for_each = var.encryption == null ? [] : [var.encryption] content { default_kms_key_name = var.encryption.default_kms_key_name } } dynamic "lifecycle_rule" { for_each = var.lifecycle_rules content { action { type = lifecycle_rule.value.action.type storage_class = lookup(lifecycle_rule.value.action, "storage_class", null) } condition { age = lookup(lifecycle_rule.value.condition, "age", null) created_before = lookup(lifecycle_rule.value.condition, "created_before", null) with_state = lookup(lifecycle_rule.value.condition, "with_state", null) matches_storage_class = lookup(lifecycle_rule.value.condition, "matches_storage_class", null) num_newer_versions = lookup(lifecycle_rule.value.condition, "num_newer_versions", null) } } } }

La documentación del proveedor es GitHub.

6. Navega al archivo variables.tf en tu módulo y agrega el siguiente código:

variable "name" { description = "The name of the bucket." type = string } variable "project_id" { description = "The ID of the project to create the bucket in." type = string } variable "location" { description = "The location of the bucket." type = string } variable "storage_class" { description = "The Storage Class of the new bucket." type = string default = null } variable "labels" { description = "A set of key/value label pairs to assign to the bucket." type = map(string) default = null } variable "bucket_policy_only" { description = "Enables Bucket Policy Only access to a bucket." type = bool default = true } variable "versioning" { description = "While set to true, versioning is fully enabled for this bucket." type = bool default = true } variable "force_destroy" { description = "When deleting a bucket, this boolean option will delete all contained objects. If false, Terraform will fail to delete buckets which contain objects." type = bool default = true } variable "iam_members" { description = "The list of IAM members to grant permissions on the bucket." type = list(object({ role = string member = string })) default = [] } variable "retention_policy" { description = "Configuration of the bucket's data retention policy for how long objects in the bucket should be retained." type = object({ is_locked = bool retention_period = number }) default = null } variable "encryption" { description = "A Cloud KMS key that will be used to encrypt objects inserted into this bucket" type = object({ default_kms_key_name = string }) default = null } variable "lifecycle_rules" { description = "The bucket's Lifecycle Rules configuration." type = list(object({ # Object with keys: # - type - The type of the action of this Lifecycle Rule. Supported values: Delete and SetStorageClass. # - storage_class - (Required if action type is SetStorageClass) The target Storage Class of objects affected by this Lifecycle Rule. action = any # Object with keys: # - age - (Optional) Minimum age of an object in days to satisfy this condition. # - created_before - (Optional) Creation date of an object in RFC 3339 (e.g. 2017-06-13) to satisfy this condition. # - with_state - (Optional) Match to live and/or archived objects. Supported values include: "LIVE", "ARCHIVED", "ANY". # - matches_storage_class - (Optional) Storage Class of objects to satisfy this condition. Supported values include: MULTI_REGIONAL, REGIONAL, NEARLINE, COLDLINE, STANDARD, DURABLE_REDUCED_AVAILABILITY. # - num_newer_versions - (Optional) Relevant only for versioned objects. The number of newer versions of an object to satisfy this condition. condition = any })) default = [] }

7. Agrega una salida a tu módulo en el archivo outputs.tf dentro de tu módulo:

output "bucket" { description = "The created storage bucket" value = google_storage_bucket.bucket }

Al igual que las variables, las salidas en los módulos realizan la misma función que en el módulo raíz, pero se accede a ellas de manera diferente. Puedes acceder a las salidas de un módulo como atributos de solo lectura en el objeto del módulo, que está disponible en la configuración que llama al módulo.

8. Regresa a main.tf en tu directorio raíz y agrega una referencia al módulo nuevo:

module "gcs-static-website-bucket" { source = "./modules/gcs-static-website-bucket" name = var.name project_id = var.project_id location = "{{{project_0.default_region | REGION}}}" lifecycle_rules = [{ action = { type = "Delete" } condition = { age = 365 with_state = "ANY" } }] }

9. En tu directorio raíz, crea un archivo outputs.tf para tu módulo raíz:

cd ~ touch outputs.tf

10. Agrega el siguiente código en el archivo outputs.tf:

output "bucket-name" { description = "Bucket names." value = "module.gcs-static-website-bucket.bucket" }

11. En tu directorio raíz, crea un archivo variables.tf:

touch variables.tf

12. Agrega el siguiente código al archivo variables.tf. Establece las variables project_id y name para que refieran de forma predeterminada al ID de tu proyecto: .

variable "project_id" { description = "The ID of the project in which to provision resources." type = string default = "FILL IN YOUR PROJECT ID HERE" } variable "name" { description = "Name of the buckets to create." type = string default = "FILL IN A (UNIQUE) BUCKET NAME HERE" } Nota: El nombre de tu bucket de almacenamiento debe ser único a nivel global. Usualmente, una buena manera de crear un nombre con esta característica es usar tu nombre y la fecha. También puedes usar tu ID del proyecto.

Cómo instalar el módulo local

Cuando agregues un módulo nuevo a una configuración, Terraform debe instalarlo para que se pueda usar. Los comandos terraform get y terraform init instalarán y actualizarán los módulos. Sin embargo, el comando terraform init también inicializará los backends y los complementos de instalación.

1. Instala el módulo:

terraform init

2. Aprovisiona tu bucket:

terraform apply

3. Responde yes en el prompt. Se aprovisionarán tu bucket y otros recursos.

Cómo subir archivos al bucket

Ya configuraste y usaste tu propio módulo para crear un sitio web estático. Te sugerimos que lo visites. En este momento, no hay nada dentro del bucket, por lo que no habrá nada para ver en el sitio web. Para ver algún tipo de contenido, deberás subir objetos a tu bucket. Para hacerlo, puedes usar el contenido del directorio www en el repositorio de GitHub.

1. Descarga el contenido de muestra a tu directorio principal:

cd ~ curl https://raw.githubusercontent.com/hashicorp/learn-terraform-modules/master/modules/aws-s3-static-website-bucket/www/index.html > index.html curl https://raw.githubusercontent.com/hashicorp/learn-terraform-modules/blob/master/modules/aws-s3-static-website-bucket/www/error.html > error.html

2. Copia los archivos en el bucket, pero reemplaza YOUR-BUCKET-NAME por el nombre de tu bucket de almacenamiento:

gsutil cp *.html gs://YOUR-BUCKET-NAME

3. En una pestaña nueva del navegador, ve al sitio web https://storage.cloud.google.com/YOUR-BUCKET-NAME/index.html; reemplaza YOUR-BUCKET-NAME por el nombre de tu bucket de almacenamiento.

Deberías ver una página web en HTML básico que dice Nothing to see here.

Haz clic en Revisar mi progreso para verificar el objetivo. Compilar un módulo

Cómo borrar el sitio web y la infraestructura

Por último, debes borrar tu proyecto. Para ello, destruye la infraestructura que acabas de crear.

1. Destruye tus recursos de Terraform:

terraform destroy

Después de responder yes en el prompt, Terraform destruirá todos los recursos que creaste en este lab.

¡Felicitaciones!

En este lab, aprendiste los fundamentos de los módulos de Terraform y cómo usar un módulo preexistente de Registry. Luego, compilaste tu propio módulo para crear un sitio web estático que se alojó en un bucket de Cloud Storage. Con estas actividades, definiste entradas, salidas y variables para tus archivos de configuración y conociste las prácticas recomendadas para compilar módulos.

Próximos pasos y más información

Los siguientes vínculos ofrecen más experiencia 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: 26 de enero de 2024

Prueba más reciente del lab: 11 de diciembre de 2023

Copyright 2024 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.