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 suivants de Google Cloud :

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

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 gratuits 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.

Go to project selector

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

Activer les API Google Kubernetes Engine, Cloud DNS.

Activer les API

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

Go to project selector

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

Activer les API Google Kubernetes Engine, Cloud DNS.

Activer les API

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 sur Google Cloud. Cloud Shell est préinstallé avec les logiciels dont vous avez besoin dans ce tutoriel, y compris Terraform, kubectl et gcloud CLI.

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

Clonez le dépôt de code :

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

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, ".")
}

Initialisez Terraform :
```
terraform init
```
Affichez les modifications d'infrastructure:
```
terraform plan
```
Lorsque vous y êtes invité, saisissez votre domaine, par exemple my-domain.net.

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

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, tel que my-domain.net.

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

networking.gke.io/managed-certificates: nom du certificat géré.
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.

Appliquez le fichier manifeste à votre cluster :
```
kubectl apply -f kubernetes-manifests.yaml
```

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 de la ressource Ingress peut prendre plusieurs minutes.

Tester l'application

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. La sortie suivante indique que le certificat SSL est prêt:
```
NAME                      AGE   STATUS
networking-managed-cert   28m   Active
```

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

Nettoyer

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 de ce document, lorsque vous le supprimez, vous supprimez é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.

Supprimez un projet Google Cloud :

gcloud projects delete PROJECT_ID

Supprimer des ressources individuelles

Supprimez les ressources Kubernetes :

kubectl delete -f kubernetes-manifests.yaml

Supprimez les ressources Terraform:
```
terraform destroy --auto-approve
```
Lorsque vous y êtes invité, saisissez votre domaine, par exemple my-domain.net.

Étapes suivantes

Apprenez-en plus sur la mise en réseau GKE.