Auf dieser Seite erfahren Sie, wie Sie den Load-Balancer konfigurieren, den Google Kubernetes Engine (GKE) erstellt, wenn Sie ein Gateway in einem GKE-Cluster bereitstellen.
Wenn Sie ein Gateway bereitstellen, bestimmt die GatewayClass-Konfiguration, welcher Load-Balancer von GKE erstellt wird. Dieser verwaltete Load Balancer ist mit Standardeinstellungen vorkonfiguriert, die Sie mithilfe einer Richtlinie ändern können.
Sie können Gateway-Ressourcen an Ihre Infrastruktur- oder Anwendungsanforderungen anpassen. Hängen Sie dazu Richtlinien an Gateways, Services oder ServiceImports an. Nachdem Sie eine Richtlinie angewendet oder geändert haben, wird sie vom Gateway-Controller verarbeitet und die zugrunde liegende Load-Balancer-Ressource wird automatisch neu konfiguriert. Dadurch müssen Sie Ihre Gateway-, Routen- oder Dienstressourcen nicht löschen oder neu erstellen.
Sie können auch eine BackendTLSPolicy verwenden, um TLS-Einstellungen für die Backend-Authentifizierung zu konfigurieren, um die Identität der Backends zu überprüfen, mit denen das Gateway eine Verbindung herstellt (wenn Sie die TLS-Terminierung mit HTTPRoute verwenden). Weitere Informationen finden Sie unter Backend-TLS konfigurieren. Informationen zum direkten Weiterleiten von verschlüsseltem TLS-Traffic an Backends mithilfe von TLSRoute, ohne TLS am Gateway zu beenden, finden Sie unter TLS-Passthrough-Gateway bereitstellen.
Hinweis
Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:
- Aktivieren Sie die Google Kubernetes Engine API. Google Kubernetes Engine API aktivieren
- Wenn Sie die Google Cloud CLI für diese Aufgabe verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die aktuelle Version mit dem Befehl
gcloud components updateab. Ältere gcloud CLI-Versionen unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.
- Prüfen Sie, ob Sie einen vorhandenen Autopilot- oder Standardcluster haben. Informationen zum Erstellen eines neuen Clusters finden Sie unter Autopilot-Cluster erstellen.
Anforderungen für GKE Gateway Controller
- Die Gateway API wird nur in VPC-nativen Clustern unterstützt.
- Wenn Sie die regionalen oder regionsübergreifenden GatewayClasses verwenden, müssen Sie ein Nur-Proxy-Subnetz aktivieren.
- Für den Cluster muss das Add-on
HttpLoadBalancingaktiviert sein. - Wenn Sie Istio verwenden, müssen Sie Istio auf eine der folgenden Versionen aktualisieren:
- 1.15.2 oder höher
- 1.14.5 oder höher
- 1.13.9 oder höher
- Wenn Sie eine gemeinsam genutzte VPC verwenden, müssen Sie dem GKE-Dienstkonto für das Dienstprojekt im Hostprojekt die Rolle
Compute Network Userzuweisen.
Limits und Einschränkungen
Zusätzlich zu den Limits und Einschränkungen für GKE Gateway Controller gelten die folgenden Einschränkungen speziell für Richtlinien, die auf die Gateway-Ressourcen angewendet werden:
GCPGatewayPolicy-Ressourcen können nur an ein
gateway.networking.k8s.io-Gateway angehängt werden.GCPGatewayPolicy-Ressourcen müssen sich im selben Namespace wie das Ziel-Gateway befinden.
Hierarchische Richtlinien werden mit GKE Gateway nicht unterstützt.
GCPBackendPolicy unterstützt die Optionen
HEADER_FIELDundHTTP_COOKIEfür die Sitzungsaffinität nicht. Verwenden Sie für die SitzungsaffinitätHEADER_FIELDoderHTTP_COOKIEdie Ressource „GCPTrafficDistributionPolicy“.Verwenden Sie nicht denselben Backend-Dienst für Gateways verschiedener GatewayClass-Typen (z. B. global im Vergleich zu regional, intern im Vergleich zu extern oder verwaltet im Vergleich zu klassisch), wenn diese Gateways inkompatible Konfigurationen erfordern. Beispielsweise kann eine GCPBackendPolicy, die mit Funktionen konfiguriert ist, die von einer „klassischen“ GatewayClass nicht unterstützt werden, nicht auf einen Dienst angewendet werden, der auch von einem „klassischen“ Gateway verwendet wird. Erstellen Sie für jedes Gateway, das unterschiedliche Richtlinieneinstellungen erfordert, einen separaten Dienst, um eine korrekte Konfiguration zu gewährleisten.
Die mit einer GCPTrafficDistributionPolicy konfigurierte Sitzungsaffinität wird nur für Single-Cluster-Gateways unterstützt.
Die Sitzungsaffinität der GCPTrafficDistributionPolicy ist nicht mit InferencePool-Ressourcen kompatibel, da diese dedizierte Algorithmen für das lokale Load Balancing verwenden.
GCPTrafficDistributionPolicy unterstützt nicht die Konfiguration von Sitzungsaffinität oder Ort-Load-Balancing-Richtlinien für den klassischen Application Load Balancer.
Wenn Sie ein Single-Cluster-Gateway verwenden, müssen GCPBackendPolicy- und HealthCheckPolicy-Ressourcen auf eine Service- oder InferencePool-Ressource verweisen.
Wenn Sie ein Multi-Cluster-Gateway verwenden, müssen sich die Ressourcen „GCPBackendPolicy“ und „HealthCheckPolicy“ auf eine „ServiceImport“- oder „GCPInferencePoolImport“-Ressource beziehen.
Es kann jeweils nur eine GCPBackendPolicy pro Protokoll (
HTTPoderTCP) an eine einzelne Zielressource (Service, ServiceImport, InferencePool oder GCPInferencePoolImport) angehängt werden. Ein Service oder ServiceImport kann eineHTTP-Richtlinie (Standard für HTTPRoute-Backends) und eineTCP-Richtlinie (spec.protocol: TCPfür TLSRoute-Backends) haben. Wenn mehrere GCPBackendPolicy-Ressourcen mit demselben Protokoll auf dieselbe Ressource abzielen, hat die älteste Richtlinie Vorrang und die neueren werden nicht angehängt.HealthCheckPolicy- und GCPBackendPolicy-Ressourcen müssen sich im selben Namespace wie die Zielressource Service, ServiceImport, InferencePool oder GCPInferencePoolImport befinden.
GCPBackendPolicy- und HealthCheckPolicy-Ressourcen können nur auf eine einzelne Ressource (z. B. einen Dienst oder einen InferencePool) ausgerichtet sein. Eine GCPBackendPolicy mit
spec.protocol: TCPkann nur auf Service- und ServiceImport-Ressourcen abzielen.Wenn Sie TLS-Passthrough mit TLSRoute verwenden, gilt Folgendes:
- BackendTLSPolicy, SSL-Richtlinien, Google Cloud Armor-Sicherheitsrichtlinien, IAP und CORS-Filter werden nicht unterstützt.
- Sie können eine HealthCheckPolicy, die die Prüftypen
TCPoderSSLverwendet, und eine GCPBackendPolicy an einen Service oder ServiceImport anhängen, auf den eine TLSRoute verweist. - Bei einer GCPBackendPolicy für ein TLSRoute-Backend (Proxy-Network Load Balancer) muss das Feld
spec.protocolauf den WertTCPgesetzt werden. Ohne das Feldspec.protocolwerden Richtlinien standardmäßig auf den WertHTTPgesetzt und gelten für HTTPRoute-Backends auf Application Load Balancern. TCP-Richtlinien unterstützen nur die folgenden Felder im Feldspec.default:timeoutSec,connectionDraining,logging.enabled,logging.sampleRate,sessionAffinity.type(gültige Werte sindCLIENT_IPoderNONE),capacityScalerPercent,balancingMode: CONNECTIONundmaxConnectionsPerEndpoint.- Wenn eine
TCP-Richtlinie auf eine ServiceImport-Ressource abzielt, können Sie die FeldercapacityScalerPercent,balancingMode: CONNECTIONundmaxConnectionsPerEndpointim Feldspec.default.scopesanstelle des Feldsspec.defaultfestlegen. Jeder Bereich gilt für die Backends, die mit dem Feldselectorübereinstimmen, z. B.gke.io/cluster-name,gke.io/zoneodergke.io/region. - Eine
TCP-Richtlinie, die ein anderes Feld im Feldspec.defaultoder in einem Bereich festlegt, oder eineHTTP-Richtlinie, die ein Feld festlegt, das nur fürTCPgilt (balancingMode: CONNECTIONodermaxConnectionsPerEndpoint), wird beim Erstellen abgelehnt. - Weitere Informationen finden Sie unter TLS-Passthrough-Gateway bereitstellen.
Best Practice: Erstellen Sie für jedes Gateway einen separaten Dienst mit einer anderen GatewayClass, um die Kompatibilität zwischen den Richtlinien des Dienstes und dem Load-Balancer-Typ sicherzustellen.
KI-Agenten-Gateway konfigurieren
Wenn Sie KI-Agenten in Ihrem Cluster hosten, können Sie ein Ingress-Agent-Gateway konfigurieren, indem Sie eine benutzerdefinierte GCPAgentGateway-Ressource (networking.gke.io/v1) bereitstellen, die auf Ihr Gateway verweist.
Wenn Sie das Agent-Gateway an den zugrunde liegenden Load Balancer anhängen möchten, geben Sie das Ziel-Gateway im Feld „spec.targetRefs“ Ihres GCPAgentGateway-Manifests an:
apiVersion: networking.gke.io/v1
kind: GCPAgentGateway
metadata:
name: my-agent-gateway
spec:
targetRefs:
- group: gateway.networking.k8s.io
kind: Gateway
name: GATEWAY_NAME
Ersetzen Sie GATEWAY_NAME durch den Namen Ihrer Gateway-Ressource.
Globalen Zugriff für Ihr regionales internes Gateway konfigurieren
In diesem Abschnitt wird eine Funktion beschrieben, die in GKE-Clustern mit Version 1.24 oder höher verfügbar ist.
Hängen Sie eine Richtlinie an die Gateway-Ressource an, um den globalen Zugriff mit Ihrem internen Gateway zu aktivieren.
Das folgende GCPGatewayPolicy-Manifest aktiviert das regionale interne Gateway für den globalen Zugriff:
apiVersion: networking.gke.io/v1
kind: GCPGatewayPolicy
metadata:
name: my-gateway-policy
namespace: default
spec:
default:
# Enable global access for the regional internal Application Load Balancer.
allowGlobalAccess: true
targetRef:
group: gateway.networking.k8s.io
kind: Gateway
name: my-gateway
Region für Ihr Multi-Cluster-Gateway konfigurieren
In diesem Abschnitt wird eine Funktion beschrieben, die in GKE-Clustern mit Version 1.30.3-gke.1225000 oder höher verfügbar ist.
Wenn Ihre Flotte Cluster in mehreren Regionen hat, müssen Sie möglicherweise regionale Gateways in verschiedenen Regionen für eine Vielzahl von Anwendungsfällen bereitstellen, z. B. für regionenübergreifende Redundanz, niedrige Latenz und Datenhoheit. In Ihrem Multi-Cluster-Gateway-Konfigurationscluster können Sie die Region angeben, in der Sie die regionalen Gateways bereitstellen möchten. Wenn Sie keine Region angeben, ist die Standardregion die Region des Konfigurationsclusters.
Verwenden Sie das Feld region in der GCPGatewayPolicy, um eine Region für Ihr Multi-Cluster-Gateway zu konfigurieren. Im folgenden Beispiel wird das Gateway in der Region us-central1 konfiguriert:
apiVersion: networking.gke.io/v1
kind: GCPGatewayPolicy
metadata:
name: my-gateway-policy
namespace: default
spec:
default:
region: us-central1
targetRef:
group: gateway.networking.k8s.io
kind: Gateway
name: my-regional-gateway
SSL-Richtlinien zum Sichern des Client-zu-Load-Balancer-Traffics konfigurieren
In diesem Abschnitt wird eine Funktion beschrieben, die in GKE-Clustern mit Version 1.24 oder höher verfügbar ist.
Konfigurieren Sie die SSL-Richtlinie, um den Client-zu-Load-Balancer-Traffic zu sichern. Fügen Sie dazu den Namen der Richtlinie der GCPGatewayPolicy hinzu. Standardmäßig ist für das Gateway keine SSL-Richtlinie definiert und angehängt.
Achten Sie darauf, dass Sie eine SSL-Richtlinie erstellen, bevor Sie auf die Richtlinie in der GCPGatewayPolicy-Ressource verweisen.
Das folgende GCPGatewayPolicy-Manifest gibt eine Sicherheitsrichtlinie mit dem Namen gke-gateway-ssl-policy an:
apiVersion: networking.gke.io/v1
kind: GCPGatewayPolicy
metadata:
name: my-gateway-policy
namespace: team1
spec:
default:
sslPolicy: gke-gateway-ssl-policy
targetRef:
group: gateway.networking.k8s.io
kind: Gateway
name: my-gateway
Systemdiagnosen konfigurieren
In diesem Abschnitt wird eine Funktion beschrieben, die in GKE-Clustern mit Version 1.24 oder höher verfügbar ist.
Standardmäßig ist die Systemdiagnose für Backend-Dienste, die die Anwendungsprotokolle HTTP oder kubernetes.io/h2c verwenden, vom Typ HTTP. Für das HTTPS-Protokoll ist die Standard-Systemdiagnose vom Typ HTTPS. Für das HTTP2-Protokoll ist die Standard-Systemdiagnose vom Typ HTTP2.
Mit einer HealthCheckPolicy können Sie die Einstellungen für die Load-Balancer-Systemdiagnose steuern. Jeder Systemdiagnosetyp (http, https, grpc, http2 und tcp) hat Parameter, die Sie definieren können. Google Cloud erstellt eine eindeutige Systemdiagnose für jeden Backend-Dienst für jeden GKE-Dienst.
Damit Ihr Load Balancer normal funktioniert, müssen Sie möglicherweise eine benutzerdefinierte HealthCheckPolicy für Ihren Load Balancer konfigurieren, wenn der Pfad der Systemdiagnose nicht der Standardpfad „/“ ist. Diese Konfiguration ist auch erforderlich, wenn Sie die Parameter der Systemdiagnose anpassen müssen. Beispiel: Wenn der Standardanfragepfad „/“ ist, auf Ihren Dienst aber nicht über diesen Anfragepfad zugegriffen werden kann und stattdessen „/health“ verwendet wird, um den Dienststatus zu melden, müssen Sie requestPath in Ihrer HealthCheckPolicy entsprechend konfigurieren.
Konfigurieren Sie für TLS-Passthrough-Backends, die TLSRoute verwenden, den Systemdiagnosetyp als TCP oder SSL (oder HTTP oder HTTPS, wenn Ihr Backend auf HTTP-Systemdiagnosen an einem separaten Port antwortet). Eine HealthCheckPolicy gilt für jedes Backend, das den Ziel-Service verwendet. Wenn sowohl eine HTTPRoute als auch eine TLSRoute auf denselben Dienst verweisen, konfiguriert die Richtlinie die Systemdiagnosen beider Routen. Dadurch können die Backends einer Route als fehlerhaft markiert werden. Wenn Sie Systemdiagnosen für jede Route separat konfigurieren möchten, verwenden Sie für jede Route einen separaten Dienst. Weitere Informationen finden Sie unter TLS-Passthrough-Gateway bereitstellen.
Beachten Sie beim Konfigurieren von Systemdiagnosen die folgenden Einschränkungen:
- Im Gegensatz zu GKE Ingress leitet GKE Gateway nicht automatisch Systemdiagnoseparameter (wie Pfad, Port oder Protokoll) aus den Bereitschafts- oder Aktivitätsprüfungen Ihres Pods ab. Wenn Ihr Dienst keine erfolgreiche Antwort im Standardstammverzeichnis (
/) zurückgibt, müssen Sie explizit einenHealthCheckPolicykonfigurieren. - Google Cloud -Systemdiagnoseprüfungen erfordern unbedingt den Antwortcode HTTP
200(OK). Wenn Ihre Anwendung Weiterleitungen (z. B. HTTP301oder302) oder Clientfehler (z. B. HTTP401oder403auf authentifizierten Endpunkten) auf dem geprüften Pfad zurückgibt, markiert der Load Balancer das Backend als fehlerhaft, was zu einem „No healthy upstream“-Fehler führt. - Sie können in GKE Gateway-
HealthCheckPolicy-Prüfungen keine benutzerdefinierten HTTP-Anfrageheader (z. B.Authorization-Header) konfigurieren. Wenn Ihr Backend Authentifizierungsheader erfordert, müssen Sie Ihre Anwendung so konfigurieren, dass nicht authentifizierter Zugriff speziell auf Ihren dedizierten Systemdiagnosepfad (z. B./healthzoder/ping) für Google Cloud IP-Bereiche für Systemdiagnosen möglich ist.
Das folgende HealthCheckPolicy-Manifest zeigt alle verfügbaren Felder beim Konfigurieren einer Systemdiagnoserichtlinie:
Dienst
# Health check configuration for the load balancer. For more information
# about these fields, see https://docs.cloud.google.com/compute/docs/reference/rest/v1/healthChecks.
apiVersion: networking.gke.io/v1
kind: HealthCheckPolicy
metadata:
name: lb-healthcheck
namespace: lb-service-namespace
spec:
default:
checkIntervalSec: INTERVAL # The default value is 15 seconds.
timeoutSec: TIMEOUT
healthyThreshold: HEALTHY_THRESHOLD
unhealthyThreshold: UNHEALTHY_THRESHOLD
logConfig:
enabled: true
config:
type: PROTOCOL
httpHealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
host: HOST
requestPath: REQUEST_PATH
response: RESPONSE
proxyHeader: PROXY_HEADER
httpsHealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
host: HOST
requestPath: REQUEST_PATH
response: RESPONSE
proxyHeader: PROXY_HEADER
grpcHealthCheck:
grpcServiceName: GRPC_SERVICE_NAME
portSpecification: PORT_SPECIFICATION
port: PORT
http2HealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
host: HOST
requestPath: REQUEST_PATH
response: RESPONSE
proxyHeader: PROXY_HEADER
tcpHealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
portName: PORT_NAME
request: REQUEST
response: RESPONSE
proxyHeader: PROXY_HEADER
# Attach to a Service in the cluster.
targetRef:
group: ""
kind: Service
name: lb-service
Multi-Cluster-Dienst
apiVersion: networking.gke.io/v1
kind: HealthCheckPolicy
metadata:
name: lb-healthcheck
namespace: lb-service-namespace
spec:
# The default and config fields control the health check configuration for the
# load balancer. For more information about these fields, see
# https://docs.cloud.google.com/compute/docs/reference/rest/v1/healthChecks.
default:
checkIntervalSec: INTERVAL
timeoutSec: TIMEOUT
healthyThreshold: HEALTHY_THRESHOLD
unhealthyThreshold: UNHEALTHY_THRESHOLD
logConfig:
enabled: ENABLED
config:
type: PROTOCOL
httpHealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
host: HOST
requestPath: REQUEST_PATH
response: RESPONSE
proxyHeader: PROXY_HEADER
httpsHealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
host: HOST
requestPath: REQUEST_PATH
response: RESPONSE
proxyHeader: PROXY_HEADER
grpcHealthCheck:
grpcServiceName: GRPC_SERVICE_NAME
portSpecification: PORT_SPECIFICATION
port: PORT
http2HealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
host: HOST
requestPath: REQUEST_PATH
response: RESPONSE
proxyHeader: PROXY_HEADER
tcpHealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
portName: PORT_NAME
request: REQUEST
response: RESPONSE
proxyHeader: PROXY_HEADER
# Attach to a multi-cluster Service by referencing the ServiceImport.
targetRef:
group: net.gke.io
kind: ServiceImport
name: lb-service
InferencePool
apiVersion: networking.gke.io/v1
kind: HealthCheckPolicy
metadata:
name: lb-healthcheck
namespace: lb-service-namespace
spec:
default:
checkIntervalSec: INTERVAL # The default value is 15 seconds.
timeoutSec: TIMEOUT
healthyThreshold: HEALTHY_THRESHOLD
unhealthyThreshold: UNHEALTHY_THRESHOLD
logConfig:
enabled: true
config:
type: PROTOCOL
httpHealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
host: HOST
requestPath: REQUEST_PATH
response: RESPONSE
proxyHeader: PROXY_HEADER
httpsHealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
host: HOST
requestPath: REQUEST_PATH
response: RESPONSE
proxyHeader: PROXY_HEADER
grpcHealthCheck:
grpcServiceName: GRPC_SERVICE_NAME
portSpecification: PORT_SPECIFICATION
port: PORT
http2HealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
host: HOST
requestPath: REQUEST_PATH
response: RESPONSE
proxyHeader: PROXY_HEADER
tcpHealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
portName: PORT_NAME
request: REQUEST
response: RESPONSE
proxyHeader: PROXY_HEADER
# Attach to an InferencePool in the cluster.
targetRef:
group: inference.networking.k8s.io
kind: InferencePool
name: my-inference-pool
Multi-Cluster-InferencePool
apiVersion: networking.gke.io/v1
kind: HealthCheckPolicy
metadata:
name: lb-healthcheck
namespace: lb-service-namespace
spec:
default:
checkIntervalSec: INTERVAL
timeoutSec: TIMEOUT
healthyThreshold: HEALTHY_THRESHOLD
unhealthyThreshold: UNHEALTHY_THRESHOLD
logConfig:
enabled: true
config:
type: PROTOCOL
httpHealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
host: HOST
requestPath: REQUEST_PATH
response: RESPONSE
proxyHeader: PROXY_HEADER
httpsHealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
host: HOST
requestPath: REQUEST_PATH
response: RESPONSE
proxyHeader: PROXY_HEADER
grpcHealthCheck:
grpcServiceName: GRPC_SERVICE_NAME
portSpecification: PORT_SPECIFICATION
port: PORT
http2HealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
host: HOST
requestPath: REQUEST_PATH
response: RESPONSE
proxyHeader: PROXY_HEADER
tcpHealthCheck:
portSpecification: PORT_SPECIFICATION
port: PORT
portName: PORT_NAME
request: REQUEST
response: RESPONSE
proxyHeader: PROXY_HEADER
# Attach to a multi-cluster InferencePool.
targetRef:
group: networking.gke.io
kind: GCPInferencePoolImport
name: my-inference-pool-import
Ersetzen Sie Folgendes:
INTERVAL: Gibt das Prüfintervall in Sekunden für jeden Systemdiagnose-Prober an. Dies ist die Zeit vom Beginn der Prüfung eines Probers bis zum Start der nächsten Prüfung. Wenn Sie diesen Parameter weglassen, beträgt der Standardwert von Google Cloud 15 Sekunden, wenn keine HealthCheckPolicy angegeben ist, und 5 Sekunden, wenn eine HealthCheckPolicy ohnecheckIntervalSec-Wert angegeben ist. Weitere Informationen finden Sie unter Mehrere Prüfungen und Häufigkeit.TIMEOUT: Gibt die Zeitspanne an, dieGoogle Cloud bei einer Prüfung auf eine Antwort wartet. Der Wert vonTIMEOUTmuss kleiner oder gleichINTERVALsein. Die Einheit sind Sekunden. Bei jeder Prüfung muss vor Ablauf des Zeitlimits ein HTTP 200-Antwortcode (OK) gesendet werden.HEALTHY_THRESHOLDundUNHEALTHY_THRESHOLD: Gibt die Anzahl der aufeinanderfolgenden Verbindungsversuche an, die für mindestens einen Prober erfolgreich sein oder fehlschlagen müssen, um den Systemzustand von fehlerfrei zu fehlerhaft oder von fehlerhaft zu fehlerfrei zu ändern. Wenn Sie einen dieser Parameter weglassen, beträgt der Standardwert für Google Cloud 2.PROTOCOL: Gibt ein Protokoll an, das von Prüfsystemen für Systemdiagnosen verwendet wird. Weitere Informationen finden Sie unter Erfolgskriterien für HTTP, HTTPS und HTTP/2, Erfolgskriterien für gRPC und Erfolgskriterien für TCP. Das ist ein erforderlicher Parameter.ENABLED: Gibt an, ob das Logging aktiviert oder deaktiviert ist.PORT_SPECIFICATION: Gibt an, ob die Systemdiagnose einen festen Port (USE_FIXED_PORT), einen benannten Port (USE_NAMED_PORT) oder einen Bereitstellungsport (USE_SERVING_PORT) verwendet. Wenn nicht angegeben, folgt die Systemdiagnose dem im Feldportangegebenen Verhalten. Wennportnicht angegeben ist, wird standardmäßigUSE_SERVING_PORTverwendet.PORT: Eine HealthCheckPolicy unterstützt nur die Angabe des Ports für die Load-Balancer-Systemdiagnose mithilfe einer Portnummer. Wenn Sie diesen Parameter weglassen, lautet der Standardwert für Google Cloud 80. Da der Load Balancer Prüfungen direkt an die IP-Adresse des Pods sendet, sollten Sie einen Port wählen, der zu einemcontainerPorteines Bereitstellungspods passt, selbst wenn dercontainerPortvon einemtargetPortdes Dienstes referenziert wird. Sie sind nicht aufcontainerPortsbeschränkt, auf die von dertargetPorteines Dienstes verwiesen wird.HOST: Wert des Host-Headers in der Systemdiagnoseanfrage. Dieser Wert verwendet die RFC 1123-Definition eines Hostnamens, wobei aber numerische IP-Adressen nicht zulässig sind. Wenn dieser Wert nicht angegeben oder leer ist, wird standardmäßig die IP-Adresse der Systemdiagnose verwendet.REQUEST: Gibt die Anwendungsdaten an, die nach dem Herstellen der TCP-Verbindung gesendet werden sollen. Wenn keine Angabe erfolgt, ist der Wert standardmäßig leer. Wenn sowohl die Anfrage als auch die Antwort leer sind, weist die hergestellte Verbindung allein auf ein fehlerfreies System hin. Die Anfragedaten dürfen nur im ASCII-Format vorliegen.REQUEST_PATH: gibt den Anfragepfad der Systemdiagnoseanfrage an. Wenn nicht angegeben oder leer gelassen, wird standardmäßig/verwendet.RESPONSE: gibt die Byte an, die mit dem Anfang der Antwortdaten abgeglichen werden sollen. Wenn nicht angegeben oder leer gelassen, interpretiert GKE jede Antwort als fehlerfrei. Die Antwortdaten können nur ASCII sein.PROXY_HEADER: Gibt den Proxy-Headertyp an. Sie könnenNONEoderPROXY_V1verwenden. Die Standardeinstellung istNONE.GRPC_SERVICE_NAMEist ein optionaler Name des gRPC-Dienstes. Lassen Sie dieses Feld weg, um alle Services anzugeben.
Weitere Informationen zu HealthCheckPolicy-Feldern finden Sie in der healthChecks-Referenz.
Cloud Armor-Backend-Sicherheitsrichtlinie zum Schutz Ihrer Backend-Dienste konfigurieren
In diesem Abschnitt wird eine Funktion beschrieben, die in GKE-Clustern mit Version 1.24 oder höher verfügbar ist.
Konfigurieren Sie die Cloud Armor-Backend-Sicherheitsrichtlinie. Fügen Sie dazu den Namen Ihrer Sicherheitsrichtlinie der GCPBackendPolicy hinzu, um Ihre Backend-Dienste zu sichern. Standardmäßig hat das Gateway keine Cloud Armor-Backend-Sicherheitsrichtlinie definiert und angehängt.
Sie müssen eine Cloud Armor-Backend-Sicherheitsrichtlinie erstellen, bevor Sie auf die Richtlinie in Ihrer GCPBackendPolicy verweisen. Wenn Sie ein regionales Gateway aktivieren, müssen Sie eine regionale Cloud Armor-Backend-Sicherheitsrichtlinie erstellen.
Das folgende GCPBackendPolicy-Manifest gibt eine Backend-Sicherheitsrichtlinie mit dem Namen example-security-policy an:
Dienst
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
# Apply a Cloud Armor security policy.
securityPolicy: example-security-policy
# Attach to a Service in the cluster.
targetRef:
group: ""
kind: Service
name: lb-service
Multi-Cluster-Dienst
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
# Apply a Cloud Armor security policy.
securityPolicy: example-security-policy
# Attach to a multi-cluster Service by referencing the ServiceImport.
targetRef:
group: net.gke.io
kind: ServiceImport
name: lb-service
InferencePool
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
securityPolicy: example-security-policy
# Attach to an InferencePool in the cluster.
targetRef:
group: inference.networking.k8s.io
kind: InferencePool
name: my-inference-pool
Multi-Cluster-InferencePool
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
securityPolicy: example-security-policy
# Attach to a multi-cluster InferencePool.
targetRef:
group: networking.gke.io
kind: GCPInferencePoolImport
name: my-inference-pool-import
IAP konfigurieren
Identity-Aware Proxy (IAP) erzwingt Zugriffssteuerungsrichtlinien für Backend-Dienste, die mit einer HTTPRoute verknüpft sind. Durch diese Erzwingung können nur authentifizierte Nutzer oder Anwendungen mit der richtigen IAM-Rolle (Identity and Access Management) auf diese Backend-Dienste zugreifen.
Standardmäßig ist kein IAP auf Ihre Backend-Dienste angewendet. Sie müssen IAP explizit in einer GCPBackendPolicy konfigurieren.
So konfigurieren Sie IAP mit Gateway:
- Rufen Sie die Client-ID und den Clientschlüssel für Ihren OAuth-Client ab. Der Clientschlüssel ist nur verfügbar, wenn Sie Ihren OAuth-Client erstellen. Weitere Informationen finden Sie unter OAuth-Clients verwalten.
-
Sie müssen keine BackendConfig erstellen, da BackendConfig eine Ingress-Konfigurationsressource ist.
So geben Sie eine IAP-Richtlinie an, die auf ein Secret verweist:
Speichern Sie das folgende GCPBackendPolicy-Manifest als
backend-policy.yaml:Dienst
apiVersion: networking.gke.io/v1 kind: GCPBackendPolicy metadata: name: backend-policy spec: default: # IAP OAuth2 settings. For more information about these fields, # see https://docs.cloud.google.com/iap/docs/reference/rest/v1/IapSettings#oauth2. iap: enabled: true oauth2ClientSecret: name: CLIENT_SECRET clientID: CLIENT_ID # Attach to a Service in the cluster. targetRef: group: "" kind: Service name: SERVICE_NAMEErsetzen Sie Folgendes:
CLIENT_SECRET: der OAuth-Clientschlüssel.CLIENT_ID: die OAuth-Client-ID.SERVICE_NAME: der Name des Dienstes, der in der GCPBackendPolicy als Ziel verwendet werden soll.
Multi-Cluster-Dienst
apiVersion: networking.gke.io/v1 kind: GCPBackendPolicy metadata: name: backend-policy spec: default: # IAP OAuth2 settings. For more information about these fields, # see https://docs.cloud.google.com/iap/docs/reference/rest/v1/IapSettings#oauth2. iap: enabled: true oauth2ClientSecret: name: CLIENT_SECRET clientID: CLIENT_ID # Attach to a multi-cluster Service by referencing the ServiceImport. targetRef: group: net.gke.io kind: ServiceImport name: SERVICEIMPORT_NAMEErsetzen Sie Folgendes:
CLIENT_SECRET: der OAuth-Clientschlüssel.CLIENT_ID: die OAuth-Client-ID.SERVICEIMPORT_NAME: der Name des ServiceImport, der in der GCPBackendPolicy als Ziel verwendet werden soll.
Wenden Sie das
backend-policy.yaml-Manifest an:kubectl apply -f backend-policy.yaml
Konfiguration überprüfen:
Prüfen Sie, ob die Richtlinie nach dem Erstellen der GCPBackendPolicy mit IAP angewendet wurde:
kubectl get gcpbackendpolicyDie Ausgabe sieht etwa so aus:
NAME AGE backend-policy 45mVerwenden Sie den „describe“-Befehl, um weitere Details zu erhalten:
kubectl describe gcpbackendpolicyDie Ausgabe sieht in etwa so aus:
Name: backend-policy Namespace: default Labels: <none> Annotations: <none> API Version: networking.gke.io/v1 Kind: GCPBackendPolicy Metadata: Creation Timestamp: 2023-05-27T06:45:32Z Generation: 2 Resource Version: 19780077 UID: f4f60a3b-4bb2-4e12-8748-d3b310d9c8e5 Spec: Default: Iap: Client ID: 441323991697-luotsrnpboij65ebfr13hlcpm5a4heke.apps.googleusercontent.com Enabled: true oauth2ClientSecret: Name: my-iap-secret Target Ref: Group: Kind: Service Name: lb-service Status: Conditions: Last Transition Time: 2023-05-27T06:48:25Z Message: Reason: Attached Status: True Type: Attached Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal ADD 46m sc-gateway-controller default/backend-policy Normal SYNC 44s (x15 over 43m) sc-gateway-controller Application of GCPBackendPolicy "default/backend-policy" was a success
Zeitlimit für Backend-Dienst konfigurieren
In diesem Abschnitt wird eine Funktion beschrieben, die in GKE-Clustern mit Version 1.24 oder höher verfügbar ist.
Das folgende GCPBackendPolicy-Manifest gibt ein Zeitlimit für den Backend-Dienst von 40 Sekunden an. Das Feld timeoutSec ist standardmäßig auf 30 Sekunden eingestellt.
Dienst
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
# Backend service timeout, in seconds, for the load balancer. The default
# value is 30.
timeoutSec: 40
# Attach to a Service in the cluster.
targetRef:
group: ""
kind: Service
name: lb-service
Multi-Cluster-Dienst
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
timeoutSec: 40
# Attach to a multi-cluster Service by referencing the ServiceImport.
targetRef:
group: net.gke.io
kind: ServiceImport
name: lb-service
InferencePool
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
timeoutSec: 40
# Attach to an InferencePool in the cluster.
targetRef:
group: inference.networking.k8s.io
kind: InferencePool
name: my-inference-pool
Multi-Cluster-InferencePool
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
timeoutSec: 40
# Attach to a multi-cluster InferencePool.
targetRef:
group: networking.gke.io
kind: GCPInferencePoolImport
name: my-inference-pool-import
Backend-Auswahl mit GCPBackendPolicy konfigurieren
Mit dem Balancing-Modus CUSTOM_METRICS in der GCPBackendPolicy können Sie bestimmte benutzerdefinierte Messwerte konfigurieren, die beeinflussen, wie Backend-Dienste von Load Balancern Traffic verteilen. Dieser Ausgleichsmodus ermöglicht Load Balancing basierend auf benutzerdefinierten Messwerten, die Sie definieren und die von den Anwendungs-Backends gemeldet werden.
Weitere Informationen finden Sie unter Trafficverwaltung mit Load Balancing auf Basis benutzerdefinierter Messwerte.
Das Array customMetrics[] im Feld backends[] enthält die folgenden Felder:
name: Gibt den benutzerdefinierten Namen des benutzerdefinierten Messwerts an.maxUtilization: Legt die Ziel- oder maximale Auslastung für diesen Messwert fest. Der gültige Bereich ist [0, 100].dryRun: ein boolesches Feld. Wenn „true“, werden die Messwertdaten an Cloud Monitoring gemeldet, haben aber keinen Einfluss auf Load-Balancing-Entscheidungen.
Beispiel
Das folgende Beispiel zeigt ein GCPBackendPolicy-Manifest, das benutzerdefinierte Messwerte für die Backend-Auswahl und das Routing auf Endpunktebene konfiguriert.
Speichern Sie das folgende Manifest als
my-backend-policy.yaml:kind: GCPBackendPolicy apiVersion: networking.gke.io/v1 metadata: name: my-backend-policy namespace: team-awesome spec: # Attach to the super-service Service. targetRef: kind: Service name: super-service default: backends: # Configuration for all locations. - location: "*" # Use the rate balancing mode for the load balancer. balancingMode: RATE # Maximum number of requests per second for each endpoint. maxRatePerEndpoint: 9000 # Configuration for us-central1-a - location: us-central1-a # maxRatePerEndpoint: 9000 inherited from the * configuration. # Use the custom metrics balancing mode for the load balancer. balancingMode: CUSTOM_METRICS # Configure the custom metrics for the load balancer to use. customMetrics: - name: gpu-load maxUtilizationPercent: 100 # value ranges from 0 to 100 and maps to the floating point range [0.0, 1.0] dryRun: falseWenden Sie das Manifest auf Ihren Cluster an:
kubectl apply -f my-backend-policy.yaml
Der Load Balancer verteilt den Traffic basierend auf dem Load-Balancing-Modus RATE und dem benutzerdefinierten Messwert gpu-load.
Routing auf Endpunktebene mit GCPTrafficDistributionPolicy konfigurieren
Die GCPTrafficDistributionPolicy API im Google Kubernetes Engine (GKE) Gateway bietet erweiterte Funktionen zur Trafficverwaltung, mit denen Sie genau steuern können, wie Traffic auf Ihre Anwendungspods verteilt wird. Diese einheitliche, GKE-native Ressource vereinfacht die Verwaltung von Load-Balancing-Algorithmen und Einstellungen für die Sitzungsaffinität.
Mit der GCPTrafficDistributionPolicy können Sie Folgendes konfigurieren:
Load-Balancing-Algorithmen: Geben Sie an, wie der Traffic auf die Endpunkte innerhalb eines Backends verteilt wird.
WEIGHTED_ROUND_ROBIN: Wenn Sie diesen Algorithmus auswählen, verwendet der Load Balancer benutzerdefinierte Messwerte, um Gewichtungen zu berechnen und Traffic basierend auf diesen gemeldeten Messwerten zu verteilen. Das ArraycustomMetrics[]in der GCPTrafficDistributionPolicy-Konfiguration enthält die folgenden Felder:name: Gibt den benutzerdefinierten Namen des benutzerdefinierten Messwerts an.dryRun: Wenntrue, werden die Messwertdaten an Cloud Monitoring gemeldet, haben aber keinen Einfluss auf das Load Balancing.
RING_HASH: Dieser Algorithmus ist für Dienste von Vorteil, die empfindlich auf die Cache-Leistung reagieren. Es wird eine konsistente Hashfunktion verwendet, um die Neuzuordnung von Anfragen zu minimieren, wenn Backend-Pods hinzugefügt oder entfernt werden. Das trägt zur Stabilität bei Skalierungsereignissen bei. Durch die Konfiguration des FeldsminimumHashRingSizewird eine detailliertere Lastverteilung ermöglicht.Sitzungsaffinität: sorgt dafür, dass Anfragen von demselben Client konsistent an denselben Backend-Pod weitergeleitet werden. Dies ist entscheidend für zustandsorientierte Arbeitslasten wie E-Commerce-Einkaufswagen oder Gaming-Sitzungen. GKE Gateway verwendet GCPTrafficDistributionPolicy, um alle Sitzungsaffinitätstypen zu unterstützen, die auf Google CloudApplication Load Balancer-Instanzen verfügbar sind, einschließlich
STRONG_COOKIE_AFFINITY,HEADER_FIELD,HTTP_COOKIE,GENERATED_COOKIEundCLIENT_IP.
Weitere Informationen finden Sie unter Trafficverwaltung mit Load Balancing auf Basis benutzerdefinierter Messwerte.
Beispiel
Das folgende Beispiel zeigt ein GCPTrafficDistributionPolicy-Manifest, das das Routing auf Endpunktebene sowohl mit dem Load-Balancing-Algorithmus WEIGHTED_ROUND_ROBIN als auch mit benutzerdefinierten Messwerten konfiguriert.
Speichern Sie das folgende Beispielmanifest als
GCPTrafficDistributionPolicy.yaml:apiVersion: networking.gke.io/v1 kind: GCPTrafficDistributionPolicy metadata: name: echoserver-v2 namespace: team1 spec: targetRefs: # Attach to the echoserver-v2 Service in the cluster. - kind: Service group: "" name: echoserver-v2 default: # Use custom metrics to distribute traffic across endpoints. localityLbAlgorithm: WEIGHTED_ROUND_ROBIN # Configure metrics from an ORCA load report to use for traffic # distribution. customMetrics: - name: orca.named_metrics.bescm11 dryRun: false - name: orca.named_metrics.bescm12 dryRun: trueWenden Sie das Manifest auf Ihren Cluster an:
kubectl apply -f GCPTrafficDistributionPolicy.yaml
Der Load Balancer verteilt den Traffic basierend auf dem WEIGHTED_ROUND_ROBIN-Algorithmus und den bereitgestellten benutzerdefinierten Messwerten auf Endpunkte.
Größe des Hash-Rings konfigurieren
Verwenden Sie für Dienste, bei denen die Minimierung von Cache-Fehlern entscheidend ist, den Algorithmus RING_HASH. Durch Anpassen des Felds minimumHashRingSize können Sie die Lastverteilung auf die Back-Ends genauer steuern. Der Load Balancer verwaltet die Ringgröße automatisch. Ein höherer Mindestwert kann jedoch dazu beitragen, dass Anfragen bei größeren Backend-Sets gleichmäßiger verteilt werden.
apiVersion: networking.gke.io/v1
kind: GCPTrafficDistributionPolicy
metadata:
name: ring-hash-policy
namespace: default
spec:
default:
localityLbAlgorithm: RING_HASH
# Defaults to 1024. Larger ring sizes result in more granular
# load distributions. Supported range is 1 to 2048.
minimumHashRingSize: 1024
targetRefs:
- group: ""
kind: Service
name: my-cache-heavy-service
Sitzungsaffinität konfigurieren
Konfigurieren Sie die Sitzungsaffinität, damit Anfragen von demselben Client konsistent an denselben Backend-Pod weitergeleitet werden.
Sitzungsaffinität mit GCPTrafficDistributionPolicy konfigurieren (Standard)
Für die in diesem Abschnitt beschriebenen Sitzungsaffinitätstypen sind die folgenden GKE-Mindestversionen erforderlich:
CLIENT_IP,HEADER_FIELD,GENERATED_COOKIEundHTTP_COOKIE: Version 1.35.2-gke.1269001 oder höher.STRONG_COOKIE_AFFINITY: Version 1.36.3-gke.1767000 oder höher.
GKE Gateway unterstützt alle Sitzungsaffinitätstypen mithilfe der GCPTrafficDistributionPolicy-Ressource. Diese Ressource bietet eine detailliertere Steuerung, z. B. Routing basierend auf benutzerdefinierten HTTP-Headern oder Cookies. Die Konfiguration der Sitzungsaffinität mit GCPTrafficDistributionPolicy ist die Standardmethode und wird empfohlen.
In der folgenden Tabelle werden die Affinitätstypen beschrieben, die bei Verwendung von GCPTrafficDistributionPolicy unterstützt werden:
| Affinitätstyp | Beschreibung |
|---|---|
STRONG_COOKIE_AFFINITY |
Zustandsorientierte cookiebasierte Sitzungspersistenz. Trägt dazu bei, dass die Sitzungsaffinität bei Skalierungsereignissen und Größenänderungen des Pod-Pools erhalten bleibt. Sie müssen das Feld cookie.name konfigurieren und können optional die Felder cookie.path und cookie.ttl konfigurieren. Funktioniert mit jeder localityLbAlgorithm-Einstellung (der Standardwert ist ROUND_ROBIN).
|
HTTP_COOKIE |
Affinität basierend auf einem HTTP-Cookie.
Wenn der Load Balancer auf die erste Anfrage antwortet, generiert er ein Cookie und stellt es in einem Set-Cookie-Antwortheader bereit. Bei nachfolgenden Anfragen gibt der Client das vom Load Balancer bereitgestellte Cookie zurück und der Load Balancer verwendet es, um Anfragen konsistent an dieselben Pods weiterzuleiten. Sie müssen das Feld cookie.name konfigurieren und können optional die Felder cookie.path und cookie.ttl konfigurieren.
Erfordert, dass das Feld localityLbAlgorithm auf MAGLEV oder RING_HASH gesetzt ist.
|
GENERATED_COOKIE |
Der Load Balancer generiert ein Cookie, um die Sitzung zu verfolgen. Der Name des Cookies lautet GCLB für globale externe Application Load Balancer und GCILB für regionale interne Application Load Balancer und regionale externe Application Load Balancer. Der Cookie-Pfad ist /. Sie können das Feld cookie.ttl optional auf maximal zwei Wochen konfigurieren. Die Felder cookie.name und cookie.path können für diesen Typ nicht konfiguriert werden. Erfordert, dass das Feld localityLbAlgorithm auf MAGLEV oder RING_HASH gesetzt ist.
|
HEADER_FIELD |
Affinität basierend auf einem bestimmten HTTP-Header. Erfordert, dass das Feld localityLbAlgorithm auf MAGLEV oder RING_HASH gesetzt ist. |
CLIENT_IP |
Affinität basierend auf der IP-Adresse des Clients. Erfordert, dass das Feld localityLbAlgorithm auf MAGLEV oder RING_HASH gesetzt ist. |
NONE |
Deaktiviert die Sitzungsaffinität. |
In den folgenden Beispielen wird gezeigt, wie Sie GCPTrafficDistributionPolicy nach Affinitätskategorie gruppiert konfigurieren: Cookie-basierte, Header-basierte und Client-IP-basierte Sitzungsaffinität.
So wenden Sie eine der folgenden Sitzungsaffinitätskonfigurationen auf Ihren Cluster an:
- Speichern Sie das ausgewählte Manifest als
policy.yaml. Wenden Sie das Manifest auf Ihren Cluster an:
kubectl apply -f policy.yaml
Cookiebasierte Sitzungsaffinität
Die cookiebasierte Sitzungsaffinität umfasst die Affinitätstypen STRONG_COOKIE_AFFINITY, HTTP_COOKIE und GENERATED_COOKIE.
Zustandsorientierte Cookie-Affinität (STRONG_COOKIE_AFFINITY)
Die zustandsorientierte Cookie-Affinität (STRONG_COOKIE_AFFINITY) bietet eine zustandsorientierte Sitzungspersistenz, die auch bei Backend-Skalierungsereignissen erhalten bleibt.
apiVersion: networking.gke.io/v1
kind: GCPTrafficDistributionPolicy
metadata:
name: strong-cookie-affinity-policy
namespace: default
spec:
default:
sessionAffinity:
type: STRONG_COOKIE_AFFINITY
cookie:
name: "GKE_STATEFUL_SESSION"
path: "/"
ttl: "24h"
targetRefs:
- group: ""
kind: Service
name: my-stateful-service
HTTP-Cookie-Affinität (HTTP_COOKIE)
Beim Affinitätstyp HTTP_COOKIE basiert die Affinität auf einem bestimmten benannten Cookie, das in einem Set-Cookie-Header zurückgegeben wird. Wenn Sie andere Sitzungsaffinitätstypen als NONE und STRONG_COOKIE_AFFINITY verwenden möchten, müssen Sie das Feld localityLbAlgorithm entweder auf MAGLEV oder RING_HASH setzen.
apiVersion: networking.gke.io/v1
kind: GCPTrafficDistributionPolicy
metadata:
name: http-cookie-affinity-policy
namespace: default
spec:
default:
sessionAffinity:
type: HTTP_COOKIE
cookie:
name: "my-app-session-id"
path: "/"
ttl: "3600s"
# HTTP_COOKIE affinity requires localityLbAlgorithm to be MAGLEV or RING_HASH.
localityLbAlgorithm: MAGLEV
targetRefs:
- group: ""
kind: Service
name: my-stateful-service
Cookie-Affinität (GENERATED_COOKIE)
Mit dem Affinitätstyp GENERATED_COOKIE kann der Load Balancer das Sitzungscookie automatisch generieren und benennen. Sie können den Wert des Felds cookie.ttl optional auf bis zu zwei Wochen (336h) konfigurieren.
apiVersion: networking.gke.io/v1
kind: GCPTrafficDistributionPolicy
metadata:
name: generated-cookie-affinity-policy
namespace: default
spec:
default:
sessionAffinity:
type: GENERATED_COOKIE
cookie:
ttl: "2h30m"
# GENERATED_COOKIE affinity requires localityLbAlgorithm to be MAGLEV or RING_HASH.
localityLbAlgorithm: MAGLEV
targetRefs:
- group: ""
kind: Service
name: my-stateful-service
Das Verhalten einer TTL von null für die cookiebasierte Sitzungsaffinität umfasst Folgendes:
Alle cookiebasierten Sitzungsaffinitäten (
STRONG_COOKIE_AFFINITY,HTTP_COOKIEundGENERATED_COOKIE) haben einttl-Attribut.Eine TTL von null Sekunden bedeutet, dass der Load Balancer dem Cookie kein
Expires-Attribut zuweist. In diesem Fall behandelt der Client das Cookie als Sitzungscookie. Die Definition einer Sitzung variiert je nach Client:- Einige Clients, z. B. Webbrowser, behalten das Cookie für die gesamte Browsersitzung bei. Bei diesem Ansatz bleibt das Cookie über mehrere Anfragen hinweg bestehen, bis die Anwendung geschlossen wird.
- Andere Clients behandeln eine Sitzung als eine einzelne HTTP-Anfrage und verwerfen das Cookie sofort nach dem Ende der Sitzung.
Header-basierte Sitzungsaffinität
Der Affinitätstyp HEADER_FIELD leitet Traffic basierend auf einem bestimmten HTTP-Header für Szenarien wie A/B-Tests oder spezialisiertes Client-Routing weiter, bei denen ein Cookie nicht geeignet ist. Wenn Sie andere Sitzungsaffinitätstypen als NONE und STRONG_COOKIE_AFFINITY verwenden möchten, müssen Sie das Feld localityLbAlgorithm entweder auf MAGLEV oder RING_HASH setzen. Im Gegensatz zum Standard-ROUND_ROBIN unterstützen diese Algorithmen konsistentes Hashing basierend auf benutzerdefinierten Feldern wie HTTP-Headern.
apiVersion: networking.gke.io/v1
kind: GCPTrafficDistributionPolicy
metadata:
name: header-affinity-policy
namespace: default
spec:
default:
sessionAffinity:
type: HEADER_FIELD
httpHeaderName: "X-User-Group-ID"
localityLbAlgorithm: MAGLEV
targetRefs:
- group: ""
kind: Service
name: SERVICE_NAME
Sitzungsaffinität basierend auf der Client-IP-Adresse
Der Affinitätstyp CLIENT_IP leitet Traffic von einer bestimmten Client-IP-Adresse auf Best-Effort-Basis an denselben Backend-Pod weiter. Wenn Sie andere Sitzungsaffinitätstypen als NONE und STRONG_COOKIE_AFFINITY verwenden möchten, müssen Sie das Feld localityLbAlgorithm entweder auf MAGLEV oder RING_HASH setzen.
apiVersion: networking.gke.io/v1
kind: GCPTrafficDistributionPolicy
metadata:
name: client-ip-affinity-policy
namespace: default
spec:
default:
sessionAffinity:
type: CLIENT_IP
localityLbAlgorithm: MAGLEV
targetRefs:
- group: ""
kind: Service
name: SERVICE_NAME
Richtlinie prüfen
Prüfen Sie den Status Ihrer GCPTrafficDistributionPolicy, nachdem Sie sie angewendet haben, um sicherzustellen, dass sie richtig konfiguriert und aktiv ist:
Führen Sie den folgenden Befehl aus, um den Status der Richtlinie zu prüfen:
kubectl describe gcptrafficdistributionpolicy POLICY_NAMEErsetzen Sie
POLICY_NAMEdurch den Namen Ihrer Richtlinie.Prüfen Sie in der Ausgabe den Abschnitt
Conditions. Der StatusTruemit dem GrundAttachedgibt an, dass die Konfiguration gültig und aktiv ist.
Sitzungsaffinität mit GCPBackendPolicy konfigurieren
In diesem Abschnitt wird beschrieben, wie Sie die Sitzungsaffinität mit GCPBackendPolicy konfigurieren.
Sie können die GCPBackendPolicy-Sitzungsaffinität anhand der folgenden Kriterien konfigurieren:
- Client-IP-Adresse (
CLIENT_IP) - Generiertes Cookie (
GENERATED_COOKIE)
Wenn Sie die Sitzungsaffinität für Ihren Dienst mithilfe von GCPBackendPolicy konfigurieren, legt das Gateway die Einstellung localityLbPolicy für den Backend-Dienst auf MAGLEV fest. Wenn Sie die Sitzungsaffinität aus der GCPBackendPolicy entfernen, setzt das Gateway die localityLbPolicy-Einstellung auf den Standardwert ROUND_ROBIN zurück.
Das folgende GCPBackendPolicy-Manifest gibt eine Sitzungsaffinität anhand der Client-IP-Adresse an:
Dienst
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
# On a best-effort basis, send requests from a specific client IP address
# to the same backend. This field also sets the load balancer locality
# policy to MAGLEV. For more information, see
# https://docs.cloud.google.com/load-balancing/docs/backend-service#lb-locality-policy
sessionAffinity:
type: CLIENT_IP
targetRef:
group: ""
kind: Service
name: lb-service
Multi-Cluster-Dienst
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
# On a best-effort basis, send requests from a specific client IP address
# to the same backend. This field also sets the load balancer locality
# policy to MAGLEV. For more information, see
# https://docs.cloud.google.com/load-balancing/docs/backend-service#lb-locality-policy
sessionAffinity:
type: CLIENT_IP
targetRef:
group: net.gke.io
kind: ServiceImport
name: lb-service
Das folgende GCPBackendPolicy-Manifest gibt eine Sitzungsaffinität anhand eines generierten Cookies an und legt die Cookie-TTL auf 50 Sekunden fest:
Dienst
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
# Include an HTTP cookie in the Set-Cookie header of the response.
# This field also sets the load balancer locality policy to MAGLEV. For more
# information, see
# https://docs.cloud.google.com/load-balancing/docs/l7-internal#generated_cookie_affinity.
sessionAffinity:
type: GENERATED_COOKIE
cookieTtlSec: 50 # The cookie expires in 50 seconds.
targetRef:
group: ""
kind: Service
name: lb-service
Multi-Cluster-Dienst
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
# Include an HTTP cookie in the Set-Cookie header of the response.
# This field also sets the load balancer locality policy to MAGLEV. For more
# information, see
# https://docs.cloud.google.com/load-balancing/docs/l7-internal#generated_cookie_affinity.
sessionAffinity:
type: GENERATED_COOKIE
cookieTtlSec: 50 # The cookie expires in 50 seconds.
targetRef:
group: net.gke.io
kind: ServiceImport
name: lb-service
Zeitlimit für Verbindungsausgleich konfigurieren
In diesem Abschnitt wird eine Funktion beschrieben, die in GKE-Clustern mit Version 1.24 oder höher verfügbar ist.
Sie können das Zeitlimit für den Verbindungsausgleich mit GCPBackendPolicy konfigurieren. Das Zeitlimit für den Verbindungsausgleich ist die Zeit in Sekunden, die gewartet wird, bis die Verbindung beendet wird. Das Zeitlimit kann zwischen 0 und 3.600 Sekunden liegen. Der Standardwert ist 0, wodurch auch der Verbindungsausgleich deaktiviert wird.
Das folgende GCPBackendPolicy-Manifest gibt ein Zeitlimit von 60 Sekunden für den Verbindungsausgleich an:
Dienst
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
connectionDraining:
drainingTimeoutSec: 60
targetRef:
group: ""
kind: Service
name: lb-service
Multi-Cluster-Dienst
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
connectionDraining:
drainingTimeoutSec: 60
targetRef:
group: net.gke.io
kind: ServiceImport
name: lb-service
InferencePool
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
connectionDraining:
drainingTimeoutSec: 60
# Attach to an InferencePool in the cluster.
targetRef:
group: inference.networking.k8s.io
kind: InferencePool
name: my-inference-pool
Multi-Cluster-InferencePool
yaml
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
connectionDraining:
drainingTimeoutSec: 60
# Attach to a multi-cluster InferencePool.
targetRef:
group: networking.gke.io
kind: GCPInferencePoolImport
name: my-inference-pool-import
Für die angegebene Dauer des Zeitlimits wartet GKE auf vorhandene Anfragen an das entfernte Backend, um den Vorgang abzuschließen. Der Load-Balancer sendet keine neuen Anfragen an das entfernte Backend. Nach dem Erreichen des Zeitlimits schließt GKE alle verbleibenden Verbindungen zum Backend.
HTTP-Zugriffs-Logging
In diesem Abschnitt wird eine Funktion beschrieben, die in GKE-Clustern mit Version 1.24 oder höher verfügbar ist.
Standard:
- Der Gateway-Controller protokolliert alle HTTP-Anfragen von Clients in Cloud Logging.
- Die Abtastrate beträgt 1.000.000, d. h., alle Anfragen werden protokolliert.
- Es werden keine optionalen Felder protokolliert.
Sie können das Zugriffs-Logging auf Ihrem Gateway mit einer GCPBackendPolicy auf drei Arten deaktivieren:
- Sie können die GCPBackendPolicy ohne
logging-Abschnitt belassen. - Sie können
logging.enabledauffalsesetzen - Sie können
logging.enabledauftrueundlogging.sampleRateauf0setzen.
Sie können auch die Abtastrate für das Zugriffs-Logging und eine Liste optionaler Felder konfigurieren, z. B. tls.cipher oder orcaLoadReport.
So aktivieren Sie das Logging der optionalen Felder:
- Setzen Sie
logging.OptionalModeaufCUSTOM. - Geben Sie die Liste der optionalen Felder an, die in
logging.optionalFieldsprotokolliert werden sollen. Eine Liste der unterstützten Felder finden Sie unter Logging und Monitoring.
Sie können das Logging der optionalen Felder auf zwei Arten deaktivieren:
- Sie können alle Einträge aus
logging.optionalFieldsentfernen. - Sie können
logging.OptionalModeaufEXCLUDE_ALL_OPTIONALsetzen.
Mit dem folgenden GCPBackendPolicy-Manifest wird die Standard-Stichprobenrate für das Zugriffs-Logging geändert und auf 50 % der HTTP-Anfragen festgelegt. Das Manifest ermöglicht auch das Logging von zwei optionalen Feldern für eine bestimmte Service-Ressource:
Dienst
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
# Access logging configuration for the load balancer.
logging:
enabled: true
# Log 50% of the requests. The value must be an integer between 0 and
# 1000000. To get the proportion of requests to log, GKE
# divides this value by 1000000.
sampleRate: 500000
# Log specific optional fields.
optionalMode: CUSTOM
optionalFields:
- tls.cipher
- orcaLoadReport.cpu_utilization
targetRef:
group: ""
kind: Service
name: lb-service
Multi-Cluster-Dienst
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
# Access logging configuration for the load balancer.
logging:
enabled: true
# Log 50% of the requests. The value must be an integer between 0 and
# 1000000. To get the proportion of requests to log, GKE
# divides this value by 1000000.
sampleRate: 500000
# Log specific optional fields.
optionalMode: CUSTOM
optionalFields:
- tls.cipher
- orcaLoadReport.cpu_utilization
targetRef:
group: net.gke.io
kind: ServiceImport
name: lb-service
InferencePool
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
# Access logging configuration for the load balancer.
logging:
enabled: true
# Log 50% of the requests. The value must be an integer between 0 and
# 1000000. To get the proportion of requests to log, GKE
# divides this value by 1000000.
sampleRate: 500000
# Log specific optional fields.
optionalMode: CUSTOM
optionalFields:
- tls.cipher
- orcaLoadReport.cpu_utilization
# Attach to an InferencePool in the cluster.
targetRef:
group: inference.networking.k8s.io
kind: InferencePool
name: my-inference-pool
Multi-Cluster-InferencePool
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: my-backend-policy
namespace: lb-service-namespace
spec:
default:
# Access logging configuration for the load balancer.
logging:
enabled: true
# Log 50% of the requests. The value must be an integer between 0 and
# 1000000. To get the proportion of requests to log, GKE
# divides this value by 1000000.
sampleRate: 500000
# Log specific optional fields.
optionalMode: CUSTOM
optionalFields:
- tls.cipher
- orcaLoadReport.cpu_utilization
# Attach to a multi-cluster InferencePool.
targetRef:
group: networking.gke.io
kind: GCPInferencePoolImport
name: my-inference-pool-import
Dieses Manifest hat die folgenden Felder:
enable: true: Aktiviert das Zugriffs-Logging explizit. Logs sind in Logging verfügbar.sampleRate: 500000: gibt an, dass 50 % der Pakete protokolliert werden. Sie können einen Wert zwischen 0 und 1.000.000 verwenden. GKE konvertiert diesen Wert in einen Gleitkommawert im Bereich [0, 1]. Dazu wird der Wert durch 1.000.000 geteilt. Dieses Feld ist nur relevant, wennenableauftruegesetzt ist.sampleRateist ein optionales Feld. Wenn es jedoch konfiguriert ist, muss auchenable: truefestgelegt werden. Wennenableauftruegesetzt ist undsampleRatenicht angegeben ist, setzt GKEenableauffalse.optionalMode: CUSTOM: Gibt an, dass eine Reihe vonoptionalFieldsin Logeinträge aufgenommen werden soll.optionalFields: tls.cipher, orcaLoadReport.cpu_utilization: Gibt an, dass Logeinträge sowohl den Namen der für den TLS-Handshake verwendeten Chiffre als auch die CPU-Auslastung des Dienstes enthalten sollen, sofern diese verfügbar sind. Wird nur unterstützt, wenn das Feldspec.protocolden WertHTTPhat.
Traffic-basiertes Autoscaling für Ihr Single-Cluster-Gateway konfigurieren
Auf Ihrem GKE-Cluster muss die Version 1.31.1-gke.2008000 oder höher ausgeführt werden.
Wenn Sie traffic-basiertes Autoscaling und kapazitätsbasiertes Load Balancing in einem Gateway mit einem einzelnen Cluster aktivieren möchten, können Sie die Servicekapazität konfigurieren. Mit der Service-Kapazität können Sie die Menge an Traffic-Kapazität angeben, die ein Service empfangen kann, bevor Pods automatisch skaliert werden oder der Traffic zu anderen verfügbaren Clustern überläuft.
Erstellen Sie zum Konfigurieren der Service-Kapazität einen Service und eine zugehörige GCPBackendPolicy. Im GCPBackendPolicy-Manifest wird das Feld maxRatePerEndpoint verwendet, das einen maximalen Wert für Anfragen pro Sekunde (RPS) pro Pod in einem Service definiert. Das folgende GCPBackendPolicy-Manifest definiert eine maximale Anzahl von Anfragen pro Sekunde von 10:
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
name: store
spec:
default:
maxRatePerEndpoint: 10
targetRef:
group: ""
kind: Service
name: store
Weitere Informationen zum traffic-basierten Autoscaling finden Sie unter Autoscaling auf Basis des Load-Balancer-Traffics.
Fehlerbehebung
In diesem Abschnitt finden Sie eine Anleitung zur Behebung häufiger Probleme beim Konfigurieren von Gateway-Ressourcen mithilfe von Richtlinien.
GCPTrafficDistributionPolicy wird nicht wirksam
Symptom: Der Traffic wird nicht gemäß den in Ihrer Richtlinie definierten Einstellungen für die Sitzungsaffinität oder den Standort verteilt.
Ursache: Dies tritt normalerweise auf, wenn die Richtlinie nicht korrekt an den Dienst gebunden ist oder wenn der Gateway-Controller beim Synchronisieren der Konfiguration mit dem Load Balancer einen Validierungsfehler festgestellt hat.
Workaround:
Richtlinienstatus prüfen: Prüfen Sie, ob die Richtlinie an Ihren Dienst angehängt wurde:
kubectl describe gcptrafficdistributionpolicy POLICY_NAMEErsetzen Sie
POLICY_NAMEdurch den Namen Ihrer Richtlinie.Suchen Sie in der Ausgabe nach dem Abschnitt
Conditions. Der StatusTruemit dem GrundAttachedgibt an, dass die Konfiguration gültig ist und angewendet wurde. Wenn der StatusFalselautet, prüfen Sie die FelderReasonundMessageauf Validierungsfehler (z. B. ein nicht unterstützter Algorithmus für den ausgewählten Affinitätstyp).Synchronisierung der Gateway-Konfiguration prüfen: Bestätigen Sie, dass das Gateway, das den Traffic verwaltet, diese Einstellungen erfolgreich mit der Cloud-Infrastruktur synchronisiert hat.
Prüfen Sie im Abschnitt
Status, ob die BedingungProgrammeddenStatusTruehat. Wenn der WertFalseist, ist beim Gateway-Controller ein Fehler aufgetreten, der möglicherweise mit Ihrer GCPTrafficDistributionPolicy zusammenhängt.Prüfen Sie die Felder
ReasonundMessageneben der BedingungProgrammed, um sofort Details zu erhalten. Detailliertere Fehlermeldungen oder einen Verlauf der Synchronisierungsfehler finden Sie imEventsam Ende der Ausgabe.
Mehrere GCPBackendPolicys, die mit demselben Dienst verknüpft sind
Symptom:
Der folgende Status kann auftreten, wenn Sie eine GCPBackendPolicy an einen Dienst oder einen ServiceImport anhängen:
status:
conditions:
- lastTransitionTime: "2023-09-26T20:18:03Z"
message: conflicted with GCPBackendPolicy "[POLICY_NAME]" of higher precedence, hence not applied
reason: Conflicted
status: "False"
type: Attached
Grund:
Dieser Status gibt an, dass Sie versuchen, eine zweite GCPBackendPolicy auf einen Dienst oder ServiceImport anzuwenden, an den bereits eine GCPBackendPolicy angehängt ist.
Mehrere GCPBackendPolicys, die mit demselben Dienst oder ServiceImport verknüpft sind, werden mit GKE Gateway nicht unterstützt. Weitere Informationen finden Sie unter Einschränkungen.
Workaround:
Konfigurieren Sie eine einzelne GCPBackendPolicy, die alle benutzerdefinierten Konfigurationen enthält, und hängen Sie sie an Ihre Zielressource (Service, ServiceImport, InferencePool oder GCPInferencePoolImport) an.
Sitzungsaffinität wird bei der Aufteilung des Traffics ignoriert
Symptom:
Anfragen werden nicht konsistent an denselben Backend-Pod weitergeleitet, obwohl die Sitzungsaffinität konfiguriert ist.
Grund:
Die gewichtete Trafficaufteilung hat Vorrang vor der Sitzungsaffinität. Wenn eine HTTPRoute Gewichtungen für mehrere Backends definiert, wählt der Load Balancer zuerst ein Backend basierend auf den Gewichtungen aus, bevor er die Affinitätslogik anwendet.
Workaround:
Vermeiden Sie die Verwendung der gewichteten Aufteilung des Traffics für dieselbe HTTPRoute-Regel, für die Sitzungsaffinität erforderlich ist.
Cloud Armor-Sicherheitsrichtlinie nicht gefunden
Symptom:
Die folgende Fehlermeldung kann angezeigt werden, wenn Sie Cloud Armor auf Ihrem regionalen Gateway aktivieren:
Invalid value for field 'resource': '{
"securityPolicy":"projects/123456789/regions/us-central1/securityPolicies/<policy_name>"}'.
The given security policy does not exist.
Grund:
Die Fehlermeldung gibt an, dass die angegebene regionale Cloud Armor-Sicherheitsrichtlinie in Ihrem Google Cloud -Projekt nicht vorhanden ist.
Workaround:
Erstellen Sie eine regionale Cloud Armor-Sicherheitsrichtlinie in Ihrem Projekt und verweisen Sie in Ihrer GCPBackendPolicy auf diese Richtlinie.
Nächste Schritte
- TLS-Weiterleitungs-Gateway bereitstellen
- Gateway bereitstellen
- Weitere Informationen zum Gateway Controller
- Gateway aus einer Ressource referenzieren
- API-Referenz zu Richtlinientypen ansehen