Trabajar con módulos de Terraform I

Índice

• 1. Introducción
• 2. Requisitos
• 3. ¿Qué son los módulos?
  • 3.1. ¿Dónde podemos encontrar módulos de Terraform?
• 4. Utilizando nuestro primer módulo
• 5. Conclusión

1. Introducción

Terraform es una tecnología de Infrastructure as Code (IAC) que nos permite definir, entre otras cosas, los recursos en la nube que vamos a aprovisionar para el despliegue de nuestras aplicaciones. Ya vimos algunos aspectos básicos y las ventajas de utilizarlo en este tutorial sobre primeros pasos con Terraform.

En esta ocasión, vamos a explorar los módulos de Terraform. Además de facilitarnos la vida al no tener que definir línea por línea cada uno de los recursos que necesitamos, también son una manera que podemos utilizar para no repetirnos (recuerda, “Don’t repeat yourself” (DRY)). Primero explicaremos el concepto de módulo y aprenderemos cómo utilizarlos. En una próxima entrega crearemos nuestros propios módulos.

2. Requisitos

Para seguir este tutorial, debes tener instalado Terraform en tu equipo y contar con una cuenta de AWS activa, tal y como se explica en el tutorial de primeros pasos con Terraform y en esta guía sobre crear una cuenta de AWS.

3. ¿Qué son los módulos?

Igual que en los lenguajes de programación tradicionales tenemos librerías y paquetes que nos permiten modularizar nuestro código para facilitar la reutilización y mantenibilidad del mismo, Terraform define el concepto de módulo. Podemos entenderlo como un conjunto de ficheros de terraform que, al aser aplicados con ciertos argumentos, aprovisionan los recursos en la nube y generan una información de salida.

¿Cómo podemos definirlos? Pues es realmente sencillo. Terraform considera cualquier conjunto de ficheros con la extensión .tf dentro de un directorio como un módulo. No hay ninguna sintaxis ni nomenclatura específica.

Lo único que debemos tener en cuenta es que los argumentos de entrada (inputs) se definen como variables de Terraform. La salida, por su parte, se define como outputs. Podemos reutilizar la salida de la aplicación de un módulo en otros entornos, de modo que podemos obtener, por ejemplo, la ID de los recursos que se han creado para inyectársela a otros.

Además, los módulos trabajan bajo la filosofía de envoltorio o wraper. Podemos definir un módulo que a su vez utilice otro módulo para apoyarse. Por ejemplo, si el módulo A se encarga de definir un bucket de S3 en AWS, podemos definir un módulo B que llame al módulo A y, además, defina una serie de objetos sobre el bucket. En última instancia, nuestro proyecto de infraestructura llamaría al módulo B con los argumentos convenientes para aprovisionar todos esos recursos en la nube.

3.1. ¿Dónde podemos encontrar módulos de Terraform?

Por suerte, no tenemos que implementar nosotros mismos todos los módulos que nos hagan falta. La comunidad de Terraform es bastante grande. Incluso podemos encontrar módulos oficiales para algunos proveedores de nube.

El registro de Terraform es el lugar principal donde encontrarlos, especialmente por la confiabilidad que ofrece. Contamos con módulos para los proveedores de nube más importantes.

Además de en este registro, podemos encontrar módulos en cualquier repositorio de GIT o Mercurial, o incluso más extraño, en sistemas de ficheros remotos. En este documento se explica cómo utilizar los módulos en función de las características de la fuente.

4. Utilizando nuestro primer módulo

Vamos a ver cómo podemos utilizar un módulo ya definido para facilitar el aprovisionamiento de nuestra infraestructura. para ello, vamos a crear una nueva VPC sobre AWS y aprovisionaremos un par de instancias de EC2. Utilizaremos los módulos que podemos encontrar en el registro de Terraform.

Como ya sabemos, una de las principales ventajas de Terraform es que podemos versionar nuestra infraestructura, ya que los ficheros definen siempre el estado final. Por tanto, creamos un repositorio nuevo en GitHub que llamaremos ‘my-modular-infrastructure’ y lo clonaremos en nuestro equipo. En las plantillas para el .gitignore, elegiremos Terraform.

Vamos a crear tres ficheros en la raíz del proyecto: main.tf, vpc.tf y ec2.tf. Aquí llamaremos a los módulos de VPC, security group y EC2.

Aquí os dejo el repositorio con el código para el tutorial que he creado. Podéis clonarlo y hacer ‘git checkout v1.0’.

# main.tf
provider "aws" {
  shared_credentials_file = "~/.aws/credentials"
  region = "eu-west-1"
}

*Debes configurar tus credenciales de AWS para que Terraform pueda hacer el aprovisionamiento de recursos. Puedes utilizar los siguientes comandos:

aws configure --profile myprofile
export AWS_PROFILE=myprofile

# vpc.tf
module "vpc" {
  source = "terraform-aws-modules/vpc/aws"

  name = "my-vpc"
  cidr = "10.0.0.0/16"

  azs             = ["eu-west-1a", "eu-west-1b"]
  private_subnets = ["10.0.1.0/24", "10.0.2.0/24"]
  public_subnets  = ["10.0.101.0/24", "10.0.102.0/24"]

  enable_nat_gateway = true

  tags = {
    Terraform = "true"
    Environment = "dev"
  }
}

• Definimos un VPC con dos subnets públicas y dos privadas.
• Elegimos dos availability zones (azs). Siempre es recomendable usar más de una. Las subnets se asignan a estas zonas de forma automática.
• El bloque de CIDR nos permite utilizar una máscara de red de 16 bits. Este valor puede modificarse entre ciertos rangos.

# ec2.tf
module "ec2_cluster" {
  source                 = "terraform-aws-modules/ec2-instance/aws"
  version                = "~> 2.0"

  name                   = "my-cluster"
  instance_count         = 2

  ami                    = "ami-ebd02392"
  instance_type          = "t2.micro"
  vpc_security_group_ids = [module.ssh_security_group.this_security_group_id]
  subnet_ids = module.vpc.private_subnets

  tags = {
    Terraform   = "true"
    Environment = "dev"
  }
}

module "ssh_security_group" {
  source  = "terraform-aws-modules/security-group/aws//modules/ssh"
  version = "~> 3.0"

  name = "ssh-server"
    description = "Security group for ssh-server with ssh ports open within VPC"
    vpc_id = module.vpc.vpc_id

    ingress_cidr_blocks = ["10.10.0.0/16"]
}

• Se crea un security group para poder acceder por SSH a las instancias.
• Se aprovisionan dos instancias de EC2.
• Las instancias se desplegarán sobre las subnets privadas.Podemos consolidar nuestro trabajo y subirlo al repositorio que hemos creado. Para terminar, realizaremos el despliegue:

  terraform init
  terraform apply

  Se mostrará el plan de acción antes de ejecutarlo. Deberían crearse en total 26 recursos. Si todo va bien, después de unos minutos deberíamos tener nuestra infraestructura creada en la nube y se nos mostrará un mensaje de éxito. Por último, vamos a destruir la infraestructura para evitar sorpresas desagradables.

  terraform destroy

  Igual que antes, deberían eliminarse 26 recursos.

5. Conclusión

Los módulos de terraform nos permiten crear nuestra infraestructura en la nube de un modo más sencillo. Con muy pocas líneas, podemos tener todo listo para desplegar nuestras aplicaciones. En esta primera parte hemos visto cómo utilizar módulos ya creados. En la próxima entrega veremos cómo crear y organizar nuestros propios módulos.