Implementa un servidor web de Flask básico con Terraform

En este instructivo, aprenderás cómo comenzar a usar Terraform y crear un servidor web básico en Compute Engine con él.

En este instructivo, harás lo que se indica a continuación:

Usa Terraform para crear una VM en Google Cloud.
Inicia un servidor básico de Flask en Python.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

Prepárate para comenzar el instructivo.

Selecciona o crea un proyecto

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.

Configura los permisos

Asegúrate de tener los permisos de Compute Engine necesarios en tu cuenta de usuario:

compute.instances.*
compute.firewalls.*

Ir a la página IAM

Obtén más información sobre los roles y permisos.

Habilitar la API

Enable the Compute Engine API.

Enable the API

Inicie Cloud Shell

Cloud Shell es una máquina virtual de Compute Engine.

Las credenciales de servicio asociadas a esta máquina virtual son automáticas, por lo que no es necesario configurar ni descargar una clave de cuenta de servicio.

Terraform está integrado en Cloud Shell, y este último autentica a Terraform de forma automática, lo que te permite comenzar sin tener que configurar demasiado.

Crea la VM de Compute Engine

Primero, define la configuración de la VM en un archivo de configuración de Terraform. Luego, ejecuta los comandos de Terraform para crear la VM en tu proyecto.

Crea el directorio

Crea un directorio nuevo. En el directorio nuevo, crea un archivo main.tf para la configuración de Terraform. En el contenido de este archivo, se describen todos los recursos de Google Cloud que se crearán en el proyecto.

En Cloud Shell:

mkdir tf-tutorial && cd tf-tutorial

nano main.tf

Crea la subred y la red de nube privada virtual

En esta sección, crearás una red y subred de nube privada virtual (VPC) para la interfaz de red de la VM.

Agrega el siguiente recurso de Terraform al archivo main.tf que creaste.

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 el recurso de VM de Compute Engine

En esta sección, crearás una sola instancia de Compute Engine que ejecuta Debian. En este instructivo, usarás el tipo de máquina más pequeño disponible. Más adelante, puedes actualizar a un tipo de máquina más grande.

Agrega el siguiente recurso google_compute_instance de Terraform al archivo main.tf que creaste.

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

El código de muestra establece la zona de Google Cloud en us-west1-a. Puedes cambiar esto a una zona diferente.

Inicialice Terraform

En este punto, puedes ejecutar terraform init para agregar los complementos necesarios y compilar el directorio .terraform.

terraform init

Resultado:

Initializing the backend...

Initializing provider plugins...
...

Terraform has been successfully initialized!

Valida la configuración de Terraform

De manera opcional, puedes validar el código de Terraform que compilaste hasta ahora. Ejecuta terraform plan, que hace lo siguiente:

Verifica que la sintaxis de main.tf sea correcta
Muestra una vista previa de los recursos que se crearán

terraform plan

Resultado:

...

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.

Aplica la configuración

Para crear la VM, ejecuta terraform apply.

terraform apply

Cuando se te solicite, ingresa yes.

Terraform llama a las API de Google Cloud para configurar la VM nueva. Consulta la página de instancias de VM para ver la VM nueva.

Ejecuta un servidor web en Google Cloud

Los siguientes pasos son crear una aplicación web, implementarla en la VM y crear una regla de firewall para permitir solicitudes de clientes a la aplicación web.

Agrega una regla de firewall SSH personalizada

La regla de firewall default-allow-ssh en la red default te permite usar SSH para conectarte a la VM. Si prefieres usar tu propia regla de firewall personalizada, puedes agregar el siguiente recurso al final de tu archivo 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"]
}

Ejecuta terraform apply para crear la regla de firewall.

Conéctate a la VM con SSH

Conéctate a la VM con SSH para validar que todo esté configurado correctamente en este punto.

Ve a la página Instancias de VM.
Busca la VM con el nombre flask-vm.
En la columna Conectar, haz clic en SSH.

Se abrirá una ventana de terminal SSH en el navegador para la VM en ejecución.

Para obtener más información, consulta Conéctate a VM.

Compila la app de Flask

Debes compilar una app de Flask en Python para este instructivo a fin de que puedas tener un solo archivo que describa tu servidor web y los extremos de prueba.

En la terminal SSH del navegador, crea un archivo llamado app.py.
```
nano app.py
```

Agrega lo siguiente al archivo app.py.

from flask import Flask
app = Flask(__name__)

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

app.run(host='0.0.0.0')

Ejecuta app.py:
```
python3 app.py
```
Flask entrega el tráfico en localhost:5000 de forma predeterminada.

Advertencia: Este es un servidor de desarrollo. No lo uses en una implementación de producción.
Abre una segunda conexión SSH:
1. Ve a la página Instancias de VM.
2. Busca la VM llamada flask-vm y haz clic en SSH.
En la segunda conexión SSH, ejecuta curl para confirmar que se muestra el saludo que configuraste en app.py.
```
curl http://0.0.0.0:5000
```
El resultado de este comando es Hello Cloud.

Abre el puerto 5000 en la VM

Para conectarse al servidor web desde tu computadora local, la VM debe tener abierto el puerto 5000. Google Cloud te permite abrir puertos al tráfico mediante reglas de firewall.

Agrega el siguiente recurso google_compute_firewall de Terraform al final del archivo 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"]
}

En Cloud Shell, ejecuta terraform apply para crear la regla de firewall.

Agrega una variable de salida para la URL del servidor web

Al final de main.tf, agrega una variable de salida de Terraform para generar la URL del servidor 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"])
}

Ejecuta terraform apply.
```
terraform apply
```
Cuando se te solicite, ingresa yes. Terraform imprime la dirección IP externa y el puerto 5000 de la VM en la pantalla, de la siguiente manera:
```
Web-server-URL = "http://IP_ADDRESS:5000"
```
En cualquier momento, puedes ejecutar terraform output para mostrar este resultado:
```
terraform output
```
Haz clic en la URL del paso anterior y ve el mensaje "Hello Cloud!".

Esto significa que tu servidor se está ejecutando.

Soluciona problemas

Si una API requerida no está habilitada, Terraform muestra un error. El mensaje de error incluye un vínculo para habilitar la API. Después de habilitar la API, puedes volver a ejecutar terraform apply.
Si no puedes conectarte a la VM a través de SSH, haz lo siguiente:
- Asegúrate de agregar la regla de firewall de SSH.
- Asegúrate de que tu VM incluya el argumento tags = ["ssh"].

Realiza una limpieza

Después de completar el instructivo, puedes borrar todo lo que creaste para no incurrir en más costos.

Terraform te permite quitar todos los recursos definidos en el archivo de configuración mediante la ejecución del comando terraform destroy:

terraform destroy

Ingresa yes para permitir que Terraform borre tus recursos.

¿Qué sigue?

Obtén información sobre cómo exportar tus recursos de Google Cloud al formato de Terraform.