Hoe Terraform te Gebruiken met DigitalOcean

Introductie

Terraform is een tool voor het bouwen en beheren van infrastructuur op een georganiseerde manier. U kunt het gebruiken om DigitalOcean Droplets, Load Balancers en zelfs DNS-vermeldingen te beheren, naast een grote verscheidenheid aan services die worden aangeboden door andere providers. Terraform maakt gebruik van een opdrachtregelinterface en kan worden uitgevoerd vanaf uw desktop of een externe server.

Terraform werkt door configuratiebestanden te lezen die de componenten beschrijven die uw applicatieomgeving of datacenter vormen. Op basis van de configuratie genereert het een uitvoeringsplan dat beschrijft wat het zal doen om de gewenste toestand te bereiken. Vervolgens gebruikt u Terraform om dit plan uit te voeren om de infrastructuur op te bouwen. Wanneer er wijzigingen in de configuratie optreden, kan Terraform incrementele plannen genereren en uitvoeren om de bestaande infrastructuur bij te werken naar de nieuw beschreven toestand.

In deze tutorial installeert u Terraform en gebruikt u het om een infrastructuur op DigitalOcean te maken die bestaat uit twee Nginx-servers die worden gebalanceerd door een DigitalOcean Load Balancer. Vervolgens gebruikt u Terraform om een DNS-vermelding op DigitalOcean toe te voegen die naar uw Load Balancer verwijst. Dit zal u helpen om aan de slag te gaan met het gebruik van Terraform, en u een idee te geven van hoe u het kunt gebruiken om een DigitalOcean-gebaseerde infrastructuur te beheren en implementeren die aan uw eigen behoeften voldoet.

Vereisten

Om deze tutorial te voltooien, heb je het volgende nodig:

• A DigitalOcean account. If you do not have one, sign up for a new account.
• A DigitalOcean Personal Access Token, which you can create via the DigitalOcean control panel. Instructions to do that can be found at: How to Create a Personal Access Token.
• A password-less SSH key added to your DigitalOcean account, which you can create by following How To Use SSH Keys with DigitalOcean Droplets. When you add the key to your account, remember the name you give it, as you’ll need it in this tutorial. (For Terraform to accept the name of your key, it must start with a letter or underscore and may contain only letters, digits, underscores, and dashes.)
• A personal domain pointed to DigitalOcean’s nameserver, which you can do by following the tutorial, How To Point to DigitalOcean Nameservers From Common Domain Registrars.

Stap 1 – Terraform installeren

Terraform is een opdrachtregeltool die je kunt uitvoeren op je desktop of op een externe server. Om het te installeren, download je het en plaats je het in je PATH, zodat je het in elke directory kunt uitvoeren waarin je werkt.

Eerst download je het juiste pakket voor je besturingssysteem en architectuur van de officiële Downloads pagina. Als je macOS of Linux gebruikt, kun je Terraform downloaden met curl.

Op macOS gebruik je deze opdracht om Terraform te downloaden en in je thuismap te plaatsen:

curl -o ~/terraform.zip https://releases.hashicorp.com/terraform/1.1.3/terraform_1.1.3_darwin_amd64.zip 

Op Linux gebruik je deze opdracht:

curl -o ~/terraform.zip https://releases.hashicorp.com/terraform/1.1.3/terraform_1.1.3_linux_amd64.zip 

Maak de ~/opt/terraform map aan:

mkdir -p ~/opt/terraform

Vervolgens pak je Terraform uit naar ~/opt/terraform met behulp van de unzip opdracht. Op Ubuntu kun je unzip installeren met apt:

sudo apt install unzip

Gebruik het om het gedownloade archief uit te pakken naar de ~/opt/terraform map door het volgende uit te voeren:

unzip ~/terraform.zip -d ~/opt/terraform

Voeg eindelijk ~/opt/terraform toe aan je PATH-omgevingsvariabele, zodat je het terraform-commando kunt uitvoeren zonder het volledige pad naar het uitvoerbare bestand op te geven.

Op Linux moet je PATH herdefiniëren in .bashrc, dat wordt uitgevoerd wanneer een nieuwe shell wordt geopend. Open het voor bewerking door het volgende uit te voeren:

nano ~/.bashrc

Voeg het volgende regel toe aan het einde van het bestand om het pad van Terraform aan je PATH toe te voegen:

export PATH=$PATH:~/opt/terraform

Sla het bestand op en sluit het af wanneer je klaar bent.

Nu kunnen al je nieuwe shell-sessies het terraform-commando vinden. Voer het volgende commando uit om het nieuwe PATH in je huidige sessie te laden als je Bash gebruikt op een Linux-systeem:

. ~/.bashrc

Als je Bash op macOS gebruikt, voer dan in plaats daarvan dit commando uit:

. .bash_profile

Als je ZSH gebruikt, voer dan dit commando uit:

. .zshrc

Om te controleren of je Terraform correct hebt geïnstalleerd, voer je het terraform-commando uit zonder argumenten:

terraform

Je ziet een uitvoer die vergelijkbaar is met het volgende:

Output
Usage: terraform [global options] <subcommand> [args]

The available commands for execution are listed below.
The primary workflow commands are given first, followed by
less common or more advanced commands.

Main commands:
  init          Prepare your working directory for other commands
  validate      Check whether the configuration is valid
  plan          Show changes required by the current configuration
  apply         Create or update infrastructure
  destroy       Destroy previously-created infrastructure

All other commands:
  console       Try Terraform expressions at an interactive command prompt
  fmt           Reformat your configuration in the standard style
  force-unlock  Release a stuck lock on the current workspace
  get           Install or upgrade remote Terraform modules
  graph         Generate a Graphviz graph of the steps in an operation
  import        Associate existing infrastructure with a Terraform resource
  login         Obtain and save credentials for a remote host
  logout        Remove locally-stored credentials for a remote host
  output        Show output values from your root module
  providers     Show the providers required for this configuration
  refresh       Update the state to match remote systems
  show          Show the current state or a saved plan
  state         Advanced state management
  taint         Mark a resource instance as not fully functional
  test          Experimental support for module integration testing
  untaint       Remove the 'tainted' state from a resource instance
  version       Show the current Terraform version
  workspace     Workspace management

Global options (use these before the subcommand, if any):
  -chdir=DIR    Switch to a different working directory before executing the
                given subcommand.
  -help         Show this help output, or the help for a specified subcommand.
  -version      An alias for the "version" subcommand.

Dit zijn de commando’s die Terraform accepteert. De uitvoer geeft je een beknopte beschrijving, en je leert er meer over tijdens deze tutorial.

Nu Terraform is geïnstalleerd, laten we het configureren om te werken met de resources van DigitalOcean.

Stap 2 — Terraform configureren voor DigitalOcean

Terraform ondersteunt verschillende serviceproviders via providers die je kunt installeren. Elke provider heeft zijn eigen specificaties, die over het algemeen overeenkomen met de API van de respectieve serviceprovider.

De DigitalOcean-provider stelt Terraform in staat om met de DigitalOcean API te communiceren om infrastructuur op te bouwen. Deze provider ondersteunt het maken van verschillende DigitalOcean-resources, waaronder de volgende:

• digitalocean_droplet: Droplets (servers)
• digitalocean_loadbalancer: Load Balancers
• digitalocean_domain: DNS-domeinvermeldingen
• digitalocean_record: DNS-records

Terraform zal uw DigitalOcean Personal Access Token gebruiken om met de DigitalOcean API te communiceren en resources in uw account te beheren. Deel deze sleutel niet met anderen en houd deze buiten scripts en versiebeheer. Exporteer uw DigitalOcean Personal Access Token naar een omgevingsvariabele genaamd DO_PAT door het volgende uit te voeren:

export DO_PAT="your_personal_access_token"

Dit zal het gebruik ervan in volgende opdrachten vergemakkelijken en het gescheiden houden van uw code.

Maak een map aan waarin je je infrastructuurconfiguratie gaat opslaan door het volgende commando uit te voeren:

mkdir ~/loadbalance

Navigeer naar de zojuist aangemaakte map:

cd ~/loadbalance

Terraform-configuraties zijn tekstbestanden die eindigen op de extensie .tf. Ze zijn leesbaar voor mensen en ondersteunen opmerkingen. (Terraform ondersteunt ook configuratiebestanden in JSON-indeling, maar die worden hier niet behandeld.) Terraform leest alle configuratiebestanden in je werkmap op een declaratieve manier, dus de volgorde van bron- en variabeledefinities doet er niet toe. Je hele infrastructuur kan in één configuratiebestand bestaan, maar je zou de configuratiebestanden moeten scheiden op basis van het type resource om de duidelijkheid te behouden.

De eerste stap om een infrastructuur met Terraform op te bouwen, is het definiëren van de provider die je gaat gebruiken.

Om de DigitalOcean-provider met Terraform te gebruiken, moet je Terraform daarover informeren en de plugin configureren met de juiste referentievariabelen. Maak een bestand genaamd provider.tf aan, waarin de configuratie voor de provider wordt opgeslagen:

nano provider.tf

Voeg de volgende regels toe aan het bestand om Terraform te vertellen dat je de DigitalOcean-provider wilt gebruiken, en instrueer Terraform waar deze te vinden:

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

Definieer vervolgens de volgende variabelen in het bestand zodat je er naar kunt verwijzen in de rest van je configuratiebestanden:

• do_token: uw persoonlijke toegangstoken voor DigitalOcean.
• pvt_key: locatie van de privésleutel, zodat Terraform deze kan gebruiken om in te loggen op nieuwe Droplets en Nginx te installeren.

U zult de waarden van deze variabelen aan Terraform doorgeven wanneer u het uitvoert, in plaats van de waarden hier hard gecodeerd te hebben. Dit maakt de configuratie draagbaarder.

Om deze variabelen te definiëren, voegt u deze regels toe aan het bestand:

...
variable "do_token" {}
variable "pvt_key" {}

Vervolgens voegt u deze regels toe om de DigitalOcean provider te configureren en de referenties voor uw DigitalOcean account te specificeren door de do_token toe te wijzen aan het token-argument van de provider:

...
provider "digitalocean" {
  token = var.do_token
}

Tenslotte wilt u dat Terraform automatisch uw SSH-sleutel toevoegt aan alle nieuwe Droplets die u maakt. Toen u uw SSH-sleutel aan DigitalOcean toevoegde, heeft u deze een naam gegeven. Terraform kan deze naam gebruiken om de openbare sleutel op te halen. Voeg deze regels toe, waarbij u terraform vervangt door de naam van de sleutel die u heeft opgegeven in uw DigitalOcean account:

...
data "digitalocean_ssh_key" "terraform" {
  name = "terraform"
}

Uw voltooide provider.tf-bestand zal er zo uitzien:

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

variable "do_token" {}
variable "pvt_key" {}

provider "digitalocean" {
  token = var.do_token
}

data "digitalocean_ssh_key" "terraform" {
  name = "terraform"
}

Als u klaar bent, slaat u het bestand op en sluit u het.

export TF_LOG=1

Initialiseer Terraform voor uw project door het volgende uit te voeren:

terraform init

Dit zal uw configuratie lezen en de plugins voor uw provider installeren. U ziet dat gelogd in de output:

Output
Initializing the backend...

Initializing provider plugins...
- Finding digitalocean/digitalocean versions matching "~> 2.0"...
- Installing digitalocean/digitalocean v2.16.0...
- Installed digitalocean/digitalocean v2.16.0 (signed by a HashiCorp partner, key ID F82037E524B9C0E8)

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.

Als je vastloopt en Terraform niet werkt zoals verwacht, kun je opnieuw beginnen door het bestand terraform.tfstate te verwijderen en handmatig de bronnen te vernietigen die zijn aangemaakt (bijv. via het bedieningspaneel).

Terraform is nu geconfigureerd en kan worden verbonden met je DigitalOcean-account. In de volgende stap zul je Terraform gebruiken om een Droplet te definiëren die een Nginx-server zal draaien.

Stap 3 — Definiëren van de Eerste Nginx-server

Je kunt Terraform gebruiken om een DigitalOcean Droplet te maken en software te installeren op de Droplet zodra deze is opgestart. In deze stap zul je een enkele Ubuntu 20.04 Droplet voorzien en de Nginx-webserver installeren met behulp van Terraform.

Maak een nieuw Terraform configuratiebestand genaamd www-1.tf, waarin de configuratie voor de Droplet wordt vastgelegd:

nano www-1.tf

Voeg de volgende regels toe om de Droplet-bron te definiëren:

resource "digitalocean_droplet" "www-1" {
    image = "ubuntu-20-04-x64"
    name = "www-1"
    region = "nyc3"
    size = "s-1vcpu-1gb"
    ssh_keys = [
      data.digitalocean_ssh_key.terraform.id
    ]

In de voorgaande configuratie definieert de eerste regel een digitalocean_droplet bron genaamd www-1. De overige regels specificeren de kenmerken van de Droplet, waaronder het datacenter waarin deze zal verblijven en de slug die de grootte van de Droplet identificeert die je wilt configureren. In dit geval gebruik je s-1vcpu-1gb, wat een Droplet zal creëren met één CPU en 1GB RAM. (Bezoek deze grootte-slugtabel om de beschikbare slugs te zien die je kunt gebruiken.)

De ssh_keys sectie specificeert een lijst van publieke sleutels die u aan de Droplet wilt toevoegen. In dit geval specificeert u de sleutel die u hebt gedefinieerd in provider.tf. Zorg ervoor dat de naam hier overeenkomt met de naam die u hebt gespecificeerd in provider.tf.

Wanneer u Terraform uitvoert tegen de DigitalOcean API, zal het verschillende informatie over de Droplet verzamelen, zoals de publieke en private IP-adressen. Deze informatie kan worden gebruikt door andere resources in uw configuratie.

Als u zich afvraagt welke argumenten vereist of optioneel zijn voor een Droplet resource, raadpleeg dan de officiële Terraform-documentatie: DigitalOcean Droplet Specificatie.

Om een connection op te zetten die Terraform kan gebruiken om verbinding te maken met de server via SSH, voegt u de volgende regels toe aan het einde van het bestand:

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

Deze regels beschrijven hoe Terraform verbinding moet maken met de server, zodat Terraform verbinding kan maken via SSH om Nginx te installeren. Let op het gebruik van de privésleutelvariabele var.pvt_key – u geeft de waarde ervan door wanneer u Terraform uitvoert.

Nu u de verbinding hebt ingesteld, configureert u de remote-exec provisioner, die u zult gebruiken om Nginx te installeren. Voeg de volgende regels toe aan de configuratie om dat te doen:

...
provisioner "remote-exec" {
    inline = [
      "export PATH=$PATH:/usr/bin",
      # nginx installeren
      "sudo apt update",
      "sudo apt install -y nginx"
    ]
  }
}

Merk op dat de strings in de inline array de commando’s zijn die de root gebruiker zal uitvoeren om Nginx te installeren.

Het voltooide bestand ziet er zo uit:

resource "digitalocean_droplet" "www-1" {
  image = "ubuntu-20-04-x64"
  name = "www-1"
  region = "nyc3"
  size = "s-1vcpu-1gb"
  ssh_keys = [
    data.digitalocean_ssh_key.terraform.id
  ]
  
  connection {
    host = self.ipv4_address
    user = "root"
    type = "ssh"
    private_key = file(var.pvt_key)
    timeout = "2m"
  }
  
  provisioner "remote-exec" {
    inline = [
      "export PATH=$PATH:/usr/bin",
      # nginx installeren
      "sudo apt update",
      "sudo apt install -y nginx"
    ]
  }
}

Sla het bestand op en sluit de editor af. Je hebt de server gedefinieerd en bent klaar om deze te implementeren, wat je nu zult doen.

Stap 4 — Gebruik Terraform om de Nginx-server te maken

Je huidige Terraform-configuratie beschrijft een enkele Nginx-server. Je zult nu de Droplet precies implementeren zoals deze is gedefinieerd.

Voer het terraform plan commando uit om het uitvoeringsplan te zien, of wat Terraform zal proberen te doen om de infrastructuur te bouwen die je hebt beschreven. Je moet de waarden opgeven voor je DigitalOcean-toegangstoken en het pad naar je privésleutel, aangezien je configuratie deze informatie gebruikt om toegang te krijgen tot je Droplet om Nginx te installeren. Voer het volgende commando uit om een plan te maken:

terraform plan \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa" 

Je ziet een uitvoer vergelijkbaar met dit:

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.www-1 zal worden aangemaakt
  + resource "digitalocean_droplet" "www-1" {
      + backups              = false
      + created_at           = (known after apply)
      + disk                 = (known after apply)
      + graceful_shutdown    = false
      + 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                 = "www-1"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = (known after apply)
      + region               = "nyc3"
      + 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)
    }

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

───────────────────────────────────────────────────────────────

Note: You didn't use the -out option to save this plan, so Terraform can't guarantee to take exactly these actions if you run "terraform apply" now.

De regel + resource "digitalocean_droplet" "www-1" betekent dat Terraform een nieuwe Droplet-resource genaamd www-1 zal aanmaken, met de details die erop volgen. Dat is precies wat er zou moeten gebeuren, dus voer het terraform apply-commando uit om het huidige plan uit te voeren:

terraform apply \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Je krijgt dezelfde uitvoer als voorheen, maar deze keer zal Terraform je vragen of je wilt doorgaan:

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

Voer yes in en druk op ENTER. Terraform zal je Droplet voorzien:

Output
digitalocean_droplet.www-1: Creating...

Na een tijdje zie je Terraform Nginx installeren met de remote-exec-provisioner, en dan zal het proces voltooid zijn:

Output
digitalocean_droplet.www-1: Provisioning with 'remote-exec'...

....

digitalocean_droplet.www-1: Creation complete after 1m54s [id=your_www-1_droplet_id]

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

Terraform heeft een nieuwe Droplet genaamd www-1 aangemaakt en Nginx erop geïnstalleerd. Als je het openbare IP-adres van je nieuwe Droplet bezoekt, zie je het welkomstscherm van Nginx. Het openbare IP-adres werd weergegeven toen de Droplet werd aangemaakt, maar je kunt het altijd bekijken door naar de huidige status van Terraform te kijken. Terraform bijwerkt het statusbestand terraform.tfstate telkens wanneer het een plan uitvoert of zijn status vernieuwt.

Om de huidige status van je omgeving te bekijken, gebruik je het volgende commando:

terraform show terraform.tfstate

Dit zal je het openbare IP-adres van je Droplet tonen.

Output
resource "digitalocean_droplet" "www-1" {
    backups              = false
    created_at           = "..."
    disk                 = 25
    id                   = "your_www-1_droplet_id"
    image                = "ubuntu-20-04-x64"
    ipv4_address         = "your_www-1_server_ip"
    ipv4_address_private = "10.128.0.2"
    ...

Navigeer naar http://je_www-1_server_ip in je browser om te controleren of je Nginx-server actief is.

terraform refresh \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

In deze stap hebt u de Droplet geïmplementeerd die u hebt beschreven in Terraform. U gaat nu een tweede maken.

Stap 5 — Het Tweede Nginx-server maken

Nu u een Nginx-server hebt beschreven, kunt u snel een tweede toevoegen door de configuratiebestand van de bestaande server te kopiëren en de naam en hostnaam van de Droplet-resource te vervangen.

Dit kunt u handmatig doen, maar het is sneller om het sed-commando te gebruiken om het bestand www-1.tf te lezen, alle gevallen van www-1 te vervangen door www-2, en een nieuw bestand genaamd www-2.tf te maken. Hier is het sed-commando om dat te doen:

sed 's/www-1/www-2/g' www-1.tf > www-2.tf

U kunt meer leren over sed door sed gebruiken te bezoeken.

Voer opnieuw terraform plan uit om de wijzigingen te bekijken die Terraform zal aanbrengen:

terraform plan \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

De uitvoer toont aan dat Terraform de tweede server, www-2, zal aanmaken:

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.www-2 zal worden aangemaakt
  + resource "digitalocean_droplet" "www-2" {
      + 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                 = "www-2"
      + price_hourly         = (known after apply)
      + price_monthly        = (known after apply)
      + private_networking   = true
      + region               = "nyc3"
      + 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)
    }

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

Voer terraform apply opnieuw uit om de tweede Droplet te maken:

terraform apply \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Zoals eerder zal Terraform vragen om te bevestigen dat u wilt doorgaan. Bekijk het plan opnieuw en typ ja om door te gaan.

Na enige tijd zal Terraform de nieuwe server maken en de resultaten weergeven:

Output
digitalocean_droplet.www-2: Creation complete after 1m47s [id=your_www-2_droplet_id]
...
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Terraform heeft de nieuwe server gemaakt, zonder de bestaande te wijzigen. U kunt deze stap herhalen om extra Nginx-servers toe te voegen.

Nu u twee Droplets met Nginx draaien heeft, zult u een load balancer definiëren en implementeren om het verkeer tussen hen te verdelen.

Stap 6 — Het maken van de Load Balancer

U zult een DigitalOcean Load Balancer gebruiken, waar de officiële Terraform-provider ondersteuning voor biedt, om het verkeer tussen de twee webservers te routeren.

Maak een nieuw Terraform-configuratiebestand genaamd loadbalancer.tf:

nano loadbalancer.tf

Voeg de volgende regels toe om de Load Balancer te definiëren:

resource "digitalocean_loadbalancer" "www-lb" {
  name = "www-lb"
  region = "nyc3"

  forwarding_rule {
    entry_port = 80
    entry_protocol = "http"

    target_port = 80
    target_protocol = "http"
  }

  healthcheck {
    port = 22
    protocol = "tcp"
  }

  droplet_ids = [digitalocean_droplet.www-1.id, digitalocean_droplet.www-2.id ]
}

De definitie van de Load Balancer specificeert de naam, het datacenter waarin het zal zijn, de poorten waarop het verkeer moet worden gebalanceerd, configuratie voor de health check, en de IDs van de Droplets die het moet balanceren, welke u ophaalt met Terraform-variabelen. Sla het bestand op en sluit het af.

Voer het terraform plan commando opnieuw uit om het nieuwe uitvoeringsplan te bekijken:

terraform plan \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Je ziet verschillende regels met output, waaronder de volgende regels:

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_loadbalancer.www-lb zal worden aangemaakt
  + resource "digitalocean_loadbalancer" "www-lb" {
      + algorithm                        = "round_robin"
      + disable_lets_encrypt_dns_records = false
      + droplet_ids                      = [
          + ...,
          + ...,
        ]
      + enable_backend_keepalive         = false
      + enable_proxy_protocol            = false
      + id                               = (known after apply)
      + ip                               = (known after apply)
      + name                             = "www-lb"
      + redirect_http_to_https           = false
      + region                           = "nyc3"
      + size_unit                        = (known after apply)
      + status                           = (known after apply)
      + urn                              = (known after apply)
      + vpc_uuid                         = (known after apply)

      + forwarding_rule {
          + certificate_id   = (known after apply)
          + certificate_name = (known after apply)
          + entry_port       = 80
          + entry_protocol   = "http"
          + target_port      = 80
          + target_protocol  = "http"
          + tls_passthrough  = false
        }

      + healthcheck {
          + check_interval_seconds   = 10
          + healthy_threshold        = 5
          + port                     = 22
          + protocol                 = "tcp"
          + response_timeout_seconds = 5
          + unhealthy_threshold      = 3
        }

      + sticky_sessions {
          + cookie_name        = (known after apply)
          + cookie_ttl_seconds = (known after apply)
          + type               = (known after apply)
        }
    }

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

Dit betekent dat de www-1 en www-2 Droplets al bestaan, en Terraform zal de www-lb Load Balancer aanmaken.

Voer terraform apply uit om de Load Balancer te bouwen:

terraform apply \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Nogmaals zal Terraform je vragen om het plan te bekijken. Keur het plan goed door yes in te voeren om door te gaan.

Zodra je dat doet, zie je output met de volgende regels, ingekort voor beknoptheid:

Output
...
digitalocean_loadbalancer.www-lb: Creating...
...
digitalocean_loadbalancer.www-lb: Creation complete after 1m18s [id=your_load_balancer_id]
...
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
...

Gebruik terraform show terraform.tfstate om het IP-adres van je Load Balancer te vinden:

terraform show terraform.tfstate

Je vindt het IP onder de invoer van www-lb:

Output
...
# digitalocean_loadbalancer.www-lb:
resource "digitalocean_loadbalancer" "www-lb" {
    algorithm                = "round_robin"
    disable_lets_encrypt_dns_records = false
    droplet_ids              = [
        your_www-1_droplet_id,
        your_www-2_droplet_id,
    ]
    enable_backend_keepalive = false
    enable_proxy_protocol    = false
    id                       = "your_load_balancer_id"
    ip                       = "your_load_balancer_ip"
    name                     = "www-lb"
    ...

Navigeer naar http://je_load_balancer_ip in je browser en je ziet een welkomstscherm van Nginx omdat de Load Balancer verkeer naar een van de twee Nginx-servers stuurt.

Je leert nu hoe je DNS configureert voor je DigitalOcean-account met behulp van Terraform.

Stap 7 — Domeinen en Records voor DNS aanmaken

Naast Droplets en Load Balancers kan Terraform ook DNS-domeinen en -records maken. Bijvoorbeeld, als je je domein wilt koppelen aan je Load Balancer, kun je de configuratie schrijven die die relatie beschrijft.

Maak een nieuw bestand om je DNS te beschrijven:

nano domain_root.tf

Voeg de volgende domeinresource toe, waarbij je your_domain vervangt door je domeinnaam:

resource "digitalocean_domain" "default" {
   name = "your_domain"
   ip_address = digitalocean_loadbalancer.www-lb.ip
}

Sla het bestand op en sluit het af wanneer je klaar bent.

Je kunt ook een CNAME-record toevoegen dat www.your_domain naar your_domain wijst. Maak een nieuw bestand voor het CNAME-record:

nano domain_cname.tf

Voeg deze regels toe aan het bestand:

resource "digitalocean_record" "CNAME-www" {
  domain = digitalocean_domain.default.name
  type = "CNAME"
  name = "www"
  value = "@"
}

Sla het bestand op en sluit het af wanneer je klaar bent.

Om de DNS-vermeldingen toe te voegen, voer je terraform plan uit gevolgd door terraform apply, net zoals bij de andere resources.

Ga naar je domeinnaam en je zult een Nginx welkomstscherm zien omdat het domein naar de Load Balancer wijst, die het verkeer naar een van de twee Nginx-servers stuurt.

Stap 8 — Je Infrastructuur Vernietigen

Hoewel niet vaak gebruikt in productieomgevingen, kan Terraform ook infrastructuur vernietigen die het heeft gecreëerd. Dit is voornamelijk handig in ontwikkelomgevingen die meerdere keren worden uitgerold en vernietigd.

Eerst maak je een uitvoeringsplan om de infrastructuur te vernietigen door terraform plan -destroy te gebruiken:

terraform plan -destroy -out=terraform.tfplan \
  -var "do_token=${DO_PAT}" \
  -var "pvt_key=$HOME/.ssh/id_rsa"

Terraform zal een plan uitvoeren met resources gemarkeerd in rood, en voorafgegaan door een minteken, wat aangeeft dat het de resources in je infrastructuur zal verwijderen.

Vervolgens gebruik je terraform apply om het plan uit te voeren:

terraform apply terraform.tfplan

Terraform zal doorgaan met het vernietigen van de resources, zoals aangegeven in het gegenereerde plan.

Conclusie

In deze tutorial heb je Terraform gebruikt om een ​​load-balanced webinfrastructuur op DigitalOcean te bouwen, met twee Nginx-webservers die achter een DigitalOcean Load Balancer draaien. Je weet hoe je resources kunt maken en vernietigen, de huidige status kunt bekijken, en Terraform kunt gebruiken om DNS-vermeldingen te configureren.

Nu je begrijpt hoe Terraform werkt, kun je configuratiebestanden maken die een serverinfrastructuur voor je eigen projecten beschrijven. Het voorbeeld in deze tutorial is een goed startpunt dat laat zien hoe je de implementatie van servers kunt automatiseren. Als je al provisioningtools gebruikt, kun je ze integreren met Terraform om servers te configureren als onderdeel van hun creatieproces in plaats van de provisioningmethode die in deze tutorial wordt gebruikt.

Terraform heeft veel meer functies en kan werken met andere providers. Bekijk de officiële Terraform-documentatie om meer te weten te komen over hoe je Terraform kunt gebruiken om je eigen infrastructuur te verbeteren.

Deze tutorial is onderdeel van de Hoe infrastructuur beheren met Terraform serie. De serie behandelt verschillende Terraform-onderwerpen, van het voor de eerste keer installeren van Terraform tot het beheren van complexe projecten.