Creación de una plantilla base de Terraform en Azure mediante Yeoman

Artículo
03/21/2023

Terraform habilita la definición, vista previa e implementación de la infraestructura en la nube. Con Terraform, se crean archivos de configuración mediante la sintaxis de HCL. La sintaxis de HCL permite especificar el proveedor de la nube, como Azure, y los elementos que componen la infraestructura de la nube. Después de crear los archivos de configuración, se crea un plan de ejecución que permite obtener una vista previa de los cambios de infraestructura antes de implementarlos. Una vez que compruebe los cambios, aplique el plan de ejecución para implementar la infraestructura.

En este artículo, aprenderá a usar la combinación de Terraform y Yeoman. Terraform es una herramienta para la creación de una infraestructura en Azure. Yeoman facilita la creación de módulos de Terraform.

En este artículo, aprenderá a realizar las siguientes tareas:

Crear una plantilla de Terraform base mediante el generador de módulos de Yeoman.
Probar la plantilla de Terraform con dos métodos diferentes.
Probar el módulo de Terraform mediante un archivo de Docker.
Ejecutar el módulo de Terraform de forma nativa en Azure Cloud Shell.

1. Configurar su entorno

Suscripción de Azure: si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.

Configuración de Terraform: si aún no lo ha hecho, configure Terraform con una de las siguientes opciones:

Visual Studio Code: descargue Visual Studio Code para su plataforma.
Docker: instale Docker para ejecutar el módulo creado por el generador de Yeoman.
Lenguaje de programación go: instalar Go como casos de prueba generados por Yeoman son código mediante el lenguaje Go.
Nodejs:Install Node.js
Instalación de Yeoman: ejecute el siguiente comando: npm install -g yo.
Plantilla de Yeoman: ejecute el siguiente comando para instalar la plantilla de Yeoman para el módulo de Terraform: npm install -g generator-az-terra-module.

2. Creación de un directorio para el módulo generado por Yeoman

La plantilla de Yeoman genera archivos en el directorio actual. Por este motivo, debe crear un directorio.

Es necesario poner este directorio vacío en $GOPATH/src. Para más información acerca de esta ruta de acceso, consulte el artículo Configuración de GOPATH.

Vaya al directorio primario desde el que se va a crear un nuevo directorio.
Ejecute el comando siguiente, reemplazando el marcador de posición. En este ejemplo, se utiliza el nombre de directorio GeneratorDocSample.
```
mkdir <new-directory-name>
```
Vaya al nuevo directorio:
```
cd <new-directory-name>
```

3. Creación de una plantilla de módulo básica

Ejecute el siguiente comando:
```
yo az-terra-module
```
Siga las instrucciones en pantalla para proporcionar la siguiente información:
- Nombre del proyecto del módulo Terraform: se usa un valor de doc-sample-module para el ejemplo.
- ¿Desea incluir el archivo de imagen de Docker? - Escriba y. Si especifica n, el código de módulo generado solo admitirá la ejecución en modo nativo.
Enumere el contenido del directorio para ver los archivos resultantes que se crean:
```
ls
```

4. Revisión del código de módulo generado

Iniciar Visual Studio Code
En la barra de menús, seleccione Archivo > abrir carpeta y seleccione la carpeta que creó.

El generador de módulos de Yeoman creó los siguientes archivos:

main.tf: define un módulo llamado random-shuffle. La entrada es de tipo string_list. El resultado es el recuento de las permutaciones.
variables.tf: define las variables de entrada y salida usadas por el módulo.
outputs.tf: define lo que genera el módulo. Aquí, es el valor devuelto por random_shuffle, que es un módulo de Terraform integrado.
Rakefile: define los pasos de compilación. Estos pasos incluyen:
- build: valida el formato del archivo main.tf.
- unit: el esqueleto del módulo generado no incluye el código para una prueba unitaria. Si desea especificar un escenario de prueba unitaria, agregaría ese código aquí.
- e2e: ejecuta una prueba de un extremo a otro del módulo.
test
- Los casos de prueba están escritos en Go.
- Todos los códigos de la prueba son pruebas de un extremo a otro.
- Las pruebas de un extremo a otro intentan aprovisionar todos los elementos definidos en fixture. Los resultados en el archivo template_output.go se comparan con los valores predefinidos esperados.
- Gopkg.lock y Gopkg.toml: define las dependencias.

Para más información sobre el generador Yeoman para Azure https://github.com/Azure/generator-az-terra-module, consulte la documentación de Terratest.

5. Prueba del módulo de Terraform mediante un archivo de Docker.

Esta sección muestra cómo probar un módulo de Terraform mediante un archivo de Docker.

Nota:

En este ejemplo se ejecuta el módulo localmente, no en Azure.

Confirmar que Docker está instalado y en ejecución

Desde un símbolo del sistema, escriba docker version.

Docker version

El resultado que se obtiene confirma que Docker está instalado.

Para confirmar que Docker se está ejecutando realmente, escriba docker info.

Docker info

Configurar un contenedor de Docker

Desde un símbolo del sistema, escriba

docker build --build-arg BUILD_ARM_SUBSCRIPTION_ID= --build-arg BUILD_ARM_CLIENT_ID= --build-arg BUILD_ARM_CLIENT_SECRET= --build-arg BUILD_ARM_TENANT_ID= -t terra-mod-example ..

Se mostrará el mensaje Successfully built (La compilación se realizó correctamente).
En el símbolo del sistema, escriba docker image ls para ver el módulo creado terra-mod-example enumerado.
Escriba docker run -it terra-mod-example /bin/sh. Después de ejecutar el comando docker run, se encuentra en el entorno de Docker. En ese momento, puede detectar el archivo mediante el comando ls.

Compilación del módulo

Ejecute el siguiente comando:
```
bundle install
```
Ejecute el siguiente comando:
```
rake build
```

Ejecución de la prueba de un extremo a otro

Ejecute el siguiente comando:
```
rake e2e
```
Poco después, aparecerá el mensaje PASS (Sin errores).
Escriba exit para finalizar la prueba y salir del entorno de Docker.

6. Uso del generador Yeoman para crear y probar un módulo

En esta sección, el generador de Yeoman se usa para crear y probar un módulo en Cloud Shell. El uso de Cloud Shell en lugar de usar un archivo de Docker simplifica en gran medida el proceso. Con Cloud Shell, todos los productos siguientes están preinstalados:

Node.js
Yeoman
Terraform

Inicio de una sesión de Cloud Shell

Inicie una sesión de Azure Cloud Shell mediante Azure Portal, shell.azure.com o la aplicación móvil de Azure.
Se abre la página de bienvenida a Azure Cloud Shell. Seleccione Bash (Linux).
Si no ha configurado una cuenta de almacenamiento de Azure, aparecerá la pantalla siguiente. Seleccione Crear almacenamiento.
Azure Cloud Shell se inicia en el shell que seleccionó anteriormente y muestra la información de la unidad en la nube que acaba de crear para usted.

Preparación de un directorio para almacenar el módulo de Terraform

En este momento, Cloud Shell ya habrá configurado GOPATH en las variables de entorno. Para ver la ruta de acceso, escriba go env.
Cree el directorio $GOPATH, si aún no existe uno: escriba mkdir ~/go.
Cree un directorio en el directorio $GOPATH. Se usa para almacenar los distintos directorios del proyecto creados en este ejemplo.
```
mkdir ~/go/src
```
Cree un directorio para contener el módulo Terraform reemplazando el marcador de posición. En este ejemplo, se utiliza el nombre de directorio my-module-name.
```
mkdir ~/go/src/<your-module-name>
```
Vaya al directorio del módulo:
```
cd ~/go/src/<your-module-name>
```

Creación y prueba del módulo de Terraform

Ejecute el siguiente comando y siga las instrucciones. Cuando se le pregunte si desea crear los archivos de Docker, escriba N.
```
yo az-terra-module
```
Ejecute el siguiente comando para instalar las dependencias:
```
bundle install
```
Ejecute el siguiente comando para compilar el módulo:
```
rake build
```
Ejecute el siguiente comando para lanzar la prueba:
```
rake e2e
```

Solución de problemas de Terraform en Azure

Solución de problemas comunes al usar Terraform en Azure

Pasos siguientes

Instalación y uso de la extensión de Visual Studio Code para Azure Terraform.