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

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.

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).
   • 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