Sie lesen die archivierte Service Mesh-Dokumentation für Version 1.21.

Verfügbare Versionen

Cloud Service Mesh – Aktuell
Cloud Service Mesh 1.28 – Archiv
Cloud Service Mesh 1.27 – Archiv
Cloud Service Mesh 1.26 – Archiv
Cloud Service Mesh 1.25 – Archiv
Cloud Service Mesh 1.24 – Archiv
Cloud Service Mesh 1.23 – Archiv
Cloud Service Mesh 1.22 – Archiv
Cloud Service Mesh 1.21 – Archiv
Cloud Service Mesh 1.20 – Archiv
Anthos Service Mesh 1.19 – Archiv

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Ingress-Gateway mithilfe eines externen Load-Balancers verfügbar machen

Übersicht

Mit Cloud Service Mesh können Sie Ingress-Gateways als Teil Ihres Service Mesh bereitstellen und verwalten. Sie können das Load-Balancing für Ihren Cluster weiter mit Cloud Service Mesh konfigurieren. Dazu verwenden Sie externe Load-Balancer (physische oder Software-Load-Balancer außerhalb des Clusters), um Traffic an das Ingress-Gateway zu senden.

Auf dieser Seite erfahren Sie, wie Sie einen externen Load-Balancer mit Cloud Service Mesh konfigurieren. Alternativ können Sie Ingress mit mehreren Backend-Konfigurationen einrichten.

Hinweis

Zum Ausführen der Schritte in diesem Dokument benötigen Sie die folgenden Ressourcen:

Einen Kubernetes-Cluster mit installiertem Cloud Service Mesh.
Einen externen Load-Balancer, der auf die Knoten zugreifen kann, auf denen Ihr Cluster ausgeführt wird. Sie konfigurieren diesen externen Load-Balancer so, dass das Ingress-Gateway Ihres Clusters über die externe IP-Adresse des Load-Balancers verbunden wird.

Umgebung einrichten

Führen Sie die folgenden Befehle über eine Workstation aus, die auf den Cluster zugreifen kann, den Sie verwenden möchten. Achten Sie darauf, dass das kubectl-Tool so konfiguriert ist, dass es den für Ihren Cluster spezifischen Clusterkontext verwendet.

Legen Sie die Umgebungsvariablen fest.

export ASM_INGRESSGATEWAY_NAMESPACE=asm-ingressgateway
export ASM_INGRESSGATEWAY_DEPLOYMENT_NAME=asm-ingressgateway
export ASM_INGRESSGATEWAY_SERVICE_NAME=asm-ingressgateway
export ASM_INGRESSGATEWAY_NODE_LABEL=asm-ingressgateway

Legen Sie die IP address des externen Load-Balancers fest.
```
export EXTERNAL_LB_IP_ADDRESS=EXTERNAL_LB_IP_ADDRESS
```
[\Optional/] Kennzeichnen Sie die Ingress-Gateway-Knoten. Dadurch wird das Gateway für bestimmte Knoten im Cluster bereitgestellt.
```
kubectl label nodes INGRESSGATEWAY_NODE_IP ${ASM_INGRESSGATEWAY_NODE_LABEL}=
```
- INGRESSGATEWAY_NODE_IP sind die Knoten in Ihrem Kubernetes Cluster, die das Ingress-Gateway hosten. Führen Sie diesen kubectl-Befehl für so viele Ingress-Knoten aus, wie Sie haben.

Ingress-Gateway erstellen

Bevor Sie die Anleitung in diesem Abschnitt ausführen, müssen Sie Ihre Implementierung der Steuerungsebene ermitteln. Folgen Sie dazu der Anleitung unter Implementierung der Steuerungsebene ermitteln.

Erstellen Sie den Namespace. Dieser Namespace wird zum Bereitstellen des Ingress-Gateways verwendet.
```
kubectl create namespace ${ASM_INGRESSGATEWAY_NAMESPACE}
```

Aktivieren Sie den Namespace für die Injektion. Die Schritte hängen von Ihrer Implementierung der Steuerungsebene ab.
Verwaltet (TD)
1. Wenden Sie das Standard-Einschleusungslabel auf den Namespace an.
kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \ istio.io/rev- istio-injection=enabled --overwrite
Verwaltet (Istiod)
Empfohlen: Führen Sie den folgenden Befehl aus, um das Standard-Injektionslabel auf den Namespace anzuwenden:
kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \ istio.io/rev- istio-injection=enabled --overwrite
Für vorhandene Nutzer der verwalteten Istiod-Steuerungsebene: Wir empfehlen die Verwendung der Standardeinschleusung. Die versionsbasierte Einschleusung wird jedoch auch unterstützt. Gehen Sie so vor:
1. Führen Sie folgenden Befehl aus, um die verfügbaren Release-Versionen zu finden:
  
  kubectl -n istio-system get controlplanerevision
  
  Die Ausgabe sieht etwa so aus:
  
  NAME AGE asm-managed-rapid 6d7h
  
  HINWEIS: Wenn in der oberen Liste zwei Versionen der Steuerungsebene angezeigt werden, entfernen Sie eine. Im Cluster werden nicht mehrere Versionen der Steuerungsebene unterstützt.
  
  In der Ausgabe ist der Wert in der Spalte NAME das Versionslabel für die verfügbare Release-Version der Cloud Service Mesh-Version.
2. Wenden Sie das Versionslabel auf den Namespace an.
  
  kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \ istio-injection- istio.io/rev=REVISION_LABEL --overwrite
Clusterintern
Empfohlen: Führen Sie den folgenden Befehl aus, um das Standard-Einschleusungslabel auf den Namespace anzuwenden:
kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \ istio.io/rev- istio-injection=enabled --overwrite
Wir empfehlen die Standardeinschleusung. Die versionsbasierte Einschleusung wird jedoch auch unterstützt. Gehen Sie so vor:
1. Verwenden Sie den folgenden Befehl, um das Versionslabel für istiod zu finden:
  
  kubectl get deploy -n istio-system -l app=istiod -o \ jsonpath={.items[*].metadata.labels.'istio\.io\/rev'}'{"\n"}'
2. Wenden Sie das Versionslabel auf den Namespace an. Im folgenden Befehl ist REVISION_LABEL der Wert des Überarbeitungslabels istiod, den Sie im vorherigen Schritt notiert haben.
  
  kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \ istio-injection- istio.io/rev=REVISION_LABEL --overwrite

Wenden Sie die Manifestdatei des Ingress-Gateways an.

kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} apply --filename https://raw.githubusercontent.com/GoogleCloudPlatform/anthos-service-mesh-samples/main/docs/ingress-gateway-external-lb/ingress-gateway.yaml

Erwartete Ausgabe:

serviceaccount/asm-ingressgateway created
role.rbac.authorization.k8s.io/asm-ingressgateway created
rolebinding.rbac.authorization.k8s.io/asm-ingressgateway created
deployment.apps/asm-ingressgateway created
service/asm-ingressgateway created
poddisruptionbudget.policy/asm-ingressgateway created
horizontalpodautoscaler.autoscaling/asm-ingressgateway created

Patchen Sie den ingressgateway-Dienst mit der IP-Adresse des externen Load-Balancers.

cat <<EOF > asm-external-ip-patch.yaml
spec:
  externalIPs:
    - ${EXTERNAL_LB_IP_ADDRESS}
  loadBalancerIP: ${EXTERNAL_LB_IP_ADDRESS}
EOF

kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} patch service/${ASM_INGRESSGATEWAY_SERVICE_NAME} --patch "$(cat asm-external-ip-patch.yaml)"

[Optional] Patchen Sie die ingressgateway-Bereitstellung für die Labelaffinität des Ingress-Gateway-Knotens.

cat <<EOF > asm-ingress-node-label-patch.yaml
spec:
  template:
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: ${ASM_INGRESSGATEWAY_NODE_LABEL}
                operator: Exists
EOF

kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} patch deployment/${ASM_INGRESSGATEWAY_DEPLOYMENT_NAME} --patch "$(cat asm-ingress-node-label-patch.yaml)"

Externen Load-Balancer einrichten

In diesem Abschnitt konfigurieren Sie den externen Load-Balancer, um eine Verbindung zum Ingress-Gateway aus dem Cluster herzustellen.

Informationen zum `Service`-Port des Ingress-Gateways abrufen

Rufen Sie die NodePorts ab.

export HTTP_INGRESS_PORT=$(kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} get service/${ASM_INGRESSGATEWAY_SERVICE_NAME} --output jsonpath='{.spec.ports[?(@.name=="http2")].nodePort}')
export HTTPS_INGRESS_PORT=$(kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} get service/${ASM_INGRESSGATEWAY_SERVICE_NAME} --output jsonpath='{.spec.ports[?(@.name=="https")].nodePort}')
export STATUS_PORT=$(kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} get service/${ASM_INGRESSGATEWAY_SERVICE_NAME} --output jsonpath='{.spec.ports[?(@.name=="status-port")].nodePort}')

Zeigen Sie die NodePorts an.

echo HTTP_INGRESS_PORT=${HTTP_INGRESS_PORT}
echo HTTPS_INGRESS_PORT=${HTTPS_INGRESS_PORT}
echo STATUS_PORT=${STATUS_PORT}

Externen Load-Balancer konfigurieren

Verwenden Sie die im vorherigen Schritt angezeigten NodePorts, um die Verbindung zwischen dem externen Load-Balancer und dem Ingress-Gateway zu konfigurieren.

Konfigurieren Sie die Systemdiagnose in der Load-Balancer-Konfiguration.
```
hosts:    CLUSTER_NODE_IP
Protocol: HTTP
Port:     STATUS_PORT
Path:     /healthz/ready
```
- CLUSTER_NODE_IP ist die IP-Adresse der Knoten in Ihrem Kubernetes-Cluster, auf denen das Ingress-Gateway gehostet wird. Diese IP-Adresse muss von Ihrem externen Load-Balancer aus erreichbar sein. Möglicherweise müssen Sie diese Konfiguration mehrmals einrichten, einmal pro Clusterknoten.
- STATUS_PORT ist der NodePort, über den die Systemdiagnose-API des Ingress Gateways bereitgestellt wird. Sie können diese Informationen aus dem vorherigen Schritt kopieren. Der Wert ist für jeden Knoten im Cluster gleich.
Konfigurieren Sie Knotenpools in Ihrem Load-Balancer für das Routing von HTTP und HTTPS Traffic. Verwenden Sie die folgende IP:PORT Konfiguration für Traffic über Port 80 (HTTP) und Port 443 (HTTPS).
```
80  ->  CLUSTER_NODE_IP:HTTP_INGRESS_PORT
443 ->  CLUSTER_NODE_IP:HTTPS_INGRESS_PORT
```
- CLUSTER_NODE_IP ist die IP-Adresse der Knoten in Ihrem Kubernetes-Cluster, auf denen das Ingress-Gateway gehostet wird. Diese IP-Adresse muss von Ihrem externen Load-Balancer aus erreichbar sein. Möglicherweise müssen Sie diese Konfiguration mehrmals einrichten, einmal pro Clusterknoten.
- HTTP_INGRESS_PORT ist der NodePort, über den der HTTP-Traffic des Ingress-Gateways bereitgestellt wird. Sie können diese Informationen aus dem vorherigen Schritt kopieren. Der Wert ist für jeden Knoten im Cluster gleich.
- HTTPS_INGRESS_PORT ist der NodePort, über den der HTTPS-Traffic des Ingress-Gateways bereitgestellt wird. Sie können diese Informationen aus dem vorherigen Schritt kopieren. Der Wert ist für jeden Knoten im Cluster gleich.

Prüfen Sie, ob die Systemdiagnosen auf Ihrem Load-Balancer erfolgreich sind.

Nächste Schritte

Gateways installieren und aktualisieren