Comment gérer l'état de Terraform dans un bucket S3 AWS

Dans cet article, nous allons voir ce qu’est un état Terraform et comment le gérer sur un bucket S3. Nous verrons également ce qu’est le “lock” dans Terraform et comment l’implémenter. Pour cela, nous devons créer un bucket S3 et une table DynamoDB sur AWS.

Avant de procéder, comprenons les bases de l’état Terraform et du Lock.

• État Terraform (fichier terraform.tstate) :
  Le fichier d’état contient des informations sur les ressources qui existent définies dans les fichiers de configuration terraform. Par exemple, si vous avez créé une instance EC2 en utilisant la configuration terraform, alors le fichier d’état contient des informations sur la ressource réelle qui a été créée sur AWS.
• S3 comme Backend pour stocker le fichier d’état :
  Si nous travaillons en équipe, il est bon de stocker le fichier d’état terraform à distance afin que les membres de l’équipe puissent y accéder. Pour stocker l’état à distance, nous avons besoin de deux choses : un bucket S3 pour stocker le fichier d’état et une ressource backend S3 terraform.
• Lock :
  Si nous stockons le fichier d’état à distance afin que plusieurs personnes puissent y accéder, nous risquons que plusieurs personnes tentent de modifier le même fichier en même temps. Nous devons donc avoir un mécanisme qui “verrouille” l’état s’il est actuellement utilisé par d’autres utilisateurs. Nous pouvons y parvenir en créant une table DynamoDB que Terraform utilisera.

Ici, nous verrons toutes les étapes, depuis la création manuelle d’un bucket S3, l’ajout de la politique requise, la création d’une table DynamoDB à l’aide de Terraform et la configuration de Terraform pour utiliser S3 comme Backend et DynamoDB pour stocker le lock.

Prérequis

1. Compréhension de base de Terraform.
2. Compréhension de base du bucket S3.
3. Terraform installé sur votre système.
4. Compte AWS (Créez-en un si vous n’en avez pas).
5. ‘access_key’ & ‘secret_key’ d’un utilisateur IAM AWS. (Cliquez ici pour apprendre à créer un utilisateur IAM avec ‘access_key’ & ‘secret_key’ sur AWS, )

Ce que nous allons faire

1. Créer un bucket S3 et y attacher une politique.
2. Créer une table DynamoDB à l’aide de Terraform.
3. Créer un EC2 en utilisant les fichiers de configuration Terraform.
4. Supprimer l’instance EC2 créée à l’aide de Terraform.

Créer un bucket S3 et y attacher une politique.

Cliquez ici pour apprendre à créer un bucket S3 sur le compte AWS. Une fois que vous avez créé un bucket, attachez la politique suivante.

{
    "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/*"
            ]
        }
    ]
}

Configurez “AWS_ACCESS_KEY_ID” et “AWS_SECRET_ACCESS_KEY” afin que vous puissiez accéder à votre compte depuis la CLI.

Utilisez la commande suivante pour exporter les valeurs de “AWS_ACCESS_KEY_ID” et “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

Une fois que vous avez configuré vos identifiants, vous pouvez simplement les tester en listant les buckets à l’aide de la commande suivante.

aws s3 ls

Créer une table DynamoDB à l’aide de Terraform

Créez ‘variables.tf’ qui contient la déclaration des variables requises.

vim variables.tf

variable "region" {
     description = "Région du VPC AWS"
}

Créez ‘main.tf’ qui est responsable de la création d’une table DynamoDB. Ce main.tf lira les valeurs des variables à partir de variables.tf. Cette table sera utilisée pour stocker le 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"  
  }  
}

La première commande à utiliser est ‘terraform init’. Cette commande télécharge et installe les plugins pour les fournisseurs utilisés dans la configuration. Dans notre cas, c’est AWS.

*terraform init

La deuxième commande à utiliser est ‘terraform plan’. Cette commande est utilisée pour voir les changements qui auront lieu sur l’infrastructure.

terraform plan

La commande ‘terraform apply’ créera les ressources sur AWS mentionnées dans le fichier main.tf. Vous serez invité à fournir votre entrée pour créer les ressources.

terraform apply

Maintenant, vous pouvez aller sur le tableau de bord DynamoDB dans la console pour vérifier si la table a été créée ou non.

Jusqu’à présent, nous avons créé un bucket S3 manuellement à partir de la console S3 et une table DynamoDB à l’aide de Terraform. Nous n’avons pas configuré le bucket S3 comme Backend pour stocker l’état et la table DynamoDB pour stocker le lock.

Pour atteindre notre objectif, nous devons modifier notre fichier main.tf de Terraform. Après avoir modifié le code et l’avoir exécuté, notre état local préexistant sera copié dans le Backend S3.

Mettez à jour notre main.tf existant avec le code suivant.

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"
  }
}

Maintenant, si vous essayez la commande “terraform plan” pour voir quelle nouvelle ressource sera créée, la commande échouera avec l’erreur suivante.

Vous serez invité à réinitialiser le backend.

Pour réinitialiser le backend, utilisez la commande “terraform init”. À cette étape, votre fichier d’état local sera copié dans le bucket S3.

terraform init

Vous pouvez observer la sortie comme indiqué dans la capture d’écran ci-dessous après avoir exécuté la commande “terraform init”, Terraform a été activé pour utiliser la table DynamoDB pour acquérir le lock. Une fois le verrouillage activé, aucune opération identique sur la même ressource ne peut être effectuée en parallèle.

Vous pouvez aller sur le tableau de bord S3 depuis la console AWS pour voir si le terraform.tfstate a été copié ou non.

Maintenant, vous pouvez à nouveau créer une nouvelle ressource et voir que l’état sera stocké dans le bucket S3. Pour créer une nouvelle table de test DynamoDB, mettez à jour le fichier main.tf avec le code suivant.

vim main.tf

variable "region" {
     description = "Région du VPC AWS"
}

Rahuls-MacBook-Pro:terraform rahul$ cat 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"
  }
}


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

Cette fois, il n’est pas nécessaire d’exécuter “terraform init” car il n’y a pas de changement dans le Backend par rapport au fournisseur.

Vous pouvez simplement utiliser la commande “terraform plan” pour voir quelles nouvelles ressources seront créées.

terraform plan

Maintenant, exécutez la commande suivante pour créer une nouvelle table de test DynamoDB.

terraform apply

Dans la capture d’écran ci-dessus, vous pouvez voir que le verrouillage a été activé, le fichier .tfstate est en cours de copie dans S3.

Maintenant, dans la console, vous pouvez voir que la nouvelle table a été créée.

Maintenant, si vous n’avez plus besoin de la ressource que vous avez créée à l’aide de Terraform, utilisez la commande suivante pour supprimer les ressources.

terraform destroy

Dès que vous supprimez les ressources, vous pouvez voir que la table qui était utilisée pour le verrouillage a également été supprimée. Si vous n’avez pas besoin du bucket S3 non plus, vous pouvez le supprimer depuis la console.

Conclusion

Dans cet article, nous avons appris la nécessité d’utiliser un état distant et le verrouillage dans Terraform. Nous avons vu les étapes pour utiliser un bucket S3 comme Backend pour stocker l’état de Terraform et une table DynamoDB pour activer le verrouillage.