Esegui il deployment di un server web Flask di base con Terraform

In questo tutorial imparerai a utilizzare Terraform per creare un server web di base su Compute Engine.

In questo tutorial imparerai a:

Utilizzare Terraform per creare una VM in Google Cloud.
Avvia un server Python Flask di base.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione Pulizia.

Prima di iniziare

Preparati per iniziare il tutorial.

Seleziona o crea un progetto

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.

Configurare le autorizzazioni

Assicurati di disporre delle autorizzazioni di Compute Engine necessarie per il tuo account utente:

compute.instances.*
compute.firewalls.*

Vai alla pagina IAM

Scopri di più su ruoli e autorizzazioni.

Abilita l'API

Enable the Compute Engine API.

Enable the API

Avvia Cloud Shell

Cloud Shell è una macchina virtuale di Compute Engine.

Le credenziali di servizio associate a questa macchina virtuale sono automatiche, quindi non è necessario configurare o scaricare una chiave dell'account di servizio.

Terraform è integrato con Cloud Shell e Cloud Shell autentica Terraform, consentendoti di iniziare con meno configurazioni.

crea la VM di Compute Engine

Innanzitutto, definisci le impostazioni della VM in un file di configurazione Terraform. Quindi, eseguirai i comandi Terraform per creare la VM nel tuo progetto.

Crea la directory

In Cloud Shell, crea una nuova directory. Nella nuova directory, crea un file main.tf per la configurazione di Terraform. I contenuti di questo file descrivono tutte le risorse Google Cloud da creare nel progetto.

mkdir tf-tutorial && cd tf-tutorial

nano main.tf

Crea la rete e la subnet Virtual Private Cloud

In questa sezione creerai una rete Virtual Private Cloud (VPC) e una subnet per l'interfaccia di rete della VM.

Aggiungi le seguenti risorse Terraform al file main.tf che hai creato:

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
}

Crea la risorsa VM di Compute Engine

In questa sezione creerai una singola istanza di Compute Engine che esegue Debian. In questo tutorial utilizzerai il tipo di macchina più piccolo disponibile. In seguito, potrai eseguire l'upgrade a un tipo di macchina più grande.

Aggiungi la seguente risorsa Terraform google_compute_instance al file main.tf che hai creato.

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

Il codice campione imposta la zona Google Cloud su us-west1-a. Puoi modificarla in un'altra zona.

Inizializza Terraform

A questo punto, puoi eseguire terraform init per aggiungere i plug-in necessari e creare la directory .terraform.

terraform init

Output:

Initializing the backend...

Initializing provider plugins...
...

Terraform has been successfully initialized!

Convalidare la configurazione di Terraform

Se vuoi, puoi convalidare il codice Terraform che hai creato finora. Esegui terraform plan, in modo da:

Verifica che la sintassi di main.tf sia corretta
Mostra un'anteprima delle risorse che verranno create

terraform plan

Output:

...

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.

Applicare la configurazione

Per creare la VM, esegui terraform apply.

terraform apply

Quando richiesto, inserisci yes.

Terraform chiama le API Google Cloud per configurare la nuova VM. Controlla la pagina Istanze VM per visualizzare la nuova VM.

Esegui un server web su Google Cloud

I passaggi successivi sono la creazione di un'applicazione web, il deployment della stessa nella VM e la creazione di una regola firewall per consentire le richieste del client all'applicazione web.

Aggiungi una regola firewall SSH personalizzata

La regola firewall default-allow-ssh nella rete default consente di utilizzare SSH per connetterti alla VM. Se preferisci utilizzare una regola firewall personalizzata, puoi aggiungere la seguente risorsa alla fine del file main.tf:

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

Esegui terraform apply per creare la regola firewall.

Connettiti alla VM con SSH

Verifica che a questo punto sia tutto configurato correttamente connettendoti alla VM con SSH.

Vai alla pagina Istanze VM.
Trova la VM con il nome flask-vm.
Nella colonna Connetti, fai clic su SSH.

Si apre una finestra del terminale SSH nel browser per la VM in esecuzione.

Per ulteriori informazioni, consulta la sezione Connessione alle VM.

Creare l'app Flask

Creerai un'app Python Flask per questo tutorial, in modo da avere un unico file che descriva il tuo server web e testare gli endpoint.

Nel terminale SSH nel browser, crea un file denominato app.py.
```
nano app.py
```

Aggiungi il seguente codice al file app.py:

from flask import Flask
app = Flask(__name__)

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

app.run(host='0.0.0.0')

Esecuzione app.py:
```
python3 app.py
```
Flask gestisce il traffico su localhost:5000 per impostazione predefinita.

Avviso: questo è un server di sviluppo. Non utilizzarlo in un deployment in produzione.
Apri una seconda connessione SSH:
1. Vai alla pagina Istanze VM.
2. Trova la VM denominata flask-vm e fai clic su SSH.
Nella seconda connessione SSH, esegui curl per confermare che venga restituito il saluto configurato in app.py.
```
curl http://0.0.0.0:5000
```
L'output di questo comando è Hello Cloud.

Apri la porta 5000 sulla VM

Per connettersi al server web dal computer locale, la VM deve avere la porta 5000 aperta. Google Cloud ti consente di aprire le porte al traffico utilizzando le regole firewall.

Aggiungi la seguente risorsa Terraform google_compute_firewall alla fine del file main.tf.

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

In Cloud Shell, esegui terraform apply per creare la regola firewall.

Aggiungi una variabile di output per l'URL del server web

Alla fine di main.tf, aggiungi una variabile di output Terraform per generare l'URL del server web:

// 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"])
}

Esegui terraform apply.
```
terraform apply
```
Quando richiesto, inserisci yes. Terraform stampa sullo schermo l'indirizzo IP esterno della VM e la porta 5000, come segue:
```
Web-server-URL = "http://IP_ADDRESS:5000"
```
Puoi eseguire terraform output in qualsiasi momento per restituire questo output:
```
terraform output
```
Fai clic sull'URL del passaggio precedente e visualizza il messaggio "Hello Cloud!".

Ciò significa che il server è in esecuzione.

Risoluzione dei problemi

Se un'API richiesta non è abilitata, Terraform restituisce un errore. Il messaggio di errore include un link per abilitare l'API. Dopo aver abilitato l'API, puoi eseguire nuovamente terraform apply.
Se non riesci a connetterti alla VM tramite SSH:
- Assicurati di aggiungere la regola firewall SSH.
- Assicurati che la tua VM includa l'argomento tags = ["ssh"].

Esegui la pulizia

Al termine del tutorial, puoi eliminare tutto ciò che hai creato in modo da non sostenere ulteriori costi.

Terraform consente di rimuovere tutte le risorse definite nel file di configurazione eseguendo il comando terraform destroy:

terraform destroy

Inserisci yes per consentire a Terraform di eliminare le risorse.

Passaggi successivi

Scopri come esportare le risorse Google Cloud in formato Terraform.