Einfachen Flask-Webserver mit Terraform bereitstellen

In dieser Anleitung erfahren Sie, wie Sie Terraform verwenden, um mit Terraform einen einfachen Webserver in Compute Engine zu erstellen.

In dieser Anleitung tun Sie Folgendes:

Mit Terraform eine VM in Google Cloud erstellen.
Starten Sie einen einfachen Python Flask-Server.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Compute Engine

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

Bereiten Sie sich auf die Anleitung vor.

Projekt auswählen oder erstellen

In the Google Cloud console, go to the project selector page.

Go to project selector
Select or create a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Berechtigungen einrichten

Prüfen Sie, ob Sie die erforderlichen Compute Engine-Berechtigungen für Ihr Nutzerkonto haben:

compute.instances.*
compute.firewalls.*

Zur IAM-Seite

Weitere Informationen zu Rollen und Berechtigungen

API aktivieren

Enable the Compute Engine API.

Enable the API

Cloud Shell starten

Cloud Shell ist eine virtuelle Compute Engine-Maschine.

Die Dienstanmeldedaten, die dieser virtuellen Maschine zugeordnet sind, erfolgen automatisch. Daher müssen Sie keinen Dienstkontoschlüssel einrichten oder herunterladen.

Terraform ist in Cloud Shell integriert und Cloud Shell authentifiziert Terraform automatisch, sodass Sie mit weniger Einrichtungsaufwand beginnen können.

Compute Engine-VM erstellen

Zuerst definieren Sie die Einstellungen der VM in einer Terraform-Konfigurationsdatei. Anschließend führen Sie Terraform-Befehle aus, um die VM in Ihrem Projekt zu erstellen.

Verzeichnis erstellen

Erstellen Sie ein neues Verzeichnis. Erstellen Sie in Ihrem neuen Verzeichnis eine main.tf-Datei für die Terraform-Konfiguration. Der Inhalt dieser Datei beschreibt alle Google Cloud-Ressourcen, die im Projekt erstellt werden sollen.

In Cloud Shell:

mkdir tf-tutorial && cd tf-tutorial

nano main.tf

Virtual Private Cloud-Netzwerk und Subnetz erstellen

In diesem Abschnitt erstellen Sie ein VPC-Netzwerk (Virtual Private Cloud) und ein Subnetz für die Netzwerkschnittstelle der VM.

Fügen Sie der Datei main.tf die folgende Terraform-Ressource hinzu:

resource "google_compute_network" "vpc_network" {
  name                    = "my-custom-mode-network"
  auto_create_subnetworks = false
  mtu                     = 1460
}

resource "google_compute_subnetwork" "default" {
  name          = "my-custom-subnet"
  ip_cidr_range = "10.0.1.0/24"
  region        = "us-west1"
  network       = google_compute_network.vpc_network.id
}

Compute Engine-VM-Ressource erstellen

In diesem Abschnitt erstellen Sie eine einzelne Compute Engine-Instanz, auf der Debian ausgeführt wird. In dieser Anleitung verwenden Sie den kleinsten Maschinentyp, der verfügbar ist. Später können Sie ein Upgrade auf einen größeren Maschinentyp durchführen.

Fügen Sie der Datei main.tf die folgende Terraform-Ressource google_compute_instance hinzu.

# Create a single Compute Engine instance
resource "google_compute_instance" "default" {
  name         = "flask-vm"
  machine_type = "f1-micro"
  zone         = "us-west1-a"
  tags         = ["ssh"]

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

  # Install Flask
  metadata_startup_script = "sudo apt-get update; sudo apt-get install -yq build-essential python3-pip rsync; pip install flask"

  network_interface {
    subnetwork = google_compute_subnetwork.default.id

    access_config {
      # Include this section to give the VM an external IP address
    }
  }
}

Der Beispielcode legt die Google Cloud-Zone auf us-west1-a fest. Sie können dies in eine andere Zone ändern.

Terraform initialisieren

An diesem Punkt können Sie terraform init ausführen, um die erforderlichen Plug-ins hinzuzufügen und das Verzeichnis .terraform zu erstellen.

terraform init

Ausgabe:

Initializing the backend...

Initializing provider plugins...
...

Terraform has been successfully initialized!

Terraform-Konfiguration validieren

Optional können Sie den bisher erstellten Terraform-Code validieren. Führen Sie terraform plan aus, wodurch Folgendes ausgeführt wird:

Überprüft, ob die Syntax von main.tf korrekt ist
Zeigt eine Vorschau der Ressourcen an, die erstellt werden

terraform plan

Ausgabe:

...

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.

Wenden Sie die Konfiguration an

Führen Sie zum Erstellen der VM terraform apply aus.

terraform apply

Geben Sie bei Aufforderung yes ein.

Terraform ruft Google Cloud APIs auf, um die neue VM einzurichten. Die neue VM finden Sie auf der Seite "VM-Instanzen".

Webserver in Google Cloud ausführen

Als Nächstes erstellen Sie eine Webanwendung, stellen diese auf der VM bereit und erstellen eine Firewallregel, um Clientanfragen an die Webanwendung zuzulassen.

Benutzerdefinierte Firewallregel für SSH hinzufügen

Mit der Firewallregel default-allow-ssh im Netzwerk default können Sie eine SSH-Verbindung zur VM herstellen. Wenn Sie Ihre eigene benutzerdefinierte Firewallregel verwenden möchten, können Sie die folgende Ressource am Ende der Datei main.tf hinzufügen:

resource "google_compute_firewall" "ssh" {
  name = "allow-ssh"
  allow {
    ports    = ["22"]
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.vpc_network.id
  priority      = 1000
  source_ranges = ["0.0.0.0/0"]
  target_tags   = ["ssh"]
}

Führen Sie terraform apply aus, um die Firewallregel zu erstellen.

SSH-Verbindung zur VM herstellen

Prüfen Sie, ob alles korrekt eingerichtet ist. Stellen Sie dazu eine SSH-Verbindung zur VM her.

Gehen Sie auf die Seite VM-Instanzen.
Suchen Sie die VM mit dem Namen flask-vm.
Klicken Sie in der Spalte Verbinden auf SSH.

Für die ausgeführte VM wird ein "SSH im Browser"-Terminalfenster geöffnet.

Weitere Informationen finden Sie unter Verbindung zu VMs herstellen.

Flask-Anwendung erstellen

Sie erstellen für diese Anleitung eine Python Flask-Anwendung, sodass Sie eine einzelne Datei haben, die Ihren Webserver und die Testendpunkte beschreibt.

Erstellen Sie im "SSH im Browser"-Terminal eine Datei mit dem Namen app.py.
```
nano app.py
```

Fügen Sie der Datei app.py folgendes hinzu:

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_cloud():
  return 'Hello Cloud!'

app.run(host='0.0.0.0')

Führen Sie app.py aus.
```
python3 app.py
```
Flask stellt Traffic standardmäßig auf localhost:5000 bereit.

Warnung: Dies ist ein Entwicklungsserver. Verwenden Sie ihn nicht in einer Produktionsbereitstellung.
Öffnen Sie eine zweite SSH-Verbindung:
1. Gehen Sie auf die Seite VM-Instanzen.
2. Suchen Sie die VM mit dem Namen flask-vm und klicken Sie auf SSH.
Führen Sie in der zweiten SSH-Verbindung curl aus, um zu bestätigen, dass die Begrüßung, die Sie in app.py konfiguriert haben, zurückgegeben wird.
```
curl http://0.0.0.0:5000
```
Die Ausgabe dieses Befehls lautet Hello Cloud.

Port 5000 auf der VM öffnen

Um von Ihrem lokalen Computer eine Verbindung zum Webserver herzustellen, muss die VM Port 5000 öffnen. Mit Google Cloud können Sie Ports mit Firewallregeln in Traffic öffnen.

Fügen Sie die folgende Terraform-Ressource google_compute_firewall am Ende der Datei main.tf hinzu:

resource "google_compute_firewall" "flask" {
  name    = "flask-app-firewall"
  network = google_compute_network.vpc_network.id

  allow {
    protocol = "tcp"
    ports    = ["5000"]
  }
  source_ranges = ["0.0.0.0/0"]
}

Führen Sie in Cloud Shell terraform apply aus, um die Firewallregel zu erstellen.

Ausgabevariable für die Webserver-URL hinzufügen

Fügen Sie am Ende von main.tf eine Terraform-Ausgabevariable hinzu, um die Webserver-URL auszugeben:

// A variable for extracting the external IP address of the VM
output "Web-server-URL" {
 value = join("",["http://",google_compute_instance.default.network_interface.0.access_config.0.nat_ip,":5000"])
}

Führen Sie terraform apply aus.
```
terraform apply
```
Geben Sie bei Aufforderung yes ein. Terraform gibt die externe IP-Adresse und den Port 5000 der VM so auf dem Bildschirm aus:
```
Web-server-URL = "http://IP_ADDRESS:5000"
```
Sie können jederzeit terraform output ausführen, um diese Ausgabe zurückzugeben:
```
terraform output
```
Klicken Sie auf die URL aus dem vorherigen Schritt und Ihnen wird die Nachricht "Hello Cloud!" angezeigt.

Dies bedeutet, dass der Server ausgeführt wird.

Fehlerbehebung

Wenn eine erforderliche API nicht aktiviert ist, gibt Terraform einen Fehler zurück. Die Fehlermeldung enthält einen Link zum Aktivieren der API. Nachdem Sie die API aktiviert haben, können Sie terraform apply noch einmal ausführen.
Wenn Sie keine Verbindung zu Ihrer VM über SSH herstellen können, gehen Sie so vor:
- Achten Sie darauf, die SSH-Firewallregel hinzuzufügen.
- Achten Sie darauf, dass die VM das Argument tags = ["ssh"] enthält.

Bereinigen

Nachdem Sie die Anleitung abgeschlossen haben, können Sie alle erstellten Elemente löschen, sodass keine weiteren Kosten anfallen.

Mit Terraform können Sie alle in der Konfigurationsdatei definierten Ressourcen mit dem Befehl terraform destroy entfernen:

terraform destroy

Geben Sie yes ein, damit Terraform Ihre Ressourcen löschen kann.

Nächste Schritte

Google Cloud-Ressourcen in das Terraform-Format exportieren