Wie man Terraform mit DigitalOcean verwendet

Einführung

Terraform ist ein Tool zum Aufbau und zur Verwaltung von Infrastruktur auf organisierte Weise. Sie können es verwenden, um DigitalOcean-Droplets, Lastenausgleicher und sogar DNS-Einträge zu verwalten, zusätzlich zu einer großen Vielfalt von Diensten, die von anderen Anbietern angeboten werden. Terraform verwendet eine Befehlszeilenschnittstelle und kann von Ihrem Desktop oder einem Remote-Server ausgeführt werden.

Terraform funktioniert, indem es Konfigurationsdateien liest, die die Komponenten beschreiben, die Ihre Anwendungsumgebung oder Ihr Rechenzentrum ausmachen. Basierend auf der Konfiguration generiert es einen Ausführungsplan, der beschreibt, was es tun wird, um den gewünschten Zustand zu erreichen. Anschließend verwenden Sie Terraform, um diesen Plan auszuführen und die Infrastruktur aufzubauen. Wenn Änderungen an der Konfiguration auftreten, kann Terraform inkrementelle Pläne generieren und ausführen, um die vorhandene Infrastruktur auf den neu beschriebenen Zustand zu aktualisieren.

In diesem Tutorial installieren Sie Terraform und verwenden es, um eine Infrastruktur auf DigitalOcean zu erstellen, die aus zwei Nginx-Servern besteht, die von einem DigitalOcean-Lastenausgleicher ausgeglichen werden. Anschließend verwenden Sie Terraform, um einen DNS-Eintrag auf DigitalOcean hinzuzufügen, der auf Ihren Lastenausgleicher verweist. Dies hilft Ihnen, mit der Verwendung von Terraform zu beginnen, und gibt Ihnen eine Vorstellung davon, wie Sie es verwenden können, um eine auf DigitalOcean basierende Infrastruktur zu verwalten und bereitzustellen, die Ihren eigenen Anforderungen entspricht.

Voraussetzungen

Um dieses Tutorial abzuschließen, benötigen Sie:

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

Schritt 1 – Installation von Terraform

Terraform ist ein Befehlszeilentool, das Sie auf Ihrem Desktop oder auf einem Remote-Server ausführen. Um es zu installieren, laden Sie es herunter und platzieren Sie es in Ihrem PATH, damit Sie es in jedem Arbeitsverzeichnis ausführen können.

Zuerst laden Sie das passende Paket für Ihr Betriebssystem und Ihre Architektur von der offiziellen Downloads-Seite herunter. Wenn Sie macOS oder Linux verwenden, können Sie Terraform mit curl herunterladen.

Auf macOS verwenden Sie diesen Befehl, um Terraform herunterzuladen und in Ihrem Home-Verzeichnis zu platzieren:

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

Auf Linux verwenden Sie diesen Befehl:

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

Erstellen Sie das Verzeichnis ~/opt/terraform:

mkdir -p ~/opt/terraform

Dann entpacken Sie Terraform mit dem Befehl unzip in das Verzeichnis ~/opt/terraform. Auf Ubuntu können Sie unzip mit apt installieren:

sudo apt install unzip

Verwenden Sie es, um das heruntergeladene Archiv in das Verzeichnis ~/opt/terraform zu extrahieren, indem Sie Folgendes ausführen:

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

Schließlich fügen Sie ~/opt/terraform Ihrer PATH-Umgebungsvariable hinzu, damit Sie den terraform-Befehl ausführen können, ohne den vollständigen Pfad zur ausführbaren Datei anzugeben.

Auf Linux müssen Sie PATH in .bashrc neu definieren, was beim Öffnen einer neuen Shell ausgeführt wird. Öffnen Sie es zur Bearbeitung, indem Sie Folgendes ausführen:

nano ~/.bashrc

Um den Pfad von Terraform zu Ihrem PATH hinzuzufügen, fügen Sie die folgende Zeile am Ende der Datei hinzu:

export PATH=$PATH:~/opt/terraform

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Jetzt können alle Ihre neuen Shell-Sitzungen den terraform-Befehl finden. Um den neuen PATH in Ihre aktuelle Sitzung zu laden, führen Sie folgenden Befehl aus, wenn Sie Bash auf einem Linux-System verwenden:

. ~/.bashrc

Wenn Sie Bash auf macOS verwenden, führen Sie stattdessen diesen Befehl aus:

. .bash_profile

Wenn Sie ZSH verwenden, führen Sie diesen Befehl aus:

. .zshrc

Um zu überprüfen, ob Terraform korrekt installiert wurde, führen Sie den terraform-Befehl ohne Argumente aus:

terraform

Sie sehen eine Ausgabe, die ähnlich der folgenden ist:

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.

Dies sind die Befehle, die Terraform akzeptiert. Die Ausgabe gibt Ihnen eine kurze Beschreibung, und Sie erfahren mehr darüber im Verlauf dieses Tutorials.

Jetzt, da Terraform installiert ist, konfigurieren wir es, um mit den Ressourcen von DigitalOcean zu arbeiten.

Schritt 2 — Konfiguration von Terraform für DigitalOcean

Terraform unterstützt eine Vielzahl von Dienstanbietern durch Provider, die Sie installieren können. Jeder Anbieter hat seine eigenen Spezifikationen, die im Allgemeinen dem API seines jeweiligen Dienstanbieters entsprechen.

Der DigitalOcean-Provider ermöglicht es Terraform, mit der DigitalOcean-API zu interagieren, um Infrastruktur aufzubauen. Dieser Anbieter unterstützt die Erstellung verschiedener DigitalOcean-Ressourcen, einschließlich der folgenden:

• digitalocean_droplet: Droplets (Server)
• digitalocean_loadbalancer: Lastenausgleich
• digitalocean_domain: DNS-Domänen-Einträge
• digitalocean_record: DNS-Einträge

Terraform wird Ihren DigitalOcean-Personal Access Token verwenden, um mit der DigitalOcean-API zu kommunizieren und Ressourcen in Ihrem Konto zu verwalten. Teilen Sie diesen Schlüssel nicht mit anderen und bewahren Sie ihn aus Skripten und Versionskontrolle heraus. Exportieren Sie Ihren DigitalOcean-Personal Access Token in eine Umgebungsvariable namens DO_PAT, indem Sie Folgendes ausführen:

export DO_PAT="your_personal_access_token"

Dies erleichtert die Verwendung in nachfolgenden Befehlen und hält sie von Ihrem Code getrennt.

Erstellen Sie ein Verzeichnis, das Ihre Infrastrukturkonfiguration speichern wird, indem Sie den folgenden Befehl ausführen:

mkdir ~/loadbalance

Navigieren Sie zum neu erstellten Verzeichnis:

cd ~/loadbalance

Terraform-Konfigurationen sind Textdateien, die mit der Dateierweiterung .tf enden. Sie sind menschenlesbar und unterstützen Kommentare. (Terraform unterstützt auch Konfigurationsdateien im JSON-Format, aber diese werden hier nicht behandelt.) Terraform liest alle Konfigurationsdateien in Ihrem Arbeitsverzeichnis deklarativ, sodass die Reihenfolge der Ressourcen- und Variablendefinitionen keine Rolle spielt. Ihre gesamte Infrastruktur kann in einer einzigen Konfigurationsdatei existieren, aber Sie sollten die Konfigurationsdateien nach Ressourcentyp trennen, um die Klarheit zu erhalten.

Der erste Schritt zum Aufbau einer Infrastruktur mit Terraform besteht darin, den Anbieter zu definieren, den Sie verwenden möchten.

Um den DigitalOcean-Anbieter mit Terraform zu verwenden, müssen Sie Terraform darüber informieren und das Plugin mit den richtigen Anmeldeinformationen konfigurieren. Erstellen Sie eine Datei namens provider.tf, die die Konfiguration für den Anbieter speichert:

nano provider.tf

Fügen Sie die folgenden Zeilen in die Datei ein, um Terraform mitzuteilen, dass Sie den DigitalOcean-Anbieter verwenden möchten, und geben Sie Terraform an, wo Sie ihn finden können:

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

Definieren Sie dann die folgenden Variablen in der Datei, damit Sie auf sie in den restlichen Ihrer Konfigurationsdateien verweisen können:

• do_token: Ihr persönlicher Zugriffstoken von DigitalOcean.
• pvt_key: Speicherort des privaten Schlüssels, damit Terraform sich anmelden und Nginx auf neuen Droplets installieren kann.

Sie werden die Werte dieser Variablen in Terraform übergeben, wenn Sie es ausführen, anstatt die Werte hier fest einzucodieren. Dies macht die Konfiguration portabler.

Um diese Variablen zu definieren, fügen Sie diese Zeilen zur Datei hinzu:

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

Fügen Sie dann diese Zeilen hinzu, um den DigitalOcean-Provider zu konfigurieren und die Anmeldeinformationen für Ihr DigitalOcean-Konto zu spezifizieren, indem Sie den do_token dem token-Argument des Providers zuweisen:

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

Zuletzt möchten Sie, dass Terraform automatisch Ihren SSH-Schlüssel zu allen neuen Droplets hinzufügt, die Sie erstellen. Als Sie Ihren SSH-Schlüssel zu DigitalOcean hinzugefügt haben, haben Sie ihm einen Namen gegeben. Terraform kann diesen Namen verwenden, um den öffentlichen Schlüssel abzurufen. Fügen Sie diese Zeilen hinzu, wobei Sie terraform durch den Namen des Schlüssels ersetzen, den Sie in Ihrem DigitalOcean-Konto angegeben haben:

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

Ihre fertige provider.tf-Datei wird so aussehen:

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

Wenn Sie fertig sind, speichern und schließen Sie die Datei.

export TF_LOG=1

Initialisieren Sie Terraform für Ihr Projekt, indem Sie Folgendes ausführen:

terraform init

Dies wird Ihre Konfiguration lesen und die Plugins für Ihren Provider installieren. Sie werden dies im Ausgabefenster protokolliert sehen:

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.

Wenn Sie feststellen, dass Terraform nicht wie erwartet funktioniert, können Sie von vorne beginnen, indem Sie die Datei terraform.tfstate löschen und die erstellten Ressourcen manuell zerstören (z. B. über das Steuerfeld).

Terraform ist jetzt konfiguriert und kann mit Ihrem DigitalOcean-Konto verbunden werden. Im nächsten Schritt verwenden Sie Terraform, um einen Droplet zu definieren, auf dem ein Nginx-Server ausgeführt wird.

Schritt 3 — Definition des ersten Nginx-Servers

Mit Terraform können Sie einen DigitalOcean-Droplet erstellen und Software auf dem Droplet installieren, sobald er hochgefahren ist. In diesem Schritt werden Sie einen einzelnen Ubuntu 20.04-Droplet bereitstellen und den Nginx-Webserver mithilfe von Terraform installieren.

Erstellen Sie eine neue Terraform-Konfigurationsdatei namens www-1.tf, die die Konfiguration für den Droplet enthält:

nano www-1.tf

Fügen Sie die folgenden Zeilen ein, um die Ressource Droplet zu definieren:

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 der vorherigen Konfiguration definiert die erste Zeile eine digitalocean_droplet-Ressource namens www-1. Die restlichen Zeilen geben die Attribute des Droplets an, einschließlich des Rechenzentrums, in dem es sich befinden wird, und des Slug, der die Größe des zu konfigurierenden Droplets identifiziert. In diesem Fall verwenden Sie s-1vcpu-1gb, was einen Droplet mit einem CPU und 1GB RAM erstellt. (Besuchen Sie diese Größentabelle für Slugs, um die verfügbaren Slugs anzuzeigen, die Sie verwenden können.)

Der Abschnitt ssh_keys gibt eine Liste von öffentlichen Schlüsseln an, die Sie dem Droplet hinzufügen möchten. In diesem Fall geben Sie den Schlüssel an, den Sie in provider.tf definiert haben. Stellen Sie sicher, dass der Name hier mit dem Namen übereinstimmt, den Sie in provider.tf angegeben haben.

Wenn Sie Terraform gegen die DigitalOcean-API ausführen, sammelt es verschiedene Informationen über den Droplet, wie seine öffentlichen und privaten IP-Adressen. Diese Informationen können von anderen Ressourcen in Ihrer Konfiguration verwendet werden.

Wenn Sie sich fragen, welche Argumente für eine Droplet-Ressource erforderlich oder optional sind, konsultieren Sie bitte die offizielle Terraform-Dokumentation: DigitalOcean Droplet Spezifikation.

Um eine Verbindung einzurichten, die Terraform verwenden kann, um über SSH mit dem Server zu verbinden, fügen Sie am Ende der Datei die folgenden Zeilen hinzu:

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

Diese Zeilen beschreiben, wie Terraform eine Verbindung zum Server herstellen soll, sodass Terraform über SSH eine Verbindung herstellen kann, um Nginx zu installieren. Beachten Sie die Verwendung der privaten Schlüsselvariablen var.pvt_key – Sie geben ihren Wert an, wenn Sie Terraform ausführen.

Jetzt, da die Verbindung eingerichtet ist, konfigurieren Sie den remote-exec-Bereitsteller, den Sie verwenden werden, um Nginx zu installieren. Fügen Sie der Konfiguration die folgenden Zeilen hinzu, um genau das zu tun:

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

Beachten Sie, dass die Zeichenfolgen im inline-Array die Befehle sind, die der root-Benutzer ausführen wird, um Nginx zu installieren.

Die fertige Datei sieht folgendermaßen aus:

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

Speichern Sie die Datei und verlassen Sie den Editor. Sie haben den Server definiert und sind bereit, ihn bereitzustellen, was Sie nun tun werden.

Schritt 4 — Verwenden von Terraform zum Erstellen des Nginx-Servers

Ihre aktuelle Terraform-Konfiguration beschreibt einen einzelnen Nginx-Server. Sie werden den Droplet jetzt genau so bereitstellen, wie er definiert ist.

Führen Sie den Befehl terraform plan aus, um den Ausführungsplan zu sehen, oder was Terraform versuchen wird, um die von Ihnen beschriebene Infrastruktur aufzubauen. Sie müssen die Werte für Ihren DigitalOcean Access Token und den Pfad zu Ihrem privaten Schlüssel angeben, da Ihre Konfiguration diese Informationen verwendet, um auf Ihren Droplet zuzugreifen und Nginx zu installieren. Führen Sie den folgenden Befehl aus, um einen Plan zu erstellen:

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

Sie sehen eine Ausgabe ähnlich wie diese:

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 wird erstellt
  + 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.

Die Zeile + resource "digitalocean_droplet" "www-1" bedeutet, dass Terraform eine neue Droplet-Ressource mit dem Namen www-1 erstellen wird, mit den anschließenden Details. Das ist genau das, was passieren soll, also führen Sie den Befehl terraform apply aus, um den aktuellen Plan auszuführen:

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

Sie erhalten dieselbe Ausgabe wie zuvor, aber diesmal wird Terraform Sie fragen, ob Sie fortfahren möchten:

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

Geben Sie yes ein und drücken Sie ENTER. Terraform wird Ihren Droplet bereitstellen:

Output
digitalocean_droplet.www-1: Creating...

Nach einer Weile sehen Sie, wie Terraform Nginx mit dem Bereitsteller remote-exec installiert, und dann wird der Prozess abgeschlossen sein:

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 hat einen neuen Droplet namens www-1 erstellt und Nginx darauf installiert. Wenn Sie die öffentliche IP-Adresse Ihres neuen Droplets besuchen, sehen Sie den Nginx-Begrüßungsbildschirm. Die öffentliche IP wurde angezeigt, als der Droplet erstellt wurde, aber Sie können sie jederzeit anzeigen, indem Sie den aktuellen Zustand von Terraform betrachten. Terraform aktualisiert die Zustandsdatei terraform.tfstate jedes Mal, wenn es einen Plan ausführt oder seinen Zustand aktualisiert.

Um den aktuellen Zustand Ihrer Umgebung anzuzeigen, verwenden Sie den folgenden Befehl:

terraform show terraform.tfstate

Dies zeigt Ihnen die öffentliche IP-Adresse Ihres Droplets an.

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

Navigieren Sie in Ihrem Browser zu http://Ihre_www-1_server_ip, um zu überprüfen, ob Ihr Nginx-Server läuft.

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

In diesem Schritt haben Sie den Droplet bereitgestellt, den Sie in Terraform beschrieben haben. Jetzt werden Sie einen zweiten erstellen.

Schritt 5 — Zweiten Nginx-Server erstellen

Jetzt, da Sie einen Nginx-Server beschrieben haben, können Sie schnell einen zweiten hinzufügen, indem Sie die Konfigurationsdatei des vorhandenen Servers kopieren und den Namen und den Hostnamen der Droplet-Ressource ersetzen.

Dies können Sie manuell tun, aber es ist schneller, den sed-Befehl zu verwenden, um die Datei www-1.tf zu lesen, alle Instanzen von www-1 durch www-2 zu ersetzen und eine neue Datei namens www-2.tf zu erstellen. Hier ist der sed-Befehl dafür:

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

Weitere Informationen zu sed finden Sie unter Verwendung von sed.

Führen Sie erneut terraform plan aus, um eine Vorschau der Änderungen zu erhalten, die Terraform vornehmen wird:

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

Die Ausgabe zeigt, dass Terraform den zweiten Server, www-2, erstellen wird:

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 wird erstellt
  + 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.
...

Führen Sie terraform apply erneut aus, um den zweiten Droplet zu erstellen:

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

Wie zuvor wird Terraform Sie auffordern, zu bestätigen, dass Sie fortfahren möchten. Überprüfen Sie den Plan erneut und geben Sie yes ein, um fortzufahren.

Nach einiger Zeit wird Terraform den neuen Server erstellen und die Ergebnisse anzeigen:

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 hat den neuen Server erstellt, ohne den vorhandenen zu ändern. Sie können diesen Schritt wiederholen, um zusätzliche Nginx-Server hinzuzufügen.

Jetzt, da Sie zwei Droplets haben, die Nginx ausführen, werden Sie einen Lastenausgleicher definieren und bereitstellen, um den Datenverkehr zwischen ihnen aufzuteilen.

Schritt 6 — Erstellen des Lastenausgleichs

Sie werden einen DigitalOcean-Lastenausgleicher verwenden, den der offizielle Terraform-Anbieter unterstützt, um den Datenverkehr zwischen den beiden Webservern zu routen.

Erstellen Sie eine neue Terraform-Konfigurationsdatei mit dem Namen loadbalancer.tf:

nano loadbalancer.tf

Fügen Sie die folgenden Zeilen hinzu, um den Lastenausgleicher zu definieren:

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

Die Definition des Lastenausgleichs gibt seinen Namen, das Rechenzentrum, in dem er sich befinden wird, die Ports, auf denen er den Datenverkehr ausgleichen soll, die Konfiguration für den Gesundheitscheck und die IDs der Droplets, die er ausgleichen soll, an, die Sie mithilfe von Terraform-Variablen abrufen. Speichern und schließen Sie die Datei.

Führen Sie erneut den Befehl terraform plan aus, um den neuen Ausführungsplan zu überprüfen:

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

Sie werden mehrere Zeilen mit Ausgaben sehen, einschließlich der folgenden Zeilen:

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 wird erstellt werden
  + 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.
...

Dies bedeutet, dass die Droplets www-1 und www-2 bereits vorhanden sind und Terraform den Lastenausgleicher www-lb erstellen wird.

Führen Sie terraform apply aus, um den Lastenausgleicher zu erstellen:

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

Erneut wird Terraform Sie auffordern, den Plan zu überprüfen. Genehmigen Sie den Plan, indem Sie yes eingeben, um fortzufahren.

Sobald Sie dies tun, werden Sie Ausgaben sehen, die die folgenden Zeilen enthalten, aus Gründen der Kürze gekürzt:

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

Verwenden Sie terraform show terraform.tfstate, um die IP-Adresse Ihres Lastenausgleichers zu ermitteln:

terraform show terraform.tfstate

Sie finden die IP unter dem Eintrag 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"
    ...

Navigieren Sie in Ihrem Browser zu http://your_load_balancer_ip und Sie sehen einen Nginx-Begrüßungsbildschirm, weil der Lastenausgleicher den Verkehr an einen der beiden Nginx-Server sendet.

Sie werden nun lernen, wie Sie die DNS-Konfiguration für Ihr DigitalOcean-Konto mit Terraform konfigurieren.

Schritt 7 — DNS-Domänen und -Einträge erstellen

Neben Droplets und Load Balancers kann Terraform auch DNS-Domänen und Rekorddomänen erstellen. Zum Beispiel, wenn Sie Ihre Domäne auf Ihren Load Balancer zeigen möchten, können Sie die Konfiguration schreiben, die diese Beziehung beschreibt.

Erstellen Sie eine neue Datei, um Ihre DNS zu beschreiben:

nano domain_root.tf

Fügen Sie die folgende Domänenressource hinzu und ersetzen Sie Ihre_Domäne durch Ihren Domänennamen:

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

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Sie können auch einen CNAME-Eintrag hinzufügen, der www.Ihre_Domäne auf Ihre_Domäne zeigt. Erstellen Sie eine neue Datei für den CNAME-Eintrag:

nano domain_cname.tf

Fügen Sie diese Zeilen zur Datei hinzu:

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

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Um die DNS-Einträge hinzuzufügen, führen Sie terraform plan gefolgt von terraform apply aus, wie bei den anderen Ressourcen.

Navigieren Sie zu Ihrem Domänennamen, und Sie sehen einen Nginx-Begrüßungsbildschirm, da die Domäne auf den Load Balancer zeigt, der den Datenverkehr an einen der beiden Nginx-Server sendet.

Schritt 8 — Zerstören Ihrer Infrastruktur

Obwohl es in Produktionsumgebungen nicht häufig verwendet wird, kann Terraform auch die von ihm erstellte Infrastruktur zerstören. Dies ist hauptsächlich nützlich in Entwicklungsumgebungen, die mehrmals bereitgestellt und zerstört werden.

Zuerst erstellen Sie einen Ausführungsplan, um die Infrastruktur zu zerstören, indem Sie terraform plan -destroy verwenden:

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

Terraform gibt einen Plan aus, bei dem Ressourcen rot markiert sind und mit einem Minuszeichen versehen sind, das darauf hinweist, dass die Ressourcen in Ihrer Infrastruktur gelöscht werden.

Dann verwenden Sie terraform apply, um den Plan auszuführen:

terraform apply terraform.tfplan

Terraform wird fortfahren, die Ressourcen zu zerstören, wie im generierten Plan angegeben.

Fazit

In diesem Tutorial haben Sie Terraform verwendet, um eine lastausgeglichene Webinfrastruktur auf DigitalOcean zu erstellen, mit zwei Nginx-Webservern, die hinter einem DigitalOcean-Lastenausgleich laufen. Sie wissen, wie Sie Ressourcen erstellen und zerstören, den aktuellen Zustand anzeigen und Terraform verwenden, um DNS-Einträge zu konfigurieren.

Jetzt, da Sie verstehen, wie Terraform funktioniert, können Sie Konfigurationsdateien erstellen, die eine Serverinfrastruktur für Ihre eigenen Projekte beschreiben. Das Beispiel in diesem Tutorial ist ein guter Ausgangspunkt, der zeigt, wie Sie die Bereitstellung von Servern automatisieren können. Wenn Sie bereits Bereitstellungstools verwenden, können Sie diese mit Terraform integrieren, um Server als Teil ihres Erstellungsprozesses zu konfigurieren, anstatt die Bereitstellungsmethode zu verwenden, die in diesem Tutorial verwendet wurde.

Terraform bietet viele weitere Funktionen und kann mit anderen Anbietern zusammenarbeiten. Schauen Sie sich die offizielle Terraform-Dokumentation an, um mehr darüber zu erfahren, wie Sie Terraform verwenden können, um Ihre eigene Infrastruktur zu verbessern.

Dieses Tutorial ist Teil der Serie So verwalten Sie Infrastruktur mit Terraform. Die Serie behandelt verschiedene Terraform-Themen, vom ersten Mal Installieren von Terraform bis zur Verwaltung komplexer Projekte.