Terraform import: uma ferramenta que o DevOps Engineer ama demais

Opa pessoal, novamente aqui e hoje trazendo conteúdo TOP demais, quando se fala em Terraform qualquer assunto é sensacional, porque estamos falando de infraestrutura como código, de automação, de Cloud e do que mais existe de avançado no momento para provisionamento de recursos em multicloud (AWS/Azure/GCP/DigitalOcean).

Bom, vamos diretamente ao que será proposto aqui nesse post, a ideia hoje é simples, vou mostrar como se usar o recurso de import do Terraform usando a Cloud da AWS no serviço S3. Vou criar manualmente, isso mesmo, do zero um bucket no serviço de storage no S3 e depois de criado vamos importar ele diretamente para o arquivo de estado, onde ele será gerenciado pelo Terraform.

E aí, afim de aprender mais essa!? COLA. ☕️

Criando manualmente o bucket no S3

Para não prolongar muito o post, vou deixar aqui a documentação do AWS S3 para que você possa executar a criação do seu lado de forma manual e testar depois usando o Terraform import. Assim que você criar o bucket, se liga na historinha abaixo do post, e deixa o bucket aí no jeito, que logo ele será utilizado.

Creating a bucket

Como era antes do DevOps Engineer

Para retratar nosso cenário, vamos supor que parte da infraestrutura esteja manual, ou seja, alguns recursos são gerenciados diretamente pela console da AWS, o profissional que esteve na linha de frente da infraestrutura, teve que criar o bucket manualmente e devido ao prazo apertado também acabou ficando dessa forma, não teve como automatizar ao longo do tempo.

Como ficou após o DevOps Engineer assumir

Eis que, é contratado um DevOps Engineer para suportar o ambiente de Cloud do cliente que roda na AWS, durante a entrevista, ele é notificado que alguns recursos da infraestrutura estão sendo gerenciados de forma manual, um exemplo é o próprio serviço AWS S3 e o gerente responsável informa que parte do trabalho dele é manter todos os serviços sendo gerenciados via infraestrutura como código, podendo utilizar qualquer ferramenta…

Passado algum tempo após a contratação e já tendo uma visão mais ampla sobre a arquitetura da infraestrutura, “o DevOps Enginner agenda uma reunião com o cliente e os gestores, para mostrar a ferramenta que ele pretende utilizar para provisionar e manter todos os recursos da Cloud via código (ele já estava pensando no Terraform 💜). Nessa apresentação ele cita as principais vantagens e os ganhos que a empresa terá utilizando o Terraform como ferramenta de infraestrutura como código.”.

Um pouco sobre o Terraform

Se liga nesse outro post que eu escrevi um tempo atrás sobre Terraform, aqui você aprenderá MUITO sobre como funciona, alguns comandos e saberá mais detalhes sobre a parte conceitual que é importante também.

(IaC) Parte 1: Criando uma instância EC2 na AWS usando Terraform

Contextualizando nosso cenário

Temos o nosso bucket criado de forma manual para exemplificar a história contada acima. O bucket que eu criei se chama amaury-teste-bucket-aws e sabemos que o DevOps Engineer fez uma talk mostrando qual ferramenta ele pretende utilizar e todos os possíveis detalhes dela (como funciona o Terraform, o que é, boas práticas e tudo mais).

AWS S3 Bucket

Principais comandos do Terraform

Sem mais delongas, abaixo vamos de fato usar alguns comandos para importar nosso recurso e depois aplicar diretamente na AWS.

terraform import

Nosso bucket não esta sendo gerenciado pelo Terraform, e qualquer alteração que eu precise fazer terá que ser manualmente e como bom profissional, o DevOps Engineer sabe que ele precisa do Terraform para manter versionada essa infraestrutura.

Para isso, vamos usar o recurso de import do Terraform, que será capaz de importar nosso bucket do S3 para dentro do state do Terraform e assim ser gerenciado de forma automatizada. Primeira coisa que devemos fazer é usar a documentação oficial do Terraform, lá explica da melhor maneira como podemos usar o recurso import do Terraform. Abaixo mostro o comando que eu utilizei para realizar o import do recurso do S3:

$ terraform import aws_s3_bucket.manually amaury-teste-bucket-aws
aws_s3_bucket.manually: Importing from ID "amaury-teste-bucket-aws"...
aws_s3_bucket.manually: Import prepared!
  Prepared aws_s3_bucket for import
aws_s3_bucket.manually: Refreshing state... [id=amaury-teste-bucket-aws]
Import successful!
The resources that were imported are shown above. These resources are now in
your Terraform state and will henceforth be managed by Terraform.

Pode verificar que ele mostra que nosso recurso foi importado com sucesso e ele também mostra na saída que fez o refresh do nosso state.

terraform console

Esse outro comando comprova que nosso bucket está sendo gerenciado pelo arquivo de estado do Terraform, basta executar o comando e depois escrever o nome do nosso recurso que ele nos mostra:

$ terraform console
> aws_s3_bucket.manually.bucket
“amaury-teste-bucket-aws”

terraform init

Agora que fizemos o import do nosso recurso, vamos iniciar o nosso projeto e baixar os plugins da AWS:

$ terraform init
Initializing the backend...
Initializing provider plugins...
- Reusing previous version of hashicorp/aws from the dependency lock file
- Using previously-installed hashicorp/aws v3.70.0
Terraform has been successfully initialized!
You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.
If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.

terraform plan

Hora de executar nosso plano antes de aplicar:

$ terraform plan
aws_s3_bucket.manual: Refreshing state... [id=devops-tutorials-files]
aws_s3_bucket.manually: Refreshing state... [id=amaury-teste-bucket-aws]
Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  ~ update in-place
  - destroy
Terraform will perform the following actions:
# aws_s3_bucket.manual will be destroyed
  - resource "aws_s3_bucket" "manual" {
      - arn                         = "arn:aws:s3:::devops-tutorials-files" -> null
      - bucket                      = "devops-tutorials-files" -> null
      - bucket_domain_name          = "devops-tutorials-files.s3.amazonaws.com" -> null
      - bucket_regional_domain_name = "devops-tutorials-files.s3.sa-east-1.amazonaws.com" -> null
      - hosted_zone_id              = "Z7KQH4QJS55SO" -> null
      - id                          = "devops-tutorials-files" -> null
      - region                      = "sa-east-1" -> null
      - request_payer               = "BucketOwner" -> null
      - tags                        = {} -> null
      - tags_all                    = {} -> null
- versioning {
          - enabled    = false -> null
          - mfa_delete = false -> null
        }
    }
# aws_s3_bucket.manually will be updated in-place
  ~ resource "aws_s3_bucket" "manually" {
      + acl                         = "private"
      + force_destroy               = false
        id                          = "amaury-teste-bucket-aws"
        tags                        = {}
        # (8 unchanged attributes hidden)
# (1 unchanged block hidden)
    }
Plan: 0 to add, 1 to change, 1 to destroy.

terraform apply

Aqui é onde vamos executar nosso apply para que nosso bucket seja gerenciado pelo Terraform:

$ terraform apply
aws_s3_bucket.manually: Refreshing state... [id=amaury-teste-bucket-aws]
No changes. Your infrastructure matches the configuration.
Terraform has compared your real infrastructure against your configuration and found no differences, so no changes are needed.
Apply complete! Resources: 0 added, 0 changed, 0 destroyed.

terraform destroy

Hora de destruir nossos recursos, pois não queremos ser cobrados por qualquer eventual custo do serviço do S3:

$ terraform destroy
aws_s3_bucket.manually: Refreshing state... [id=amaury-teste-bucket-aws]
Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  - destroy
Terraform will perform the following actions:
# aws_s3_bucket.manually will be destroyed
  - resource "aws_s3_bucket" "manually" {
      - acl                         = "private" -> null
      - arn                         = "arn:aws:s3:::amaury-teste-bucket-aws" -> null
      - bucket                      = "amaury-teste-bucket-aws" -> null
      - bucket_domain_name          = "amaury-teste-bucket-aws.s3.amazonaws.com" -> null
      - bucket_regional_domain_name = "amaury-teste-bucket-aws.s3.sa-east-1.amazonaws.com" -> null
      - force_destroy               = false -> null
      - hosted_zone_id              = "Z7KQH4QJS55SO" -> null
      - id                          = "amaury-teste-bucket-aws" -> null
      - region                      = "sa-east-1" -> null
      - request_payer               = "BucketOwner" -> null
      - tags                        = {} -> null
      - tags_all                    = {} -> null
- versioning {
          - enabled    = false -> null
          - mfa_delete = false -> null
        }
    }
Plan: 0 to add, 0 to change, 1 to destroy.
Do you really want to destroy all resources?
  Terraform will destroy all your managed infrastructure, as shown above.
  There is no undo. Only 'yes' will be accepted to confirm.
Enter a value: yes
aws_s3_bucket.manually: Destroying... [id=amaury-teste-bucket-aws]
aws_s3_bucket.manually: Destruction complete after 1s
Destroy complete! Resources: 1 destroyed.

Finalizando…

E aí pessoal, gostaram da história? Dessa vez acabei envolvendo uma role da nossa área para exemplificar melhor, foi um fato bem básico mesmo, na vida real sabemos que a pegada é outra.

Bom, espero que tenham gostado e aprendido pelo menos um pouco como se usa o recurso do terraform import , nos próximos posts eu volto com mais conteúdo de Terraform. Comentem abaixo se gostaram, se achou que algum ponto precisa ser melhorado e talz, por hoje é isso e até a próxima! Tmj!