Hoe een Terraform-project structuren

Introductie

Het juiste structuren van Terraform-projecten op basis van hun gebruikscase en perceptuele complexiteit is essentieel om ze bij houdbaarheid en uitbreidbaarheid te verzekeren in dagelijkse operationele activiteiten. Een systematisch aanpak voor het goede organiseren van codebestanden is noodzakelijk om er voor te zorgen dat het project scalabel blijft tijdens de implementatie en bruikbaar blijft voor jou en je team.In deze tutorial leer je hoe je Terraform-projecten structureert volgens hun algemene doelen en complexiteit. Daarna maak je een project met een simpele structuur met de meer gebruikelijke functies van Terraform: variabellen, lokale waarden, data bronnen en provisioners. Uiteraard wordt uw project een Ubuntu 20.04 server (Droplets) op DigitalOcean deployen, installeren van een Apache webserver en sturen uw domein naar de webserver.

Voorbereidingen

• Een DigitalOcean persoonlijk access token, welke je kunt maken via de DigitalOcean controlepanel. Je vindt instructies in de DigitalOcean product documenten, Hoe je een persoonlijk access token maakt.

• Een wachtwoordloze SSH-sleutel toegevoegd aan uw DigitaalOceaan account, die u kunt maken door volgende stappen te volgen: Hoe gebruik je SSH-sleutels met DigitalOcean droplets.

• Terraform geïnstalleerd op uw lokale machine. Voor instructies naar behore bij uw besturingssysteem, zie Stap 1 van de Hoe Terraform gebruiken met DigitalOcean tutorial.

• Python 3 is geïnstalleerd op de lokale machine. U kunt de Step 1 van Hoe Installeren en Instellen van een Lokale Programmaring Omgeving voor Python 3 voltooien voor uw OS.
• Een volledig geregistreerde domeinnaam toegevoegd aan uw DigitalOcean-account. Voor instructies over hoe dat te doen, bezoek de officiële documentatie.

Terraform Project Struktuur begrijpen

In deze sectie leer je wat Terraform consideraat als een project, hoe je de infrastructuur-code kan structuren en wanneer je welke methode moet kiezen. Je leert ook over Terraforms werkruimten, wat ze doen en hoe Terraform statistiek opslaat.

Een resource is een entiteit van een cloud-dienst (zoals een DigitalOcean Droplet) die in Terraform-code wordt gedefinieerd en volgens specifiek en afleiden eigenschappen wordt gemaakt. Meerdere resources vormen samen infrastructuur met hun mutuale connecties.

Terraform gebruikt een speciale programmeertaal voor het definieren van infrastructuur, genaamd Hashicorp Configuration Language (HCL). HCL-code wordt meestal in bestanden gehouden met de extensie tf. Een Terraform-project is elke map die tf-bestanden bevat en die door de init commando is geïnitialiseerd, waarop Terraform caches en standaard lokaal staat worden ingesteld.

Terraform statistiek is de mechanisme waarmee het de schakel tussen de daadwerkelijke resource deployments in de cloud bijhoudt. Statistiek wordt opgeslagen via backends (locally op disk of remote op een cloud file storage service of speciale state management software), voor optimale redundantie en betrouwbaarheid. U kunt meer informatie over verschillende backends lezen in de documentatie van Terraform.

Project werkruimten bieden je de mogelijkheid om meerdere statussen te hebben in dezelfde achterkant, gebonden aan dezelfde configuratie. Dit staat je toe om meerdere verschillende instanties van dezelfde infrastructuur te deployen. Elke project start met een werkruimte genaamd default— dit wordt gebruikt als je geen expliciete creatie of overschakeling naar een andere werkruimte hebt.

Module in Terraform (analogous aan bibliotheken in andere programmeertalen) zijn parameteriseerde code container die meerdere resource declaraties enclose. Ze staan je toe om een gemeenschappelijke onderdelen van je infrastructuur abstrakteren en later met andere inputten te hergebruiken.

Een Terraform-project kan ook externe code bestanden inbevatten voor gebruik met dynamische data-inputs, die de JSON-uitvoer van een CLI-opdracht parsen en het aanbieden voor gebruik in resource declaraties. In deze handleiding zullen we dat doen met een Python-script.

Nu dat je weet wat een Terraform-project bestaat, lees je twee algemenne methoden voor structuren van Terraform-projecten over.

Simpele structuur

Een eenvoudige structuur is geschikt voor kleine en testprojecten, met een paar verschillende soorten resources en variabelen. Het heeft een paar configuratiebestanden, meestal één per resource type (of meer helperbestanden samen met een hoofdbestand), en geen aangepaste modules, omdat de meeste resources uniek zijn en er niet genoeg zijn om gegeneraliseerd en hergebruikt te worden. Volgens dit model wordt de meeste code opgeslagen in hetzelfde directory, naast elkaar. Deze projecten hebben vaak een paar variabelen (zoals een API-sleutel voor toegang tot de cloud) en kunnen dynamische gegevensinvoer en andere functies van Terraform en HCL gebruiken, hoewel dit niet de belangrijkste is.

Als voorbeeld van de bestandsstructuur van dit aanpakken is dit hoe het project dat u in deze handleiding zal bouwen eruit zal zien:

.
└── tf/
    ├── versions.tf
    ├── variables.tf
    ├── provider.tf
    ├── droplets.tf
    ├── dns.tf
    ├── data-sources.tf
    └── external/
        └── name-generator.py

Omdat dit project een Apache web server Droplet zal deployen en DNS-records zal instellen, zal de definitie van projectvariabelen, de Terraform provider van DigitalOcean, de Droplet en de DNS-records in hun respectievelijke bestanden worden opgeslagen. De minimale vereiste versies van Terraform en de DigitalOcean provider worden gespecificeerd in versions.tf, terwijl het Python-script dat een naam zal genereren voor de Droplet (en als dynamische gegevensbron zal worden gebruikt in data-sources.tf) in de external map wordt opgeslagen, om het van de HCL-code te scheiden.

Complexe Structuur

Het biedt een eenvoudige structuur, maar deze aanpak is geschikt voor grote projecten met duidelijk gedefinieerde subdirectory’s die meerdere modules bevatten van verschillende complexiteit, naast de gebruikelijke code. Deze modules kunnen elkaar afhankelijk zijn. Gemengd met versiebeheerstelsels kunnen deze projecten uitgebreid gebruik maken van werkruimten. Deze aanpak is geschikt voor grotere projecten die meerdere apps beheren terwijl zij de code zo veel mogelijk hergebruiken.

Ontwikkeling, staging, kwaliteitscontrole en productie-infrastructuur-instanties kunnen eveneens onder hetzelfde project in verschillende directory’s worden ondergebracht door middel van gemeenschappelijke modules, waardoor dubbelcode wordt vermeden en het project de centrale bron van de waarheid wordt. Hier is de bestandstructuur van een voorbeeldproject met een complexere structuur, die meerdere deployment apps, Terraform modules en doel cloudomgevingen bevat:

.
└── tf/
    ├── modules/
    │   ├── network/
    │   │   ├── main.tf
    │   │   ├── dns.tf
    │   │   ├── outputs.tf
    │   │   └── variables.tf
    │   └── spaces/
    │       ├── main.tf
    │       ├── outputs.tf
    │       └── variables.tf
    └── applications/
        ├── backend-app/
        │   ├── env/
        │   │   ├── dev.tfvars
        │   │   ├── staging.tfvars
        │   │   ├── qa.tfvars
        │   │   └── production.tfvars
        │   └── main.tf
        └── frontend-app/
            ├── env/
            │   ├── dev.tfvars
            │   ├── staging.tfvars
            │   ├── qa.tfvars
            │   └── production.tfvars
            └── main.tf

Deze aanpak wordt uitgebreid behandeld in de reeks Hoe Terraform gebruikt wordt voor het beheren van infrastructuur.

U kent nu wat een Terraform-project is, hoe u het best kunt structureren volgens de verwachte complexiteit en welke rol Terraform-werkruimten vervullen. In de volgende stappen zult u een project met een eenvoudige structuur aanmaken dat een Droplet met een geïnstalleerd Apache web服务器 en DNS-records voor uw domein in orde brengt. U zult eerst uw project initialiseren met de DigitalOcean provider en variabelen, en daarna doorgaan met het definiëren van de Droplet, een dynamische gegevensbron om zijn naam te leveren, en een DNS-record voor de deployering.

Stap 1 — Instelling van je eerste project

In deze sectie zal u de DigitalOcean Terraform provider aan je project toevoegen, definiëren van de project variabelen en declareren van een DigitalOcean provider-instantie, zodat Terraform met je account kan verbinden.

Begin door met het maken van een map voor je Terraform-project met de volgende opdracht:

mkdir ~/apache-droplet-terraform

Ga naar die map:

cd ~/apache-droplet-terraform

Omdat dit project de simpele structurering aanpakt, zal u de provider, variabelen, Droplets en DNS-records code in aparte bestanden opslaan, per de bestandsstructuur uit de vorige sectie. Eerst moet u de DigitalOcean Terraform provider toevoegen aan je project als een verplichte provider.

Maak een bestand aan genaamd versions.tf en open het voor editing door te runnen:

nano versions.tf

Voeg de volgende lijnen toe:

terraform {
  required_providers {
    digitalocean = {
      source = "digitalocean/digitalocean"
      version = "~> 2.0"
    }
  }
}

In deze terraform blok stelt u de benodigde providers (DigitalOcean, versie 2.x) vast. Wanneer u klaar is, slaaf en sluit het bestand.

Dan definiëren de variabelen die uw project aanbiedt in het variables.tf bestand, volgens de methode om verschillende resource typen in aparte code bestanden te storen:

nano variables.tf

Voeg de volgende variabelen toe:

variable "do_token" {}
variable "domain_name" {}

Slaaf en sluit het bestand.

De variabele do_token zal uw DigitalOcean Persoonlijke Toegangs Token bevatten en domain_name zal uw gewenste domeinnaam specificeren. De geïmplementeerde Droplet zal automatisch de SSH-sleutel installeren, die wordt geïdentificeerd door de SSH-vingerafdruk.

Volgend, definieer we de DigitalOcean provider instantie voor dit project. U zal deze opslaan in een bestand genaamd provider.tf. Maak het bestand aan en open het voor bewerking door het uit te voeren:

nano provider.tf

Voeg de provider toe:

provider "digitalocean" {
  token = var.do_token
}

Bewaar en sluit af wanneer u klaar bent. U hebt de digitalocean provider gedefinieerd, die overeenkomt met de vereiste provider die u eerder specificeerde in provider.tf, en heeft u zijn token ingesteld op de waarde van de variabele, die tijdens de runtime wordt aangeleverd.

In deze stap heeft u een directory voor uw project aangemaakt, gevraagd om de DigitalOcean provider beschikbaar te maken, aangekondigd project variabelen en de verbinding met een DigitalOcean provider instantie geconfigureerd om een authenticatietoken te gebruiken dat later wordt aangeleverd. Nu zult u een script schrijven dat dynamische data zal genereren voor uw project definities.

Stap 2 — Een Python Script schrijven voor Dynamische Data

Voor de definitie van een Droplet zullen we eerst een Python-script schrijven dat automatisch de naam van de Droplet genereert en een bronresource declareren om hem te parsen. De naam wordt geconcateneerd met een constante string (web) en de huidige tijd op de lokale machine, uitgedrukt in de UNIX epoch formaat. Een namingscript kan nuttig zijn wanneer meerdere Droplets worden gemaakt volgens een naamschema, om ze gemakkelijk te onderscheiden.

Jouw script zal in een bestand genaamd name-generator.py worden geplaatst, in een map genaamd extern. Eerst maak de map aan door de volgende commando’s te gebruiken:

mkdir external

De extern map resideert in de root van je project en zal non-HCL code-bestanden, zoals het Python-script dat je schrijft, bevatten.

Maak name-generator.py onder extern aan en open het voor editing:

nano external/name-generator.py

Voeg de volgende code toe:

import json, time

fixed_name = "web"
result = {
  "name": f"{fixed_name}-{int(time.time())}",
}

print(json.dumps(result))

Dit Python-script importeert de modules json en time, declareert een dictionary genaamd result, en stelt de waarde van de name key vast aan een interpolateerde string, die combineert de fixed_name met de huidige UNIX-tijd van de machine waarop het script wordt uitgevoerd. Daarna wordt de result convertie naar JSON en wordt er op stdout uitgevoerd. De uitvoer zal elke keer wat anders zijn als het script wordt uitgevoerd:

Output
{"name": "web-1597747959"}

Als u klaar bent, sla de bestanden op en sluit ze af.

Nu de script klaar is, kunt u de gegevensbron definiëren, die de gegevens uit het script zal halen. U zal de gegevensbron opslaan in een bestand genaamd data-sources.tf aan de root van uw project, volgens de eenvoudige structuuringsmethode.

Maak het bestand aan om het te bewerken door de volgende commando uit te voeren:

nano data-sources.tf

Voeg de volgende definitie toe:

data "external" "droplet_name" {
  program = ["python3", "${path.module}/external/name-generator.py"]
}

Sla het bestand op en sluit het af.

Deze gegevensbron wordt droplet_name genoemd en voert het script name-generator.py uit met Python 3, dat zich in de net aangemaakte external map bevindt. Het automatisch parset zijn uitvoer en biedt de deserialiseerde gegevens onder zijn result eigenschap aan voor gebruik in andere resource definities.

Met de gegevensbron nu gedefinieerd, kunt u de Droplet definiëren die Apache op zal draaien.

Stapel 3 — Definieren van de Dropleten

In deze stap schrijf je de definitie van de Droplet-resource en stuur je dit naar een codebestand toe dat is gereserveerd voor Droplet-resources, zoals bij de simpele structuur aanpak. De naam komt uit de dynamische bron die je net hebt gemaakt en wordt elke keer opnieuw gelijk.

Maak en open het bestand droplets.tf voor het editeren:

nano droplets.tf

Voeg de volgende Droplet-resource definitie toe:

data "digitalocean_ssh_key" "ssh_key" {
  name = "your_ssh_key_name"
}

resource "digitalocean_droplet" "web" {
  image  = "ubuntu-20-04-x64"
  name   = data.external.droplet_name.result.name
  region = "fra1"
  size   = "s-1vcpu-1gb"
  ssh_keys = [
    data.digitalocean_ssh_key.ssh_key.id
  ]
}

Je beginnen met de declaratie van een DigitialOcean SSH-sleutel resource genaamd ssh_key, die een sleutel uit je account haalt door zijn naam. Maak zorg dat je de gethighlighted code vervangt met de naam van je SSH-sleutel.

Dan declareert je een Droplet-resource, genaamd web. De actuele naam in de cloud is verschillend, omdat hij wordt gevraagd vanuit de droplet_name externe gegevens bron. Om elke keer te bootteen met een SSH-sleutel wanneer de Droplet wordt deployd, wordt de ID van de ssh_key doorgegeven aan de ssh_keys parameter, zodat DigitalOcean weet welke sleutel te gebruiken.

Voor nu is dat al wat je moet configureren betrekking op droplet.tf, dus slaaf en sluit het bestand af als je klaar bent.

Je zal nu de configuratie schrijven voor de DNS-record die naar de juiste Dropleten van je domein wijst.

Stapel 4 — Definieren van DNS-records

Het laatste stappen in de proces is om de DNS-record te configureren die naar de Droplets van je domein wijst.

Je zal de DNS-configuratie opslaan in een bestand genaamd dns.tf, omdat het een aparte bronsoort is dan de andere stappen waarin je hebt geoefend. Maak en open het bestand voor bewerkingsdoelen:

nano dns.tf

Voeg de volgende lijnen toe:

resource "digitalocean_record" "www" {
  domain = var.domain_name
  type   = "A"
  name   = "@"
  value  = digitalocean_droplet.web.ipv4_address
}

Dit code declareert een DigitalOcean DNS-record aan je domeinnaam (gebruikt wordt met de variabele), van type A. De record heeft de naam @, wat is een plaatshalter voor de domeinnaam en de IP-adres van de Dropleten als zijn waarde. Je kunt de naam waarde vervangen door iets anders, wat resulteert in een subdomein worden gemaakt.

Wanneer je klaar is, slaaf en sluit het bestand.

Nu dat je de Dropleten, de naamgenerator datasource en een DNS-record heeft geconfigureerd, ga je naar de volgende stap: project deployeren in de cloud.

Stapel 5 — Planning en Applicatie van de configuratie

In deze sectie wordt uw Terraform-project initialiseren, wordt het geïnstalleerd op de cloud en wordt gecheckd of alles correct is geïnsteld.

Nu de projectinfrastructuur volledig is definieerd, alles wat er nog over is voordat u de implementatie uitvoert is om de Terraform-project te initialiseren. Doen dat door de volgende opdracht te runnen:

terraform init

U krijgt de volgende uitvoer:

Output
Initializing the backend...

Initializing provider plugins...
- Finding digitalocean/digitalocean versions matching "~> 2.0"...
- Finding latest version of hashicorp/external...
- Installing digitalocean/digitalocean v2.10.1...
- Installed digitalocean/digitalocean v2.10.1 (signed by a HashiCorp partner, key ID F82037E524B9C0E8)
- Installing hashicorp/external v2.1.0...
- Installed hashicorp/external v2.1.0 (signed by HashiCorp)

Partner and community providers are signed by their developers.
If you'd like to know more about provider signing, you can read about it here:
https://www.terraform.io/docs/cli/plugins/signing.html

Terraform has created a lock file .terraform.lock.hcl to record the provider
selections it made above. Include this file in your version control repository
so that Terraform can guarantee to make the same selections by default when
you run "terraform init" in the future.

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.

U moet nu de Droplet met een dynamisch genereerde naam en een bijbehorende domeinnaam instellen voor uw DigitalOcean-account.

Begin met het definieren van de domeinnaam, de SSH-sleutelfingerprint, en uw persoonelijke toegangs token als omgevingsvariabelen, zodat u ze niet elke keer moet kopieren wanneer u Terraform uitvoert. Run de volgende commando’s, waarbij de gehighlighteerde waarden vervangen:

export DO_PAT="your_do_api_token"
export DO_DOMAIN_NAME="your_domain"

U kunt uw API-token vinden in uw DigitalOcean-controlepaneel.

Run the plan command with the variable values passed in to see what steps Terraform would take to deploy your project:

terraform plan -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}"

The output will be similar to the following:

Output
Terraform used the selected providers to generate the following execution plan. Resource
actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # digitalocean_droplet.web will be created
  + resource "digitalocean_droplet" "web" {
      + backups              = false
      + created_at           = (known after apply)
      + disk                 = (known after apply)
      + id                   = (known after apply)
      + image                = "ubuntu-20-04-x64"
      + ipv4_address         = (known after apply)
      + ipv4_address_private = (known after apply)
      + ipv6                 = false
      + ipv6_address         = (known after apply)
      + locked               = (known after apply)
      + memory               = (known after apply)
      + monitoring           = false
      + name                 = "web-1625908814"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = (known after apply)
      + region               = "fra1"
      + resize_disk          = true
      + size                 = "s-1vcpu-1gb"
      + ssh_keys             = [
          + "...",
        ]
      + status               = (known after apply)
      + urn                  = (known after apply)
      + vcpus                = (known after apply)
      + volume_ids           = (known after apply)
      + vpc_uuid             = (known after apply)
    }

  # digitalocean_record.www will be created
  + resource "digitalocean_record" "www" {
      + domain = "your_domain'"
      + fqdn   = (known after apply)
      + id     = (known after apply)
      + name   = "@"
      + ttl    = (known after apply)
      + type   = "A"
      + value  = (known after apply)
    }

Plan: 2 to add, 0 to change, 0 to destroy.
...

The lines starting with a green + signify that Terraform will create each of the resources that follow after—which is exactly what should happen, so you can apply the configuration:

terraform apply -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}"

The output will be the same as before, except that this time you’ll be asked to confirm:

Output
Plan: 2 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`

Enter yes, and Terraform will provision your Droplet and the DNS record:

Output
digitalocean_droplet.web: Creating...
...
digitalocean_droplet.web: Creation complete after 33s [id=204432105]
digitalocean_record.www: Creating...
digitalocean_record.www: Creation complete after 1s [id=110657456]

Apply complete! Resources: 2 added, 0 changed, 0 destroyed.

Terraform heeft nu de geïnstalleerde resources bijgehouden in zijn staat. Om te controleren of de DNS-records en de Droplets succesvol verbonden zijn, kunt u het volgende commando uitvoeren om de IP-adres van de Droplet te krijgen:

terraform show | grep "ipv4"

U zal het IP-adres van de Droplet krijgen:

Output
ipv4_address       = "your_Droplet_IP"
...

U kunt de publieke A-records verifieren door te runnen:

nslookup -type=a your_domain | grep "Address" | tail -1

De uitvoer zal de IP-adres tonen waarop de A-record wijst:

Output
Address: your_Droplet_IP

Ze zijn dezelfde, zoals ze moeten zijn, wat betekent dat de Dropleten en DNS-records succesvol ingesteld zijn.

Voor de wijzigingen in de volgende stap te treffen, moet u de geprovisioneerde resources verwijderden door te runnen:

terraform destroy -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}"

Wanneer u wordt aangevraagd, voer dan ja in om te continueren.

In deze stap heeft u uw infrastructuur gemaakt en hem toegepast aan uw DigitalOcean-account. U zal nu de Terraform provisioners gebruiken om automatisch de Apache webserver op de geprovisioneerde Dropleten te installeren.

Stap 6 — Uitvoering code met provisioners

Nu zet je de installatie van de Apache webserver op je geprovisioneerde Dropleten in staan door de remote-exec provisioner te gebruiken om aangepaste commando’s uit te voeren.

Terraform provisioners kunnen worden gebruikt om specifieke acties te uitvoeren op gecreërd remote-resources (met de remote-exec provisioner) of op de lokale machine waar de code wordt uitgevoerd (met de local-exec provisioner). Als een provisioner faalt, wordt de knooppunt markiert als bruikbaar in de huidige staat, wat betekent dat het zal worden verwijderd en hersteld tijdens de volgende run.

Om verbinding te maken met een provisioneerde Droptoon moet Terraform de privé-SSH-sleutel van de Dropton hebben die is ingesteld op de Dropton. De beste manier om de locatie van de privé-sleutel te passeren is door variabelen te gebruiken, dus open variables.tf voor het editeren:

nano variables.tf

Voeg de gehighlightede lijn toe:

variable "do_token" {}
variable "domain_name" {}
variable "private_key" {}

Jouw project hebt nu een nieuwe variabele toegevoegd, genaamd private_key , aan je project. Sla en sluit de bestand aan.

Gezien jouw Dropton configuratie nu toevoegen met de verbindingsdata en de declaraties van de remote provisioner, open droplets.tf voor het editeren door te运行:

nano droplets.tf

Voeg de gehighlightede lijnen toe:

data "digitalocean_ssh_key" "ssh_key" {
  name = "your_ssh_key_name"
}

resource "digitalocean_droplet" "web" {
  image  = "ubuntu-20-04-x64"
  name   = data.external.droplet_name.result.name
  region = "fra1"
  size   = "s-1vcpu-1gb"
  ssh_keys = [
    data.digitalocean_ssh_key.ssh_key.id
  ]

  connection {
    host        = self.ipv4_address
    user        = "root"
    type        = "ssh"
    private_key = file(var.private_key)
    timeout     = "2m"
  }

  provisioner "remote-exec" {
    inline = [
      "export PATH=$PATH:/usr/bin",
      # Installeer Apache
      "apt update",
      "apt -y install apache2"
    ]
  }
}

De connection blok specificeert hoe Terraform moet verbinden met de doel Dropton. De provisioner blok bevat de array van commando’s, binnen de inline parameter, die teruggaat naar executie na provisionering. Dus, bijwerken van de pakketmanager cache en installeren van Apache. Sla en sluit wanneer je klaar is.

Je kunt ook een tijdelijke omgevingstagenaam voor de pad van de privé-sleutel toevoegen:

export DO_PRIVATE_KEY="private_key_location"

Probeer de configuratie opnieuw toe te passen:

terraform apply -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}" -var "private_key=${DO_PRIVATE_KEY}"

Gebruik ja als er bijvoorbeeld een prompt komt. Je krijgt uitvoer gelijk aan de vorige keer, maar dan met langere uitvoer van de remote-exec provisoner:

Output
digitalocean_droplet.web: Creating...
digitalocean_droplet.web: Still creating... [10s elapsed]
digitalocean_droplet.web: Still creating... [20s elapsed]
digitalocean_droplet.web: Still creating... [30s elapsed]
digitalocean_droplet.web: Provisioning with 'remote-exec'...
digitalocean_droplet.web (remote-exec): Connecting to remote host via SSH...
digitalocean_droplet.web (remote-exec):   Host: ...
digitalocean_droplet.web (remote-exec):   User: root
digitalocean_droplet.web (remote-exec):   Password: false
digitalocean_droplet.web (remote-exec):   Private key: true
digitalocean_droplet.web (remote-exec):   Certificate: false
digitalocean_droplet.web (remote-exec):   SSH Agent: false
digitalocean_droplet.web (remote-exec):   Checking Host Key: false
digitalocean_droplet.web (remote-exec): Connected!
...
digitalocean_droplet.web: Creation complete after 1m5s [id=204442200]
digitalocean_record.www: Creating...
digitalocean_record.www: Creation complete after 1s [id=110666268]

Apply complete! Resources: 2 added, 0 changed, 0 destroyed.

Je kan nu naar je domein navigeren in een webbrowser. Je zal de standaard Apache welkomstpagina zien.

Dit betekent dat Apache succesvol is geïnstalleerd en dat Terraform alles correct heeft geprovisioneerd.

Om de gebruikte resources te verwijderen, voer de volgende commando uit en gebruik ja als er bijvoorbeeld een prompt komt:

terraform destroy -var "do_token=${DO_PAT}" -var "domain_name=${DO_DOMAIN_NAME}" -var "private_key=${DO_PRIVATE_KEY}"

Je hebt nu een kleine Terraform-project afgerond met een simpele structuur die de Apache webserver op een Droplet installeert en DNS-records instellen voor de gewenste domeinnaam.

Conclusie

In deze tutorial hebben we twee algemene aanpakken besproken voor het organiseren van uw Terraform-projecten, volgens hun complexiteit. Volgens de simpele structuur aanpak hebben we een Dropleten met Apache geïnstalleerd, samen met DNS-records voor uw domein naar behoren.

Voor referentie, hier is de bestandsstructuur van het project dat u in deze tutorial heeft gemaakt:

.
└── tf/
    ├── versions.tf
    ├── variables.tf
    ├── provider.tf
    ├── droplets.tf
    ├── dns.tf
    ├── data-sources.tf
    └── external/
        └── name-generator.py

De bronnen die u definierde (Dropleten, DNS-records en dynamische data-sources, de DigitalOcean-provider en variabelen) zijn op basis van de simpele projectstructuur uit de eerste sectie van deze tutorial in elk aparte bestand opgeslagen.

Voor meer informatie over Terraform-provisioners en hun parameterwaarden, bezoek de officiële documentatie.

Deze tutorial is onderdeel van de How To Manage Infrastructure with Terraform reeks. Deze reeks covert een aantal Terraform-topics, van installering Terraform voor het eerste keer tot het beheren van complexe projecten.