Déployer un serveur Web Flask de base à l'aide de Terraform

Dans ce tutoriel, vous allez faire vos premiers pas avec Terraform, en l'utilisant pour créer un serveur Web de base sur Compute Engine.

Dans ce tutoriel, vous allez effectuer les opérations suivantes :

Utilisez Terraform pour créer une VM dans Google Cloud.
Démarrez un serveur Python Flask de base.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Instance

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Préparez-vous à démarrer le tutoriel.

Sélectionner ou créer un projet

Dans Google Cloud Console, accédez à la page de sélection du projet.

Accéder au sélecteur de projet
Sélectionnez ou créez un projet Google Cloud.

Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

Configurer les autorisations

Assurez-vous que vous disposez des autorisations Compute Engine nécessaires sur votre compte utilisateur :

compute.instances.*
compute.firewalls.*

Accéder à la page IAM

En savoir plus sur les rôles et les autorisations.

Activer l'API

Activez l'API Compute Engine

Activer l'API

Démarrer Cloud Shell

Cloud Shell est une machine virtuelle Compute Engine.

Les identifiants de service associés à cette machine virtuelle sont automatiques. Vous n'avez donc pas besoin de configurer ni de télécharger une clé de compte de service.

Terraform est intégré à Cloud Shell et Cloud Shell authentifie automatiquement Terraform, ce qui vous permet de vous lancer en minimisant le travail de configuration.

Créer la VM Compute Engine

Commencez par définir les paramètres de la VM dans un fichier de configuration Terraform. Vous exécutez ensuite des commandes Terraform pour créer la VM dans votre projet.

Créez le répertoire.

Dans Cloud Shell, créez un répertoire : Dans votre nouveau répertoire, créez un fichier main.tf pour la configuration Terraform. Le contenu de ce fichier décrit toutes les ressources Google Cloud à créer dans le projet.

mkdir tf-tutorial && cd tf-tutorial

nano main.tf

Créer le réseau et le sous-réseau cloud privé virtuel

Dans cette section, vous allez créer un réseau et un sous-réseau cloud privé virtuel (VPC) pour l'interface réseau de la VM.

Ajoutez la ressource Terraform suivante au fichier main.tf que vous avez créé :

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
}

Créer la ressource de VM Compute Engine

Dans cette section, vous allez créer une seule instance Compute Engine exécutant Debian. Dans ce tutoriel, vous utiliserez le plus petit type de machine disponible. Par la suite, vous pourrez passer à un type de machine plus grand.

Ajoutez la ressource Terraform google_compute_instance suivante au fichier main.tf que vous avez créé.

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

L'exemple de code définit la zone Google Cloud sur us-west1-a. Vous pouvez définir une autre zone.

Initialiser Terraform

À ce stade, vous pouvez exécuter terraform init pour ajouter les plug-ins nécessaires et créer le répertoire .terraform.

terraform init

Sortie :

Initializing the backend...

Initializing provider plugins...
...

Terraform has been successfully initialized!

Valider la configuration Terraform

Si vous le souhaitez, vous pouvez valider le code Terraform que vous avez créé jusqu'à présent. Exécutez terraform plan, qui effectue les opérations suivantes :

Vérifie que la syntaxe de main.tf est correcte
Affiche un aperçu des ressources qui seront créées

terraform plan

Sortie :

...

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.

Appliquer la configuration

Pour créer la VM, exécutez terraform apply.

terraform apply

Lorsque vous y êtes invité, saisissez yes.

Terraform appelle les API Google Cloud pour configurer la nouvelle VM. Consultez la page Instances de VM pour afficher la nouvelle VM.

Exécuter un serveur Web sur Google Cloud

Les étapes suivantes consistent à créer une application Web, à la déployer sur la VM et à créer une règle de pare-feu pour autoriser les requêtes des clients vers l'application Web.

Ajouter une règle de pare-feu SSH personnalisée

La règle de pare-feu default-allow-ssh du réseau default vous permet d'utiliser SSH pour vous connecter à la VM. Si vous préférez utiliser votre propre règle de pare-feu personnalisée, vous pouvez ajouter la ressource suivante à la fin de votre fichier 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"]
}

Exécutez terraform apply pour créer la règle de pare-feu.

Connectez-vous à la VM à l'aide de SSH :

Vérifiez que tout est correctement configuré à ce stade en vous connectant à la VM à l'aide de SSH.

Accédez à la page Instances de VM.
Recherchez la VM nommée flask-vm.
Dans la colonne Connecter, cliquez sur SSH.

Une fenêtre de terminal SSH dans le navigateur s'ouvre pour la VM en cours d'exécution.

Pour en savoir plus, consultez la page Se connecter à des VM.

Créer l'application Flask

Créez une application Flask de Python pour ce tutoriel afin de pouvoir disposer d'un seul fichier décrivant votre serveur Web et vos points de terminaison de test.

Dans le terminal SSH du navigateur, créez un fichier appelé app.py.
```
nano app.py
```

Ajoutez ce qui suit au fichier app.py.

from flask import Flask
app = Flask(__name__)

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

app.run(host='0.0.0.0')

Exécutez app.py :
```
python3 app.py
```
Par défaut, Flask diffuse le trafic sur localhost:5000.

Avertissement : Il s'agit d'un serveur de développement. Ne l'utilisez pas dans un déploiement en production.
Ouvrez une deuxième connexion SSH :
1. Accédez à la page Instances de VM.
2. Recherchez la VM nommée flask-vm, puis cliquez sur SSH.
Dans la deuxième connexion SSH, exécutez curl pour vérifier que le message d'accueil que vous avez configuré dans le fichier app.py est renvoyé.
```
curl http://0.0.0.0:5000
```
Le résultat de cette commande est Hello Cloud.

Ouvrir le port 5000 sur la VM

Pour vous connecter au serveur Web à partir de votre ordinateur local, le port 5000 doit être ouvert sur la VM. Google Cloud vous permet d'ouvrir des ports pour le trafic à l'aide de règles de pare-feu.

Ajoutez la ressource Terraform google_compute_firewall suivante à la fin de votre fichier 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"]
}

Dans Cloud Shell, exécutez terraform apply pour créer la règle de pare-feu.

Ajoutez une variable de sortie pour l'URL du serveur Web.

À la fin de main.tf, ajoutez une variable de sortie Terraform pour générer l'URL du serveur 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"])
}

Exécutez terraform apply.
```
terraform apply
```
Lorsque vous y êtes invité, saisissez yes. Terraform affiche l'adresse IP externe de la VM et le port 5000 à l'écran, comme suit :
```
Web-server-URL = "http://IP_ADDRESS:5000"
```
Vous pouvez à tout moment exécuter la commande terraform output pour renvoyer ce résultat :
```
terraform output
```
Cliquez sur l'URL de l'étape précédente et voyez le message "Hello Cloud!".

Cela signifie que votre serveur est en cours d'exécution.

Dépannage

Si une API requise n'est pas activée, Terraform renvoie une erreur. Le message d'erreur comprend un lien permettant d'activer l'API. Après avoir activé l'API, vous pouvez relancer terraform apply.
Si vous ne parvenez pas à vous connecter à votre VM via SSH :
- Veillez à ajouter la règle de pare-feu SSH.
- Assurez-vous que votre VM inclut l'argument tags = ["ssh"].

Effectuer un nettoyage

Une fois le tutoriel terminé, vous pouvez supprimer tous les éléments que vous avez créés afin d'éviter tous frais supplémentaires.

Terraform vous permet de supprimer toutes les ressources définies dans le fichier de configuration en exécutant la commande terraform destroy :

terraform destroy

Saisissez yes pour autoriser Terraform à supprimer vos ressources.

Étape suivante

Découvrez comment exporter vos ressources Google Cloud au format Terraform.