Configurer la mise en réseau pour un cluster de production de base

Autopilot Standard

Ce tutoriel est destiné aux architectes cloud et aux administrateurs d'opérations qui souhaitent déployer une application Web sur un cluster Google Kubernetes Engine (GKE) et l'exposer avec un équilibreur de charge HTTPS.

Objectifs

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

• créer un cluster GKE ;
• Créer une adresse IP globale et une zone Cloud DNS avec Terraform
• Configurer l'équilibrage de charge HTTPS
• Déployer un exemple d'application Web

Coûts

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

• GKE
• Cloud Load Balancing
• External IP address

Vous pouvez obtenir 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 sans frais.

Une fois que vous avez terminé les tâches décrites dans ce document, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Configurer votre projet

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.

In the Google Cloud console, on the project selector page, click Create project to begin creating a new Google Cloud project.

Roles required to create a project

To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Google Kubernetes Engine, Cloud DNS APIs.

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 APIs

In the Google Cloud console, on the project selector page, click Create project to begin creating a new Google Cloud project.

Roles required to create a project

To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Google Kubernetes Engine, Cloud DNS APIs.

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 APIs

• Vous devez détenir un nom de domaine. Celui-ci ne doit pas dépasser 63 caractères. Vous pouvez utiliser Google Domains ou un autre service d'enregistrement.

Configurer votre 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 gcloud CLI.

1. Définissez les variables d'environnement :

   PROJECT_ID=$(gcloud config get-value project)
   gcloud config set project $PROJECT_ID
   gcloud config set compute/region us-central1
   

2. Clonez le dépôt de code :

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
   

3. Accédez au répertoire de travail :

   cd kubernetes-engine-samples/autopilot/networking-tutorial
   

Créer un cluster GKE

Le fichier Terraform suivant crée un cluster GKE :

terraform {
  required_version = "~> 1.3"
}

provider "google" {}

variable "region" {
  type        = string
  description = "Region where the cluster will be created."
  default     = "us-central1"
}

variable "cluster_name" {
  type        = string
  description = "Name of the cluster"
  default     = "networking-cluster"
}

resource "google_container_cluster" "default" {
  name             = var.cluster_name
  description      = "Cluster for sample web application"
  location         = var.region
  enable_autopilot = true

  ip_allocation_policy {}
}

output "region" {
  value       = var.region
  description = "Compute region"
}

output "cluster_name" {
  value       = google_container_cluster.default.name
  description = "Cluster name"
}

Le fichier Terraform suivant crée une adresse IP globale et une zone Cloud DNS :

terraform {
  required_version = "~> 1.3"
}

variable "base_domain" {
  type        = string
  description = "Your base domain"
}

variable "name" {
  type        = string
  description = "Name of resources"
  default     = "networking-tutorial"
}

data "google_client_config" "current" {}

resource "google_compute_global_address" "default" {
  name = var.name
}

resource "google_dns_managed_zone" "default" {
  name        = var.name
  dns_name    = "${var.name}.${var.base_domain}."
  description = "DNS Zone for web application"
}

resource "google_dns_record_set" "a" {
  name         = google_dns_managed_zone.default.dns_name
  type         = "A"
  ttl          = 300
  managed_zone = google_dns_managed_zone.default.name

  rrdatas = [google_compute_global_address.default.address]
}

resource "google_dns_record_set" "cname" {
  name         = join(".", compact(["www", google_dns_record_set.a.name]))
  type         = "CNAME"
  ttl          = 300
  managed_zone = google_dns_managed_zone.default.name

  rrdatas = [google_dns_record_set.a.name]
}

output "dns_zone_name_servers" {
  value       = google_dns_managed_zone.default.name_servers
  description = "Write these virtual name servers in your base domain."
}

output "domain" {
  value = trim(google_dns_record_set.a.name, ".")
}

1. Initialisez Terraform :

   terraform init
   

2. Affichez les modifications apportées à l'infrastructure :

   terraform plan
   

   Lorsque vous y êtes invité, saisissez votre domaine, par exemple my-domain.net.

3. Appliquez la configuration Terraform :

   terraform apply --auto-approve
   

   Lorsque vous y êtes invité, saisissez votre domaine, par exemple my-domain.net.

   Le résultat ressemble à ce qui suit :

   Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
   
   Outputs:
   
   cluster_name = "networking-cluster"
   region = "us-central1"
   

Créer un équilibreur de charge d'application externe

1. Le fichier manifeste suivant décrit un objet ManagedCertificate, FrontendConfig, Deployment, Service et Ingress:

   ---
   apiVersion: networking.gke.io/v1
   kind: ManagedCertificate
   metadata:
     name: networking-managed-cert
   spec:
     domains:
       - DOMAIN_NAME
       - www.DOMAIN_NAME
   ---
   apiVersion: networking.gke.io/v1beta1
   kind: FrontendConfig
   metadata:
     name: networking-fc
   spec:
     redirectToHttps:
       enabled: true
       responseCodeName: MOVED_PERMANENTLY_DEFAULT
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: frontend
   spec:
     selector:
       matchLabels:
         app: frontend
     replicas: 2
     template:
       metadata:
         labels:
           app: frontend
       spec:
         containers:
         - name: echo-amd64
           image: us-docker.pkg.dev/google-samples/containers/gke/hello-app-cdn:1.0
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: frontend
   spec:
     type: LoadBalancer
     selector:
       app: frontend
     ports:
     - name: http
       port: 80
       targetPort: 8080
   ---
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: frontend
     annotations:
       networking.gke.io/managed-certificates: networking-managed-cert
       networking.gke.io/v1beta1.FrontendConfig: networking-fc
       kubernetes.io/ingress.global-static-ip-name: networking-tutorial
       kubernetes.io/ingress.class: gce
     labels:
       app: frontend
   spec:
     defaultBackend:
       service:
         name: frontend
         port:
           number: 80

   Remplacez DOMAIN_NAME par votre nom de domaine, par exemple my-domain.net.

   Ce fichier manifeste possède les propriétés suivantes :

   • networking.gke.io/managed-certificates : nom du certificat géré (ManagedCertificate). Cette ressource provisionne un certificat SSL géré par Google (classique).
   • networking.gke.io/v1beta1.FrontendConfig : nom de la ressource FrontendConfig.
   • kubernetes.io/ingress.global-static-ip-name : nom de l'adresse IP.
   • kubernetes.io/ingress.class : indique au contrôleur GKE Ingress de créer un équilibreur de charge d'application externe.

2. Appliquez le fichier manifeste à votre cluster :

   kubectl apply -f kubernetes-manifests.yaml
   

3. Vérifiez que l'objet Ingress a été créé:

   kubectl describe ingress frontend
   

   Le résultat ressemble à ce qui suit :

   ...
     Events:
       Type    Reason  Age   From                     Message
       ----    ------  ----  ----                     -------
       Normal  ADD     2m    loadbalancer-controller  default/frontend
       Normal  CREATE  1m    loadbalancer-controller  ip: 203.0.113.2
   ...
   

   Le provisionnement d'Ingress peut prendre plusieurs minutes.

Tester l'application

1. Vérifiez l'état du certificat SSL :

   kubectl get managedcertificates.networking.gke.io networking-managed-cert
   

   Le provisionnement du certificat SSL peut prendre jusqu'à 30 minutes. Le résultat suivant indique que le certificat SSL est prêt :

   NAME                      AGE   STATUS
   networking-managed-cert   28m   Active
   

2. Exécutez une commande curl:

   curl -Lv https://DOMAIN_NAME
   

   Le résultat ressemble à ce qui suit :

   *   Trying 34.160.115.33:443...
   * Connected to DOMAIN_NAME (34.160.115.33) port 443 (#0)
   ...
   * TLSv1.3 (IN), TLS handshake, Certificate (11):
   ...
   * Server certificate:
   *  subject: CN=DOMAIN_NAME
   ...
   > Host: DOMAIN_NAME
   

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

Attention : La suppression d'un projet aura les effets suivants :

• Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
• Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Supprimer des ressources individuelles

1. Supprimez les ressources Kubernetes :

   kubectl delete -f kubernetes-manifests.yaml
   

2. Supprimez les ressources Terraform :

   terraform destroy --auto-approve
   

   Lorsque vous y êtes invité, saisissez votre domaine, par exemple my-domain.net.

Étapes suivantes

• Découvrez la mise en réseau GKE.