Esta página se ha traducido con Cloud Translation API.

Desplegar un servidor web Flask básico con Terraform

En este tutorial, aprenderás a empezar a usar Terraform para crear un servidor web básico en Compute Engine.

En este tutorial, harás lo siguiente:

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

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

Compute Engine

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos Google Cloud pueden disfrutar de una prueba gratuita.

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que has creado. Para obtener más información, consulta la sección Limpiar.

Antes de empezar

Prepárate para empezar el tutorial.

Seleccionar o crear un proyecto

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

Go to project selector
Select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
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.

Configurar permisos

Asegúrate de que tu cuenta de usuario tenga los permisos de Compute Engine necesarios:

compute.instances.*
compute.firewalls.*

Ir a la página de gestión de identidades y accesos

Más información sobre los roles y los permisos

Activar la API

Enable the Compute Engine API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

Iniciar 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 con Cloud Shell, y Cloud Shell autentica automáticamente Terraform, lo que te permite empezar con menos configuración.

Crear la VM de Compute Engine

Primero, define los ajustes de la VM en un archivo de configuración de Terraform. A continuación, ejecuta comandos de Terraform para crear la máquina virtual en tu proyecto.

Crea el directorio

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

En Cloud Shell:

mkdir tf-tutorial && cd tf-tutorial

nano main.tf

Crea la red y la subred de Virtual Private Cloud

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

Añade los siguientes recursos de Terraform al archivo main.tf que has creado:

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 máquina virtual de Compute Engine

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

Añade el siguiente recurso de Terraform google_compute_instance al archivo main.tf que has creado.

# 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 ejemplo asigna la zona Google Cloud a us-west1-a. Puedes cambiarla por otra zona.

Inicializar Terraform

En este punto, puedes ejecutar terraform init para añadir los complementos necesarios y crear el directorio .terraform.

terraform init

Resultado:

Initializing the backend...

Initializing provider plugins...
...

Terraform has been successfully initialized!

Validar la configuración de Terraform

También puedes validar el código de Terraform que has creado 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 van a crear.

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, introduce yes.

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

Ejecutar un servidor web en Google Cloud

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

Añadir una regla de cortafuegos SSH personalizada

La regla de cortafuegos default-allow-ssh de la red default te permite usar SSH para conectarte a la VM. Si prefieres usar tu propia regla de firewall personalizada, puedes añadir el siguiente recurso al final del 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 cortafuegos.

Conectarse a la VM con SSH

Valida que todo esté configurado correctamente en este punto conectándote a la máquina virtual con SSH.

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 el artículo Conectarse a máquinas virtuales.

Crear la aplicación Flask

En este tutorial, crearás una aplicación Python Flask para que tengas un solo archivo que describa tu servidor web y los endpoints de prueba.

En el terminal SSH en el navegador, crea un archivo llamado app.py.
```
nano app.py
```

Añade 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 sirve el tráfico en localhost:5000 de forma predeterminada.

Advertencia: Este es un servidor de desarrollo. No lo utilices 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 máquina virtual llamada flask-vm y haz clic en SSH.
En la segunda conexión SSH, ejecuta curl para confirmar que se devuelve el saludo que has configurado en app.py.
```
curl http://0.0.0.0:5000
```
El resultado de este comando es Hello Cloud.

Abrir el puerto 5000 en la VM

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

Añade el siguiente recurso de Terraform google_compute_firewall 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 cortafuegos.

Añadir una variable de salida para la URL del servidor web

Al final de main.tf, añade una variable de salida de Terraform para mostrar 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, introduce yes. Terraform muestra en pantalla la dirección IP externa y el puerto 5000 de la VM, tal como se indica a continuación:
```
Web-server-URL = "http://IP_ADDRESS:5000"
```
Puedes ejecutar terraform output en cualquier momento para obtener este resultado:
```
terraform output
```
Haz clic en la URL del paso anterior y verás el mensaje "Hello Cloud!".

Esto significa que tu servidor está en funcionamiento.

Solución de problemas

Si una API obligatoria no está habilitada, Terraform devuelve un error. El mensaje de error incluye un enlace para habilitar la API. Después de habilitar la API, puedes volver a ejecutar terraform apply.
Si no puedes conectarte a tu VM mediante SSH:
- Asegúrate de añadir la regla de cortafuegos SSH.
- Asegúrate de que tu máquina virtual incluya el argumento tags = ["ssh"].

Limpieza

Una vez que hayas completado el tutorial, puedes eliminar todo lo que hayas creado para que no se te apliquen más costes.

Terraform te permite eliminar todos los recursos definidos en el archivo de configuración ejecutando el comando terraform destroy:

terraform destroy

Escribe yes para permitir que Terraform elimine tus recursos.

Siguientes pasos

Consulta cómo exportar tus recursos Google Cloud al formato de Terraform.