HowtoForge

Wie man den Terraform-Status in einem AWS S3 Bucket verwaltet

von ·

In diesem Artikel erfährst du, was ein Terraform-Status ist und wie du ihn in einem S3-Bucket verwaltest. Außerdem erfährst du, was ein „Lock“ in Terraform ist und wie du ihn implementierst. Dazu müssen wir ein S3 Bucket und eine DynamoDB Tabelle auf AWS erstellen.

Bevor wir fortfahren, wollen wir die Grundlagen von Terraform State und Lock verstehen.

  • Terraform State (terraform.tstate file):
    Die State-Datei enthält Informationen darüber, welche Ressourcen in den Terraform-Konfigurationsdateien definiert sind. Wenn du zum Beispiel eine EC2-Instanz mit terraform config erstellt hast, enthält die Statusdatei Informationen über die tatsächliche Ressource, die auf AWS erstellt wurde.
  • S3 als Backend, um die Statusdatei zu speichern:
    Wenn wir in einem Team arbeiten, ist es gut, die Terraform-Statusdatei aus der Ferne zu speichern, damit die Teammitglieder auf sie zugreifen können. Um den Status remote zu speichern, brauchen wir zwei Dinge: einen s3 Bucket, um die Statusdatei zu speichern und eine terraform s3 Backend Ressource.
  • Sperre:
    Wenn wir die Statusdatei aus der Ferne speichern, so dass viele Personen darauf zugreifen können, besteht die Gefahr, dass mehrere Personen gleichzeitig versuchen, Änderungen an der gleichen Datei vorzunehmen. Deshalb brauchen wir einen Mechanismus, der den Status „sperrt“, wenn er gerade von anderen Nutzern verwendet wird. Das können wir erreichen, indem wir eine DynamoDB-Tabelle erstellen, die Terraform verwenden kann.

Hier sehen wir uns alle Schritte an, angefangen bei der manuellen Erstellung eines S3-Buckets, über das Hinzufügen der erforderlichen Richtlinie bis hin zur Erstellung einer DynamoDB-Tabelle mit Terraform und der Konfiguration von Terraform zur Verwendung von S3 als Backend und DynamoDB zur Speicherung der Sperre.

Vorraussetzungen

  1. Grundlegendes Verständnis von Terraform.
  2. Grundlegendes Verständnis von S3 Bucket.
  3. Terraform muss auf deinem System installiert sein.
  4. AWS-Konto(Erstelle es, wenn du noch keines hast).
  5. ‚access_key‘ & ’secret_key‘ eines AWS IAM-Benutzers. (Klicke hier, um zu lernen, wie du einen IAM-Benutzer mit ‚access_key‘ & ’secret_key‘ auf AWS anlegst).

Was wir tun werden

  1. Ein S3 Bucket erstellen und ihm eine Richtlinie zuweisen.
  2. Eine DynamoDB-Tabelle mit Terraform erstellen
  3. Erstelle eine EC2-Instanz mit Hilfe der Terraform-Konfigurationsdateien.
  4. Lösche die erstellte EC2-Instanz mit Terraform.

Erstelle ein S3 Bucket und füge ihm eine Policy hinzu.

Klicke hier, um zu erfahren, wie du ein S3 Bucket auf einem AWS-Konto erstellst. Sobald du einen Bucket erstellt hast, füge die folgende Richtlinie hinzu.

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

Konfiguriere „AWS_ACCESS_KEY_ID“ und „AWS_SECRET_ACCESS_KEY“ so, dass du über die CLI auf dein Konto zugreifen kannst.

Verwende den folgenden Befehl, um die Werte von „AWS_ACCESS_KEY_ID“ und „AWS_SECRET_ACCESS_KEY“ zu exportieren

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

Sobald du deine Zugangsdaten konfiguriert hast, kannst du sie einfach testen, indem du die Buckets mit dem folgenden Befehl auflistest.

aws s3 ls

Erstelle eine DynamoDB-Tabelle mit Terraform

Erstelle die Datei „variables.tf“, die die erforderlichen Variablen für die Deklaration enthält.

vim variables.tf

variable "region" {
     description = "Region of AWS VPC"
}

Erstelle „main.tf“, die für die Erstellung einer DynamoDB-Tabelle verantwortlich ist. main.tf liest die Werte der Variablen aus variables.tf. Diese Tabelle wird verwendet, um die Sperre zu speichern.

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

Der erste Befehl, der verwendet wird, ist „terraform init“. Dieser Befehl lädt die Plugins für die in der Konfiguration verwendeten Anbieter herunter und installiert sie. In unserem Fall ist es AWS.

terraform init

Der zweite Befehl ist „terraform plan“. Dieser Befehl wird verwendet, um die Änderungen zu sehen, die an der Infrastruktur vorgenommen werden.

terraform plan

Der Befehl ‚terraform apply‘ erstellt die Ressourcen auf der AWS, die in der Datei main.tf angegeben sind. Du wirst aufgefordert, deine Daten einzugeben, um die Ressourcen zu erstellen.

terraform apply

Jetzt kannst du im DynamoDB Dashboard auf der Konsole überprüfen, ob die Tabelle erstellt wurde oder nicht.

Bis zu diesem Zeitpunkt haben wir einen S3-Bucket manuell über die S3-Konsole und eine DynamoDB-Tabelle mit Terraform erstellt. Wir haben das S3 Bucket nicht als Backend konfiguriert, um den Status zu speichern, und die DynamoDB Tabelle, um die Sperre zu speichern.

Um unser Ziel zu erreichen, müssen wir unsere Terraform main.tf Datei ändern. Nachdem wir den Code geändert und ausgeführt haben, wird unser bereits vorhandener lokaler Status in das S3 Backend kopiert.

Aktualisiere unsere bestehende main.tf mit dem folgenden Code.

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

Wenn du jetzt den Befehl „terraform plan“ versuchst, um zu sehen, welche neue Ressource erstellt wird, schlägt der Befehl mit der folgenden Fehlermeldung fehl.

Du wirst aufgefordert, das Backend neu zu initialisieren.

Um das Backend neu zu initialisieren, verwende den Befehl „terraform init“. Bei diesem Schritt wird deine lokale Statusdatei in den S3 Bucket kopiert.

terraform init

Nach der Ausführung des „terraform init“-Befehls kannst du die Ausgabe im folgenden Screenshot sehen: Terraform wurde aktiviert, um die DynamoDb-Tabelle zum Erfassen der Sperre zu verwenden. Sobald das Locking aktiviert ist, können keine zwei gleichen Operationen auf derselben Ressource parallel durchgeführt werden.

Du kannst von der AWS-Konsole aus das S3 Dashboard aufrufen, um zu sehen, ob der terraform.tfstate kopiert wurde oder nicht.

Jetzt kannst du wieder eine neue Ressource erstellen und sehen, dass der Status im S3 Bucket gespeichert wird. Um eine neue DynamoDB-Testtabelle zu erstellen, aktualisiere die Datei main.tf mit dem folgenden Code.

vim main.tf

variable "region" {
     description = "Region of AWS VPC"
}

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

Diesmal ist es nicht nötig, „terraform init“ auszuführen, da es keine Änderung im Backend des Providers gibt.

Du kannst einfach den Befehl „terraform plan“ verwenden, um zu sehen, welche neuen Ressourcen erstellt werden.

terraform plan

Führe nun den folgenden Befehl aus, um eine neue DynamoDb-Testtabelle zu erstellen.

terraform apply

Im obigen Screenshot kannst du sehen, dass das Locking aktiviert wurde und die .tfstate-Datei nach S3 kopiert wird.

In der Konsole kannst du nun sehen, dass die neue Tabelle erstellt wurde.

Wenn du die Ressource, die du mit Terraform erstellt hast, nicht mehr benötigst, kannst du sie mit dem folgenden Befehl löschen.

terraform zerstören

Sobald du die Ressourcen löschst, kannst du sehen, dass die Tabelle, die zum Sperren verwendet wurde, ebenfalls gelöscht wurde. Wenn du den S3 Bucket nicht mehr brauchst, kannst du ihn auch über die Konsole löschen.

Fazit

In diesem Artikel haben wir gelernt, dass es notwendig ist, einen Remote-Status und Locking in Terraform zu verwenden. Wir haben gesehen, wie wir ein S3 Bucket als Backend verwenden, um den Terraform-Status zu speichern, und eine DynamoDb-Tabelle, um das Locking zu aktivieren.

Das könnte dich auch interessieren …