Este artigo foi publicado originalmente em: https://www.concrete.com.br/2018/12/28/automotize-a-sua-infraestrutura-com-terraform/

***

Se você viu o filme “O Homem de Aço”, vai se lembrar da cena em que o general Zod quer ‘terraformar’ o planeta Terra em Krypton.

Bom, é exatamente isso que o Terraform faz. Brincadeiras à parte, vamos ver neste artigo como essa ferramenta funciona e porque tem tanta gente usando e falando sobre ela.

O Terraform transforma nosso ambiente da forma que desejarmos, por isso vem ganhando muito espaço no mundo DevOps: por conta do provisionamento de infraestrutura automatizada. Mas o que muitos ainda não sabem, é que ela vai além, já que têm outros recursos bem legais.

O que é?

Primeiramente, se você nunca ouviu falar, o Terraform é basicamente uma ferramenta para construir, alterar e configurar infraestrutura de maneira segura e eficiente. Ele é opensource e foi desenvolvido pela Hashicorp, empresa bem famosa por ter vários produtos/ferramentas amplamente usados pela comunidade DevOps, como Consul, Vault, Packer e Vagrant.

E se você não conhece nenhuma dessas ferramentas e quer conhecer, deixe aí nos comentários que faremos um artigo falando delas, que são muito boas para atender determinados cenários.

O Terraform dá suporte a quase todos os principais Providers de nuvem, citando os mais conhecidos: AWS, Google Cloud, Azure, Digital Ocean e etc.

Mas aí você pensa: “Ah, mas a AWS tem o CloudFormation e o Beanstalk, então por que eu usaria outra ferramenta?”. Não precisa responder – eu respondo por você, meu jovem.

A vantagem de usar o Terraform é que primeiro, como falamos anteriormente, ele é MultiCloud. Ou seja, conseguimos provisionar vários ambientes em diferentes provedores de nuvem usando uma única ferramenta.

Segundo, tanto o CloudFormation quanto o Beanstalk são serviços pagos na AWS e só funcionam na AWS. Sendo assim, se você migrar para uma outra nuvem, basicamente toda a sua infraestrutura automatizada estará “presa” na AWS, mas digo isso sem criticar os serviços, que são ótimos!

Outro benefício é a vantagem de não precisar aprender uma linguagem nova para criar a infraestrutura no Terraform. A Hashicorp criou a HCL (HashiCorp Configuration Language). Com isso, a ferramenta se tornou bem amigável e fácil de usar: você olha o código e sabe o que está sendo feito.

O Terraform também aceita o formato Json, mas o uso do HCL é fortemente recomendado, visto que você escreve bem menos código usando HCL e a chance de você esquecer uma chave na hora de criar o Json é grande.

Exemplo de arquivo .tf, extensão usada pelo Terraform para provisionamento de uma instância EC2.

# Create a new instance of the latest Ubuntu 14.04 on an
# t2.micro node with an AWS Tag naming it "HelloWorld"
provider "aws" {
  region = "us-west-2"
}
data "aws_ami" "ubuntu" {
  most_recent = true
  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-trusty-14.04-amd64-server-*"]
  }
  filter {
    name   = "virtualization-type"
    values = ["hvm"]
  }
  owners = ["099720109477"] # Canonical
}

resource "aws_instance" "web" {
  ami           = "${data.aws_ami.ubuntu.id}"
  instance_type = "t2.micro"
  tags = {
    Name = "HelloWorld"
  }
}

Quando falei código, deve ter Sysadmin que ficou com os cabelos em pé, né? É desejável para uma melhor utilização da ferramenta que se conheça um pouco de lógica de programação.

Isso vai ajudar bastante na hora de usar os recursos avançados do Terraform ou ambientes mais complexos que demandem a criação e a dependência de vários objetos. Mas é bem tranquilo, não se assustem.

Um exemplo: vou subir uma aplicação e preciso criar um load balance com autoscale para fazer o balanceamento das aplicações e preciso criar antes o banco de dados para que a minha aplicação suba sem problemas.

Este é só um exemplo de uma infraestrutura que podemos pressionar de maneira automatizada usando a ferramenta.

Infrastructure as code (IAC)

Quando utilizamos qualquer ferramenta ou script que vai provisionar de maneira automatizada nosso ambiente e vamos declarar/escrever isso em um arquivo, estamos falando de infraestrutura como código IAC. Seguindo essa abordagem, ganhamos várias vantagens:

• Documentação da infraestrutura
• Versionamento da infraestrutura
• Garantia da integridade e estado desejado da infraestrutura (Infraestrutura Imutável)
• Automatização do build da infra no Pipeline
• Garantia do mesmo resultado todas as vezes que rodar o script – o resultado será sempre o mesmo (idempotência)
• Redução de erros humanos
• Não há retrabalho: você faz apenas uma vez
• Pode ser usada em conjunto com Ansible, Chef ou Puppet, etc

E a lista só aumenta, mas acho que já te convenci de usar o Terraform.

Preparei um repositório onde podemos brincar à vontade com o Terraform, sem a necessidade de criar uma conta na AWS, Google ou Azure. E o melhor: vamos fazer isso a 0800!

Coisas legais que conseguimos fazer no Terraform

Antes, uma dica rápida: atualmente trabalho em um projeto no qual utilizamos o Gitlab e trabalhamos com microsserviços, ou seja, sempre que criamos um serviço novo temos que criar um novo repositório no Gitlab, e isso com o tempo fica tedioso, monótono, chato e muito repetitivo – acho que você já entendeu.

E eu nem preciso falar que já temos a ferramenta para resolver isso, né? O Terraform consegue fazer isso pra nós.

Neste link da documentação tem o que precisamos configurar para fazer o provisionamento de repositórios no Gitlab de maneira automatizada, mas depois você olha isso – agora vamos para a demo!

Demo Terraform

Agora vem a parte legal. Veremos se esse Terraform é bom mesmo. Toda abordagem da demo que vou usar aqui neste artigo está aqui.

Play with Docker (PWD)

Vamos usar o PWD para não precisar instalar nada na nossa máquina e poder executar em qualquer lugar, desde que tenha acesso à Internet e um browser.

Observação: esse vai ser o ambiente que vamos usar para o lab. Logo, é necessário ter uma conta no GitHub ou Dockerhub para logar no PWD.

Depois de logar precisaremos lançar uma instância. Lembrando que o PWD fornece uma janela de quatro horas para usar o ambiente. Após esse período a sessão expira e o conteúdo criado nessa instância é destruído, mas não vamos demorar nem cinco minutos pra subir nosso ambiente, fiquem tranquilos.

Instalando o Terraform no Play With Docker

Todos os passos a seguir serão executados no terminal da instância do PWD.

Copie e cole os comandos a seguir no terminal:

wget https://releases.hashicorp.com/terraform/0.11.8/terraform_0.11.8_linux_amd64.zip
unzip terraform_0.11.8_linux_amd64.zip
mv terraform /bin/
terraform

Essa sequência de comandos vai baixar o Terraform com o Wget, e em seguida vamos descompactar o arquivo zip com unzip e mover para o diretório /bin. Após isso, o último comando vai checar se o Terraform está instalado.

A saída do comando deve ser igual a dessa da imagem:

Clonando o repositório do Lab

Após o Terraform estar devidamente instalado, vamos clonar o repositório onde tem o arquivo da infra que vamos criar usando o Terraform. Em seguida, entraremos na pasta onde se encontra o código do Terraform mais.tf que vamos usar para buildar e fazer o deploy da nossa infra.

git clone https://gitlab.com/cristianvitortrucco/terraform-docker

cd terraform-docker

Dica rápida

Use o Vscode e instale os plugins do Terraform para deixar ainda melhor a experiência de criar sua infraestrutura de forma fácil, rápida e com qualidade, usando esses recursos muito bacanas que o Vscode oferece.

O que estamos fazendo neste Lab?

O que esse código (main.tf) acima está fazendo, exatamente: ele vai subir um container Docker usando o provider “local”. Ou seja, ele vai usar a máquina onde estamos rodando o Terraform “localhost”. Lembrando que a instância do PWD já tem o Docker instalado. Logo, se for rodar esse código na máquina se certifique de que o Docker está lá.

Vamos usar a imagem docker (pengbai/docker-supermario) que está declarada no fim do arquivo, mapeando a porta do Host da 8080 para 8080 do container.

Rodando o Terraform

O comando a seguir vai inicializar o projeto no Terraform e, automaticamente, baixar os plugins necessários para que o Terraform consiga interagir com a API do Docker.

terraform init

O comando a seguir “plan” vai verificar o que o Terraform vai fazer. É uma prévia do que o Terraform vai provisionar, então é nesse momento que conferimos se está tudo ok conforme declaramos no código.

terraform plan

Outra coisa legal é que o Terraform informa que vai criar determinado recurso por meio do sinal de “+”.

Após verificar a saída, o comando “apply” vai construir a infraestrutura declarada no arquivo main.tf.

terraform apply

Agora é só confirmar com “yes” para realizar o deploy e construir, de fato, a nossa infra.

Depois disso, o painel do PWD vai expor a porta 8080, então vamos clicar e acessar o link para chegar no container (Aplicação). Vale lembrar que essa porta é aquela que declaramos no Terraform.

Agora que você já estudou e aprendeu um conteúdo novo, podemos fazer uma pausa e jogar esse jogo do Mario rodando diretamente no container Docker que acabamos de provisionar com o Terraform:

terraform destroy

Na saída do comando, confirme com “yes” para que o Terraform destrua a infra declarada no arquivo main.tf. Uma outra coisa legal é que o Terraform mostra por meio de cores e sinais o que ele vai fazer no ambiente.

Por exemplo: quando vai destruir um recurso, ele o coloca em vermelho junto ao sinal de subtração “-”, informando que aquele recurso declarado no arquivo vai ser excluído.

Conclusão

O legal disso tudo é que não usamos nenhum comando do Docker – tudo foi feito de maneira automatizada usando o Terraform. E isso é só o básico! No site do Terraform eles fazem um overview bem legal sobre a ferramenta.

A documentação oficial está disponível neste link e o treinamento Katacoda 0800, aqui. Este último link apresenta três cenários ensinando a usar o Terraform – ideal para quem está começando com a ferramenta.

Legal, né?

Deixe um comentário logo abaixo dizendo se o conteúdo ajudou em alguma coisa.

Obrigado e até logo!