Eine Einführung in Terraform für Einsteiger – Terraform Tutorial

Sie fragen sich, was Terraform ist? Lassen Sie uns das herausfinden.

Infrastructure as Code (IaC) ist eine weit verbreitete Terminologie unter DevOps-Experten. Es handelt sich dabei um den Prozess der Verwaltung und Bereitstellung der gesamten IT-Infrastruktur (die sowohl physische als auch virtuelle Maschinen umfasst) mithilfe von maschinenlesbaren Definitionsdateien. Es handelt sich dabei um einen softwaretechnischen Ansatz für den Betrieb. Er hilft bei der Automatisierung des gesamten Rechenzentrums mit Hilfe von Programmierskripten.

Bei all den Funktionen, die Infrastructure as Code bietet, gibt es zahlreiche Herausforderungen:

• Sie müssen lernen zu programmieren
• Sie wissen nicht, welche Auswirkungen die Änderungen haben.
• Sie müssen die Änderung rückgängig machen
• Sie können Änderungen nicht nachverfolgen
• Eine Ressource kann nicht automatisiert werden
• Mehrere Umgebungen für die Infrastruktur

Terraform wurde entwickelt, um diese Herausforderungen zu lösen.

Nachfolgend finden Sie einige der Vorteile der Verwendung von Terraform.

• Ermöglicht Orchestrierung, nicht nur Konfigurationsmanagement
• Unterstützt mehrere Anbieter wie AWS, Azure, GCP, DigitalOcean und viele mehr
• Bietet eine unveränderliche Infrastruktur, in der sich die Konfiguration reibungslos ändern lässt
• Verwendet eine leicht verständliche Sprache, HCL (HashiCorp Konfigurationssprache)
• Leicht auf jeden anderen Anbieter übertragbar
• Unterstützt eine reine Client-Architektur, so dass keine zusätzliche Konfigurationsverwaltung auf einem Server erforderlich ist

Terraform Kernkonzepte

Nachfolgend finden Sie die wichtigsten Konzepte/Terminologien, die in Terraform verwendet werden:

• Variablen: Auch als Eingabevariablen bezeichnet, handelt es sich um Schlüssel-Wert-Paare, die von Terraform-Modulen verwendet werden, um Anpassungen zu ermöglichen.
• Anbieter: Ein Plugin, das mit den APIs eines Dienstes interagiert und auf die zugehörigen Ressourcen zugreift.
• Modul: Es ist ein Ordner mit Terraform-Vorlagen, in dem alle Konfigurationen definiert sind
• Status: Er besteht aus zwischengespeicherten Informationen über die von Terraform verwaltete Infrastruktur und die zugehörigen Konfigurationen.
• Ressourcen: Bezieht sich auf einen Block von einem oder mehreren Infrastrukturobjekten (Compute-Instanzen, virtuelle Netzwerke usw.), die bei der Konfiguration und Verwaltung der Infrastruktur verwendet werden.
• Datenquelle: Sie wird von Providern implementiert, um Informationen über externe Objekte an Terraform zurückzugeben.
• Ausgabewerte: Dies sind Rückgabewerte eines Terraform-Moduls, die von anderen Konfigurationen verwendet werden können.
• Plan: Dies ist eine der Phasen, in denen festgelegt wird, was erstellt, aktualisiert oder zerstört werden muss, um vom realen/aktuellen Zustand der Infrastruktur zum gewünschten Zustand zu gelangen.
• Anwenden: Dies ist eine der Phasen, in denen die Änderungen am realen/aktuellen Zustand der Infrastruktur angewendet werden, um den gewünschten Zustand zu erreichen.

Terraform Lebenszyklus

Der Lebenszyklus von Terraform besteht aus init, plan, apply und destroy.

• Terraform init initialisiert das Arbeitsverzeichnis, in dem sich alle Konfigurationsdateien befinden
• Terraform plan wird verwendet, um einen Ausführungsplan zu erstellen, um den gewünschten Zustand der Infrastruktur zu erreichen. Es werden Änderungen an den Konfigurationsdateien vorgenommen, um den gewünschten Zustand zu erreichen.
• Terraform apply nimmt dann die im Plan definierten Änderungen an der Infrastruktur vor, und die Infrastruktur erreicht den gewünschten Zustand.
• Terraform destroy wird verwendet, um alle alten Infrastruktur-Ressourcen zu löschen, die nach der apply-Phase als “tainted” markiert sind.

Wie funktioniert Terraform?

Terraform besteht aus zwei Hauptkomponenten, die seine Architektur ausmachen:

• Terraform-Kern
• Anbieter

Terraform-Kern

Terraform Core verwendet zwei Eingabequellen, um seine Arbeit zu erledigen.

Die erste Eingabequelle ist eine Terraform-Konfiguration, die Sie als Benutzer konfigurieren. Hier legen Sie fest, was erstellt oder bereitgestellt werden muss. Und die zweite Eingabequelle ist ein Status, in dem Terraform den aktuellen Zustand der Infrastruktur festhält, wie sie derzeit eingerichtet ist.

Terraform Core nimmt also die Eingaben auf und erstellt einen Plan, was zu tun ist. Er vergleicht den aktuellen Zustand mit der Konfiguration, die Sie sich für das Endergebnis wünschen. Es findet heraus, was getan werden muss, um den gewünschten Zustand in der Konfigurationsdatei zu erreichen. Es findet heraus, was erstellt, was aktualisiert und was gelöscht werden muss, um die Infrastruktur zu erstellen und bereitzustellen.

Anbieter

Die zweite Komponente der Architektur sind Provider für bestimmte Technologien. Dies können Cloud-Anbieter wie AWS, Azure, GCP oder andere Infrastruktur-as-a-Service-Plattformen sein. Es handelt sich auch um einen Provider für höherwertige Komponenten wie Kubernetes oder andere Platform-as-a-Service-Tools, ja sogar um Software als Self-Service-Tool.

Es gibt Ihnen die Möglichkeit, eine Infrastruktur auf verschiedenen Ebenen zu erstellen.

Erstellen Sie zum Beispiel eine AWS-Infrastruktur, setzen Sie Kubernetes darauf und erstellen Sie dann Services/Komponenten innerhalb dieses Kubernetes-Clusters.

Terraform verfügt über mehr als hundert Provider für verschiedene Technologien, und jeder Provider gibt dem Terraform-Benutzer Zugriff auf seine Ressourcen. Über den AWS-Provider haben Sie zum Beispiel Zugriff auf Hunderte von AWS-Ressourcen wie EC2-Instanzen, die AWS-Benutzer usw. Mit dem Kubernetes-Provider haben Sie Zugriff auf Commodities, Ressourcen wie Services und Deployments und Namespaces, usw.

So funktioniert Terraform also, und auf diese Weise versucht es, Ihnen bei der Bereitstellung zu helfen und die komplette Anwendungseinrichtung von der Infrastruktur bis hin zur Anwendung abzudecken.

Lassen Sie uns ein paar praktische Dinge tun. 👨‍💻

Wir werden Terraform auf Ubuntu installieren und eine sehr einfache Infrastruktur einrichten.

Terraform installieren

Laden Sie das neueste Terraform-Paket herunter.

Auf der offiziellen Download-Seite finden Sie die neueste Version für das jeweilige Betriebssystem.

geekflare@geekflare:~$ wget https://releases.hashicorp.com/terraform/0.13.0/terraform_0.13.0_linux_amd64.zip
--2020-08-14 16:55:38--
https://releases.hashicorp.com/terraform/0.13.0/terraform_0.13.0_linux_amd64.zip
Auflösen von releases.hashicorp.com (releases.hashicorp.com)... 151.101.153.183, 2a04:4e42:24::439
Verbindung zu releases.hashicorp.com (releases.hashicorp.com)|151.101.153.183|:443... hergestellt.
HTTP-Anfrage gesendet, warte auf Antwort... 200 OK
Länge: 34851622 (33M) [Anwendung/zip]
Speichern in: 'terraform_0.13.0_linux_amd64.zip'

terraform_0.13.0_linux_amd64.zip
100%[=================================================================>] 33.24M
90.3KB/s in 5m 28s

2020-08-14 17:01:06 (104 KB/s) - 'terraform_0.13.0_linux_amd64.zip' gespeichert [34851622/34851622]

Entpacken Sie das heruntergeladene Paket.

geekflare@geekflare:~$ unzip terraform_0.13.0_linux_amd64.zip
Archiv:
terraform_0.13.0_linux_amd64.zip
aufblasen: terraform

Verschieben Sie die ausführbare Datei terraform in den unten angegebenen Pfad. Überprüfen Sie die Terraform-Version.

geekflare@geekflare:~$ sudo mv terraform /usr/local/bin/
[sudo] Passwort für geekflare:
geekflare@geekflare:~$ terraform -v
Terraform v0.13.0

Sie können sehen, dass diese Befehle in Terraform zur Ausführung bereitstehen.

geekflare@geekflare:~$ terraform
Verwendung: terraform [-version] [-help]  [args]

Die verfügbaren Befehle für die Ausführung sind unten aufgeführt.
Die gebräuchlichsten und nützlichsten Befehle werden zuerst angezeigt, gefolgt von
weniger verbreitete oder fortgeschrittene Befehle. Wenn Sie gerade erst anfangen
mit Terraform beginnen, bleiben Sie bei den gebräuchlichen Befehlen. Für die
anderen Befehle lesen Sie bitte vor der Verwendung die Hilfe und die Dokumentation.

Allgemeine Befehle:
apply Baut oder ändert die Infrastruktur
console Interaktive Konsole für Terraform-Interpolationen
destroy Zerstört die von Terraform verwaltete Infrastruktur
env Arbeitsbereich-Verwaltung
fmt Schreibt die Konfigurationsdateien in ein kanonisches Format um
get Herunterladen und Installieren von Modulen für die Konfiguration
graph Erstellen einer visuellen Grafik der Terraform-Ressourcen
import Vorhandene Infrastruktur in Terraform importieren
init Initialisieren eines Terraform-Arbeitsverzeichnisses
login Abrufen und Speichern von Anmeldeinformationen für einen entfernten Host
logout Entfernen der lokal gespeicherten Anmeldeinformationen für einen entfernten Host
output Lesen einer Ausgabe aus einer Statusdatei
plan Erzeugen und Anzeigen eines Ausführungsplans
providers Druckt einen Baum mit den in der Konfiguration verwendeten Providern
refresh Aktualisiert die lokale Zustandsdatei gegen reale Ressourcen
show Terraform-Status oder -Plan einsehen
taint Manuelles Markieren einer Ressource zur Wiederherstellung
untaint Manuelles Aufheben der Markierung einer Ressource als tainted
validate Validiert die Terraform-Dateien
version Druckt die Terraform-Version aus
workspace Verwaltung des Arbeitsbereichs

Alle anderen Befehle:
0.12upgrade Schreibt den Quellcode von Modulen vor 0.12 für v0.12 um
0.13upgrade Schreibt den Quellcode von Modulen vor Version 0.13 für Version 0.13 um
debug Debug-Ausgabeverwaltung (experimentell)
force-unlock Manuelles Entsperren des Terraform-Status
push Veralteter Befehl für Terraform Enterprise Legacy (v1)
state Erweiterte Statusverwaltung

Bereitstellung einer AWS EC2-Instanz mit Terraform

In dieser Demo werde ich eine neue AWS EC2-Instanz mit Terraform starten.

Erstellen Sie ein Arbeitsverzeichnis für diese Terraform-Demo.

geekflare@geekflare:~$ mkdir terraform_demo

Wechseln Sie in das Verzeichnis und erstellen Sie eine Terraform-Konfigurationsdatei, in der Sie den Provider und die Ressourcen für den Start einer AWS EC2-Instanz definieren.

geekflare@geekflare:~$ cd terraform_demo/
geekflare@geekflare:~/terraform_demo$ gedit awsec2.tf

anbieter "aws" {
access_key = "B5KG6Fe5GUKIATUF5UD"
secret_key = "R4gb65y56GBF6765ejYSJA4YtaZ T6GY7H"
region = "us-west-2"
}

ressource "aws_instance" "terraform_demo" {
ami = "ami-0a634ae95e11c6f91"
instance_type = "t2.micro"
}

Hinweis: Ich habe die Zugriffs- und Geheimschlüssel geändert 😛, Sie müssen Ihre eigenen verwenden.

Aus der oben genannten Konfiguration können Sie ersehen, dass ich den Anbieter AWS angebe. Innerhalb des Anbieters gebe ich die AWS-Benutzeranmeldedaten und die Regionen an, in denen die Instanz gestartet werden muss.

Bei den Ressourcen gebe ich die AMI-Details von Ubuntu (ami-0a634ae95e11c6f91) an und erwähne, dass der Instanztyp t2.micro sein sollte

Sie können sehen, wie einfach und lesbar die Konfigurationsdatei ist, selbst wenn Sie kein eingefleischter Programmierer sind.

terraform init

Der erste Schritt besteht nun darin, terraform zu initialisieren.

geekflare@geekflare:~/terraform_demo$ terraform init

Initialisierung des Backends...

Initialisierung der Provider-Plugins...
- Verwendung der zuvor installierten hashicorp/aws v3.2.0

Die folgenden Provider haben keine Versionsbeschränkungen in der Konfiguration,
daher wurde die neueste Version installiert.

Um automatische Upgrades auf neue Hauptversionen zu verhindern, die möglicherweise wichtige Änderungen enthalten
änderungen enthalten können, empfehlen wir, Versionseinschränkungen in einem required_providers-Block
in Ihre Konfiguration einzufügen, und zwar mit den unten vorgeschlagenen Einschränkungen.

* hashicorp/aws: version = "~> 3.2.0"

Terraform wurde erfolgreich initialisiert!

Sie können nun mit Terraform arbeiten. Versuchen Sie, "terraform plan" auszuführen, um zu sehen
alle Änderungen, die für Ihre Infrastruktur erforderlich sind. Alle Terraform-Befehle
sollten jetzt funktionieren.

Wenn Sie jemals Module oder die Backend-Konfiguration für Terraform einstellen oder ändern,
führen Sie diesen Befehl erneut aus, um Ihr Arbeitsverzeichnis neu zu initialisieren. Wenn Sie dies vergessen, werden andere
befehle dies erkennen und Sie daran erinnern, dies zu tun.

terraform plan

Als Nächstes folgt die Planungsphase, in der der Ausführungsgraph für die Erstellung und Bereitstellung der Infrastruktur erstellt wird.

geekflare@geekflare:~/terraform_demo$ terraform plan
Auffrischen des Terraform-Status im Speicher vor dem Plan...
Der aktualisierte Status wird zur Berechnung dieses Plans verwendet, wird aber nicht
wird jedoch nicht in den lokalen oder entfernten Statusspeicher übernommen.

------------------------------------------------------------------------

Ein Ausführungsplan wurde generiert und ist unten abgebildet.
Ressourcenaktionen sind mit den folgenden Symbolen gekennzeichnet:
  erstellen

Terraform führt die folgenden Aktionen aus:

# aws_instance.terraform_demo wird erstellt
  ressource "aws_instance" "terraform_demo" {
  ami = "ami-0a634ae95e11c6f91"
  arn = (bekannt nach apply)
  associate_public_ip_address = (nach dem Anwenden bekannt)
  availability_zone = (nach dem Anwenden bekannt)
  cpu_core_count = (nach dem Anwenden bekannt)
  cpu_threads_per_core = (nach dem Anwenden bekannt)
  get_password_data = false
  host_id = (nach dem Anwenden bekannt)
  id = (nach dem Anwenden bekannt)
  instance_state = (nach dem Anwenden bekannt)
  instance_type = "t2.micro"
  ipv6_address_count = (nach dem Anwenden bekannt)
  ipv6_addresses = (nach dem Anwenden bekannt)
  key_name = (nach dem Anwenden bekannt)
  outpost_arn = (nach dem Anwenden bekannt)
  password_data = (bekannt nach Anwendung)
  placement_group = (bekannt nach Anwendung)
  primary_network_interface_id = (bekannt nach Anwendung)
  private_dns = (bekannt nach Anwendung)
  private_ip = (bekannt nach Anwendung)
  public_dns = (bekannt nach dem Anwenden)
  public_ip = (bekannt nach Anwendung)
  secondary_private_ips = (bekannt nach dem Anwenden)
  security_groups = (bekannt nach dem Anwenden)
  source_dest_check = true
  subnet_id = (nach dem Anwenden bekannt)
  tenancy = (nach dem Anwenden bekannt)
  volume_tags = (bekannt nach Anwendung)
  vpc_security_group_ids = (bekannt nach dem Anwenden)

  ebs_block_device {
  delete_on_termination = (bekannt nach dem Anwenden)
  device_name = (bekannt nach Anwendung)
  encrypted = (bekannt nach Anwendung)
  iops = (bekannt nach Anwendung)
  kms_key_id = (bekannt nach Anwendung)
  snapshot_id = (bekannt nach dem Anwenden)
  volume_id = (bekannt nach dem Anwenden)
  volume_size = (bekannt nach dem Anwenden)
  volume_type = (bekannt nach Anwendung)
}

  ephemeral_block_device {
  device_name = (nach dem Anwenden bekannt)
  no_device = (nach dem Anwenden bekannt)
  virtual_name = (nach dem Anwenden bekannt)
}

  metadata_options {
  http_endpoint = (nach dem Anwenden bekannt)
  http_put_response_hop_limit = (bekannt nach apply)
  http_tokens = (nach der Anwendung bekannt)
}

  network_interface {
  delete_on_termination = (bekannt nach dem Anwenden)
  device_index = (bekannt nach dem Anwenden)
  network_interface_id = (bekannt nach apply)
}

  root_block_device {
  delete_on_termination = (bekannt nach dem Anwenden)
  device_name = (bekannt nach dem Anwenden)
  encrypted = (bekannt nach Anwendung)
  iops = (bekannt nach Anwendung)
  kms_key_id = (bekannt nach Anwendung)
  volume_id = (bekannt nach Anwendung)
  volume_size = (bekannt nach dem Anwenden)
  volume_type = (bekannt nach Anwendung)
}
}

Plan: 1 zum Hinzufügen, 0 zum Ändern, 0 zum Zerstören.

------------------------------------------------------------------------

Hinweis: Sie haben keinen "-out" Parameter angegeben, um diesen Plan zu speichern, so dass Terraform
kann daher nicht garantieren, dass genau diese Aktionen ausgeführt werden, wenn
"terraform apply" anschließend ausgeführt wird.

terraform anwenden

In der apply-Phase wird die Konfigurationsdatei ausgeführt und eine AWS EC2-Instanz gestartet. Wenn Sie den Befehl apply ausführen, werden Sie gefragt: “Möchten Sie diese Aktionen durchführen?”, Sie müssen “Ja” eingeben und die Eingabetaste drücken.

geekflare@geekflare:~/terraform_demo$ terraform apply

Ein Ausführungsplan wurde generiert und ist unten abgebildet.
Die Ressourcenaktionen sind mit den folgenden Symbolen gekennzeichnet:
  erstellen

Terraform wird die folgenden Aktionen durchführen:

# aws_instance.terraform_demo wird erstellt
  ressource "aws_instance" "terraform_demo" {
  ami = "ami-0a634ae95e11c6f91"
  arn = (bekannt nach apply)
  associate_public_ip_address = (nach dem Anwenden bekannt)
  availability_zone = (nach dem Anwenden bekannt)
  cpu_core_count = (nach dem Anwenden bekannt)
  cpu_threads_per_core = (nach dem Anwenden bekannt)
  get_password_data = false
  host_id = (nach dem Anwenden bekannt)
  id = (nach dem Anwenden bekannt)
  instance_state = (nach dem Anwenden bekannt)
  instance_type = "t2.micro"
  ipv6_address_count = (nach dem Anwenden bekannt)
  ipv6_addresses = (nach dem Anwenden bekannt)
  key_name = (nach dem Anwenden bekannt)
  outpost_arn = (bekannt nach dem Anwenden)
  password_data = (bekannt nach Anwendung)
  placement_group = (bekannt nach Anwendung)
  primary_network_interface_id = (bekannt nach Anwendung)
  private_dns = (bekannt nach Anwendung)
  private_ip = (bekannt nach Anwendung)
  public_dns = (bekannt nach dem Anwenden)
  public_ip = (bekannt nach Anwendung)
  secondary_private_ips = (bekannt nach dem Anwenden)
  security_groups = (bekannt nach dem Anwenden)
  source_dest_check = true
  subnet_id = (nach dem Anwenden bekannt)
  tenancy = (nach dem Anwenden bekannt)
  volume_tags = (bekannt nach Anwendung)
  vpc_security_group_ids = (bekannt nach dem Anwenden)

  ebs_block_device {
  delete_on_termination = (bekannt nach dem Anwenden)
  device_name = (bekannt nach Anwendung)
  encrypted = (bekannt nach Anwendung)
  iops = (bekannt nach Anwendung)
  kms_key_id = (bekannt nach Anwendung)
  snapshot_id = (bekannt nach dem Anwenden)
  volume_id = (bekannt nach dem Anwenden)
  volume_size = (bekannt nach dem Anwenden)
  volume_type = (bekannt nach Anwendung)
}

  ephemeral_block_device {
  device_name = (nach dem Anwenden bekannt)
  no_device = (nach dem Anwenden bekannt)
  virtual_name = (nach dem Anwenden bekannt)
}

  metadata_options {
  http_endpoint = (nach dem Anwenden bekannt)
  http_put_response_hop_limit = (nach dem Anwenden bekannt)
  http_tokens = (nach der Anwendung bekannt)
}

  network_interface {
  delete_on_termination = (bekannt nach dem Anwenden)
  device_index = (bekannt nach dem Anwenden)
  network_interface_id = (bekannt nach apply)
}

  root_block_device {
  delete_on_termination = (bekannt nach dem Anwenden)
  device_name = (bekannt nach dem Anwenden)
  encrypted = (bekannt nach Anwendung)
  iops = (bekannt nach Anwendung)
  kms_key_id = (bekannt nach Anwendung)
  volume_id = (bekannt nach Anwendung)
  volume_size = (bekannt nach dem Anwenden)
  volume_type = (bekannt nach Anwendung)
}
}

Plan: 1 zum Hinzufügen, 0 zum Ändern, 0 zum Zerstören.

Möchten Sie diese Aktionen durchführen?
Terraform wird die oben beschriebenen Aktionen durchführen.
Nur ein 'Ja' wird zur Genehmigung akzeptiert.

Geben Sie einen Wert ein: ja

aws_instance.terraform_demo: Erstellen...
aws_instance.terraform_demo: Noch im Aufbau... [10s verstrichen]
aws_instance.terraform_demo: Wird noch erstellt... [20s verstrichen]
aws_instance.terraform_demo: Erstellt noch... [30s abgelaufen]
aws_instance.terraform_demo: Erzeugt immer noch... [40s verstrichen]
aws_instance.terraform_demo: Erstellung abgeschlossen nach 44s [id=i-0eec33286ea4b0740]

Anwendung abgeschlossen! Ressourcen: 1 hinzugefügt, 0 geändert, 0 zerstört.

Gehen Sie zu Ihrem AWS EC2 Dashboard und Sie werden sehen, dass eine neue Instanz mit der am Ende des apply-Befehls genannten Instanz-ID erstellt wurde.

Sie haben erfolgreich eine AWS EC2-Instanz mit Terraform gestartet.

terraform zerstören

Wenn Sie die Infrastruktur schließlich löschen möchten, müssen Sie den Befehl destroy ausführen.

geekflare@geekflare:~/terraform_demo$ terraform destroy
aws_instance.terraform_demo: Aktualisiere Zustand... [id=i-0eec33286ea4b0740]

Es wurde ein Ausführungsplan erstellt, der im Folgenden dargestellt ist.
Ressourcenaktionen sind mit den folgenden Symbolen gekennzeichnet:
- zerstören

Terraform wird die folgenden Aktionen durchführen:

# aws_instance.terraform_demo wird zerstört
- ressource "aws_instance" "terraform_demo" {
- ami = "ami-0a634ae95e11c6f91" -> null
- arn = "arn:aws:ec2:us-west-2:259212389929:instance/i-0eec33286ea4b0740" -> null
- associate_public_ip_address = true -> null
- availability_zone = "us-west-2c" -> null
- cpu_core_count = 1 -> null
- cpu_threads_pro_Kern = 1 -> null
- disable_api_termination = false -> null
- ebs_optimiert = falsch -> null
- get_password_data = falsch -> null
- hibernation = falsch -> null
- id = "i-0eec33286ea4b0740" -> null
- instance_state = "läuft" -> null
- instance_type = "t2.micro" -> null
- ipv6_address_count = 0 -> null
- ipv6_addresses = [] -->

 null
- überwachung = false -> null
- primary_network_interface_id = "eni-02a46f2802fd15634" -> null
- private_dns = "ip-172-31-13-160.us-west-2.compute.internal" -> null
- private_ip = "172.31.13.160" -> null
- public_dns = "ec2-34-221-77-94.us-west-2.compute.amazonaws.com" -> null
- öffentliche_IP = "34.221.77.94" -> null
- secondary_private_ips = [] -> null
- security_groups = [
- "default",
] -> null
- source_dest_check = true -> null
- subnet_id = "subnet-5551200c" -> null
- tags = {} -> null
- tenancy = "standard" -> null
- volume_tags = {} -> null
- vpc_security_group_ids = [
- "sg-b5b480d1",
] -->

 null

- credit_specification {
- cpu_credits = "standard" -> null
}

- metadata_options {
- http_endpoint = "aktiviert" -> null
- http_put_response_hop_limit = 1 -> null
- http_tokens = "optional" -> null
}

- root_block_device {
- delete_on_termination = true -> null
- geräte_name = "/dev/sda1" -> null
- encrypted = false -> null
- iops = 100 -> null
- volume_id = "vol-0be2673afff6b1a86" -> null
- volume_size = 8 -> null
- volume_type = "gp2" -> null
}
}

Plan: 0 zum Hinzufügen, 0 zum Ändern, 1 zum Zerstören.

Wollen Sie wirklich alle Ressourcen zerstören?
Terraform wird Ihre gesamte verwaltete Infrastruktur zerstören, wie oben gezeigt.
Es gibt kein Rückgängigmachen. Nur 'Ja' wird zur Bestätigung akzeptiert.

Geben Sie einen Wert ein: ja

aws_instance.terraform_demo: Destroying... [id=i-0eec33286ea4b0740]
aws_instance.terraform_demo: Immer noch am Zerstören... [id=i-0eec33286ea4b0740, 10s verstrichen]
aws_instance.terraform_demo: Zerstört immer noch... [id=i-0eec33286ea4b0740, 20s verstrichen]
aws_instance.terraform_demo: Zerstört immer noch... [id=i-0eec33286ea4b0740, 30s verstrichen]
aws_instance.terraform_demo: Zerstörung abgeschlossen nach 34s

Zerstörung abgeschlossen! Ressourcen: 1 zerstört.

Wenn Sie das EC2-Dashboard erneut überprüfen, sehen Sie, dass die Instanz beendet wurde.

Fazit

Ich glaube, die obigen Ausführungen geben Ihnen eine Vorstellung davon, wie Sie mit Terraform loslegen können. Probieren Sie das soeben gezeigte Beispiel einfach aus.

Sie sollten sich auch diese Software zur Automatisierung von Infrastrukturen ansehen.

Wenn Sie mehr erfahren möchten, empfehle ich Ihnen den Kurs Learning DevOps with Terraform.