Netzwerk für einen einfachen Produktionscluster konfigurieren

Diese Anleitung richtet sich an Cloud-Architekten und Betriebsadministratoren, die eine Webanwendung in einem GKE-Cluster (Google Kubernetes Engine) bereitstellen und mit einem HTTPS-Load-Balancer verfügbar machen möchten.

Ziele

In dieser Anleitung erhalten Sie Informationen zu folgenden Themen:

  • einen GKE-Cluster installieren
  • Erstellen Sie eine globale IP-Adresse und eine Cloud DNS-Zone mit Terraform.
  • Konfigurieren Sie das HTTPS-Load-Balancing.
  • Stellen Sie eine Beispielwebanwendung bereit.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Vorbereitung

Projekt einrichten

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

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

  3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  4. Enable the Google Kubernetes Engine, Cloud DNS APIs.

    Enable the APIs

    5.

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

  6. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  7. Enable the Google Kubernetes Engine, Cloud DNS APIs.

    Enable the APIs

    8.

  • Sie müssen Inhaber des Domainnamens sein. Der Domainname darf maximal 63 Zeichen haben. Sie können Google Domains oder einen anderen Registrator verwenden.

Umgebung einrichten

In dieser Anleitung verwenden Sie Cloud Shell zum Verwalten von Ressourcen, die in Google Cloud gehostet werden. Die Software, die Sie für diese Anleitung benötigen, ist in Cloud Shell vorinstalliert, einschließlich Docker, kubectl und der gcloud CLI.

  1. Legen Sie Umgebungsvariablen fest:

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

  2. Klonen Sie das Code-Repository:

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

  3. Wechseln Sie in das Arbeitsverzeichnis:

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

GKE-Cluster erstellen

Mit der folgenden Terraform-Datei wird ein GKE-Cluster erstellt:


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"
}

Die folgende Terraform-Datei erstellt eine globale IP-Adresse und eine Cloud DNS-Zone:


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. Initialisieren Sie Terraform:

    terraform init

  2. Rufen Sie die Infrastrukturänderungen auf:

    terraform plan

    Geben Sie bei entsprechender Aufforderung Ihre Domain ein, z. B. my-domain.net.

  3. Wenden Sie die Terraform-Konfiguration an:

    terraform apply --auto-approve

    Geben Sie bei entsprechender Aufforderung Ihre Domain ein, z. B. my-domain.net.

    Die Ausgabe sieht in etwa so aus:

    Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Outputs:

cluster_name = "networking-cluster"
region = "us-central1"

Externen Application Load Balancer erstellen

  1. Das folgende Manifest beschreibt ManagedCertificate, FrontendConfig, Deployment, Service und 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

    Ersetzen Sie DOMAIN_NAME durch Ihren Domainnamen, z. B. my-domain.net.

    Dieses Manifest hat folgende Attribute:

    • networking.gke.io/managed-certificates ist der Name des ManagedCertificate.
    • networking.gke.io/v1beta1.FrontendConfig ist der Name der FrontendConfig-Ressource.
    • kubernetes.io/ingress.global-static-ip-name ist der Name der IP-Adresse.
    • kubernetes.io/ingress.class: weist den GKE-Ingress-Controller an, einen externen Anwendungs-Load-Balancer zu erstellen.

  2. Wenden Sie das Manifest auf Ihren Cluster an:

    kubectl apply -f kubernetes-manifests.yaml

  3. Prüfen Sie, ob das Ingress erstellt wurde:

    kubectl describe ingress frontend

    Die Ausgabe sieht in etwa so aus:

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

    Es kann einige Minuten dauern, bis Ingress bereitgestellt wird.

App testen

  1. Prüfen Sie den Status des SSL-Zertifikats:

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

    Die Bereitstellung des SSL-Zertifikats kann bis zu 30 Minuten dauern. Die folgende Ausgabe zeigt an, dass das SSL-Zertifikat bereit ist:

    NAME                      AGE   STATUS
networking-managed-cert   28m   Active

  2. Führen Sie einen curl-Befehl aus:

    curl -Lv https://DOMAIN_NAME

    Die Ausgabe sieht in etwa so aus:

    *   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

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Projekt löschen

    Delete a Google Cloud project:

    gcloud projects delete PROJECT_ID

Einzelne Ressourcen löschen

  1. Löschen Sie die Kubernetes-Ressourcen:

    kubectl delete -f kubernetes-manifests.yaml

  2. Löschen Sie die Terraform-Ressourcen:

    terraform destroy --auto-approve

    Geben Sie bei entsprechender Aufforderung Ihre Domain ein, z. B. my-domain.net.

Nächste Schritte