Sie fragen sich, was Terraform ist? Finden wir es heraus.
Infrastructure as Code (IaC) ist eine unter DevOps-Experten weit verbreitete Terminologie. Es ist der Prozess der Verwaltung und Bereitstellung der gesamten IT-Infrastruktur (beinhaltet sowohl physische als auch virtuelle Maschinen) unter Verwendung von maschinenlesbaren Definitionsdateien. Es ist ein softwaretechnischer Ansatz für den Betrieb. Es hilft bei der Automatisierung des gesamten Rechenzentrums durch die Verwendung von Programmierskripten.
Mit all den Funktionen, die Infrastructure as Code bietet, hat es mehrere Herausforderungen:
- Programmieren lernen müssen
- Kenne die Auswirkung der Änderung nicht.
- Sie müssen die Änderung rückgängig machen
- Änderungen können nicht nachverfolgt werden
- Eine Ressource kann nicht automatisiert werden
- Mehrere Umgebungen für die Infrastruktur
Terraform wurde entwickelt, um diese Herausforderungen zu lösen.
Was ist Terraform?
Terraform ist eine von HashiCorp entwickelte Open-Source-Infrastruktur als Code-Tool. Es wird verwendet, um die vollständige Infrastruktur mithilfe einer leicht zu erlernenden deklarativen Sprache zu definieren und bereitzustellen.
Es ist ein Infrastrukturbereitstellungstool, in dem Sie Ihre Cloud-Infrastruktureinrichtung als Codes speichern können. Es ist sehr ähnlich zu Tools wie z Wolkenbildung, mit dem Sie Ihre AWS-Infrastruktur automatisieren würden, aber Sie können das nur auf AWS verwenden. Mit Terraform können Sie es auch auf anderen Cloud-Plattformen verwenden.
Nachfolgend sind einige der Vorteile der Verwendung von Terraform aufgeführt.
- Bietet Orchestrierung, nicht nur Konfigurationsmanagement
- Unterstützt mehrere Anbieter wie AWS, Azure, GCP, DigitalOcean und viele mehr
- Stellen Sie eine unveränderliche Infrastruktur bereit, in der sich die Konfiguration reibungslos ändert
- Verwendet eine leicht verständliche Sprache, HCL (HashiCorp Configuration Language)
- Einfach auf jeden anderen Anbieter übertragbar
- Unterstützt nur Client-Architektur, sodass keine zusätzliche Konfigurationsverwaltung auf einem Server erforderlich ist
Inhaltsverzeichnis
Terraform Core-Konzepte
Nachfolgend sind die in Terraform verwendeten Kernkonzepte/Terminologien aufgeführt:
- Variablen: Wird auch als Eingabevariable verwendet und ist ein Schlüssel-Wert-Paar, das von Terraform-Modulen verwendet wird, um eine Anpassung zu ermöglichen.
- Anbieter: Es ist ein Plugin, um mit APIs des Dienstes zu interagieren und auf die zugehörigen Ressourcen zuzugreifen.
- Modul: Es ist ein Ordner mit Terraform-Vorlagen, in dem alle Konfigurationen definiert sind
- Zustand: 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 (Recheninstanzen, virtuelle Netzwerke usw.), die zum Konfigurieren und Verwalten der Infrastruktur verwendet werden.
- Datenquelle: Wird von Anbietern implementiert, um Informationen zu externen Objekten an Terraform zurückzugeben.
- Ausgabewerte: Dies sind Rückgabewerte eines Terraform-Moduls, die von anderen Konfigurationen verwendet werden können.
- Planen: Dies ist eine der Phasen, in der festgelegt wird, was erstellt, aktualisiert oder zerstört werden muss, um vom tatsächlichen/aktuellen Zustand der Infrastruktur in den gewünschten Zustand überzugehen.
- Anwenden: Dies ist eine der Phasen, in der die Änderungen des tatsächlichen/aktuellen Zustands der Infrastruktur angewendet werden, um in den gewünschten Zustand überzugehen.
Terraform-Lebenszyklus
Der Terraform-Lebenszyklus besteht aus – Initialisieren, Planen, Anwenden und Zerstören.
- Terraform init initialisiert das Arbeitsverzeichnis, das aus allen Konfigurationsdateien besteht
- Der Terraform-Plan wird verwendet, um einen Ausführungsplan zu erstellen, um einen gewünschten Zustand der Infrastruktur zu erreichen. Änderungen in den Konfigurationsdateien werden 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 Infrastrukturressourcen zu löschen, die nach der Apply-Phase als „tainted“ markiert sind.
Wie funktioniert Terraform?
Terraform hat zwei Hauptkomponenten, die seine Architektur ausmachen:
Terraform-Kern
Der Terraform-Kern verwendet zwei Eingabequellen, um seine Arbeit zu erledigen.
Die erste Eingabequelle ist eine Terraform-Konfiguration, die Sie als Benutzer konfigurieren. Hier definieren Sie, was erstellt oder bereitgestellt werden muss. Und die zweite Eingabequelle ist ein Zustand, in dem Terraform den aktuellen Stand darüber hält, wie die aktuelle Einrichtung der Infrastruktur aussieht.
Was der Terraform-Kern also tut, ist, dass er die Eingaben entgegennimmt und den Plan herausfindet, was getan werden muss. Es vergleicht den Status, den aktuellen Status und die gewünschte Konfiguration im Endergebnis. Es findet heraus, was getan werden muss, um den gewünschten Zustand in der Konfigurationsdatei zu erreichen. Es zeigt, was erstellt, aktualisiert und gelöscht werden muss, um die Infrastruktur zu erstellen und bereitzustellen.
Anbieter
Die zweite Komponente der Architektur sind Anbieter für bestimmte Technologien. Dies können Cloud-Anbieter wie AWS, Azure, GCP oder andere Infrastructure-as-a-Service-Plattformen sein. Es ist auch ein Anbieter für höherwertige Komponenten wie Kubernetes oder andere Platform-as-a-Service-Tools, sogar einige Software als Self-Service-Tool.
Es gibt Ihnen die Möglichkeit, Infrastruktur auf verschiedenen Ebenen zu schaffen.
Erstellen Sie beispielsweise eine AWS-Infrastruktur, stellen Sie dann Kubernetes darauf bereit und erstellen Sie dann Dienste/Komponenten innerhalb dieses Kubernetes-Clusters.
Terraform hat über hundert Anbieter für verschiedene Technologien, und jeder Anbieter gewährt Terraform-Benutzern dann Zugriff auf seine Ressourcen. So haben Sie beispielsweise über den AWS-Anbieter Zugriff auf Hunderte von AWS-Ressourcen wie EC2-Instances, die AWS-Benutzer usw. Mit dem Kubernetes-Anbieter haben Sie Zugriff auf Waren, Ressourcen wie Dienste und Bereitstellungen und Namespaces usw.
So funktioniert also Terraform und versucht, Ihnen dabei zu helfen, die komplette Anwendungseinrichtung von der Infrastruktur bis hin zur Anwendung bereitzustellen und abzudecken.
Lass uns ein paar praktische Sachen machen. 👨💻
Wir werden Terraform auf Ubuntu installieren und eine sehr einfache Infrastruktur bereitstellen.
Installieren Sie Terraform
Laden Sie das neueste Terraform-Paket herunter.
Beziehen Sie sich auf die offizielle Downloadseite um die neueste Version für das jeweilige Betriebssystem zu erhalten.
[email protected]:~$ 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 Resolving releases.hashicorp.com (releases.hashicorp.com)... 151.101.153.183, 2a04:4e42:24::439 Connecting to releases.hashicorp.com (releases.hashicorp.com)|151.101.153.183|:443... connected. HTTP request sent, awaiting response... 200 OK Length: 34851622 (33M) [application/zip] Saving to: ‘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’ saved [34851622/34851622]
Extrahieren Sie das heruntergeladene Paket.
[email protected]:~$ unzip terraform_0.13.0_linux_amd64.zip Archive: terraform_0.13.0_linux_amd64.zip inflating: terraform
Verschieben Sie die ausführbare Terraform-Datei in den unten gezeigten Pfad. Überprüfen Sie die Terraform-Version.
[email protected]:~$ sudo mv terraform /usr/local/bin/ [sudo] password for wdzwdz: [email protected]:~$ terraform -v Terraform v0.13.0
Sie können sehen, dass dies die verfügbaren Befehle in Terraform zur Ausführung sind.
[email protected]:~$ terraform Usage: terraform [-version] [-help] <command> [args] The available commands for execution are listed below. The most common, useful commands are shown first, followed by less common or more advanced commands. If you're just getting started with Terraform, stick with the common commands. For the other commands, please read the help and docs before usage. Common commands: apply Builds or changes infrastructure console Interactive console for Terraform interpolations destroy Destroy Terraform-managed infrastructure env Workspace management fmt Rewrites config files to canonical format get Download and install modules for the configuration graph Create a visual graph of Terraform resources import Import existing infrastructure into Terraform init Initialize a Terraform working directory login Obtain and save credentials for a remote host logout Remove locally-stored credentials for a remote host output Read an output from a state file plan Generate and show an execution plan providers Prints a tree of the providers used in the configuration refresh Update local state file against real resources show Inspect Terraform state or plan taint Manually mark a resource for recreation untaint Manually unmark a resource as tainted validate Validates the Terraform files version Prints the Terraform version workspace Workspace management All other commands: 0.12upgrade Rewrites pre-0.12 module source code for v0.12 0.13upgrade Rewrites pre-0.13 module source code for v0.13 debug Debug output management (experimental) force-unlock Manually unlock the terraform state push Obsolete command for Terraform Enterprise legacy (v1) state Advanced state management
Stellen Sie eine AWS EC2-Instance mit Terraform bereit
In dieser Demo werde ich eine neue AWS EC2-Instance mit Terraform starten.
Erstellen Sie ein Arbeitsverzeichnis für diese Terraform-Demo.
[email protected]:~$ mkdir terraform_demo
Wechseln Sie in das Verzeichnis und erstellen Sie eine Terraform-Konfigurationsdatei, in der Sie den Anbieter und die Ressourcen zum Starten einer AWS EC2-Instance definieren.
[email protected]:~$ cd terraform_demo/
[email protected]:~/terraform_demo$ gedit awsec2.tf
provider "aws" {
access_key = "B5KG6Fe5GUKIATUF5UD"
secret_key = "R4gb65y56GBF6765ejYSJA4YtaZ+T6GY7H"
region = "us-west-2"
}
resource "aws_instance" "terraform_demo" {
ami = "ami-0a634ae95e11c6f91"
instance_type = "t2.micro"
}
Hinweis: Ich habe die Zugangs- und Geheimschlüssel geändert 😛, Sie müssen Ihre eigenen verwenden.
Aus der oben erwähnten Konfiguration können Sie sehen, dass ich den Anbieter wie AWS erwähne. Innerhalb des Anbieters gebe ich AWS-Benutzeranmeldeinformationen und Regionen an, in denen die Instanz gestartet werden muss.
In den Ressourcen gebe ich 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, auch wenn Sie kein eingefleischter Programmierer sind.
Terraform-Init
Der erste Schritt besteht nun darin, Terraform zu initialisieren.
[email protected]:~/terraform_demo$ terraform init Initializing the backend... Initializing provider plugins... - Using previously-installed hashicorp/aws v3.2.0 The following providers do not have any version constraints in configuration, so the latest version was installed. To prevent automatic upgrades to new major versions that may contain breaking changes, we recommend adding version constraints in a required_providers block in your configuration, with the constraint strings suggested below. * hashicorp/aws: version = "~> 3.2.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
Als nächstes kommt die Planungsphase; Es erstellt das Ausführungsdiagramm zum Erstellen und Bereitstellen der Infrastruktur.
[email protected]:~/terraform_demo$ terraform plan
Refreshing Terraform state in-memory prior to plan...
The refreshed state will be used to calculate this plan, but will not be
persisted to local or remote state storage.
------------------------------------------------------------------------
An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
+ create
Terraform will perform the following actions:
# aws_instance.terraform_demo will be created
+ resource "aws_instance" "terraform_demo" {
+ ami = "ami-0a634ae95e11c6f91"
+ arn = (known after apply)
+ associate_public_ip_address = (known after apply)
+ availability_zone = (known after apply)
+ cpu_core_count = (known after apply)
+ cpu_threads_per_core = (known after apply)
+ get_password_data = false
+ host_id = (known after apply)
+ id = (known after apply)
+ instance_state = (known after apply)
+ instance_type = "t2.micro"
+ ipv6_address_count = (known after apply)
+ ipv6_addresses = (known after apply)
+ key_name = (known after apply)
+ outpost_arn = (known after apply)
+ password_data = (known after apply)
+ placement_group = (known after apply)
+ primary_network_interface_id = (known after apply)
+ private_dns = (known after apply)
+ private_ip = (known after apply)
+ public_dns = (known after apply)
+ public_ip = (known after apply)
+ secondary_private_ips = (known after apply)
+ security_groups = (known after apply)
+ source_dest_check = true
+ subnet_id = (known after apply)
+ tenancy = (known after apply)
+ volume_tags = (known after apply)
+ vpc_security_group_ids = (known after apply)
+ ebs_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ snapshot_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}
+ ephemeral_block_device {
+ device_name = (known after apply)
+ no_device = (known after apply)
+ virtual_name = (known after apply)
}
+ metadata_options {
+ http_endpoint = (known after apply)
+ http_put_response_hop_limit = (known after apply)
+ http_tokens = (known after apply)
}
+ network_interface {
+ delete_on_termination = (known after apply)
+ device_index = (known after apply)
+ network_interface_id = (known after apply)
}
+ root_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}
}
Plan: 1 to add, 0 to change, 0 to destroy.
------------------------------------------------------------------------
Note: You didn't specify an "-out" parameter to save this plan, so Terraform
can't guarantee that exactly these actions will be performed if
"terraform apply" is subsequently run.
Terraform gelten
Die Apply-Phase führt die Konfigurationsdatei aus und startet eine AWS EC2-Instance. Wenn Sie den Befehl apply ausführen, werden Sie gefragt: „Möchten Sie diese Aktionen ausführen?“, Sie müssen yes eingeben und die Eingabetaste drücken.
[email protected]:~/terraform_demo$ terraform apply
An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
+ create
Terraform will perform the following actions:
# aws_instance.terraform_demo will be created
+ resource "aws_instance" "terraform_demo" {
+ ami = "ami-0a634ae95e11c6f91"
+ arn = (known after apply)
+ associate_public_ip_address = (known after apply)
+ availability_zone = (known after apply)
+ cpu_core_count = (known after apply)
+ cpu_threads_per_core = (known after apply)
+ get_password_data = false
+ host_id = (known after apply)
+ id = (known after apply)
+ instance_state = (known after apply)
+ instance_type = "t2.micro"
+ ipv6_address_count = (known after apply)
+ ipv6_addresses = (known after apply)
+ key_name = (known after apply)
+ outpost_arn = (known after apply)
+ password_data = (known after apply)
+ placement_group = (known after apply)
+ primary_network_interface_id = (known after apply)
+ private_dns = (known after apply)
+ private_ip = (known after apply)
+ public_dns = (known after apply)
+ public_ip = (known after apply)
+ secondary_private_ips = (known after apply)
+ security_groups = (known after apply)
+ source_dest_check = true
+ subnet_id = (known after apply)
+ tenancy = (known after apply)
+ volume_tags = (known after apply)
+ vpc_security_group_ids = (known after apply)
+ ebs_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ snapshot_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}
+ ephemeral_block_device {
+ device_name = (known after apply)
+ no_device = (known after apply)
+ virtual_name = (known after apply)
}
+ metadata_options {
+ http_endpoint = (known after apply)
+ http_put_response_hop_limit = (known after apply)
+ http_tokens = (known after apply)
}
+ network_interface {
+ delete_on_termination = (known after apply)
+ device_index = (known after apply)
+ network_interface_id = (known after apply)
}
+ root_block_device {
+ delete_on_termination = (known after apply)
+ device_name = (known after apply)
+ encrypted = (known after apply)
+ iops = (known after apply)
+ kms_key_id = (known after apply)
+ volume_id = (known after apply)
+ volume_size = (known after apply)
+ volume_type = (known after apply)
}
}
Plan: 1 to add, 0 to change, 0 to destroy.
Do you want to perform these actions?
Terraform will perform the actions described above.
Only 'yes' will be accepted to approve.
Enter a value: yes
aws_instance.terraform_demo: Creating...
aws_instance.terraform_demo: Still creating... [10s elapsed]
aws_instance.terraform_demo: Still creating... [20s elapsed]
aws_instance.terraform_demo: Still creating... [30s elapsed]
aws_instance.terraform_demo: Still creating... [40s elapsed]
aws_instance.terraform_demo: Creation complete after 44s [id=i-0eec33286ea4b0740]
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
Gehen Sie zu Ihrem AWS EC2-Dashboard und Sie werden sehen, dass eine neue Instanz mit der Instanz-ID erstellt wurde, die am Ende des Apply-Befehls erwähnt wurde.
Sie haben erfolgreich eine AWS EC2-Instance mit Terraform gestartet.
Terraform zerstören
Wenn Sie schließlich die Infrastruktur löschen möchten, müssen Sie den Befehl „destroy“ ausführen.
[email protected]:~/terraform_demo$ terraform destroy
aws_instance.terraform_demo: Refreshing state... [id=i-0eec33286ea4b0740]
An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
- destroy
Terraform will perform the following actions:
# aws_instance.terraform_demo will be destroyed
- resource "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_per_core = 1 -> null
- disable_api_termination = false -> null
- ebs_optimized = false -> null
- get_password_data = false -> null
- hibernation = false -> null
- id = "i-0eec33286ea4b0740" -> null
- instance_state = "running" -> null
- instance_type = "t2.micro" -> null
- ipv6_address_count = 0 -> null
- ipv6_addresses = [] -> null
- monitoring = 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
- public_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 = "default" -> null
- volume_tags = {} -> null
- vpc_security_group_ids = [
- "sg-b5b480d1",
] -> null
- credit_specification {
- cpu_credits = "standard" -> null
}
- metadata_options {
- http_endpoint = "enabled" -> null
- http_put_response_hop_limit = 1 -> null
- http_tokens = "optional" -> null
}
- root_block_device {
- delete_on_termination = true -> null
- device_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 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_instance.terraform_demo: Destroying... [id=i-0eec33286ea4b0740]
aws_instance.terraform_demo: Still destroying... [id=i-0eec33286ea4b0740, 10s elapsed]
aws_instance.terraform_demo: Still destroying... [id=i-0eec33286ea4b0740, 20s elapsed]
aws_instance.terraform_demo: Still destroying... [id=i-0eec33286ea4b0740, 30s elapsed]
aws_instance.terraform_demo: Destruction complete after 34s
Destroy complete! Resources: 1 destroyed.
Wenn Sie das EC2-Dashboard erneut überprüfen, sehen Sie, dass die Instance beendet wurde.
Fazit
Ich glaube, das Obige gibt Ihnen eine Idee, wie Sie mit Terraform beginnen können. Gehen Sie voran und probieren Sie das Beispiel aus, das ich gerade gezeigt habe.
Sie sollten sich auch diese Software zur Infrastrukturautomatisierung ansehen.
Wenn Sie daran interessiert sind, mehr zu erfahren, würde ich vorschlagen, dies zu überprüfen DevOps lernen mit Terraform-Kurs.