En introduktion til Terraform for begyndere – Terraform Tutorial

Gad vide, hvad er Terraform? Lad os finde ud af det.

Infrastructure as Code (IaC) er en udbredt terminologi blandt DevOps-professionelle. Det er processen med at administrere og klargøre den komplette IT-infrastruktur (omfatter både fysiske og virtuelle maskiner) ved hjælp af maskinlæsbare definitionsfiler. Det er en softwareteknisk tilgang til drift. Det hjælper med at automatisere hele datacenteret ved at bruge programmeringsscripts.

Med alle de funktioner, som Infrastructure as Code giver, har den flere udfordringer:

• Skal lære at kode
• Kender ikke ændringens effekt.
• Skal fortryde ændringen
• Kan ikke spore ændringer
• Kan ikke automatisere en ressource
• Flere miljøer til infrastruktur

Terraform er skabt til at løse disse udfordringer.

Hvad er Terraform?

Terraform er en open source-infrastruktur som kodeværktøj udviklet af HashiCorp. Det bruges til at definere og levere den komplette infrastruktur ved hjælp af et deklarativt sprog, der er let at lære.

Det er et infrastrukturforsyningsværktøj, hvor du kan gemme din cloud-infrastrukturopsætning som koder. Det minder meget om værktøjer som f.eks CloudFormation, som du ville bruge til at automatisere din AWS-infrastruktur, men du kan kun bruge det på AWS. Med Terraform kan du også bruge det på andre cloud-platforme.

Nedenfor er nogle af fordelene ved at bruge Terraform.

• Udfører orkestrering, ikke kun konfigurationsstyring
• Understøtter flere udbydere såsom AWS, Azure, GCP, DigitalOcean og mange flere
• Sørg for uforanderlig infrastruktur, hvor konfigurationen ændres jævnt
• Bruger letforståeligt sprog, HCL (HashiCorp konfigurationssprog)
• Kan nemt transporteres til enhver anden udbyder
• Understøtter kun klientarkitektur, så der er ikke behov for yderligere konfigurationsstyring på en server

Terraform Kernekoncepter

Nedenfor er de kernebegreber/terminologier, der bruges i Terraform:

• Variabler: Bruges også som inputvariabler, det er nøgleværdi-par, der bruges af Terraform-moduler for at tillade tilpasning.
• Udbyder: Det er et plugin til at interagere med API’er og få adgang til dets relaterede ressourcer.
• Modul: Det er en mappe med Terraform skabeloner, hvor alle konfigurationer er defineret
• Tilstand: Den består af cachelagrede oplysninger om infrastrukturen, der administreres af Terraform, og de relaterede konfigurationer.
• Ressourcer: Det refererer til en blok af et eller flere infrastrukturobjekter (computerinstanser, virtuelle netværk osv.), som bruges til at konfigurere og administrere infrastrukturen.
• Datakilde: Det er implementeret af udbydere at returnere oplysninger om eksterne objekter til terraform.
• Outputværdier: Disse er returværdier for et terraform-modul, som kan bruges af andre konfigurationer.
• Plan: Det er et af de stadier, hvor det bestemmer, hvad der skal oprettes, opdateres eller destrueres for at flytte fra reel/nuværende tilstand af infrastrukturen til den ønskede tilstand.
• Anvend: Det er et af de stadier, hvor det anvender ændringerne i reelle/nuværende tilstand af infrastrukturen for at flytte til den ønskede tilstand.

Terraform livscyklus

Terraforms livscyklus består af – indlede, planlægge, anvende og ødelægge.

• Terraform init initialiserer arbejdsbiblioteket, som består af alle konfigurationsfilerne
• Terraform-planen bruges til at lave en udførelsesplan for at nå en ønsket tilstand af infrastrukturen. Ændringer i konfigurationsfilerne udføres for at opnå den ønskede tilstand.
• Terraform application foretager derefter ændringerne i infrastrukturen som defineret i planen, og infrastrukturen kommer i den ønskede tilstand.
• Terraform destroy bruges til at slette alle de gamle infrastrukturressourcer, som er mærket plettet efter anvendelsesfasen.

Hvordan virker Terraform?

Terraform har to hovedkomponenter, der udgør dens arkitektur:

Terraform kerne

Terraform core bruger to inputkilder til at udføre sit arbejde.

Den første inputkilde er en Terraform-konfiguration, som du som bruger konfigurerer. Her definerer du, hvad der skal oprettes eller klargøres. Og den anden inputkilde er en tilstand, hvor terraform holder den opdaterede tilstand af, hvordan den aktuelle opsætning af infrastrukturen ser ud.

Så hvad terraform kerne gør er, at den tager input, og den finder ud af planen for, hvad der skal gøres. Den sammenligner tilstanden, hvad er den nuværende tilstand, og hvad er den konfiguration, du ønsker i slutresultatet. Den finder ud af, hvad der skal gøres for at komme til den ønskede tilstand i konfigurationsfilen. Den viser, hvad der skal oprettes, hvad der skal opdateres, hvad der skal slettes for at skabe og levere infrastrukturen.

Udbydere

Den anden komponent i arkitekturen er udbydere af specifikke teknologier. Dette kan være cloud-udbydere som AWS, Azure, GCP eller anden infrastruktur som en serviceplatform. Det er også en udbyder af komponenter på højt niveau som Kubernetes eller andre platform-as-a-service-værktøjer, endda noget software som et selvbetjeningsværktøj.

Det giver dig mulighed for at skabe infrastruktur på forskellige niveauer.

For eksempel – opret en AWS-infrastruktur, implementer derefter Kubernetes oven på den og opret derefter tjenester/komponenter inde i den Kubernetes-klynge.

Terraform har over hundrede udbydere til forskellige teknologier, og hver udbyder giver derefter terraform brugeradgang til sine ressourcer. Så gennem AWS-udbyderen har du for eksempel adgang til hundredvis af AWS-ressourcer som EC2-instanser, AWS-brugerne osv. Med Kubernetes-udbyderen får du adgang til råvarer, ressourcer som tjenester og implementeringer og navnerum osv.

Så det er sådan, Terraform fungerer, og på denne måde forsøger den at hjælpe dig med at klargøre og dække hele applikationsopsætningen fra infrastruktur og hele vejen til applikationen.

Lad os lave nogle praktiske ting. 👨‍💻

Vi vil installere Terraform på Ubuntu og levere en meget grundlæggende infrastruktur.

Installer Terraform

Download den seneste terraform-pakke.

Der henvises til officiel download side for at få den seneste version til det respektive OS.

[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]

Udpak den downloadede pakke.

[email protected]:~$ unzip terraform_0.13.0_linux_amd64.zip
Archive:
terraform_0.13.0_linux_amd64.zip
inflating: terraform

Flyt den eksekverbare terraform-fil til stien vist nedenfor. Tjek terraform-versionen.

[email protected]:~$ sudo mv terraform /usr/local/bin/
[sudo] password for toadmin.dk:
[email protected]:~$ terraform -v
Terraform v0.13.0

Du kan se, at disse er de tilgængelige kommandoer i terraform til udførelse.

[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

Levering af AWS EC2-instans ved hjælp af Terraform

I denne demo vil jeg lancere en ny AWS EC2-instans ved hjælp af Terraform.

Opret en arbejdsmappe til denne Terraform-demo.

[email protected]:~$ mkdir terraform_demo

Gå til biblioteket og opret en terraform-konfigurationsfil, hvor du definerer udbyderen og ressourcerne til at starte en AWS EC2-instans.

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

Bemærk: Jeg har ændret adgangs- og hemmelige nøgler 😛, du skal bruge din egen.

Fra konfigurationen nævnt ovenfor kan du se, at jeg nævner udbyderen som AWS. Inde i udbyderen giver jeg AWS brugerlegitimationsoplysninger og regioner, hvor instansen skal startes.

I ressourcer giver jeg AMI-oplysninger om Ubuntu (ami-0a634ae95e11c6f91) og nævner, at instanstypen skal være t2.micro

Du kan se, hvor let og læsbar konfigurationsfilen er, selvom du ikke er en die-hard koder.

terraform init

Nu er det første skridt at initialisere terraform.

[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

Dernæst er planfasen; det vil oprette udførelsesgrafen til oprettelse og klargøring af infrastrukturen.

[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 gælder

Anvendelsesstadiet vil udføre konfigurationsfilen og starte en AWS EC2-instans. Når du kører Anvend kommando, vil den spørge dig, “Vil du udføre disse handlinger?”, Du skal skrive ja og trykke på Enter.

[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.

Gå til dit AWS EC2-dashboard, og du vil se en ny instans med det instans-id, der er nævnt i slutningen af ​​anvende kommandoen er blevet oprettet.

Du har med succes lanceret en AWS EC2-instans ved hjælp af Terraform.

terraform ødelægge

Til sidst, hvis du vil slette infrastrukturen, skal du køre kommandoen destroy.

[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.

Hvis du tjekker EC2-dashboardet igen, vil du se, at forekomsten er blevet afsluttet.

Konklusion

Jeg tror på, at ovenstående giver dig en idé til at komme i gang med Terraform. Gå videre og prøv det eksempel, jeg lige har vist.

Du bør også tjekke disse software til infrastrukturautomatisering.

Hvis du er interesseret i at lære mere, så vil jeg foreslå at tjekke Lær DevOps med Terraform kursus.