Epic Terraform AWS Provider für Ihre Amazon-Infrastruktur

Tutorials
AWS Terraform

Wenn Sie planen, Amazon Web Services (AWS) zu verwalten und damit zu arbeiten, ist die Verwendung des Terraform AWS-Anbieters ein Muss. Es ermöglicht Ihnen, mit den vielen von AWS unterstützten Ressourcen zu interagieren, wie Amazon S3, Elastic Beanstalk, Lambda und viele mehr.

In diesem ultimativen Leitfaden lernen Sie Schritt für Schritt alles, was Sie über den AWS-Anbieter wissen müssen und wie Sie diesen Anbieter mit Terraform verwenden können, um Ihre Amazon-Infrastruktur zu verwalten.

Lassen Sie uns loslegen!

Voraussetzungen

Wenn Sie diesem Tutorial folgen möchten, stellen Sie bitte sicher, dass Sie Folgendes bereit haben:

Verwandt: So installieren Sie Terraform unter Windows

  • A code editor – Even though you can use any text editor to work with Terraform configuration files, you should have one that understands the HCL Terraform language. Try out Visual Studio (VS) Code.

Verwandt: Was Sie über Visual Studio Code wissen müssen: Ein Tutorial

Was ist der Terraform AWS-Provider?

Terraform ist auf Plugins angewiesen, um mit Cloud-Anbietern wie AWS, Google Cloud Platform (GCP) und Oracle zu interagieren. Einer der am häufigsten verwendeten Anbieter ist der AWS-Anbieter. Dieser Anbieter interagiert mit vielen von AWS unterstützten Ressourcen, wie zum Beispiel Amazon S3, Elastic Beanstalk, Lambda und viele andere.

Terraform verwendet den AWS-Anbieter mit den richtigen Anmeldeinformationen, um eine Verbindung mit Amazon herzustellen und Dutzende von AWS-Diensten zu verwalten oder zu bereitstellen/aktualisieren.

Der AWS-Anbieter wird in der Terraform-Konfigurationsdatei deklariert und enthält verschiedene Parameter wie Version, Endpunkt-URLs oder Cloud-Regionen usw.

Deklaration des AWS-Anbieters

Wenn Sie den Namen eines Anbieters angeben müssen, müssen Sie einen lokalen Namen definieren. Der lokale Name ist der Name des Anbieters, der innerhalb des required_providers-Blocks zugewiesen wird. Lokale Namen werden beim Anfordern eines Anbieters zugewiesen und müssen pro Modul eindeutig sein.

Bei der Deklaration der required_providers müssen Sie auch den source-Parameter in Terraform 0.13 und späteren Versionen angeben. Der source-Parameter legt die Quelladresse fest, von der Terraform Plugins herunterladen kann.

Quelladressen bestehen aus drei Teilen, wie folgt:

  • Hostname – Der Hostname des Terraform-Registers, das den Anbieter verteilt. Der Standard-Hostname ist registry.terraform.io.
  • Namespace – Ein organisatorischer Namespace innerhalb des angegebenen Registers.
  • Typ – Ein Typ ist ein kurzer Name, den Sie für die Plattform oder das System angeben, das der Anbieter verwaltet, und er muss eindeutig sein.

Unten sehen Sie die Syntax der Deklaration des source-Parameters, bei der die drei Teile einer Quelladresse durch Schrägstriche (/) abgegrenzt sind.

## <HOSTNAME>/]<NAMESPACE>/<TYPE>

# BEISPIELNUTZUNG DER SYNTAX DES SOURCE-PARAMETERS

# Deklaration des Quellorts/der Adresse, von dem/den Terraform Plugins herunterladen kann
# Der offizielle AWS-Provider gehört zum Namespace von Hashicorp auf dem 
# registry.terraform.io-Register. Daher lautet die Quelladresse von Hashicorp hashicorp/aws
source  = "hashicorp/aws"

Die folgende Terraform-Konfiguration gibt den erforderlichen Namen des Providers (aws) an, zusammen mit der Quelladresse, der AWS-Provider-Version und konfiguriert die Region des Providers (us-east-2).

# Deklaration der Anforderungen an den Provider, wenn Terraform 0.13 und höher installiert ist
terraform {
  # Eine Anforderung an den Provider besteht aus einem lokalen Namen (aws), 
  # Quellort und einer Versionsbeschränkung. 
  required_providers {
    aws = {     
      # Deklaration des Quellorts/der Adresse, von dem/den Terraform Plugins herunterladen kann
      source  = "hashicorp/aws"
      # Deklaration der Version des AWS-Providers als größer als 3.0
      version = "~> 3.0"  
    }
  }
}

# Konfiguration des AWS-Providers in der Region us-east-2
provider "aws" {
  region = "us-east-2"
}

Authentifizierung eines AWS-Kontos mit fest codierten Anmeldeinformationen

Jetzt, da Sie ein grundlegendes Verständnis dafür haben, wie der AWS-Provider deklariert wird, gehen wir darüber, wie Sie ein AWS-Konto authentifizieren, näher ein.

Sie können den AWS-Anbieter über verschiedene Methoden authentifizieren, wie z.B. das Deklarieren von Umgebungsvariablen und das Speichern von Anmeldeinformationen in einem benannten Profil. Aber der schnellste Weg, um sich bei einem AWS-Konto anzumelden, ist das Einbetten der Anmeldeinformationen direkt in Ihren AWS-Anbieter.

Auch wenn das Einbetten von Anmeldeinformationen nicht empfohlen wird, da sie anfällig für Lecks sind, können Sie dennoch hartcodierte Anmeldeinformationen in der Terraform-Konfiguration deklarieren, um schnell eine beliebige AWS-Ressource zu testen. Aber lesen Sie weiter und Sie werden später eine bessere Möglichkeit kennenlernen, sich bei einem AWS-Konto anzumelden, indem Sie Umgebungsvariablen deklarieren.

Die folgende Konfiguration deklariert einen lokalen Namen (aws) zusammen mit der Anbieterregion (us-east-2), wie unten gezeigt. Sie können sehen, dass der AWS-Anbieterblock auch einen Zugriffsschlüssel und einen Geheimschlüssel deklariert, um ein AWS-Konto zu authentifizieren.

# Deklarieren eines AWS-Anbieters mit dem Namen aws
provider "aws" {
  # Deklarieren der Anbieterregion
  region = "us-east-2"
  # Deklarieren des Zugriffsschlüssels und des Geheimschlüssels
  access_key = "access-key"
  secret_key = "secret-key"
}

Absichern von Anmeldeinformationen durch Deklarieren von Umgebungsvariablen

Sie haben gerade gelernt, dass das Hartcodieren statischer Anmeldeinformationen zur Authentifizierung von AWS-Cloud-Services mit Terraform möglich ist. Aber das Hartcodieren ist unsicher und wird nur empfohlen, wenn Sie es in einer Testumgebung schnell testen möchten.

Gibt es eine andere Möglichkeit, Anmeldeinformationen zu sichern? Ja, indem Sie sie als Umgebungsvariablen deklarieren, gibt es keine Begrenzung, wie viele Sie deklarieren können. Umgebungsvariablen sind Variablen, deren Werte außerhalb der Terraform-Konfigurationsdatei gesetzt werden und aus einem Namen/Wert-Paar bestehen.

Führen Sie die folgende Reihe von export-Befehlen aus, um jede Umgebungsvariable zu exportieren. Durch das Exportieren von Umgebungsvariablen stehen sie im gesamten Programm oder bis Terraform ausgeführt wird zur Verfügung.

# Exportieren der Variablen AWS_ACCESS_KEY_ID
export AWS_ACCESS_KEY_ID="access-key"
# Exportieren von AWS_SECRET_ACCESS_KEY
export AWS_SECRET_ACCESS_KEY="secret-key"
# Exportieren von AWS_DEFAULT_REGION
export AWS_DEFAULT_REGION="us-east-2"

Speichern mehrerer Anmeldeinformationen in einem benannten Profil

Sowohl das Festcodieren als auch das Deklarieren von Anmeldeinformationen als Umgebungsvariablen ermöglichen die Authentifizierung eines AWS-Kontos einzeln. Aber was ist, wenn Sie mehrere Anmeldeinformationen speichern und sie bei Bedarf verwenden müssen? Das Speichern von Anmeldeinformationen in einem benannten Profil ist die ideale Option.

Der folgende Code erstellt ein benanntes Profil (Myprofile), das einen Zugriffsschlüssel und einen geheimen Schlüssel enthält.

Der Standardort der benannten Profile ist $HOME/.aws/credentials/Myprofile unter Linux und macOS oder %USERPROFILE%\.aws\credentials\Myprofile unter Windows. Ersetzen Sie Myprofile durch den tatsächlichen Namen des benannten Profils.

# Erstellen des benannten Profils namens 'Mein Profil'
[Myprofile]
aws_access_key_id = AKIAVWOJMI5836154yRW31
aws_secret_accesss_key = vIaGmx2bJCAK90hQbpNhPV2k5wlW7JsVrP1bm9Ft

Nachdem Sie ein benanntes Profil in ~/.aws/credentials erstellt haben, können Sie dieses Profil in Ihrer Terraform-Konfiguration mit dem Profil-Attribut referenzieren. Im Folgenden verweisen Sie auf das benannte Profil namens Mein Profil.

# Konfigurieren des AWS-Anbieters namens 'aws' in der Region us-east-2
provider "aws" {
  region = "us-east-2"
  # Deklarieren des benannten Profils (Mein Profil)
  profile = "Myprofile"
}

Deklarieren des Assume Role im AWS-Anbieter

Sie haben gerade gelernt, einen AWS-Anbieter zu konfigurieren, indem Sie fest codierte Anmeldeinformationen deklarieren, bevor Sie Terraform ausführen. Aber vielleicht möchten Sie Anmeldeinformationen zur Laufzeit deklarieren. Wenn ja, ist die AssumeRole-API das, was Sie brauchen. AssumeRole bietet temporäre Anmeldeinformationen, die eine Zugriffsschlüssel-ID, geheime Zugriffsschlüssel und ein Sicherheitstoken enthalten. Mit diesen Anmeldeinformationen können Sie eine Verbindung zu AWS herstellen.

Der folgende Code deklariert den Anbieter namens aws und eine assume_role, die einen Rollennamen und einen Sitzungsnamen enthält. Um den Zugriff auf AssumeRole zu konfigurieren, müssen Sie eine IAM-Rolle definieren, die die Berechtigungen festlegt, die sie gewährt, und welche Entitäten sie annehmen können.

# Deklarieren des AWS-Anbieters namens 'aws'
provider "aws" {
  # Deklarieren von AssumeRole
  assume_role {
		# Deklarieren eines Ressourcennamens.
    # Die role_arn ist der Amazon Resource Name (ARN) der IAM-Rolle, die angenommen werden soll.
    # ARN ist eine eindeutige Nummer, die allen Ressourcen im AWS-Konto zugeordnet ist.
    role_arn     = "arn:aws:iam::ACCOUNT_ID:role/ROLE_NAME"
    # Deklarieren eines Sitzungsnamens
    session_name = "SESSION_NAME"
  }
}

Multiple AWS-Anbieter deklarieren

Sie haben nun gelernt, wie Sie den AWS-Anbieter in Terraform deklarieren und konfigurieren können, der mit einer einzelnen Region funktioniert. Aber was ist, wenn Sie Ihre Infrastruktur oder AWS-Services in mehreren Cloud-Regionen verwalten müssen? In diesem Fall müssen Sie das Schlüsselwort alias deklarieren.

Das Alias ermöglicht es, mehrere Konfigurationen für denselben Anbieter zu definieren und auszuwählen, welche auf einer pro-Ressource oder pro-Modul-Basis verwendet werden sollen oder mehrere Regionen zu unterstützen.

Der folgende Code deklariert den Standard-AWS-Anbieter mit dem Namen aws und der Einstellung region auf us-east-2. Und dann wird ein zusätzlicher AWS-Anbieter mit demselben Namen deklariert, aber mit einem deklarierten alias namens west und einer region auf us-west-2.

Das Deklarieren eines alias ermöglicht es Ihnen, standardmäßig Ressourcen in der Region us-east-2 zu erstellen oder, je nach Bedarf, in der Region us-west-2, wenn Sie den Anbieter aws.west wählen.

# Die Standardanbieterkonfigurationsressourcen, die mit aws. beginnen.
provider "aws" {
  # Deklaration der Region us-east-2 für den AWS-Anbieter mit dem Namen 'aws'
  region = "us-east-2" 
}

# Zusätzliche Anbieterkonfiguration für die westliche Region.
# Ressourcen können auf aws.west verweisen.
provider "aws" {
  alias  = "west"
  # Deklaration der Region us-west-2 für den AWS-Anbieter mit dem Verweis 'west'
  region = "us-west-2"
}

# Deklaration der Ressource mit einem zusätzlichen Anbieter in der westlichen Region
resource "aws_instance" "west-region" {
  # Deklaration des Anbieters als aws.west
  # aws.west wird vom AWS-Anbieter mit dem Namen 'aws' und dem Alias 'west' referenziert
  provider = aws.west
}

# Deklaration der Ressource unter Verwendung des Standardanbieters
resource "aws_instance" "east-region" 
}

Anpassen der Endpunktkonfiguration des AWS-Anbieters

Das Anpassen der Endpunktkonfiguration ist nützlich, wenn Sie sich mit nicht standardmäßigen AWS-Service-Endpunkten wie AWS Snowball verbinden oder lokale Tests durchführen möchten.

Konfigurieren Sie den Terraform AWS-Anbieter so, dass benutzerdefinierte Endpunkte verwendet werden. Tun Sie dies, indem Sie den Konfigurationsblock endpoints innerhalb des Blocks des Anbieters deklarieren, wie unten gezeigt.

Die folgende Konfiguration ermöglicht Ihnen den Zugriff auf den AWS S3-Dienst am lokalen Port 4572, als ob Sie tatsächlich auf den AWS S3-Dienst in einem AWS-Konto zugreifen würden. Ebenso ermöglicht es Ihnen, lokal auf Port 4569 auf dynamodb zuzugreifen. DynamoDB ist ein NoSQL-Datenbankdienst, der schnelle Leistung bei nahtloser Skalierbarkeit bietet.

Überprüfen Sie die Liste der benutzerdefinierten Endpunkte, die der Terraform AWS-Anbieter zulässt.

# Deklaration des AWS-Anbieters mit dem Namen 'aws'
provider "aws" {
  # Deklaration der Endpunkte
  endpoints { 
    # Deklaration von dynamodb auf dem localhost mit Port 4569 
    dynamodb = "<http://localhost:4569>"  
    # Deklaration von S3 auf dem localhost mit Port 4572
    s3 = "<http://localhost:4572>"  
  }
}

Hinzufügen von Tags

Zuvor haben Sie gelernt, wie ein AWS-Anbieter mit Konfigurationen wie Region, Quellort usw. deklariert wird. Um Ihre Ressourcen besser zu verwalten, müssen Sie jedoch auf Anbieterebene Tags hinzufügen.

Tags sind Bezeichnungen, die aus benutzerdefinierten Schlüsseln und Werten bestehen. Tags sind praktisch, wenn Sie die Abrechnung, Eigentumsverhältnisse, Automatisierung, Zugriffskontrolle und viele andere Anwendungsfälle im AWS-Konto überprüfen müssen.

Anstatt Tags zu allen Ressourcen einzeln hinzuzufügen, lernen wir, wie man Tags auf Anbieterebene hinzufügt, was viel Code und Zeit spart.

Der folgende Code konfiguriert einen AWS-Anbieter mit Tags, die innerhalb der default_tags definiert sind. Der Vorteil des Hinzufügens von Tags innerhalb des Anbieters besteht darin, dass die angegebenen Tags automatisch hinzugefügt werden, wenn Sie eine Ressource mit diesem Anbieter erstellen.

# Konfiguration des AWS-Anbieters mit dem Namen 'aws'
provider "aws" {
  # Hinzufügen der Standardtags Umgebung und Besitzer auf Anbieterebene
  default_tags {
    # Deklaration der Tagwerte
    tags = {
      Environment = "Production"
      Owner       = "shanky"
    }
  }
}
# Erstellen der Ressource 'aws_vpc' mit dem Tag Name=MyVPC
resource "aws_vpc" "myinstance" {
  tags = {
    Name = "MyVPC"
  }
}

Tags ignorieren

Das Aktivieren von Tags auf Anbieterebene hilft dabei, Tags in der gesamten Umgebung anzuwenden. Aber manchmal müssen Sie die Tags ignorieren, zum Beispiel, wenn Sie einem EC2-Instanz keinen Standardtag hinzufügen möchten und ihn stattdessen auf die restlichen Ressourcen im AWS-Konto anwenden möchten. Lass es uns überprüfen!

Der folgende Code konfiguriert einen AWS-Anbieter mit dem innerhalb des Anbieters definierten ignore_tags. Der Vorteil der Verwendung des Ignore-Tags besteht darin, dass Sie Standardtags für bestimmte Ressourcen nicht hinzufügen möchten und sie stattdessen auf die restlichen Ressourcen anwenden möchten.

Im unten stehenden Code werden beim Erstellen einer Ressource mit dem aws-Anbieter alle Ressourcen die Tags LastScanned und kubernetes.io ignorieren.

# Konfiguration des AWS-Anbieters mit dem Namen aws
provider "aws" {
	# Tags mit key_prefixes und Schlüsseln für alle Ressourcen unter dem AWS-Anbieter (aws) ignorieren
  ignore_tags {
    key_prefixes = ["kubernetes.io"]
  }
  ignore_tags {
    keys = ["LastScanned"]
  }
}

Erstellen eines AWS S3 Buckets

Sie haben nun alles über die Deklaration und Konfiguration der AWS-Anbieter im Detail gelernt. Aber nur die Deklaration des AWS-Anbieters bewirkt nichts, bis Sie AWS-Ressourcen verwalten, wie z.B. die Bereitstellung eines AWS S3-Buckets oder das Löschen einer Ec2-Instanz usw. Also, lassen Sie uns lernen, wie man einen AWS S3-Bucket erstellt!

1. Erstellen Sie einen Ordner namens ~/terraform-s3-demo, und wechseln Sie dann (cd) in diesen Ordner. Der Ordner ~/terraform-s3-demo enthält Ihre Konfigurationsdatei und alle zugehörigen Dateien, die Terraform erstellen wird.

mkdir ~/terraform-s3-demo
cd ~/terraform-s3-demo

2. Kopieren Sie die unten stehende Konfiguration in Ihren bevorzugten Code-Editor und speichern Sie sie als main.tf im Verzeichnis ~/terraform-s3-demo.

Die Datei main.tf erstellt einige notwendige Ressourcen:

  • Provider-Anforderung: Eine Provider-Anforderung besteht aus einem lokalen Namen, einem Quellort und einer Versionsbeschränkung.
  • Verschlüsselungsschlüssel: Der Amazon S3-Verschlüsselungsschlüssel hilft dem S3-Bucket, sodass alle neuen Objekte verschlüsselt werden, wenn sie im Bucket gespeichert werden. Verschlüsselungsschlüssel werden mit aws_kms_key in Terraform erstellt.
  • Konfiguration des AWS-Anbieters: Deklaration des Anbieternamens (aws) zusammen mit der Region us-east-2.
  • Eimer: Dieses Terraform-Modul erstellt einen Eimer namens terraformdemobucket. Terraform kann diesen Eimer nicht zerstören, da er einen Flag force_destroy enthält.

Versionierung: Versionierung in Amazon S3 bedeutet, mehrere Versionen eines Objekts im selben Eimer zu behalten

# Konfiguration des AWS-Anbieters namens aws
provider "aws" {
# Ignorieren von Tag-Schlüsselpräfixen und Schlüsseln für alle Ressourcen unter einem Anbieter aws. 
  ignore_tags {
    key_prefixes = ["kubernetes.io/"]
  }
  ignore_tags {
    keys = ["LastScanned"]
  }
}

# Deklaration der Anforderungen des Anbieters
terraform {
  required_providers {
    aws = {
      source = "hashicorp/aws"
      version = "~> 3.0"
    }
  }
}

# Konfiguration des AWS-Anbieters (aws) mit der Region 'us-east-2' festgelegt
provider "aws" {
  region = "us-east-2"
}

# Gewähren des Eimerzugriffs
resource "aws_s3_bucket_public_access_block" "publicaccess" {
  bucket = aws_s3_bucket.demobucket.id
  block_public_acls = false
  block_public_policy = false
}

# Erstellen des Verschlüsselungsschlüssels, der die Eimerobjekte verschlüsselt
resource "aws_kms_key" "mykey" {
  deletion_window_in_days = "20"
}

# Erstellen des Eimers namens terraformdemobucket
resource "aws_s3_bucket" "demobucket" {
  bucket = terraformdemobucket
  force_destroy = false
  server_side_encryption_configuration {
    rule {
        apply_server_side_encryption_by_default {
        kms_master_key_id = aws_kms_key.mykey.arn
        sse_algorithm = "aws:kms"
      }
    }
  }
  # Mehrere Versionen eines Objekts im selben Eimer behalten
  versioning {
    enabled = true
  }
}

3. Führen Sie nun die folgenden Befehle aus, um zum Verzeichnis ~\\terraform-s3-demo zu navigieren und Terraform zu initialisieren. Terraform initialisiert die Plugins und Anbieter, die zum Arbeiten mit Ressourcen erforderlich sind.

Verwandt:Erstellen Sie Ihren ersten EKS-Cluster mit Terraform [Schritt für Schritt]

Terraform verwendet typischerweise einen Dreischritt-Ansatz in sequenzieller Reihenfolge terraform init, terraform plan und terraform apply. 

cd ~\terraform-s3-demo       # Wechseln Sie zum Verzeichnis ~\terraform-s3-demo
terraform init               # Initialisieren Sie Terraform
terraform plan               # Stellen Sie sicher, dass die Syntax Ihrer Konfiguration korrekt ist
terraform apply -auto-approve # Bereitstellung des AWS S3-Buckets

Erstellen von AWS EC2-Instanzen und IAM-Benutzern

In dem vorherigen Abschnitt haben Sie gelernt, wie Sie ein einzelnes Objekt (AWS S3-Bucket) mit Terraform und dem AWS-Provider erstellen können. Tatsächlich können Sie jedoch mehrere Objekte derselben Art mit Terraform und dem AWS-Provider erstellen.

1. Erstellen Sie einen Ordner mit dem Namen ~/terraform-ec2-iam-demo, und navigieren Sie dann dorthin

2. Öffnen Sie Ihren bevorzugten Code-Editor, kopieren Sie die Konfiguration unten und speichern Sie die Datei als main.tf im Verzeichnis ~/terraform-ec2-iam-demo.

Der folgende Code erstellt zwei EC2-Instanzen ec21a und ec21a mit den t2.micro und t2.medium Instanztypen und erstellt dann IAM-Benutzer mit vier verschiedenen Namen. Das im Code deklarierte ami ist ein Amazon Machine Image (AMI), das die erforderlichen Informationen für das Starten einer Instanz bereitstellt, wie z. B. den OS-Typ, welche Software zu installieren ist, usw.

Sie können Linux-AMIs über die Amazon EC2-Konsole finden.

# Erstellen der Instanz mit dem instance_type t2.micro und t2.medium
resource "aws_instance" "my-machine" {
# AMI deklarieren
  ami = "ami-0a91cd140a1fc148a"
  for_each  = {
      key1 = "t2.micro"
	    key2 = "t2.medium"
   }
  instance_type  = each.value
	key_name       = each.key
    tags =  {
	   Name  = each.value
	}
}
# Erstellen der IAM-Benutzer mit vier verschiedenen Namen
resource "aws_iam_user" "accounts" {
  for_each = toset( ["Account1", "Account2", "Account3", "Account4"] )
  name     = each.key
}

3. Als nächstes erstellen Sie eine weitere Datei, kopieren Sie den folgenden Code und speichern Sie die Datei als vars.tf im Verzeichnis ~/terraform-ec2-iam-demo.

Der folgende Code deklariert alle Variablen, auf die im main.tf-Datei verwiesen wird. Nach Ausführung des Terraform-Codes wird die Variable tag_ec2 mit den Werten ec21a und ec21b den beiden im main.tf-Datei definierten EC2-Instanzen zugewiesen. 

variable "tag_ec2" {
  type = list(string)
  default = ["ec21a","ec21b"]
}

4. Erstellen Sie eine weitere Terraform-Konfigurationsdatei mit dem Namen output.tf im Verzeichnis ~/terraform-ec2-iam-demo, kopieren Sie dann den folgenden Code in die Datei output.tf.

Nach erfolgreicher Ausführung des Befehls terraform apply sollten Sie am Ende der Ausgabe des Befehls die Werte von ${aws_instance.my-machine.*.id} und ${aws_iam_user.accounts.*.name} sehen.

Der folgende Code weist Terraform an, auf die in der main.tf-Konfigurationsdatei definierten Ressourcen aws_instance und aws_iam_user zu verweisen.

output "aws_instance" {
   value = "${aws_instance.my-machine.*.id}"
}
output "aws_iam_user" {
   value = "${aws_iam_user.accounts.*.name}"
}

5. Erstellen Sie eine weitere Konfigurationsdatei im Verzeichnis ~/terraform-ec2-iam-demo mit dem Namen provider.tf und fügen Sie den untenstehenden Code in die Datei provider.tf ein. Die folgende provider.tf-Datei definiert den Terraform AWS-Provider, damit Terraform weiß, wie er mit all den AWS-Ressourcen interagieren soll, die Sie in den vorherigen Schritten definiert haben. 

provider "aws" {
   region = "us-east-2"
 }

6. Überprüfen Sie nun, ob alle erforderlichen Dateien im Ordner ~/terraform-ec2-iam-demo mit dem Befehl tree enthalten sind.

Showing all the Terraform configuration files required

7. Führen Sie die folgenden Befehle in aufeinanderfolgender Reihenfolge aus, um Terraform zu initialisieren und AWS EC2-Instanzen und IAM-Benutzer zu erstellen. 

terraform init
terraform plan
terraform apply
Terraform apply command executed successfully.

Schließlich wechseln Sie zur AWS Management Console und dann zur AWS EC2-Service- und IAM-Konsole.

In den folgenden Screenshots können Sie überprüfen, ob die EC2-Instanzen und IAM-Benutzer vorhanden sind.

Verifying the two EC2 instances that got created using Terraform
Verifying the four IAM users that got created using Terraform

Fazit

Mit diesem ultimativen Leitfaden haben Sie jetzt das Wissen, das Sie benötigen, um mit dem AWS Provider zu arbeiten, von der Deklaration bis zur Ausführung des AWS Providers innerhalb von Terraform. Sie haben auch gelernt, wie der AWS Provider es Ihnen ermöglicht, Anmeldeinformationen auf sichere Weise auf verschiedene Arten zu deklarieren.

Welchen AWS-Dienst haben Sie jetzt vor, mit AWS Provider und Terraform zu verwalten?

Source:
https://adamtheautomator.com/terraform-aws/