Como Gerenciar o Estado do Terraform em um Bucket S3 da AWS

Neste artigo, veremos o que é um estado do Terraform e como gerenciá-lo em um Bucket S3. Também veremos o que é “lock” no Terraform e como implementá-lo. Para implementar isso, precisamos criar um Bucket S3 e uma Tabela DynamoDB na AWS.

Antes de prosseguir, vamos entender os conceitos básicos do estado do Terraform e do Lock.

• Estado do Terraform (arquivo terraform.tstate):
  O arquivo de estado contém informações sobre quais recursos existem definidos nos arquivos de configuração do terraform. Por exemplo, se você criou uma Instância EC2 usando a configuração do terraform, então o arquivo de estado contém informações sobre o recurso real que foi criado na AWS.
• S3 como um Backend para armazenar o arquivo de estado:
  Se estamos trabalhando em equipe, então é bom armazenar o arquivo de estado do terraform remotamente para que as pessoas da equipe possam acessá-lo. Para armazenar o estado remotamente, precisamos de duas coisas: um bucket s3 para armazenar o arquivo de estado e um recurso de backend s3 do terraform.
• Lock:
  Se armazenamos o arquivo de estado remotamente para que muitas pessoas possam acessá-lo, corremos o risco de várias pessoas tentarem fazer alterações no mesmo arquivo ao mesmo tempo. Portanto, precisamos ter um mecanismo que “trave” o estado se ele estiver sendo usado por outros usuários. Podemos conseguir isso criando uma tabela dynamoDB para o terraform usar.

Aqui, veremos todas as etapas desde a criação manual de um Bucket S3, adicionando a política necessária a ele, criando a Tabela DynamoDB usando o Terraform e configurando o Terraform para usar o S3 como um Backend e o DynamoDB para armazenar o lock.

Pré-requisitos

1. Compreensão básica do Terraform.
2. Compreensão básica do Bucket S3.
3. Terraform instalado em seu sistema.
4. Conta AWS (Crie se você não tiver uma).
5. ‘access_key’ & ‘secret_key’ de um Usuário IAM da AWS. (Clique aqui para aprender a criar um usuário IAM com ‘access_key’ & ‘secret_key’ na AWS, )

O que faremos

1. Criar um Bucket S3 e anexar uma política a ele.
2. Criar uma Tabela DynamoDB usando o Terraform
3. Criar uma EC2 usando os arquivos de configuração do Terraform.
4. Excluir a instância EC2 criada usando o Terraform.

Criar um Bucket S3 e anexar uma política a ele.

Clique aqui para aprender a criar um Bucket S3 na Conta AWS. Depois de criar um Bucket, anexe a seguinte Política a ele.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "Stmt1560164441598",
            "Effect": "Allow",
            "Principal": "*",
            "Action": [
                "s3:PutObject*",
                "s3:List*",
                "s3:Get*",
                "s3:Delete*"
            ],
            "Resource": [
                "arn:aws:s3:::state-lock-rahul",
                "arn:aws:s3:::state-lock-rahul/*"
            ]
        }
    ]
}

Configure “AWS_ACCESS_KEY_ID” e “AWS_SECRET_ACCESS_KEY” para que você possa acessar sua conta a partir da CLI.

Use o seguinte comando para exportar os valores de “AWS_ACCESS_KEY_ID” e “AWS_SECRET_ACCESS_KEY”

export AWS_ACCESS_KEY_ID=AKIAQ6GAIA5XC2XMMM7W
export AWS_SECRET_ACCESS_KEY=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
echo $AWS_ACCESS_KEY_ID
echo $AWS_SECRET_ACCESS_KEY

Depois de configurar suas credenciais, você pode simplesmente testá-las listando os buckets usando o seguinte comando.

aws s3 ls

Criar uma Tabela DynamoDB usando o Terraform

Crie ‘variables.tf’ que contém a declaração das variáveis necessárias.

vim variables.tf

variable "region" {
     description = "Região do VPC da AWS"
}

Crie ‘main.tf’ que é responsável por criar uma Tabela DynamoDB. Este main.tf lerá os valores das variáveis do variables.tf. Esta tabela será usada para armazenar o lock.

provider "aws" {
      region     = "${var.region}"
}  
resource "aws_dynamodb_table" "terraform_locks" {  
  name         = "rahul-test-dynamodb-table"  
  billing_mode = "PAY_PER_REQUEST"  
  hash_key     = "LockID"  
  attribute {  
    name = "LockID"  
    type = "S"  
  }  
}

O primeiro comando a ser usado é ‘terraform init’. Este comando baixa e instala plugins para provedores usados dentro da configuração. No nosso caso, é a AWS.

* terraform init*

O segundo comando a ser usado é ‘terraform plan’. Este comando é usado para ver as mudanças que ocorrerão na infraestrutura.

terraform plan

O comando ‘terraform apply’ criará os recursos na AWS mencionados no arquivo main.tf. Você será solicitado a fornecer sua entrada para criar os recursos.

terraform apply

Agora, você pode ir ao Painel do DynamoDB no console para verificar se a Tabela foi criada ou não.

Até este ponto, criamos um Bucket S3 manualmente a partir do Console S3 e uma Tabela DynamoDB usando o Terraform. Não configuramos o Bucket S3 como um Backend para armazenar o estado e a Tabela DynamoDB para armazenar o lock.

Para alcançar nosso objetivo, precisamos modificar nosso arquivo main.tf do Terraform. Após modificar o código e executá-lo, nosso estado local pré-existente será copiado para o Backend S3.

Atualize nosso main.tf existente com o seguinte código.

vim main.tf

provider "aws" {
      region     = "${var.region}"
}
 
terraform {
  backend "s3" {
    bucket         = "state-lock-rahul"
    key            = "test/terraform.tfstate"
    region         = "eu-west-3"
    dynamodb_table = "rahul-test-dynamodb-table"
  }
}
 
resource "aws_dynamodb_table" "terraform_locks" {
  name         = "rahul-test-dynamodb-table"
  billing_mode = "PAY_PER_REQUEST"
  hash_key     = "LockID"
  attribute {
    name = "LockID"
    type = "S"
  }
}

Agora, se você tentar o comando “terraform plan” para ver quais novos recursos serão criados, o comando falhará com o seguinte erro.

Você será solicitado a re-inicializar o backend.

Para re-inicializar o backend, use o comando “terraform init”. Neste passo, seu arquivo de estado local será copiado para o Bucket S3.

terraform init

Você pode observar a saída conforme mostrado na captura de tela abaixo após executar o comando “terraform init”, o Terraform foi habilitado para usar a Tabela DynamoDB para adquirir o lock. Uma vez que o Locking está habilitado, não é possível realizar duas operações iguais no mesmo recurso em paralelo.

Você pode ir ao Painel S3 do Console AWS para ver se o terraform.tfstate foi copiado ou não.

Agora, novamente você pode criar um novo recurso e ver que o estado será armazenado no Bucket S3. Para criar uma nova tabela de teste DynamoDB, atualize o arquivo main.tf com o seguinte código.

vim main.tf

variable "region" {
     description = "Região do VPC da AWS"
}

Rahuls-MacBook-Pro:terraform rahul$ cat main.tf 
provider "aws" {
      region     = "${var.region}"
}


tf {
  backend "s3" {
    bucket         = "state-lock-rahul"
    key            = "test/terraform.tfstate"
    region         = "eu-west-3"
    dynamodb_table = "rahul-test-dynamodb-table"
  }
}

resource "aws_dynamodb_table" "terraform_locks" {
  name         = "rahul-test-dynamodb-table"
  billing_mode = "PAY_PER_REQUEST"
  hash_key     = "LockID"
  attribute {
    name = "LockID"
    type = "S"
  }
}


resource "aws_dynamodb_table" "test-table" {
  name         = "rahul-test-table"
  billing_mode = "PAY_PER_REQUEST"
  hash_key     = "LockID"
  attribute {
    name = "LockID"
    type = "S"
  }
}

Desta vez, não há necessidade de executar “terraform init” uma vez que não há mudança no Backend para o Provedor.

Você pode apenas usar o comando “terraform plan” para ver quais novos recursos serão criados.

terraform plan

Agora, execute o seguinte comando para criar uma nova Tabela de Teste DynamoDb.

terraform apply

Na captura de tela acima, você pode ver que o Locking foi habilitado, o arquivo .tfstate está sendo copiado para o S3.

Agora, no console você pode ver que a nova tabela foi criada

Agora, se você não precisar mais do recurso que criou usando o Terraform, use o seguinte comando para excluir os recursos.

terraform destroy

Assim que você excluir os recursos, poderá ver que a tabela que estava sendo usada para o lock também foi excluída. Se você não precisar do Bucket S3 também, pode excluí-lo do console.

Conclusão

Neste artigo, aprendemos sobre a necessidade de usar um estado remoto e locking no Terraform. Vimos os passos para usar o Bucket S3 como um Backend para armazenar o Estado do Terraform e a Tabela DynamoDb para habilitar o Locking.