Terraform: O que é e boas práticas

Existem muitas ferramentas dentro do universo do Infrastructure as Code (IaC), mas uma das preferidas é a Terraform.

Este artigo tem o objetivo de apresentar o que é o Terraform e as melhores práticas de uso da ferramenta.

Muitas dessas boas práticas são oficiais, oferecidas pela própria Hashicorp, fabricante do produto. Entretanto, outras são práticas que reconhecemos como boas ao longo baseadas em anos de utilização desta ferramenta. Vamos lá:

Afinal, o que é Terraform?

A ascensão das clouds públicas – como AWS, Azure e GCP – trouxe uma nova tendência muito citada quando o assunto é DevOps, que é a Infrastructure as Code (IaC).

Ferramentas como SaltStack, CloudFormation, Chef, Puppet, Vagrant, CFEngie e outras surgiram quase que simultaneamente. Mas nos dias de hoje, uma das ferramentas que a comunidade mais tem usado é o Terraform.

Como descrito em seu próprio site (em tradução livre), o Terraform é uma ferramenta para construção, manutenção e versionamento de infraestrutura de forma segura e eficiente. O Terraform pode gerenciar tanto provedores públicos quanto privados.

Boas práticas para trabalhar com o Terraform

Uma ferramenta tão relevante como o Terraform possui diversos usos e boas práticas. A seguir, vamos listar algumas delas.

1) Rode o comando terraform com ’var-file’

Com o var-file, você consegue gerenciar ambientes de forma mais fácil e evita uma longa lista de pares chave-valor para as variáveis ( -var chave=valor), transformando o comando em algo quase ilegível. Por exemplo:

$ cat config/dev.tfvars
name = "dev-stack"
s3_terraform_bucket = "dev-stack-terraform"
tag_team_name = "hello-world"
$ terraform plan -var-file=config/dev.tfvars

2) Sempre use backends para gerenciar os tfstates

Todas as vezes que recursos são criados via ‘terraform apply’, o arquivo tfstate é criado ou modificado. Se recursos são modificados ou novo recursos são adicionados, o tfstate é atualizado.

Em um time, vários membros podem modificar o código terraform. Logo, para manter o mesmo tfstate, deve-se usar um backend. Recomendamos mantê-lo em um S3 bucket.

3) Ative o controle de versão nos buckets dos tfstates

Sempre ative o versionamento do bucket S3 de backend. Dessa forma, você conseguirá acompanhar com mais precisão o que foi alterado (e quando) na infraestrutura. 

4) Nunca commit em seu repositório o tfstate

O tfstate armazena informações de mapeamento entre os recursos que você criou e sua real infraestrutura. Comitar estes arquivos gera vários riscos, tais como, por exemplo:

– Você pode estar expondo configurações de aplicação, passwords, string de conexões com bancos etc.

– Você pode estar executando um tfstate obsoleto ou antigo que ficou commitado.

5) Execute o Terraform em builds automatizados

Rodar código em uma ferramenta de build automatizado tem várias vantagens, que incluem ter um processo repetível e histórico de mudanças.

O conceito de build é bem útil quando aplicado ao Terraform, garantindo mais visibilidade sobre o que e quando foi alterado na infraestrutura (para auditoria ou mesmo, debug)

6) Não altere o tfstate manualmente (sempre use o CLI)

Quando quiser mover ou remover algum estado, não fique tentado a se aventurar pelo ftstate. É perfeitamente possível fazer a alteração manual, mas o tfstate pode se tornar um arquivo muito complexo e caótico.

A melhor forma é utilizar o CLI do Terraform, que lhe provê comandos como ‘terraform state rm’ e ‘terraform state mv’.

7) Ative o DEBUG quando precisar de troubleshooting

Às vezes, as mensagens de erro do Terraform podem ser bem incompreensíveis. Por isso, para facilitar o troubleshooting, ative o DEBUG do log do Terraform. 

Basta alterar o valor da variável de ambiente TF_LOG. Por exemplo: TF_LOG=DEBUG && terraform plan

8) Use o ‘terraform import’ para importar recursos

Recursos que já foram codificados não têm a necessidade de serem refeitos. Evite retrabalho.

9) Evite configurações ‘hard coded’ sempre que possível

Dentre as razões, podemos listar as várias formas de quebra de segurança e também dificuldade de editar essas configurações.

Algumas informações, como account id, account alias e region podem ser obtidas via data sources. Por exemplo:

data "aws_caller_identity" "current" {}
data "aws_iam_account_alias" "current" {}
data "aws_region" "current" {}

locals {
   account_id = data.aws_caller_identity.current.account_id
   account_alias = data.aws_iam_account_alias.current.account_alias
   region = data.aws_region.current.name
}

10) Use o ‘terraform fmt’

Sempre rode ‘terraform fmt’ para manter seus arquivos de configuração formatados. Você pode inclusive colocar a execução do ‘terraform fmt’ na sua esteira de CI/CD, sempre que for fazer o merge para o master. Por exemplo:

terraform validate
terraform fmt -check=true -write=false -diff=true

11) Use módulos compartilhados

Não há necessidade de ficar reescrevendo código. Por isso, utilizar módulos no terraform irá lhe poupar algumas boas horas de programação.

Para mais detalhes de como usar os módulos compartilhados, seguem alguns links de referência:

• Terraform module usage
• Terraform Module Registry
• Terraform aws modules

12) Atualize sempre a versão do Terraform

A Hashicorp nem sempre segue de perto as regras de versionamento semântico. Sem contar que novas funcionalidades liberadas pelos cloud provider podem não funcionar em versões antigas do Terraform, mesmo atualizando os plugins.

13) Rode o Terraform a partir de um container

Existem containers oficiais de Terraform que você pode usar. Com isso, você controla de forma mais fácil e transparente qual versão do Terraform está usando. 

Para esteira CI/CD, é extremamente recomendado usar essas imagens. Exemplo de utilização:

$ TERRAFORM_IMAGE=hashicorp/terraform:0.12.3
$ TERRAFORM_CMD=`docker run -ti --rm -w /app -v ${HOME}/.aws:/root/.aws -v ${HOME}/.ssh:/root/.ssh -v `pwd`:/app -w /app $TERRAFORM_IMAGE`
$ `TERRAFORM_CMD` init
$ `TERRAFORM_CMD` plan

14) Use a variável ‘self’

A variável ‘self’, como na maioria das linguagens de programação, se refere ao próprio objeto. E, no caso do Terraform, se refere ao resource.

Logo, sempre que precisar de alguma informação do próprio objeto que se esteja manipulando, use a sintaxe self.<ATTRIBUTE>

Vale observar que a sintaxe self.<ATTRIBUTE> só é permitida dentro de provisioners. Por exemplo:

resource "aws_ecr_repository" "jenkins" {
   name = var.image_name
   provisioner "local-exec" {
     command = "./deploy-image.sh ${self.repository_url}"
  }
}

15) Use plugins pré-instalados

Há uma forma de usar plugins pré-instalados no Terraform em vez de baixá-los a cada ‘terraform init’. 

Você pode usar estes plugins colocando-os no mesmo diretório do binário do Terraform ou passando a flag -plugin-dir.  Entenda melhor neste link de referência. 

16) Use o locking of state file

O Terraform oferece uma forma de realizar uma prevenção de execuções paralelas em cima de um mesmo tfstate. Este locking ajuda a garantir que apenas um membro do time esteja alterando configurações da infraestrutura em um mesmo momento.

Esse locking ajuda a prever conflitos, perda de dados e evita que o tfstate fique corrompido.

O DynamoDB pode ser usado como o mecanismo de locking. A tabela precisa ter uma chave chamada LockID. Por exemplo:

resource “aws_dynamodb_table” “terraform_state_lock” {
    name = “terraform-lock”
    read_capacity = 5
    write_capacity = 5
    hash_key = “LockID”
    attribute {
        name = “LockID”
        type = “S”
    }
}

terraform {
    backend “s3” {
        bucket = “terraformbackend”
        key = “terraform”
        region = “us-east-2”
        dynamodb_table = “terraform-lock”
    }
}

17) Não coloque credenciais hard-coded

Colocar as credenciais no código é uma enorme quebra de segurança, principalmente se forem suas credenciais pessoais (e não de serviço). Para evitar isso, temos 2 soluções rápidas:

Environment variables:

$ export AWS_ACCESS_KEY_ID=”accesskey”
$ export AWS_SECRET_ACCESS_KEY=”secretkey”
$ export AWS_DEFAULT_REGION=”us-west-2"
$ terraform plan

Shared credentials file:

provider “aws” {
    region = “sa-east-1”
    shared_credentials_file = “/Users/tf_user/.aws/creds”
    profile = “myprofile”
}

18) Gere o README para cada módulo com inputs e outputs

Um módulo bem documentado tem muito mais chances de ser utilizado. E você nem ao menos precisa gerar a documentação manualmente. 

Uma ferramenta chamada ‘terraform-docs’ pode criar esta documentação para você. Para mais detalhes, verifique o repositório da ferramenta.

19) Conheça as built-in functions, aprenda algumas e use-as!

O Terraform provê várias built-in functions e algumas delas podem ser realmente muito úteis quando se está criando infraestruturas mais completas. 

Várias podem realmente valer a pena de serem estudadas. Algumas delas são: chomp, format, indent, join, regex, replace, split, trim, upper, concat, contain, list, map, sort, base64encode, abspath, basename, fileexits, dateformat, timestamp, base64sha256, md5, tobool, tonumber, tostring, cidrhost, cidrnetmask, cidrsubnet, dentre outras.

20) Conheças “side-tools”

O Terraform, como qualquer ferramenta, linguagem ou framework, tem várias ferramentas de terceiros que facilitam muito sua utilização. Conheça algumas e use as que preferir. Algumas delas são, por exemplo: 

• Atlantis; 
• Terragrunt; 
• Terraspace; 
• Terraform-docs.

21) Visite o site Terraform Best Practices

Uma boa fonte de boas práticas é o site voltado para boas práticas, Terraform Best Practices. Acessá-lo periodicamente pode ser muito útil, pois ele está sempre sendo atualizado à medida que novas versões surgem.

Conclusão

Agora que você sabe o que é Terraform e mais de 20 boas práticas sobre ele, tem tudo para mandar muito bem no seu próximo projeto!

Tem mais alguma dica de boa prática de Terraform? Então deixe sua dica nos comentários e ajude o próximo!

LEIA TAMBÉM: