Introducción a Terraform para principiantes - Tutorial de Terraform

¿Te preguntas qué es Terraform? Averigüémoslo.

La infraestructura como código (IaC) es una terminología muy extendida entre los DevOps profesionales. Es el proceso de gestión y aprovisionamiento de toda la infraestructura informática (comprende tanto máquinas físicas como virtuales) mediante archivos de definición legibles por máquina. Es un enfoque de ingeniería de software hacia las operaciones. Ayuda a automatizar todo el centro de datos mediante scripts de programación.

Con todas las características que Infraestructura como código proporciona, tiene múltiples retos:

• Necesidad de aprender a programar
• Desconozco el impacto del cambio.
• Necesidad de revertir el cambio
• No se pueden rastrear los cambios
• No se puede automatizar un recurso
• Múltiples entornos para la infraestructura

Terraform se ha creado para resolver estos retos.

A continuación se enumeran algunas de las ventajas de utilizar Terraform.

• Orquestación, no sólo gestión de la configuración
• Soporta múltiples proveedores como AWS, Azure, GCP, DigitalOcean y muchos más
• Proporcionar una infraestructura inmutable en la que la configuración cambie sin problemas.
• Utiliza un lenguaje fácil de entender, el HCL (lenguaje de configuración de HashiCorp)
• Fácilmente transportable a cualquier otro proveedor
• Admite arquitectura de sólo cliente, por lo que no es necesario gestionar la configuración adicional en un servidor.

Conceptos básicos de Terraform

A continuación se presentan los conceptos básicos/terminologías utilizadas en Terraform:

• Variables: También se utiliza como variables de entrada, es un par clave-valor utilizado por los módulos Terraform para permitir la personalización.
• Proveedor: Es un plugin para interactuar con APIs de servicio y acceder a sus recursos relacionados.
• Módulo: Es una carpeta con plantillas de Terraform donde se definen todas las configuraciones
• Estado: Consiste en información almacenada en caché sobre la infraestructura gestionada por Terraform y las configuraciones relacionadas.
• Recursos: Se refiere a un bloque de uno o más objetos de infraestructura (instancias de computación, redes virtuales, etc.), que se utilizan para configurar y gestionar la infraestructura.
• Fuente de datos: Lo implementan los proveedores para devolver información sobre objetos externos a terraformar.
• Valores de salida: Son valores de retorno de un módulo terraform que pueden ser utilizados por otras configuraciones.
• Plan: Es una de las etapas donde se determina lo que hay que crear, actualizar o destruir para pasar del estado real/actual de la infraestructura al estado deseado.
• Solicitar: Es una de las etapas donde se aplican los cambios estado real/actual de la infraestructura para pasar al estado deseado.

Ciclo de vida de Terraform

El ciclo de vida de Terraform consiste en init, plan, aplicary destruir.

• Terraform init inicializa el directorio de trabajo que consta de todos los archivos de configuración
• Terraform plan se utiliza para crear un plan de ejecución para alcanzar un estado deseado de la infraestructura. Se realizan cambios en los archivos de configuración para alcanzar el estado deseado.
• A continuación, Terraform apply realiza los cambios en la infraestructura según lo definido en el plan, y la infraestructura alcanza el estado deseado.
• Terraform destroy se utiliza para eliminar todos los recursos de infraestructura antiguos, que se marcan como contaminados después de la fase de aplicación.

¿Cómo funciona Terraform?

Terraform tiene dos componentes principales que conforman su arquitectura:

• Núcleo de Terraform
• Proveedores

Núcleo de Terraform

Terraform core utiliza dos fuentes de entrada para hacer su trabajo.

En primero es una configuración de Terraform que tú, como usuario, configuras. Aquí, usted define lo que necesita ser creado o aprovisionado. Y la segundo fuente de entrada es un estado en el que terraform mantiene el estado actualizado de cómo es la configuración actual de la infraestructura.

Así, lo que hace terraform core es tomar la entrada, y calcula el plan de lo que hay que hacer. Compara el estado, cuál es el estado actual, y cuál es la configuración que desea en el resultado final. Calcula lo que hay que hacer para llegar a ese estado deseado en el archivo de configuración. Calcula lo que hay que crear, lo que hay que actualizar, lo que hay que eliminar para crear y aprovisionar la infraestructura.

Proveedores

El segundo componente de la arquitectura son los proveedores de tecnologías específicas. Puede tratarse de proveedores de nube como AWS, Azure, GCP u otra plataforma de infraestructura como servicio. También es un proveedor para componentes de más alto nivel como Kubernetes u otras herramientas de plataforma como servicio, incluso algún software como herramienta de autoservicio.

Le ofrece la posibilidad de crear infraestructuras a distintos niveles.

Por ejemplo, crear una infraestructura de AWS, luego implementar Kubernetes sobre ella y luego crear servicios/componentes dentro de ese clúster de Kubernetes.

Terraform tiene más de cien proveedores para diferentes tecnologías, y cada proveedor da acceso al usuario terraform a sus recursos. Así que a través del proveedor de AWS, por ejemplo, tienes acceso a cientos de recursos de AWS como instancias EC2, los usuarios de AWS, etc. Con el proveedor de Kubernetes, accedes a productos básicos, recursos como servicios y despliegues y espacios de nombres, etc.

Así es como funciona Terraform, y de esta forma, intenta ayudarte a aprovisionar y cubrir la configuración completa de la aplicación, desde la infraestructura hasta la aplicación.

Hagamos cosas prácticas. 👨‍💻

Instalaremos Terraform en Ubuntu y aprovisionaremos una infraestructura muy básica.

Instalar Terraform

Descarga el último paquete de terraformación.

Consulte el página oficial de descargas para obtener la última versión del sistema operativo correspondiente.

geekflare@geekflare:~$ wget https://releases.hashicorp.com/terraform/0.13.0/terraform_0.13.0_linux_amd64.zip
--2020-08-14 16:55:38--
https://releases.hashicorp.com/terraform/0.13.0/terraform_0.13.0_linux_amd64.zip
Resolving releases.hashicorp.com (releases.hashicorp.com)... 151.101.153.183, 2a04:4e42:24::439
Connecting to releases.hashicorp.com (releases.hashicorp.com)|151.101.153.183|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 34851622 (33M) [application/zip]
Saving to: ‘terraform_0.13.0_linux_amd64.zip’

terraform_0.13.0_linux_amd64.zip
100%[=================================================================>] 33.24M
90.3KB/s in 5m 28s

2020-08-14 17:01:06 (104 KB/s) - ‘terraform_0.13.0_linux_amd64.zip’ saved [34851622/34851622]

Extraiga el paquete descargado.

geekflare@geekflare:~$ unzip terraform_0.13.0_linux_amd64.zip
Archive:
terraform_0.13.0_linux_amd64.zip
inflating: terraform

Mueva el archivo ejecutable de terraform a la ruta que se muestra a continuación. Compruebe la versión de terraform.

geekflare@geekflare:~$ sudo mv terraform /usr/local/bin/
[sudo] password for geekflare:
geekflare@geekflare:~$ terraform -v
Terraform v0.13.0

Puedes ver que estos son los comandos disponibles en terraform para su ejecución.

geekflare@geekflare:~$ terraform
Usage: terraform [-version] [-help] <command> [args]

The available commands for execution are listed below.
The most common, useful commands are shown first, followed by
less common or more advanced commands. If you're just getting
started with Terraform, stick with the common commands. For the
other commands, please read the help and docs before usage.

Common commands:
apply Builds or changes infrastructure
console Interactive console for Terraform interpolations
destroy Destroy Terraform-managed infrastructure
env Workspace management
fmt Rewrites config files to canonical format
get Download and install modules for the configuration
graph Create a visual graph of Terraform resources
import Import existing infrastructure into Terraform
init Initialize a Terraform working directory
login Obtain and save credentials for a remote host
logout Remove locally-stored credentials for a remote host
output Read an output from a state file
plan Generate and show an execution plan
providers Prints a tree of the providers used in the configuration
refresh Update local state file against real resources
show Inspect Terraform state or plan
taint Manually mark a resource for recreation
untaint Manually unmark a resource as tainted
validate Validates the Terraform files
version Prints the Terraform version
workspace Workspace management

All other commands:
0.12upgrade Rewrites pre-0.12 module source code for v0.12
0.13upgrade Rewrites pre-0.13 module source code for v0.13
debug Debug output management (experimental)
force-unlock Manually unlock the terraform state
push Obsolete command for Terraform Enterprise legacy (v1)
state Advanced state management

Aprovisionar una instancia AWS EC2 con Terraform

En esta demostración, voy a lanzar un nuevo Instancia AWS EC2 utilizando Terraform.

Crea un directorio de trabajo para esta demo de Terraform.

geekflare@geekflare:~$ mkdir terraform_demo

Ve al directorio y crea un archivo de configuración terraform donde definas el proveedor y los recursos para lanzar una instancia AWS EC2.

geekflare@geekflare:~$ cd terraform_demo/
geekflare@geekflare:~/terraform_demo$ gedit awsec2.tf

provider "aws" {
access_key = "B5KG6Fe5GUKIATUF5UD"
secret_key = "R4gb65y56GBF6765ejYSJA4YtaZ+T6GY7H"
region = "us-west-2"
}

resource "aws_instance" "terraform_demo" {
ami = "ami-0a634ae95e11c6f91"
instance_type = "t2.micro"
}

Nota: He cambiado las claves de acceso y secretas 😛, necesitas usar las tuyas.

De la configuración mencionada anteriormente, se puede ver que estoy mencionando el proveedor como AWS. Dentro del proveedor, estoy dando credenciales de usuario de AWS y regiones donde la instancia debe ser lanzada.

En los recursos, estoy dando detalles AMI de Ubuntu (ami-0a634ae95e11c6f91) y mencionar el tipo de instancia debe ser t2.micro

Puedes ver lo fácil y legible que es el archivo de configuración, incluso si no eres un programador empedernido.

terraformar init

Ahora, el primer paso es inicializar Terraform.

geekflare@geekflare:~/terraform_demo$ terraform init

Initializing the backend...

Initializing provider plugins...
- Using previously-installed hashicorp/aws v3.2.0

The following providers do not have any version constraints in configuration,
so the latest version was installed.

To prevent automatic upgrades to new major versions that may contain breaking
changes, we recommend adding version constraints in a required_providers block
in your configuration, with the constraint strings suggested below.

* hashicorp/aws: version = "~> 3.2.0"

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.

plan de terraformación

A continuación viene la fase de planificación, que creará el gráfico de ejecución para crear y aprovisionar la infraestructura.

geekflare@geekflare:~/terraform_demo$ 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.

------------------------------------------------------------------------

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:

# aws_instance.terraform_demo will be created
+ resource "aws_instance" "terraform_demo" {
+ ami = "ami-0a634ae95e11c6f91"
+ arn = (known after apply)
+ associate_public_ip_address = (known after apply)
+ availability_zone = (known after apply)
+ cpu_core_count = (known after apply)
+ cpu_threads_per_core = (known after apply)
+ get_password_data = false
+ host_id = (known after apply)
+ id = (known after apply)
+ instance_state = (known after apply)
+ instance_type = "t2.micro"
+ ipv6_address_count = (known after apply)
+ ipv6_addresses = (known after apply)
+ key_name = (known after apply)
+ outpost_arn = (known after apply)
+ password_data = (known after apply)
+ placement_group = (known after apply)
+ primary_network_interface_id = (known after apply)
+ private_dns = (known after apply)
+ private_ip = (known after apply)
+ public_dns = (known after apply)
+ public_ip = (known after apply)
+ secondary_private_ips = (known after apply)
+ security_groups = (known after apply)
+ source_dest_check = true
+ subnet_id = (known after apply)
+ tenancy = (known after apply)
+ volume_tags = (known after apply)
+ vpc_security_group_ids = (known after apply)

+ ebs_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ snapshot_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}

+ ephemeral_block_device {
+ device_name = (known after apply)
+ no_device = (known after apply)
+ virtual_name = (known after apply)
}

+ metadata_options {
+ http_endpoint = (known after apply)
+ http_put_response_hop_limit = (known after apply)
+ http_tokens = (known after apply)
}

+ network_interface {
+ delete_on_termination = (known after apply)
+ device_index = (known after apply)
+ network_interface_id = (known after apply)
}

+ root_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (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.

terraformar aplicar

La etapa apply ejecutará el archivo de configuración y lanzará una instancia AWS EC2. Cuando ejecutes el comando apply, te preguntará: "¿Deseas realizar estas acciones?", debes escribir sí y pulsar enter.

geekflare@geekflare:~/terraform_demo$ terraform apply

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:

# aws_instance.terraform_demo will be created
+ resource "aws_instance" "terraform_demo" {
+ ami = "ami-0a634ae95e11c6f91"
+ arn = (known after apply)
+ associate_public_ip_address = (known after apply)
+ availability_zone = (known after apply)
+ cpu_core_count = (known after apply)
+ cpu_threads_per_core = (known after apply)
+ get_password_data = false
+ host_id = (known after apply)
+ id = (known after apply)
+ instance_state = (known after apply)
+ instance_type = "t2.micro"
+ ipv6_address_count = (known after apply)
+ ipv6_addresses = (known after apply)
+ key_name = (known after apply)
+ outpost_arn = (known after apply)
+ password_data = (known after apply)
+ placement_group = (known after apply)
+ primary_network_interface_id = (known after apply)
+ private_dns = (known after apply)
+ private_ip = (known after apply)
+ public_dns = (known after apply)
+ public_ip = (known after apply)
+ secondary_private_ips = (known after apply)
+ security_groups = (known after apply)
+ source_dest_check = true
+ subnet_id = (known after apply)
+ tenancy = (known after apply)
+ volume_tags = (known after apply)
+ vpc_security_group_ids = (known after apply)

+ ebs_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ snapshot_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}

+ ephemeral_block_device {
+ device_name = (known after apply)
+ no_device = (known after apply)
+ virtual_name = (known after apply)
}

+ metadata_options {
+ http_endpoint = (known after apply)
+ http_put_response_hop_limit = (known after apply)
+ http_tokens = (known after apply)
}

+ network_interface {
+ delete_on_termination = (known after apply)
+ device_index = (known after apply)
+ network_interface_id = (known after apply)
}

+ root_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}
}

Plan: 1 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

aws_instance.terraform_demo: Creating...
aws_instance.terraform_demo: Still creating... [10s elapsed]
aws_instance.terraform_demo: Still creating... [20s elapsed]
aws_instance.terraform_demo: Still creating... [30s elapsed]
aws_instance.terraform_demo: Still creating... [40s elapsed]
aws_instance.terraform_demo: Creation complete after 44s [id=i-0eec33286ea4b0740]

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

Vaya a su panel de AWS EC2 y verá que se ha creado una nueva instancia con el id de instancia mencionado al final del comando apply.

Has lanzado con éxito una instancia AWS EC2 utilizando Terraform.

terraformar destruir

Por último, si desea eliminar la infraestructura, debe ejecutar el comando destroy.

geekflare@geekflare:~/terraform_demo$ terraform destroy
aws_instance.terraform_demo: Refreshing state... [id=i-0eec33286ea4b0740]

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
- destroy

Terraform will perform the following actions:

# aws_instance.terraform_demo will be destroyed
- resource "aws_instance" "terraform_demo" {
- ami = "ami-0a634ae95e11c6f91" -> null
- arn = "arn:aws:ec2:us-west-2:259212389929:instance/i-0eec33286ea4b0740" -> null
- associate_public_ip_address = true -> null
- availability_zone = "us-west-2c" -> null
- cpu_core_count = 1 -> null
- cpu_threads_per_core = 1 -> null
- disable_api_termination = false -> null
- ebs_optimized = false -> null
- get_password_data = false -> null
- hibernation = false -> null
- id = "i-0eec33286ea4b0740" -> null
- instance_state = "running" -> null
- instance_type = "t2.micro" -> null
- ipv6_address_count = 0 -> null
- ipv6_addresses = [] -> null
- monitoring = false -> null
- primary_network_interface_id = "eni-02a46f2802fd15634" -> null
- private_dns = "ip-172-31-13-160.us-west-2.compute.internal" -> null
- private_ip = "172.31.13.160" -> null
- public_dns = "ec2-34-221-77-94.us-west-2.compute.amazonaws.com" -> null
- public_ip = "34.221.77.94" -> null
- secondary_private_ips = [] -> null
- security_groups = [
- "default",
] -> null
- source_dest_check = true -> null
- subnet_id = "subnet-5551200c" -> null
- tags = {} -> null
- tenancy = "default" -> null
- volume_tags = {} -> null
- vpc_security_group_ids = [
- "sg-b5b480d1",
] -> null

- credit_specification {
- cpu_credits = "standard" -> null
}

- metadata_options {
- http_endpoint = "enabled" -> null
- http_put_response_hop_limit = 1 -> null
- http_tokens = "optional" -> null
}

- root_block_device {
- delete_on_termination = true -> null
- device_name = "/dev/sda1" -> null
- encrypted = false -> null
- iops = 100 -> null
- volume_id = "vol-0be2673afff6b1a86" -> null
- volume_size = 8 -> null
- volume_type = "gp2" -> null
}
}

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

Do you really want to destroy all resources?
Terraform will destroy all your managed infrastructure, as shown above.
There is no undo. Only 'yes' will be accepted to confirm.

Enter a value: yes

aws_instance.terraform_demo: Destroying... [id=i-0eec33286ea4b0740]
aws_instance.terraform_demo: Still destroying... [id=i-0eec33286ea4b0740, 10s elapsed]
aws_instance.terraform_demo: Still destroying... [id=i-0eec33286ea4b0740, 20s elapsed]
aws_instance.terraform_demo: Still destroying... [id=i-0eec33286ea4b0740, 30s elapsed]
aws_instance.terraform_demo: Destruction complete after 34s

Destroy complete! Resources: 1 destroyed.

Si vuelve a comprobar el panel de EC2, verá que la instancia se ha cerrado.

Conclusión

Creo que lo anterior te da una idea para empezar con Terraform. Siga adelante y pruebe el ejemplo que acabo de mostrar.

También debería consultar estos software de automatización de infraestructuras.

Si está interesado en saber más, le sugiero que consulte Curso de Aprendizaje de DevOps con Terraform.