Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Créer un cluster et déployer une charge de travail à l'aide de Terraform

Autopilot

Un cluster Kubernetes fournit des ressources de calcul, de stockage, de mise en réseau et d'autres services pour les applications, semblables à un centre de données virtuel. Les applications et les services associés qui s'exécutent dans Kubernetes sont appelés charges de travail.

Ce tutoriel vous permet de voir rapidement un cluster Google Kubernetes Engine et un exemple de charge de travail en cours d'exécution, le tout configuré à l'aide de Terraform. Vous pouvez ensuite explorer la charge de travail dans la console Google Cloud avant de passer à notre parcours de formation plus approfondi ou de commencer à planifier et à créer votre propre cluster prêt pour la production. Dans ce tutoriel, nous partons du principe que vous connaissez déjà Terraform.

Si vous préférez configurer votre cluster et votre charge de travail dans la console Google Cloud , consultez Créer un cluster dans la console Google Cloud .

Avant de commencer

Procédez comme suit pour activer l'API Kubernetes Engine :

Connectez-vous à votre compte Google Cloud . Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits sans frais pour exécuter, tester et déployer des charges de travail.

Installez la Google Cloud CLI.

Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

Pour initialiser la gcloud CLI, exécutez la commande suivante :

gcloud init

Créez ou sélectionnez un projet Google Cloud .

Rôles requis pour sélectionner ou créer un projet

Sélectionnez un projet : la sélection d'un projet ne nécessite pas de rôle IAM spécifique. Vous pouvez sélectionner n'importe quel projet pour lequel un rôle vous a été attribué.
Créer un projet : pour créer un projet, vous devez disposer du rôle Créateur de projet (roles/resourcemanager.projectCreator), qui contient l'autorisation resourcemanager.projects.create. Découvrez comment attribuer des rôles.

Créez un projet Google Cloud :
```
gcloud projects create PROJECT_ID
```
Remplacez PROJECT_ID par le nom du projet Google Cloud que vous créez.
Sélectionnez le projet Google Cloud que vous avez créé :
```
gcloud config set project PROJECT_ID
```
Remplacez PROJECT_ID par le nom de votre projet Google Cloud .

Vérifiez que la facturation est activée pour votre projet Google Cloud .

Activez l'API GKE :

Rôles requis pour activer les API

Pour activer les API, vous avez besoin du rôle IAM Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin), qui contient l'autorisation serviceusage.services.enable. Découvrez comment attribuer des rôles.

gcloud services enable container.googleapis.com

Installez la Google Cloud CLI.

Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

Pour initialiser la gcloud CLI, exécutez la commande suivante :

gcloud init

Créez ou sélectionnez un projet Google Cloud .

Rôles requis pour sélectionner ou créer un projet

Sélectionnez un projet : la sélection d'un projet ne nécessite pas de rôle IAM spécifique. Vous pouvez sélectionner n'importe quel projet pour lequel un rôle vous a été attribué.
Créer un projet : pour créer un projet, vous devez disposer du rôle Créateur de projet (roles/resourcemanager.projectCreator), qui contient l'autorisation resourcemanager.projects.create. Découvrez comment attribuer des rôles.

Créez un projet Google Cloud :
```
gcloud projects create PROJECT_ID
```
Remplacez PROJECT_ID par le nom du projet Google Cloud que vous créez.
Sélectionnez le projet Google Cloud que vous avez créé :
```
gcloud config set project PROJECT_ID
```
Remplacez PROJECT_ID par le nom de votre projet Google Cloud .

Vérifiez que la facturation est activée pour votre projet Google Cloud .

Activez l'API GKE :

Rôles requis pour activer les API

gcloud services enable container.googleapis.com

Attribuez des rôles à votre compte utilisateur. Exécutez la commande suivante une fois pour chacun des rôles IAM suivants : roles/container.admin, roles/compute.networkAdmin, roles/iam.serviceAccountUser
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
Remplacez les éléments suivants :
- PROJECT_ID : ID de votre projet
- USER_IDENTIFIER : identifiant de votre compte d'utilisateur. Par exemple, myemail@example.com.
- ROLE : rôle IAM que vous accordez à votre compte utilisateur.

Préparer l'environnement

Dans ce tutoriel, vous utilisez Cloud Shell pour gérer les ressources hébergées surGoogle Cloud. Cloud Shell est préinstallé avec les logiciels dont vous avez besoin dans ce tutoriel, y compris Terraform, kubectl et Google Cloud CLI.

Lancez une session Cloud Shell depuis la console Google Cloud en cliquant sur l'icône d'activation Cloud Shell Activer Cloud Shell . Une session s'ouvre dans le volet inférieur de la console Google Cloud .

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.
Avant d'exécuter des commandes, définissez votre projet par défaut dans gcloud CLI à l'aide de la commande suivante :
```
gcloud config set project PROJECT_ID
```
Remplacez PROJECT_ID par votre ID de projet.

Clonez le dépôt GitHub.

git clone https://github.com/terraform-google-modules/terraform-docs-samples.git --single-branch

Accédez au répertoire de travail :

cd terraform-docs-samples/gke/quickstart/autopilot

Examiner les fichiers Terraform

Le fournisseurGoogle Cloud est un plug-in qui vous permet de gérer et de provisionner des ressources Google Cloud à l'aide de Terraform. Il sert de passerelle entre les configurations Terraform et les API Google Cloud , ce qui vous permet de définir de manière déclarative des ressources d'infrastructure, telles que des machines virtuelles et des réseaux.

Le cluster et l'application exemple pour ce tutoriel sont spécifiés dans deux fichiers Terraform qui utilisent les fournisseurs Google Cloud et Kubernetes.

Examinez le fichier cluster.tf :

cat cluster.tf

Le résultat ressemble à ce qui suit :

resource "google_compute_network" "default" {
  name = "example-network"

  auto_create_subnetworks  = false
  enable_ula_internal_ipv6 = true
}

resource "google_compute_subnetwork" "default" {
  name = "example-subnetwork"

  ip_cidr_range = "10.0.0.0/16"
  region        = "us-central1"

  stack_type       = "IPV4_IPV6"
  ipv6_access_type = "INTERNAL" # Change to "EXTERNAL" if creating an external loadbalancer

  network = google_compute_network.default.id
  secondary_ip_range {
    range_name    = "services-range"
    ip_cidr_range = "192.168.0.0/24"
  }

  secondary_ip_range {
    range_name    = "pod-ranges"
    ip_cidr_range = "192.168.1.0/24"
  }
}

resource "google_container_cluster" "default" {
  name = "example-autopilot-cluster"

  location                 = "us-central1"
  enable_autopilot         = true
  enable_l4_ilb_subsetting = true

  network    = google_compute_network.default.id
  subnetwork = google_compute_subnetwork.default.id

  ip_allocation_policy {
    stack_type                    = "IPV4_IPV6"
    services_secondary_range_name = google_compute_subnetwork.default.secondary_ip_range[0].range_name
    cluster_secondary_range_name  = google_compute_subnetwork.default.secondary_ip_range[1].range_name
  }

  # Set `deletion_protection` to `true` will ensure that one cannot
  # accidentally delete this instance by use of Terraform.
  deletion_protection = false
}

Ce fichier décrit les ressources suivantes :

google_compute_network : réseau VPC avec IPv6 interne activé.
google_compute_subnetwork : sous-réseau à double pile.
google_container_cluster : cluster en mode Autopilot à double pile situé dans us-central1. Le paramètre deletion_protection indique si vous pouvez utiliser Terraform pour supprimer ce cluster. Si vous définissez la valeur du champ deletion_protection sur false, Terraform peut supprimer le cluster. Pour en savoir plus, consultez la documentation de référence sur google_container_cluster.

Examinez le fichier app.tf :

cat app.tf

Le résultat ressemble à ce qui suit :

data "google_client_config" "default" {}

provider "kubernetes" {
  host                   = "https://${google_container_cluster.default.endpoint}"
  token                  = data.google_client_config.default.access_token
  cluster_ca_certificate = base64decode(google_container_cluster.default.master_auth[0].cluster_ca_certificate)

  ignore_annotations = [
    "^autopilot\\.gke\\.io\\/.*",
    "^cloud\\.google\\.com\\/.*"
  ]
}

resource "kubernetes_deployment_v1" "default" {
  metadata {
    name = "example-hello-app-deployment"
  }

  spec {
    selector {
      match_labels = {
        app = "hello-app"
      }
    }

    template {
      metadata {
        labels = {
          app = "hello-app"
        }
      }

      spec {
        container {
          image = "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
          name  = "hello-app-container"

          port {
            container_port = 8080
            name           = "hello-app-svc"
          }

          security_context {
            allow_privilege_escalation = false
            privileged                 = false
            read_only_root_filesystem  = false

            capabilities {
              add  = []
              drop = ["NET_RAW"]
            }
          }

          liveness_probe {
            http_get {
              path = "/"
              port = "hello-app-svc"

              http_header {
                name  = "X-Custom-Header"
                value = "Awesome"
              }
            }

            initial_delay_seconds = 3
            period_seconds        = 3
          }
        }

        security_context {
          run_as_non_root = true

          seccomp_profile {
            type = "RuntimeDefault"
          }
        }

        # Toleration is currently required to prevent perpetual diff:
        # https://github.com/hashicorp/terraform-provider-kubernetes/pull/2380
        toleration {
          effect   = "NoSchedule"
          key      = "kubernetes.io/arch"
          operator = "Equal"
          value    = "amd64"
        }
      }
    }
  }
}

resource "kubernetes_service_v1" "default" {
  metadata {
    name = "example-hello-app-loadbalancer"
    annotations = {
      "networking.gke.io/load-balancer-type" = "Internal" # Remove to create an external loadbalancer
    }
  }

  spec {
    selector = {
      app = kubernetes_deployment_v1.default.spec[0].selector[0].match_labels.app
    }

    ip_family_policy = "RequireDualStack"

    port {
      port        = 80
      target_port = kubernetes_deployment_v1.default.spec[0].template[0].spec[0].container[0].port[0].name
    }

    type = "LoadBalancer"
  }

  depends_on = [time_sleep.wait_service_cleanup]
}

# Provide time for Service cleanup
resource "time_sleep" "wait_service_cleanup" {
  depends_on = [google_container_cluster.default]

  destroy_duration = "180s"
}

Ce fichier décrit les ressources suivantes :

Un déploiement avec un exemple d'image de conteneur.
Un service de type LoadBalancer. Le service expose le déploiement sur le port 80.

(Facultatif) Exposer l'application sur Internet

Les fichiers Terraform de l'exemple décrivent une application avec une adresse IP interne, à laquelle vous ne pouvez accéder qu'à partir du même cloud privé virtuel (VPC) que l'application exemple. Si vous souhaitez accéder à l'interface Web de l'application de démonstration en cours d'exécution depuis Internet (par exemple, depuis votre ordinateur portable), modifiez les fichiers Terraform pour créer une adresse IP publique à la place avant de créer le cluster. Pour ce faire, vous pouvez utiliser un éditeur de texte directement dans Cloud Shell ou l'éditeur Cloud Shell.

Pour exposer l'application de démonstration sur Internet :

Dans cluster.tf, remplacez ipv6_access_type par EXTERNAL.INTERNAL
```
ipv6_access_type = "EXTERNAL"
```
Dans app.tf, configurez un équilibreur de charge externe en supprimant l'annotation networking.gke.io/load-balancer-type.
```
 annotations = {
   "networking.gke.io/load-balancer-type" = "Internal" # Remove this line
 }
```

Créer un cluster et déployer une application

Dans Cloud Shell, exécutez la commande suivante pour vérifier que Terraform est disponible :

terraform

La sortie devrait ressembler à ce qui suit :

Usage: terraform [global options] <subcommand> [args]

The available commands for execution are listed below.
The primary workflow commands are given first, followed by
less common or more advanced commands.

Main commands:
  init          Prepare your working directory for other commands
  validate      Check whether the configuration is valid
  plan          Show changes required by the current configuration
  apply         Create or update infrastructure
  destroy       Destroy previously-created infrastructure

Initialisez Terraform :
```
terraform init
```
Planifiez la configuration Terraform :
```
terraform plan
```
Appliquez la configuration Terraform :
```
terraform apply
```
Lorsque vous y êtes invité, saisissez yes pour confirmer les actions. Cette commande peut prendre plusieurs minutes. Le résultat ressemble à ce qui suit :
```
Apply complete! Resources: 6 added, 0 changed, 0 destroyed.
```

Vérifier que le cluster fonctionne

Procédez comme suit pour vérifier que votre cluster fonctionne correctement :

Accédez à la page Charges de travail dans la console Google Cloud :

Accéder à la page Charges de travail
Cliquez sur la charge de travail example-hello-app-deployment. La page des détails du pod s'affiche. Cette page affiche des informations sur le pod, telles que les annotations, les conteneurs s'exécutant sur le pod, les services exposant le pod, mais aussi les métriques telles que l'utilisation du processeur, de la mémoire et du disque.
Accédez à la page Services et entrées de la console Google Cloud :

Accéder à la page Services et entrées
Cliquez sur le Service LoadBalancer example-hello-app-loadbalancer. La page "Informations sur le service" s'affiche. Cette page affiche des informations sur le service, telles que les pods associés et les ports utilisés par les services.
Dans la section Points de terminaison externes, cliquez sur lien IPv4 ou lien IPv6 pour afficher votre service dans le navigateur. Le résultat ressemble à ce qui suit :
```
Hello, world!
Version: 2.0.0
Hostname: example-hello-app-deployment-5df979c4fb-kdwgr
```

Effectuer un nettoyage

Pour éviter que les ressources utilisées dans cette démonstration soient facturées sur votre compte Google Cloud , supprimez le projet Google Cloud qui les contient.

Si vous prévoyez de suivre d'autres tutoriels ou d'explorer davantage votre exemple, attendez d'avoir terminé avant de procéder à cette étape de nettoyage.

Dans Cloud Shell, exécutez la commande suivante pour supprimer les ressources Terraform :
```
terraform destroy --auto-approve
```

Résoudre les erreurs de nettoyage

Si un message d'erreur semblable à The network resource 'projects/PROJECT_ID/global/networks/example-network' is already being used by 'projects/PROJECT_ID/global/firewalls/example-network-yqjlfql57iydmsuzd4ot6n5v' apparaît, procédez comme suit :

Supprimez les règles de pare-feu :

gcloud compute firewall-rules list --filter="NETWORK:example-network" --format="table[no-heading](name)" | xargs gcloud --quiet compute firewall-rules delete

Exécutez à nouveau la commande Terraform :
```
terraform destroy --auto-approve
```

Étapes suivantes

Explorez votre cluster et votre charge de travail dans la console Google Cloud pour découvrir certains des paramètres et ressources clés que vous avez déployés.
Pour en savoir plus sur la configuration et l'utilisation de Terraform avec GKE, consultez Compatibilité de Terraform avec GKE.
Essayez notre Parcours de formation plus détaillé : Applications évolutives.
Découvrez comment commencer à administrer des clusters dans la Présentation de l'administration de cluster.