Questa pagina è stata tradotta dall'API Cloud Translation.

Configurare il networking per un cluster di produzione di base

Autopilot Standard

Questo tutorial è rivolto ad architetti cloud e amministratori delle operazioni interessati a eseguire il deployment di un'applicazione web in un cluster Google Kubernetes Engine (GKE) ed esporla 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.
Esegui il deployment di un'applicazione web di esempio.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

Configura il progetto

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Make sure that billing is enabled for your Google Cloud project.

Enable the Google Kubernetes Engine, Cloud DNS APIs.

Enable the APIs

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

Make sure that billing is enabled for your Google Cloud project.

Enable the Google Kubernetes Engine, Cloud DNS APIs.

Enable the APIs

Devi possedere un nome di dominio. Il nome di dominio non deve superare i 63 caratteri. Puoi utilizzare la modalità 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 gcloud CLI.

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

Clona il repository di codice:

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

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

Inizializza Terraform:
```
terraform init
```
Visualizza le modifiche all'infrastruttura:
```
terraform plan
```
Quando richiesto, inserisci il tuo dominio, ad esempio my-domain.net.

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"

Creare un bilanciatore del carico delle applicazioni esterno

Il manifest seguente descrive un ManagedCertificate, FrontendConfig, Deployment, servizio 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 presenta le seguenti proprietà:

networking.gke.io/managed-certificates: il nome del ManagedCertificate.
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 GKE Ingress di creare un bilanciatore del carico delle applicazioni esterno.

Applica il manifest al cluster:

kubectl apply -f kubernetes-manifests.yaml

Verifica che l'oggetto 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.

Applicazione di test

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. L'output seguente indica che il certificato SSL è pronto:
```
NAME                      AGE   STATUS
networking-managed-cert   28m   Active
```

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

Esegui la pulizia

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, quando lo elimini elimini anche tutto il lavoro 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 appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Elimina singole risorse

Elimina le risorse Kubernetes:

kubectl delete -f kubernetes-manifests.yaml

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.