Diese Seite wurde von der Cloud Translation API übersetzt.

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 Trusted Clouderstellen.
Starten Sie einen einfachen Python Flask-Server.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Trusted Cloud by S3NS:

Compute Engine

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Neuen Trusted 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 Trusted Cloud console, go to the project selector page.

Go to project selector
Select or create a Trusted 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

gcloud CLI installiert

Zur Verwendung von Terraform aus einer lokalen Entwicklungsumgebung installieren und initialisieren Sie die Google Cloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein:

Installieren Sie die gcloud CLI.
Initialisieren Sie die gcloud CLI:
```
gcloud init
```
Erstellen Sie lokale Anmeldedaten zur Authentifizierung für Ihr Konto:
```
gcloud auth application-default login
```

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 Trusted Cloud -Ressourcen, die im Projekt erstellt werden sollen.

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

Im Beispielcode wird die Trusted Cloud -Zone auf us-west1-a festgelegt. 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 Trusted Cloud APIs auf, um die neue VM einzurichten. Die neue VM finden Sie auf der Seite „VM-Instanzen“.

Webserver auf Trusted Cloudausfü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. Trusted Cloud Mit Firewallregeln können Sie Ports für 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 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.