Navigating Terraform Provisioners with Practical Code Illustrations

Greetings, readers! In today's blog, we will delve into the realm of DevOps, exploring a critical component of the Infrastructure as Code (IaC) ecosystem - Terraform Provisioners. For those unfamiliar with the term, Terraform is an open-source IaC software tool. It’s a darling of the DevOps community as it allows efficient and dependable provisioning and administration of resources on a multitude of platforms.

A Primer on Terraform Provisioners

In the simplest terms, Terraform provisioners are a 'plan B' that lets you execute scripts on a local or remote machine during the resource creation or destruction process. They come in handy for bootstrapping a resource, readying it for operation, or removing resources. However, their usage adds a certain level of complexity and unpredictability, mainly because they need to interact with resources or systems directly, creating dependencies that might not always behave as predicted.

For that reason, it's recommended to limit the use of provisioners and to opt for server configuration management tools like cloud-init whenever possible.

A Practical Walkthrough of a Terraform Provisioner - Including Code

For a clearer perspective, let's go through an illustrative coding example using a Terraform provisioner. We'll use the local-exec provisioner in this scenario, which triggers a local executable once a resource is built.

This is a basic Terraform configuration script that establishes an AWS instance and employs a local-exec provisioner to transfer the instance ID to a local text file.

provider "aws" {
  region = "us-west-2"
}

resource "aws_instance" "example" {
  ami           = "ami-0c94855ba95c574c8"
  instance_type = "t2.micro"

  provisioner "local-exec" {
    command = "echo ${self.id} > instance_id.txt"
  }
}

Here's a breakdown of the script:

• The provider "aws" block sets the AWS provider in motion with the specified region being "us-west-2".

• The resource "aws_instance" "example" block establishes an AWS instance, leveraging a free-tier eligible Amazon Machine Image (AMI) and instance type.

• The provisioner "local-exec" block instructs Terraform to initiate a local command once the instance is built. The command parameter defines the command to be executed. Here, we're pushing the ID of the instance into a text file named instance_id.txt. The ${self.id} expression signifies the ID of the instance being established.

Please remember that the AMI ID used here is specific to the region and could differ, so ensure to replace the AMI ID with the correct one for your region and needs.

Word of Caution

While provisioners can be a potent tool, they also carry potential risks. A failing provisioner will not retry automatically, potentially leaving resources in a limbo. This absence of idempotency is why provisioners are best used sparingly, and only when there are no viable alternatives.

Wrap-up

Terraform provisioners, in certain instances, can prove to be incredibly beneficial, but it's crucial to use them judiciously and with care. The local-exec provisioner we discussed is just one among many provisioners provided by Terraform. Other types include remote-exec (executes a command on the resource), file (transfers files to the resource), and more.

However, always keep in mind that while Terraform provisioners may simplify certain tasks, they introduce complexity and potential fragility into your Terraform configurations. Wherever feasible, consider alternatives like cloud-init or other robust configuration management tools for setting up and configuring systems.

We will delve deeper into Terraform and other IaC tools in our upcoming blogs, exploring advanced techniques, best practices, and more. Stay connected!