Terraform and Ansible: Combining Terraform and Ansible for infrastructure automation

Are you tired of manually setting up your infrastructure for your applications? Do you want to automate the process to make it faster and more efficient? If the answer is yes, then you're in the right place! In this article, we'll be talking about how to use Terraform and Ansible to automate your infrastructure deployment.

Terraform is a tool for building, changing, and versioning infrastructure safely and efficiently. It creates an execution plan that describes what resources need to be created, updated, or deleted to reach the desired state of your infrastructure. Ansible, on the other hand, is a tool for automation of application deployment, configuration management, and task automation. It allows the user to write "playbooks" that automate the process of setting up an application.

Using these two tools together can make for a powerful combination. Terraform can be used to provision the infrastructure, and Ansible can be used to configure it. This setup is especially beneficial when dealing with large and complex infrastructure.

Getting started

Before we dive into combining Terraform and Ansible, let's first get familiar with both tools.

Terraform

Terraform uses a domain-specific language (DSL) called HashiCorp Configuration Language (HCL) to define infrastructure resources. With HCL, you can define resources such as virtual machines, load balancers, and storage accounts. Terraform then interprets the HCL and creates the necessary resources in your cloud provider.

Let's take a look at a simple Terraform file:

# main.tf

provider "aws" {
  region = "us-east-1"
}

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

  tags = {
    Name = "example-instance"
  }
}

In this file, we're defining an AWS provider and an EC2 instance resource. We're using the aws_instance resource to create a new EC2 instance with the specified AMI and instance type. We're also adding a tag to the instance with the name "example-instance".

To run this Terraform file, we need to initialize Terraform in the directory and then apply the changes:

terraform init
terraform apply

Terraform will then create the AWS resources specified in the main.tf file.

Ansible

Ansible uses a YAML-based syntax to define tasks, which are then executed on one or more remote hosts. The tasks can range from installing packages, configuring the host, and deploying an application.

Let's take a look at a simple Ansible playbook:

# main.yml

---

- hosts: web
  become: true

  tasks:
  - name: install nginx
    apt:
      name: nginx
      state: present

  - name: copy nginx config
    copy:
      src: nginx.conf
      dest: /etc/nginx/nginx.conf

  - name: start nginx
    service:
      name: nginx
      state: started

In this playbook, we're installing nginx on the remote host, copying an nginx configuration file, and then starting the nginx service. We're assuming that we've already defined the remote host in Ansible's inventory file.

To run this Ansible playbook, we need to run the following command:

ansible-playbook main.yml -i inventory

The -i flag specifies the inventory file that contains the remote host information.

Combining Terraform and Ansible

Now that we're familiar with both Terraform and Ansible, let's talk about how to combine them.

Using Terraform to provision the infrastructure

The first step in combining Terraform and Ansible is to use Terraform to provision the infrastructure. This means defining the resources that will be used by Ansible to configure the host(s).

Let's say we want to create an EC2 instance and install nginx on it using Ansible. We can create a Terraform file that defines the EC2 instance, and then use an Ansible provisioner to configure the instance.

Here's an example Terraform file:

# main.tf

provider "aws" {
  region = "us-east-1"
}

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

  tags = {
    Name = "example-instance"
  }

  provisioner "ansible" {
    playbook_file = "./ansible/main.yml"
    inventory_file = "./ansible/inventory"
  }
}

In this Terraform file, we're creating an AWS provider and an EC2 instance resource. We're also adding an Ansible provisioner to the instance with the location of the playbook and inventory files.

We're assuming that we've created the main.yml and inventory files in the ./ansible/ directory. We'll create those files in the next section.

To run this Terraform file, we need to initialize Terraform in the directory and then apply the changes:

terraform init
terraform apply

Terraform will then create the AWS resources specified in the main.tf file, including the EC2 instance. Terraform will also use the Ansible provisioner to configure the instance using the main.yml playbook.

Using Ansible to configure the host

The second step in combining Terraform and Ansible is to use Ansible to configure the host. This means defining the tasks that will be executed on the host(s) created by Terraform.

Let's create the main.yml playbook that we referenced in the Terraform file:

# main.yml

---

- hosts: all
  become: true

  tasks:
  - name: install nginx
    apt:
      name: nginx
      state: present

  - name: copy nginx config
    copy:
      src: nginx.conf
      dest: /etc/nginx/nginx.conf

  - name: start nginx
    service:
      name: nginx
      state: started

In this playbook, we're installing nginx, copying the nginx configuration file, and starting the nginx service.

We're also specifying hosts: all, which means that this playbook can be used to configure any host that Ansible has access to. Terraform will automatically add the EC2 instance that we created to Ansible's inventory file, so we don't have to worry about manually adding it.

To run this playbook, we need to run the following command:

ansible-playbook main.yml

The playbook will be executed on the EC2 instance that was created by Terraform.

Folder Structure

Lastly, let's talk about the folder structure of the project.

Here's an example folder structure that we can use for combining Terraform and Ansible:

.
├── ansible
│   ├── inventory
│   ├── main.yml
│   └── nginx.conf
└── terraform
    ├── main.tf
    └── variables.tf

In this structure, we have two directories: ansible and terraform. The ansible directory contains the Ansible playbook, inventory file, and configuration file. The terraform directory contains the Terraform files that define the infrastructure.

Conclusion

By combining Terraform and Ansible, we can automate the entire process of setting up infrastructure and deploying applications. Terraform can be used to provision the resources, and Ansible can be used to configure them.

This setup can save time and increase efficiency, especially when dealing with large and complex infrastructure. With Terraform and Ansible, we can have a repeatable and reliable process for creating and configuring our infrastructure.

If you're new to Terraform or Ansible, don't worry. Both tools have extensive documentation and a large community of users, so there are plenty of resources available to help you get started.

Thank you for reading, and happy automating!

Editor Recommended Sites