Epic Terraform AWS Provider voor uw Amazon-infrastructuur

Handleidingen
AWS Terraform

Als je van plan bent om te werken met Amazon Web Services (AWS), is het gebruik van de Terraform AWS-provider een absolute must. Het stelt je in staat om te communiceren met de vele resources die door AWS worden ondersteund, zoals Amazon S3, Elastic Beanstalk, Lambda, en nog veel meer.

In deze ultieme handleiding ga je stap voor stap leren over bijna alles wat je moet weten over de AWS-provider en hoe je deze provider kunt gebruiken met Terraform om je Amazon-infrastructuur te beheren.

Laten we eraan beginnen!

Vereisten

Als je deze tutorial wilt volgen, zorg er dan voor dat je het volgende hebt:

Gerelateerd:Hoe Terraform te installeren op 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.

Gerelateerd:Wat je moet weten over Visual Studio Code: Een tutorial

Wat is de Terraform AWS-provider?

Terraform is afhankelijk van plugins om te communiceren met cloudproviders zoals AWS, Google Cloud Platform (GCP) en Oracle. Een van de meest gebruikte providers is de AWS-provider. Deze provider communiceert met veel resources die worden ondersteund door AWS, zoals Amazon S3, Elastic Beanstalk, Lambda, en nog veel meer.

Terraform gebruikt de AWS-provider met de juiste referenties om verbinding te maken met Amazon om tientallen AWS-services te beheren of implementeren/bijwerken.

De AWS-provider wordt gedeclareerd in het Terraform-configuratiebestand en bevat verschillende parameters zoals versie, eindpunt-URL’s of cloudregio’s, enz.

Declaratie van de AWS-provider

Wanneer u naar de naam van een provider moet verwijzen, moet u een lokale naam definiëren. De lokale naam is de naam van de provider die wordt toegewezen binnen het required_providers-blok. Lokale namen worden toegewezen bij het vereisen van een provider en moeten uniek zijn per module.

Bij het declareren van de required_providers moet u ook de source-parameter in Terraform 0.13 en latere versies declareren. De source-parameter stelt het bronadres in waar Terraform plugins kan downloaden.

Bronadressen bestaan uit drie delen, zoals hieronder beschreven:

  • Hostname – De hostname van het Terraform-register dat de provider distribueert. De standaard hostname is registry.terraform.io.
  • Namespace – Een organisatorische namespace binnen het gespecificeerde register.
  • Type – Een type is een korte naam die u opgeeft voor het platform of systeem dat de provider beheert, en het moet uniek zijn.

Hieronder ziet u de syntaxis voor de declaratie van de source-parameter, waarbij de drie delen van een bronadres worden gescheiden door slashes (/).

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

# VOORBEELD VAN GEBRUIK VAN BRONPARAMETERSYNTAX

# De bronlocatie/adres waar Terraform plugins kan downloaden
# De officiële AWS-provider behoort tot de hashicorp-namespace op de 
# registry.terraform.io-registry. Dus, het adres van hashicorp's bron is hashicorp/aws
source  = "hashicorp/aws"

De Terraform-configuratie hieronder verklaart nu de vereiste naam van de provider (aws), samen met het bronadres, de versie van de AWS-provider, en configureert de regio van de provider (us-east-2).

# Verklaren van de vereisten van de provider wanneer Terraform 0.13 of later is geïnstalleerd
terraform {
  # Een vereiste van de provider bestaat uit een lokale naam (aws), 
  # bronlocatie en een versiebeperking. 
  required_providers {
    aws = {     
      # De bronlocatie/adres aangeven waar Terraform plugins kan downloaden
      source  = "hashicorp/aws"
      # De versie van de aws-provider als groter dan 3.0 verklaren
      version = "~> 3.0"  
    }
  }
}

# Configuratie van de AWS-provider in de regio us-east-2
provider "aws" {
  region = "us-east-2"
}

Authenticeren van een AWS-account met hardgecodeerde referenties

Nu je een basiskennis hebt van hoe je de AWS-provider kunt verklaren, gaan we over naar hoe je een AWS-account kunt authenticeren.

U kunt de AWS-provider authenticeren via verschillende methoden, zoals het declareren van omgevingsvariabelen en het opslaan van referenties in een genoemd profiel. Maar de snelste manier om u aan te melden bij een AWS-account is door de referenties rechtstreeks in uw AWS-provider te coderen.

Hoewel hardgecodeerde referenties niet worden aanbevolen omdat ze gevoelig zijn voor lekken, kunt u nog steeds hardgecodeerde referenties declareren in de Terraform-configuratie om snel een AWS-resource te testen. Maar lees verder en u zult later een betere manier leren om een AWS-account te authenticeren door omgevingsvariabelen te declareren.

De onderstaande configuratie declareert een lokale naam (aws) samen met de regio van de provider (us-east-2), zoals hieronder weergegeven. U kunt zien dat het AWS-providerblok ook een toegangs- en geheime sleutel declareert om een AWS-account te authenticeren.

# Het declareren van een AWS-provider met de naam aws
provider "aws" {
  # Het declareren van de providerregio
  region = "us-east-2"
  # Het declareren van de toegangs- en geheime sleutel
  access_key = "access-key"
  secret_key = "secret-key"
}

Referenties beveiligen door omgevingsvariabelen te declareren

U heeft zojuist geleerd dat het mogelijk is om statische referenties hard te coderen om AWS-cloudservices te authenticeren met Terraform. Maar, hard coderen is onveilig en alleen aanbevolen tijdens implementatie in een testomgeving om code snel te testen.

Is er een andere manier om referenties te beveiligen? Ja, door ze te declareren als omgevingsvariabelen, is er geen limiet aan hoeveel je er kunt declareren. Omgevingsvariabelen zijn variabelen waarvan de waarden buiten het terraform configuratiebestand worden ingesteld en bestaan uit een naam/waarde-paar.

Voer de reeks export commando’s hieronder uit om elke omgevingsvariabele te exporteren. Door omgevingsvariabelen te exporteren zijn ze beschikbaar in het hele programma of totdat Terraform wordt uitgevoerd.

# Variabele AWS_ACCESS_KEY_ID exporteren
export AWS_ACCESS_KEY_ID="access-key"
# Variabele AWS_SECRET_ACCESS_KEY exporteren
export AWS_SECRET_ACCESS_KEY="secret-key"
# Variabele AWS_DEFAULT_REGION exporteren
export AWS_DEFAULT_REGION="us-east-2"

Het opslaan van meerdere referenties in een genoemd profiel

Zowel hardcoderen als het declareren van referenties als omgevingsvariabelen stellen je in staat om één voor één een AWS-account te authenticeren. Maar wat als je meerdere referenties moet opslaan en ze wilt gebruiken wanneer dat nodig is? Het opslaan van referenties in een genoemd profiel is de ideale optie.

De code hieronder maakt een genoemd profiel (Mijnprofiel) aan dat een toegangscode en geheime toegangscode bevat.

De standaardlocatie van de genoemde profielen is $HOME/.aws/credentials/Mijnprofiel op Linux en macOS, of %USERPROFILE%\.aws\credentials\Mijnprofiel op Windows. Vervang Mijnprofiel door de daadwerkelijke naam van het genoemde profiel.

# Het aanmaken van het genoemde profiel genaamd 'Mijnprofiel'
[Myprofile]
aws_access_key_id = AKIAVWOJMI5836154yRW31
aws_secret_accesss_key = vIaGmx2bJCAK90hQbpNhPV2k5wlW7JsVrP1bm9Ft

Nadat je een genoemd profiel hebt aangemaakt in ~/.aws/credentials, kun je vervolgens naar dat profiel verwijzen in je Terraform-configuratie met behulp van het profiel-attribuut. Hieronder verwijs je naar het genoemde profiel genaamd Mijnprofiel.

# Het configureren van de AWS-provider genaamd 'aws' in de regio us-east-2
provider "aws" {
  region = "us-east-2"
  # Het verklaren van een genoemd profiel (Mijnprofiel)
  profile = "Myprofile"
}

Het verklaren van de Assumerol in de AWS-provider

Je hebt zojuist geleerd hoe je een AWS-provider kunt configureren door hardgecodeerde referenties te verklaren voordat je Terraform uitvoert. Maar misschien wil je referenties op uitvoeringstijd verklaren. Zo ja, dan heb je de AssumeRole-API nodig. AssumeRole biedt tijdelijke referenties die een toegangssleutel-ID, geheime toegangssleutel en een beveiligingstoken bevatten. Met deze referenties kun je verbinding maken met AWS.

De onderstaande code verklaart de provider genaamd aws en een assume_role die een rolnaam en een sessienaam bevat. Om toegang tot AssumeRole te configureren, moet je een IAM-rol definiëren die de privileges specificeert die het verleent en welke entiteiten het kunnen aannemen.

# Verklaring van AWS-provider genaamd 'aws'
provider "aws" {
  # Verklaring van AssumeRole
  assume_role {
		# Verklaring van een bron naam. 
    # De rol_arn is de Amazon Resource Name (ARN) van de IAM Role die moet worden aangenomen. 
    # ARN is een uniek nummer dat is uitgelijnd met alle resources in het AWS-account.
    role_arn     = "arn:aws:iam::ACCOUNT_ID:role/ROLE_NAME"
    # Verklaring van een sessienaam
    session_name = "SESSION_NAME"
  }
}

Verklaring van Meerdere AWS-providers

Je hebt nu geleerd hoe je AWS Provider in Terraform moet verklaren en configureren die werkt met een enkele regio. Maar wat als je je infrastructuur of AWS-services in meerdere cloudregio’s moet beheren? In dat geval moet je het trefwoord alias verklaren.

De alias maakt het mogelijk om meerdere configuraties te definiëren voor dezelfde provider en te selecteren welke te gebruiken op basis van een bron of module, of om meerdere regio’s te ondersteunen.

De onderstaande code verklaart de standaard AWS-provider met de naam aws met de regio ingesteld op us-east-2. En verklaart vervolgens een extra AWS-provider met dezelfde naam, maar met een verklaarde alias met de naam west en een regio ingesteld op us-west-2.

Verklaren van een alias stelt u in staat om resources te maken in de regio us-east-2 standaard, of in de regio us-west-2 als u de provider aws.west kiest, afhankelijk van de vereisten.

# De standaardprovider configuratieresources die beginnen met aws.
provider "aws" {
  # Declaratie van regio us-east-2 voor AWS-provider met de naam 'aws'
  region = "us-east-2" 
}

# Extra providerconfiguratie voor de westelijke regio.
# Resources kunnen hiernaar verwijzen als aws.west.
provider "aws" {
  alias  = "west"
  # Verklaring van regio us-west-2 voor AWS-provider aangeduid als 'west'
  region = "us-west-2"
}

# Declaratie van de resource met behulp van een extra provider in de westelijke regio
resource "aws_instance" "west-region" {
  # Verklaring van provider als aws.west
  # aws.west wordt gebruikt als referentie van de AWS-provider met de naam 'aws' en met de alias 'west'
  provider = aws.west
}

# Declaratie van de resource met behulp van de standaardprovider
resource "aws_instance" "east-region" 
}

Aanpassen van de Endpoint-configuratie van de AWS-provider

Het aanpassen van de eindpuntconfiguratie is handig bij het verbinden met niet-standaard AWS-service-eindpunten, zoals AWS Snowball, of bij het uitvoeren van lokale tests.

provider: Configureer de Terraform AWS Provider om aangepaste eindpunten te gebruiken. Doe dit door het endpoints-configuratieblok binnen het blok van de provider te verklaren, zoals hieronder getoond.

De onderstaande configuratie stelt u in staat om toegang te krijgen tot de AWS S3-service op de lokale poort 4572, alsof u daadwerkelijk toegang hebt tot de AWS S3-service op een AWS-account. Op dezelfde manier kunt u via de configuratie dynamodb lokaal toegang krijgen op poort 4569. DynamoDB is een NoSQL-database service die snelle prestaties biedt met naadloze schaalbaarheid.

Controleer de lijst met aangepaste eindpunten die Terraform AWS Provider toestaat.

# Verklaren van AWS-provider genaamd 'aws'
provider "aws" {
  # Verklaren van eindpunten
  endpoints { 
    # Verklaren van dynamodb op de localhost met poort 4569 
    dynamodb = "<http://localhost:4569>"  
    # Verklaren van S3 op de localhost met poort 4572
    s3 = "<http://localhost:4572>"  
  }
}

Tags toevoegen

Eerder heb je geleerd hoe een AWS-provider wordt verklaard met configuraties zoals regio, bronlocatie, enz. Maar om uw middelen beter te beheren, moet u tags op het niveau van de provider toevoegen.

Tags zijn labels bestaande uit door de gebruiker gedefinieerde sleutels en waarden. Tags zijn handig wanneer je de facturatie, eigendom, automatisering, toegangscontrole en vele andere gebruiksscenario’s in het AWS-account moet controleren.

In plaats van tags toe te voegen aan alle resources afzonderlijk, laten we leren hoe we tags kunnen toevoegen aan alle resources op het niveau van de provider, wat veel code en tijd zal besparen.

De onderstaande code configureert een AWS-provider met tags gedefinieerd binnen de default_tags. Het voordeel van het toevoegen van tags binnen de provider is dat gespecificeerde tags automatisch worden toegevoegd wanneer je een resource maakt met deze provider.

# Configuratie van de AWS-provider genaamd 'aws'
provider "aws" {
  # Toevoegen van de standaardtags Environment en Owner op het niveau van de provider
  default_tags {
    # Declaratie van tagwaarden
    tags = {
      Environment = "Production"
      Owner       = "shanky"
    }
  }
}
# Het creëren van de resource 'aws_vpc' getagd met Name=MyVPC
resource "aws_vpc" "myinstance" {
  tags = {
    Name = "MyVPC"
  }
}

Tags negeren

Het inschakelen van tags op provider niveau helpt bij het toepassen van tags door de hele omgeving. Maar soms moet je de tags negeren, zoals wanneer je geen standaardtag wilt toevoegen aan een EC2-instantie en deze liever wilt toepassen op de rest van de resources in het AWS-account. Laten we eens kijken!

De onderstaande code configureert een AWS-provider met ignore_tags gedefinieerd binnen de provider. Het voordeel van het gebruik van de ignore-tag is dat wanneer je geen standaardtags wilt toevoegen aan bepaalde resources en deze wilt toepassen op de rest van de resources.

In de onderstaande code, wanneer je een bron creëert met behulp van de aws-provider, zullen alle resources de tags LastScanned en kubernetes.io negeren.

# Configuratie van de AWS-provider met de naam aws
provider "aws" {
	# Negeer tag key_prefixes en keys voor alle resources onder de AWS-provider (aws)
  ignore_tags {
    key_prefixes = ["kubernetes.io"]
  }
  ignore_tags {
    keys = ["LastScanned"]
  }
}

Creëer een AWS S3-bucket

Je hebt nu alles geleerd over hoe je AWS-providers in detail declareert en configureert. Maar alleen het declareren van de AWS-provider doet niets totdat je AWS-resources beheert, zoals het aanmaken van een AWS S3-bucket of het verwijderen van een Ec2-instantie, enzovoort. Laten we dus leren hoe je een AWS S3-bucket maakt!

1. Maak een map met de naam ~/terraform-s3-demo, en wijzig vervolgens met het commando (cd) naar die map. De ~/terraform-s3-demo-map bevat je configuratiebestand en alle bijbehorende bestanden die Terraform zal aanmaken. 

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

2. Kopieer en plak de onderstaande configuratie in je favoriete code-editor en sla het op als main.tf in de map ~/terraform-s3-demo.

Het bestand main.tf maakt een paar noodzakelijke resources aan:

  • Providervereiste: Een providervereiste bestaat uit een lokale naam, de locatie van de bron en een versiebeperking.
  • Encryptiesleutel: De Amazon S3-encryptiesleutel helpt de S3-bucket zodat alle nieuwe objecten worden versleuteld wanneer ze worden opgeslagen in de bucket. Encryptiesleutels worden aangemaakt met behulp van aws_kms_key in Terraform.
  • Configuratie van AWS-provider: Verklaren van de providernaam (aws) samen met de regio us-east-2.
  • Bucket: Deze Terraform-module maakt een bucket met de naam terraformdemobucket aan. Terraform kan deze bucket niet vernietigen omdat het de vlag force_destroy bevat.

Versiebeheer: Versiebeheer in Amazon S3 betekent dat er meerdere versies van een object in dezelfde bucket worden bewaard

# Configuratie van de AWS-provider genaamd aws
provider "aws" {
# Negeer tag key_prefixes en keys voor alle resources onder een provider aws. 
  ignore_tags {
    key_prefixes = ["kubernetes.io/"]
  }
  ignore_tags {
    keys = ["LastScanned"]
  }
}

# Verklaren van de providervereisten
terraform {
  required_providers {
    aws = {
      source = "hashicorp/aws"
      version = "~> 3.0"
    }
  }
}

# Configuratie van de AWS-provider (aws) met regio ingesteld op 'us-east-2'
provider "aws" {
  region = "us-east-2"
}

# Verlenen van toegang tot de bucket
resource "aws_s3_bucket_public_access_block" "publicaccess" {
  bucket = aws_s3_bucket.demobucket.id
  block_public_acls = false
  block_public_policy = false
}

# Aanmaken van de versleutelingssleutel die de objecten in de bucket zal versleutelen
resource "aws_kms_key" "mykey" {
  deletion_window_in_days = "20"
}

# Aanmaken van de bucket met de naam 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"
      }
    }
  }
  # Bewaren van meerdere versies van een object in dezelfde bucket
  versioning {
    enabled = true
  }
}

3. Voer nu de onderstaande commando’s uit om naar de map ~\\terraform-s3-demo te navigeren en Terraform te initiëren. Terraform initialiseert de plugins en providers die nodig zijn om met resources te werken.

Gerelateerd:Je eerste EKS-cluster maken met Terraform [Stap-voor-stap]

Terraform gebruikt doorgaans een driestappenbenadering in sequentiële volgorde: terraform init, terraform plan en terraform apply. 

cd ~\terraform-s3-demo       # Ga naar de map ~\terraform-s3-demo
terraform init               # Initialiseer Terraform
terraform plan               # Zorg ervoor dat de syntaxis van je configuratie correct is
terraform apply -auto-approve # Voorzie de AWS S3-bucket

Maak AWS EC2-instanties en IAM-gebruikers

In het vorige gedeelte heb je geleerd hoe je een enkel object (AWS S3-bucket) kunt maken met Terraform en de AWS Provider. Maar eigenlijk kun je met Terraform en de AWS Provider meerdere objecten van dezelfde soort maken.

1. Maak een map met de naam ~/terraform-ec2-iam-demo, en ga er vervolgens naartoe.

2. Open je favoriete code-editor, kopieer/plak de onderstaande configuratie, en sla het bestand op als main.tf in de ~/terraform-ec2-iam-demo directory.

De onderstaande code creëert twee EC2-instanties ec21a en ec21a, met t2.micro en t2.medium instantietypes, en maakt vervolgens IAM-gebruikers met vier verschillende namen aan. De in de code aangegeven ami is een Amazon Machine Image (AMI), die de benodigde informatie levert om een instantie te starten, zoals het type besturingssysteem, welke software te installeren, enz.

Je kunt Linux AMI’s vinden via de Amazon EC2-console.

# Het maken van de instantie met de instantietype t2.micro en t2.medium
resource "aws_instance" "my-machine" {
# Het declareren van de AMI
  ami = "ami-0a91cd140a1fc148a"
  for_each  = {
      key1 = "t2.micro"
	    key2 = "t2.medium"
   }
  instance_type  = each.value
	key_name       = each.key
    tags =  {
	   Name  = each.value
	}
}
# Het aanmaken van de IAM-gebruikers met vier verschillende namen
resource "aws_iam_user" "accounts" {
  for_each = toset( ["Account1", "Account2", "Account3", "Account4"] )
  name     = each.key
}

3. Maak vervolgens een ander bestand, kopieer/plak de onderstaande code en sla het bestand op als vars.tf in de ~/terraform-ec2-iam-demo directory.

De onderstaande code declareert alle variabelen die worden gebruikt in het main.tf bestand. Nadat je de Terraform-code hebt uitgevoerd, wordt de variabele tag_ec2 met de waarden ec21a en ec21b toegewezen aan de twee in het main.tf bestand gedefinieerde EC2-instanties. 

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

4. Maak een ander Terraform-configuratiebestand genaamd output.tf in de ~/terraform-ec2-iam-demo directory, kopieer/plak vervolgens de onderstaande code naar het bestand output.tf.

Na een succesvolle uitvoering van het terraform apply commando, zou je de waarden van ${aws_instance.my-machine.*.id} en ${aws_iam_user.accounts.*.name} aan het einde van de uitvoer van het commando moeten zien.

De onderstaande code vertelt Terraform om te verwijzen naar de in het main.tf configuratiebestand gedefinieerde bronnen aws_instance en aws_iam_user.

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

5. Maak nog één configuratiebestand aan in de map ~/terraform-ec2-iam-demo genaamd provider.tf, en plak de onderstaande code in het bestand provider.tf. Het onderstaande provider.tf-bestand definieert de Terraform AWS-provider, zodat Terraform weet hoe te communiceren met alle AWS-resources die je eerder hebt gedefinieerd. 

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

6. Verifieer nu dat alle vereiste bestanden hieronder aanwezig zijn in de map ~/terraform-ec2-iam-demo door het tree-commando uit te voeren.

Showing all the Terraform configuration files required

7. Voer de onderstaande commando’s in sequentiële volgorde uit om Terraform te initialiseren en AWS EC2-instanties en IAM-gebruikers te maken. 

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

Tenslotte, ga naar de AWS Management Console, en ga vervolgens naar de AWS EC2-service en IAM-console.

In de volgende schermafbeeldingen kun je controleren of de EC2-instanties en IAM-gebruikers bestaan.

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

Conclusie

Met deze Ultieme handleiding heb je nu de kennis die je nodig hebt om te werken met de AWS Provider, van het declareren tot het uitvoeren van de AWS Provider binnen Terraform. Je hebt ook geleerd hoe AWS Provider je in staat stelt om op vele manieren veilig referenties te declareren.

Welke AWS-service heb je nu in gedachten om te beheren met AWS Provider en Terraform?

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