Configura il networking per un cluster di produzione di base

Autopilot Standard

Questo tutorial è rivolto ad architetti cloud e amministratori delle operazioni interessati al deployment di un'applicazione web in un cluster Google Kubernetes Engine (GKE) e alla sua esposizione con un bilanciatore del carico HTTPS.

Obiettivi

In questo tutorial imparerai a:

• Creare un cluster GKE.
• Creare un indirizzo IP globale e una zona Cloud DNS con Terraform.
• Configurare il bilanciamento del carico HTTPS.
• Eseguire il deployment di un'applicazione web di esempio.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

• GKE
• Cloud Load Balancing
• External IP address

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi Google Cloud utenti potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per saperne di più, consulta Esegui la pulizia.

Prima di iniziare

Configura il progetto

Accedi al tuo Google Cloud account. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

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

• Devi essere proprietario di un nome di dominio. Il nome di dominio non deve superare i 63 caratteri. Puoi utilizzare Google Domains o un altro registrar.

Configura l'ambiente

In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Cloud Shell è preinstallato con il software necessario per questo tutorial, tra cui Terraform, kubectl e la gcloud CLI.

1. Imposta le variabili di ambiente:

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

2. Clona il repository di codice:

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

3. Passa alla directory di lavoro:

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

Crea un cluster GKE

Il seguente file Terraform crea 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"
}

Il seguente file Terraform crea un indirizzo IP globale e una zona 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. Inizializza Terraform:

   terraform init
   

2. Visualizza le modifiche all'infrastruttura:

   terraform plan
   

   Quando richiesto, inserisci il tuo dominio, ad esempio my-domain.net.

3. Applica la configurazione Terraform:

   terraform apply --auto-approve
   

   Quando richiesto, inserisci il tuo dominio, ad esempio my-domain.net.

   L'output è simile al seguente:

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

Crea un bilanciatore del carico delle applicazioni esterno

1. Il seguente manifest descrive un ManagedCertificate, FrontendConfig, Deployment, Service e 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

   Sostituisci DOMAIN_NAME con il tuo nome di dominio, ad esempio my-domain.net.

   Questo manifest ha le seguenti proprietà:

   • networking.gke.io/managed-certificates: il nome del ManagedCertificate. Questa risorsa esegue il provisioning di un certificato SSL gestito da Google (classico).
   • networking.gke.io/v1beta1.FrontendConfig: il nome della risorsa FrontendConfig.
   • kubernetes.io/ingress.global-static-ip-name: il nome dell'indirizzo IP.
   • kubernetes.io/ingress.class: indica al controller Ingress di GKE di creare un bilanciatore del carico delle applicazioni esterno.

2. Applica il manifest al cluster:

   kubectl apply -f kubernetes-manifests.yaml
   

3. Verifica che Ingress sia stato creato:

   kubectl describe ingress frontend
   

   L'output è simile al seguente:

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

   Il provisioning di Ingress potrebbe richiedere diversi minuti.

Testa l'applicazione

1. Controlla lo stato del certificato SSL:

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

   Il provisioning del certificato SSL potrebbe richiedere fino a 30 minuti. Il seguente output indica che il certificato SSL è pronto:

   NAME                      AGE   STATUS
   networking-managed-cert   28m   Active
   

2. Esegui un comando curl:

   curl -Lv https://DOMAIN_NAME
   

   L'output è simile al seguente:

   *   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
   

Libera spazio

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per, le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Elimina un Google Cloud progetto:

gcloud projects delete PROJECT_ID

Elimina singole risorse

1. Elimina le risorse Kubernetes:

   kubectl delete -f kubernetes-manifests.yaml
   

2. Elimina le risorse Terraform:

   terraform destroy --auto-approve
   

   Quando richiesto, inserisci il tuo dominio, ad esempio my-domain.net.

Passaggi successivi

• Scopri di più sul networking GKE.