Getting started with Terraform
Tags: terraform, docker
Published: 2020-02-18 08:09:49

---
title: Getting started with Terraform
published: true
date: 2019-10-10 00:00:00 UTC
tags: terraform, docker
canonical_url: https://owendavies.net/articles/getting-started-with-terraform/
---

Terraform allows you to setup Infrastructure as expressed by code, (Infrastructure As Code IaC). It’s platform independent, and supports a wide range of different things, from cloud providers like Azure, AWS, GCP, to databases to DNS, pretty much everything.

<!--more-->

# What we're going to do:

1. Install Terraform on Debian
2. Install Docker
3. Create a terraform script to download a docker image of jekyll
4. Modify our terraform script to spin up the jekyll container.

# Setting up your workstation

I’m using Debian 10 (buster) for my installation here but Terraform can literally be installed on anything since it is written in golang.

## Install Terraform

Download the most recent package for your operating system from [the terraform download page](https://www.terraform.io/downloads.html)

```
curl -O https://releases.hashicorp.com/terraform/0.12.10/terraform_0.12.10_linux_amd64.zip

```

## Unzip the package into our /usr/local/bin to install it locally

```
sudo unzip terraform_0.11.10_linux_amd64.zip -d /usr/local/bin

```

## Confirm it’s working

Now lets run the following command to check that it’s working and available

```
terraform -version

```

You should receive the following version output _Terraform v0.12.10_

![Terraform version](terraform-getting-started/terraform-version.png)

As you can see Terraform is still not at version 1, it’s still in beta and is in active development and each version can and has change quite drastically. So just be aware of this.

# Install Docker

If you already have docker installed locally you can skip these steps

Install the prerequisites to add a new repository over https

```
sudo apt-get update && apt-get install apt-transport-https ca-certificates curl software-properties-common

```

Import the GPG key from docker

```
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -

```

Add the docker apt repository to our repository list

```
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"

```

update apt and install Docker CE

```
sudo apt-get update
sudo apt-get install docker-ce

```

# Creating our first Terraform script

## Pull a docker image from the Terraform Docker provider

### Create our new script

```
mkdir terraform-gettingstarted
touch main.tf

```

### Create the script content

Now open up the main.tf in your favourite text editor and add the following:

```
# Download the latest jekyll image
resource "docker_image" "image_id" {
  name = "jekyll:latest"
}                                 

```

### Initialise our Terraform directory

This command will initialise our directory by creating a .terraform directory. And download any providers that are necessary.

```
terraform init

```

This will download the terraform docker provider. The providers are stored in the .terraform directory. If you look in .terraform/plugins/linux\_amd64/ you will see the terraform provider.

### View the changes that will happen

```
terraform plan

```

By running _terraform plan_ we will see all the changes that are going to be applied.

### Run our new script

Once we have viewed the plan, and we are happy it isn’t doing something we didn’t expect we will run the following command:

```
terraform apply

```

This will download the docker image that we specified in the main.tf file.

### See what was applied

```
terraform show

```

This will return the docker image id that we asked it to download

# Interpolation syntax

Interpolational syntax is a way for you to reference variables and other objects from within your infrastructure.

The documentation on terraform.io explains this in depth. (Link)[https://www.terraform.io/docs/configuration/interpolation.html]

## Create a docker container of the image

Let’s add to our main.tf file and actually create a container using the image above, referenced with interpolation syntax

### Open main.tf and edit

Let’s go ahead and open the main.tf file that we created above, and add the following code below:

```
# Start the container
resource "docker_container" "container_id" {
  name = "blog"
  image = "${docker_image.image_id.latest}"
  ports {
    internal = "2368"
    external = "80"
  }
}

```

You can see the $ sign, this is how we are referencing the image above.

### Run our changes

Now lets view the plan of the changes by running the below:

```
terraform plan

```

You’ll see that it is referencing our id of our image

Now lets apply our changes

```
terraform apply

```

Now if you run:

```
docker ps -a

```

You will see our container is running with the ports open.

If you now browse to port 80 in a web browser you will see the jekyll blog setup.

## Clear terraform infrastructure

To remove all the infrastructure we just created above we can use the destroy command.

```
terraform destroy

```

It will tell you what you are about to destroy, and require you to type _yes_.