Come utilizzare Terraform con DigitalOcean

Introduzione

Terraform è uno strumento per la costruzione e la gestione dell’infrastruttura in modo organizzato. Puoi usarlo per gestire Droplet di DigitalOcean, Bilanciatori di Carico e persino voci DNS, oltre a una vasta varietà di servizi offerti da altri provider. Terraform utilizza un’interfaccia a riga di comando e può essere eseguito dal tuo desktop o da un server remoto.

Terraform funziona leggendo file di configurazione che descrivono i componenti che compongono l’ambiente dell’applicazione o del datacenter. In base alla configurazione, genera un piano di esecuzione che descrive cosa farà per raggiungere lo stato desiderato. Quindi usi Terraform per eseguire questo piano per creare l’infrastruttura. Quando avvengono modifiche alla configurazione, Terraform può generare ed eseguire piani incrementali per aggiornare l’infrastruttura esistente allo stato appena descritto.

In questo tutorial, installerai Terraform e lo userai per creare un’infrastruttura su DigitalOcean composta da due server Nginx bilanciati da un Bilanciatore di Carico di DigitalOcean. Quindi, utilizzerai Terraform per aggiungere una voce DNS su DigitalOcean che punti al tuo Bilanciatore di Carico. Questo ti aiuterà a iniziare ad usare Terraform e ti darà un’idea di come puoi utilizzarlo per gestire e distribuire un’infrastruttura basata su DigitalOcean che soddisfi le tue esigenze personali.

Prerequisiti

Per completare questo tutorial, avrai bisogno di:

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

Passaggio 1 — Installare Terraform

Terraform è uno strumento da riga di comando che eseguirai sul tuo computer desktop o su un server remoto. Per installarlo, lo scaricherai e lo collocherai nel tuo PATH così da poterlo eseguire in qualsiasi directory tu stia lavorando.

Prima di tutto, scarica il pacchetto appropriato per il tuo sistema operativo e architettura dalla pagina ufficiale dei Download. Se stai usando macOS o Linux, puoi scaricare Terraform con curl.

Su macOS, usa questo comando per scaricare Terraform e collocarlo nella tua directory home:

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

Su Linux, usa questo comando:

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

Crea la directory ~/opt/terraform:

mkdir -p ~/opt/terraform

Successivamente, decomprimi Terraform in ~/opt/terraform usando il comando unzip. Su Ubuntu, puoi installare unzip usando apt:

sudo apt install unzip

Usalo per estrarre l’archivio scaricato nella directory ~/opt/terraform eseguendo:

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

Infine, aggiungi ~/opt/terraform alla tua variabile di ambiente PATH in modo da poter eseguire il comando terraform senza specificare il percorso completo dell’eseguibile.

Su Linux, sarà necessario ridefinire PATH in .bashrc, che viene eseguito quando si apre una nuova shell. Aprilo per modificarlo eseguendo:

nano ~/.bashrc

Per aggiungere il percorso di Terraform al tuo PATH, aggiungi la seguente riga alla fine del file:

export PATH=$PATH:~/opt/terraform

Salva e chiudi il file quando hai finito.

Ora tutte le nuove sessioni della shell saranno in grado di trovare il comando terraform. Per caricare il nuovo PATH nella tua sessione corrente, esegui il seguente comando se stai usando Bash su un sistema Linux:

. ~/.bashrc

Se stai usando Bash su macOS, esegui invece questo comando:

. .bash_profile

Se stai usando ZSH, esegui questo comando:

. .zshrc

Per verificare di aver installato correttamente Terraform, esegui il comando terraform senza argomenti:

terraform

Vedrai un output simile al seguente:

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.

Questi sono i comandi accettati da Terraform. L’output fornisce una breve descrizione, e ne apprenderai di più durante questo tutorial.

Ora che Terraform è installato, configuriamolo per lavorare con le risorse di DigitalOcean.

Passaggio 2 — Configurazione di Terraform per DigitalOcean

Terraform supporta una varietà di fornitori di servizi tramite fornitori che è possibile installare. Ogni fornitore ha le proprie specifiche, che in genere corrispondono all’API del rispettivo fornitore di servizi.

Il fornitore DigitalOcean consente a Terraform di interagire con l’API di DigitalOcean per creare infrastrutture. Questo fornitore supporta la creazione di vari risorse DigitalOcean, tra cui le seguenti:

• digitalocean_droplet: Droplets (server)
• digitalocean_loadbalancer: Bilanciatori di carico
• digitalocean_domain: Voci del dominio DNS
• digitalocean_record: Record DNS

Terraform utilizzerà il tuo Token di Accesso Personale DigitalOcean per comunicare con l’API di DigitalOcean e gestire le risorse nel tuo account. Non condividere questa chiave con altri e tenerla fuori dagli script e dal controllo delle versioni. Esporta il tuo Token di Accesso Personale DigitalOcean in una variabile d’ambiente chiamata DO_PAT eseguendo:

export DO_PAT="your_personal_access_token"

Questo renderà più semplice utilizzarlo nei comandi successivi e lo manterrà separato dal tuo codice.

Crea una directory che conterrà la configurazione dell’infrastruttura eseguendo il seguente comando:

mkdir ~/loadbalance

Naviga alla directory appena creata:

cd ~/loadbalance

Le configurazioni di Terraform sono file di testo che terminano con l’estensione file .tf. Sono leggibili dall’uomo e supportano i commenti. (Terraform supporta anche file di configurazione in formato JSON, ma non saranno trattati qui.) Terraform leggerà tutti i file di configurazione nella tua directory di lavoro in modo dichiarativo, quindi l’ordine delle definizioni di risorse e variabili non ha importanza. Tutta la tua infrastruttura può esistere in un singolo file di configurazione, ma dovresti separare i file di configurazione per tipo di risorsa per mantenere la chiarezza.

Il primo passo per costruire un’infrastruttura con Terraform è definire il provider che intendi utilizzare.

Per utilizzare il provider DigitalOcean con Terraform, devi informare Terraform a riguardo e configurare il plugin con le variabili di credenziali corrette. Crea un file chiamato provider.tf, che conterrà la configurazione del provider:

nano provider.tf

Aggiungi le seguenti righe nel file per informare Terraform che desideri utilizzare il provider DigitalOcean e istruire Terraform su dove trovarlo:

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

In seguito, definisci le seguenti variabili nel file in modo da poterle fare riferimento nel resto dei tuoi file di configurazione:

• do_token: il tuo Token di Accesso Personale DigitalOcean.
• pvt_key: posizione della chiave privata, così Terraform può utilizzarla per accedere alle nuove Droplet e installare Nginx.

Passerai i valori di queste variabili a Terraform quando lo eseguirai, piuttosto che codificarli qui. Questo rende la configurazione più portabile.

Per definire queste variabili, aggiungi queste righe al file:

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

Quindi, aggiungi queste righe per configurare il provider DigitalOcean e specificare le credenziali per il tuo account DigitalOcean assegnando il do_token all’argomento token del provider:

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

Infine, vorrai far sì che Terraform aggiunga automaticamente la tua chiave SSH a tutte le nuove Droplet che crei. Quando hai aggiunto la tua chiave SSH a DigitalOcean, le hai dato un nome. Terraform può usare questo nome per recuperare la chiave pubblica. Aggiungi queste righe, sostituendo terraform con il nome della chiave fornito nel tuo account DigitalOcean:

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

Il tuo file provider.tf completato apparirà così:

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

Quando hai finito, salva e chiudi il file.

export TF_LOG=1

Inizializza Terraform per il tuo progetto eseguendo:

terraform init

Questo leggerà la tua configurazione e installerà i plugin per il tuo provider. Vedrai ciò registrato nell’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.

Se per caso ti trovi bloccato e Terraform non funziona come ti aspetti, puoi ricominciare cancellando il file terraform.tfstate e distruggendo manualmente le risorse create (ad esempio, tramite il pannello di controllo).

Terraform è ora configurato e può essere collegato al tuo account DigitalOcean. Nel prossimo passaggio, userai Terraform per definire un Droplet che eseguirà un server Nginx.

Passaggio 3 — Definizione del Primo Server Nginx

Puoi utilizzare Terraform per creare un Droplet DigitalOcean e installare software sul Droplet una volta che è stato avviato. In questo passaggio, provvederai a un singolo Droplet Ubuntu 20.04 e installerai il server web Nginx utilizzando Terraform.

Crea un nuovo file di configurazione Terraform chiamato www-1.tf, che conterrà la configurazione per il Droplet:

nano www-1.tf

Inserisci le seguenti righe per definire la risorsa Droplet:

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
    ]

Nella configurazione precedente, la prima riga definisce una risorsa digitalocean_droplet chiamata www-1. Il resto delle righe specifica gli attributi del Droplet, inclusi il data center in cui risiederà e lo slug che identifica la dimensione del Droplet che desideri configurare. In questo caso stai utilizzando s-1vcpu-1gb, che creerà un Droplet con una CPU e 1GB di RAM. (Visita questa tabella delle dimensioni degli slug per vedere gli slug disponibili che puoi utilizzare.)

La sezione ssh_keys specifica una lista di chiavi pubbliche che desideri aggiungere al Droplet. In questo caso stai specificando la chiave che hai definito in provider.tf. Assicurati che il nome qui corrisponda al nome specificato in provider.tf.

Quando esegui Terraform contro l’API di DigitalOcean, raccoglierà una varietà di informazioni sul Droplet, come i suoi indirizzi IP pubblici e privati. Queste informazioni possono essere utilizzate da altre risorse nella tua configurazione.

Se ti stai chiedendo quali argomenti sono obbligatori o facoltativi per una risorsa Droplet, consulta la documentazione ufficiale di Terraform: Specifiche del Droplet di DigitalOcean.

Per configurare una connessione che Terraform può utilizzare per connettersi al server via SSH, aggiungi le seguenti righe alla fine del file:

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

Queste righe descrivono come Terraform dovrebbe connettersi al server, quindi Terraform può connettersi via SSH per installare Nginx. Nota l’uso della variabile chiave privata var.pvt_key— passerai il suo valore quando eseguirai Terraform.

Ora che hai configurato la connessione, configura il provisioner remote-exec, che userai per installare Nginx. Aggiungi le seguenti righe alla configurazione per fare proprio questo:

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

Nota che le stringhe nell’array inline sono i comandi che l’utente root eseguirà per installare Nginx.

Il file completato appare così:

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",
      # installa nginx
      "sudo apt update",
      "sudo apt install -y nginx"
    ]
  }
}

Salva il file ed esci dall’editor. Hai definito il server ed è pronto per essere distribuito, cosa che farai ora.

Passaggio 4 — Utilizzo di Terraform per creare il server Nginx

La tua attuale configurazione di Terraform descrive un singolo server Nginx. Ora distribuirai il Droplet esattamente come è definito.

Esegui il comando terraform plan per vedere il piano di esecuzione, o cosa Terraform cercherà di fare per costruire l’infrastruttura che hai descritto. Dovrai specificare i valori per il tuo Token di Accesso DigitalOcean e il percorso alla tua chiave privata, poiché la tua configurazione utilizza queste informazioni per accedere al tuo Droplet e installare Nginx. Esegui il seguente comando per creare un piano:

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

Vedrai un output simile a questo:

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 verrà creato
  + 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.

La riga + risorsa "digitalocean_droplet" "www-1" significa che Terraform creerà una nuova risorsa Droplet chiamata www-1, con i dettagli che seguono. Esattamente ciò che dovrebbe accadere, quindi esegui il comando terraform apply per eseguire il piano corrente:

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

Otterrai lo stesso output di prima, ma questa volta Terraform ti chiederà se vuoi procedere:

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

Inserisci sì e premi INVIO. Terraform provvederà alla creazione del tuo Droplet:

Output
digitalocean_droplet.www-1: Creating...

Dopo un po’ di tempo, vedrai Terraform installare Nginx con il provisioner remote-exec, e quindi il processo si completerà:

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 ha creato un nuovo Droplet chiamato www-1 e ha installato Nginx su di esso. Se visiti l’indirizzo IP pubblico del tuo nuovo Droplet, vedrai la schermata di benvenuto di Nginx. L’indirizzo IP pubblico è stato visualizzato quando il Droplet è stato creato, ma puoi sempre visualizzarlo guardando lo stato corrente di Terraform. Terraform aggiorna il file di stato terraform.tfstate ogni volta che esegue un piano o aggiorna il suo stato.

Per visualizzare lo stato corrente del tuo ambiente, usa il seguente comando:

terraform show terraform.tfstate

Questo ti mostrerà l’indirizzo IP pubblico del tuo Droplet.

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

Naviga su http://your_www-1_server_ip nel tuo browser per verificare che il tuo server Nginx sia in esecuzione.

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

In questo passaggio, hai distribuito il Droplet che hai descritto in Terraform. Ora ne creerai uno secondo.

Passaggio 5 — Creare il Secondo Server Nginx

Ora che hai descritto un server Nginx, puoi aggiungerne un secondo rapidamente copiando il file di configurazione del server esistente e sostituendo il nome e l’hostname della risorsa Droplet.

Puoi farlo manualmente, ma è più veloce usare il comando sed per leggere il file www-1.tf, sostituire tutte le occorrenze di www-1 con www-2, e creare un nuovo file chiamato www-2.tf. Ecco il comando sed per farlo:

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

Puoi saperne di più su sed visitando Utilizzare sed.

Esegui nuovamente terraform plan per visualizzare le modifiche che Terraform apporterà:

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

L’output mostra che Terraform creerà il secondo server, www-2:

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 sarà creato
  + 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.
...

Esegui di nuovo il comando terraform apply per creare il secondo Droplet:

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

Come prima, Terraform ti chiederà di confermare se desideri procedere. Rivedi il piano nuovamente e digita yes per continuare.

Dopo un po’ di tempo, Terraform creerà il nuovo server e visualizzerà i risultati:

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 ha creato il nuovo server, senza modificare quello esistente. Puoi ripetere questo passaggio per aggiungere ulteriori server Nginx.

Ora che hai due Droplets che eseguono Nginx, definirai e distribuirai un bilanciamento del carico per dividere il traffico tra di essi.

Passaggio 6 — Creazione del Bilanciamento del Carico

Userai un Bilanciamento del Carico DigitalOcean, supportato dal provider Terraform ufficiale, per instradare il traffico tra i due server web.

Crea un nuovo file di configurazione Terraform chiamato loadbalancer.tf:

nano loadbalancer.tf

Aggiungi le seguenti righe per definire il Bilanciamento del Carico:

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

La definizione del Bilanciamento del Carico specifica il suo nome, il datacenter in cui si troverà, le porte su cui ascoltare per bilanciare il traffico, la configurazione per il controllo dello stato di salute e gli ID dei Droplets che dovrebbero essere bilanciati, che vengono recuperati usando le variabili Terraform. Salva e chiudi il file.

Esegui nuovamente il comando terraform plan per rivedere il nuovo piano di esecuzione:

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

Vedrai diverse righe di output, tra cui le seguenti righe:

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 sarà creato
  + 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.
...

Questo significa che i Droplets www-1 e www-2 esistono già e Terraform creerà il Bilanciamento del Carico www-lb.

Esegui terraform apply per creare il Bilanciamento del Carico:

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

Di nuovo, Terraform ti chiederà di esaminare il piano. Approva il piano inserendo sì per continuare.

Dopo averlo fatto, vedrai un output che contiene le seguenti righe, troncate per brevità:

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

Utilizza terraform show terraform.tfstate per individuare l’indirizzo IP del tuo Bilanciamento del Carico:

terraform show terraform.tfstate

Troverai l’IP sotto l’ingresso 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"
    ...

Vai su http://il_tuo_indirizzo_ip_del_bilanciamento_del_carico nel tuo browser e vedrai una schermata di benvenuto di Nginx perché il Bilanciamento del Carico sta inviando traffico a uno dei due server Nginx.

Ora imparerai come configurare il DNS per il tuo account DigitalOcean usando Terraform.

Passaggio 7 — Creazione di Domini DNS e Record

Oltre ai Droplets e ai Load Balancers, Terraform può anche creare domini DNS e record di domini. Ad esempio, se desideri puntare il tuo dominio al tuo Load Balancer, puoi scrivere la configurazione che descrive tale relazione.

Crea un nuovo file per descrivere il tuo DNS:

nano domain_root.tf

Aggiungi la seguente risorsa di dominio, sostituendo your_domain con il nome del tuo dominio:

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

Salva e chiudi il file quando hai finito.

Puoi anche aggiungere un record CNAME che punta www.your_domain a your_domain. Crea un nuovo file per il record CNAME:

nano domain_cname.tf

Aggiungi queste righe al file:

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

Salva e chiudi il file quando hai finito.

Per aggiungere le voci DNS, esegui terraform plan seguito da terraform apply, come per le altre risorse.

Vai al tuo nome di dominio e vedrai una schermata di benvenuto di Nginx perché il dominio punta al Load Balancer, che sta inviando traffico a uno dei due server Nginx.

Passaggio 8 — Distruggere la tua infrastruttura

Anche se non comunemente utilizzato negli ambienti di produzione, Terraform può anche distruggere l’infrastruttura che ha creato. Questo è principalmente utile negli ambienti di sviluppo che vengono distribuiti e distrutti più volte.

Prima, crea un piano di esecuzione per distruggere l’infrastruttura utilizzando terraform plan -destroy:

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

Terraform produrrà un piano con risorse contrassegnate in rosso e precedute da un segno meno, indicando che eliminerà le risorse nella tua infrastruttura.

Successivamente, utilizza terraform apply per eseguire il piano:

terraform apply terraform.tfplan

Terraform procederà a distruggere le risorse, come indicato nel piano generato.

Conclusion

In questo tutorial, hai utilizzato Terraform per creare un’infrastruttura web bilanciata su DigitalOcean, con due server web Nginx in esecuzione dietro un bilanciamento del carico DigitalOcean. Sai come creare e distruggere risorse, visualizzare lo stato attuale e utilizzare Terraform per configurare voci DNS.

Ora che comprendi come funziona Terraform, puoi creare file di configurazione che descrivono un’infrastruttura server per i tuoi progetti. L’esempio in questo tutorial è un buon punto di partenza che dimostra come puoi automatizzare il deployment dei server. Se già utilizzi strumenti di provisioning, puoi integrarli con Terraform per configurare i server come parte del loro processo di creazione anziché utilizzare il metodo di provisioning utilizzato in questo tutorial.

Terraform ha molte altre funzionalità e può funzionare con altri fornitori. Dai un’occhiata alla Documentazione ufficiale di Terraform per scoprire di più su come puoi utilizzare Terraform per migliorare la tua infrastruttura.

Questo tutorial fa parte della serie Come Gestire l’Infrastruttura con Terraform. La serie tratta vari argomenti di Terraform, dall’installazione di Terraform per la prima volta alla gestione di progetti complessi.