Anthos Service Mesh und Traffic Director heißen jetzt Cloud Service Mesh. Weitere Informationen finden Sie in der Übersicht zu Cloud Service Mesh.

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

Überblick

Mit Anthos 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 mit Anthos Service Mesh weiter 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 Anthos Service Mesh konfigurieren. Alternativ können Sie Ingress mit mehreren Back-End-Konfigurationen einrichten.

Hinweise

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

Einen Kubernetes-Cluster mit installiertem Anthos Service Mesh.
Ein externer Load-Balancer, der auf die Knoten zugreifen kann, auf denen Ihr Cluster ausgeführt wird. Sie konfigurieren diesen externen Load-Balancer so, dass er dem Ingress-Gateway Ihres Clusters über External IP Address vorgeht.

Umgebung einrichten

Führen Sie die folgenden Befehle auf einer Workstation aus, die auf den gewünschten Cluster zugreifen kann. 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 auf bestimmten Knoten im Cluster bereitgestellt.
```
kubectl label nodes INGRESSGATEWAY_NODE_IP ${ASM_INGRESSGATEWAY_NODE_LABEL}=
```
- INGRESSGATEWAY_NODE_IP ist der oder die Knoten im Kubernetes-Cluster, der das Ingress-Gateway hostet. Führen Sie diesen kubectl-Befehl für beliebig viele Ingress-Knoten aus.

Ingress-Gateway erstellen

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 Injection: Die Schritte hängen vom Anthos Service Mesh-Typ ab (entweder verwaltet oder im Cluster).
Verwaltet
1. Verwenden Sie folgenden Befehl, um die verfügbaren Release-Kanäle zu finden:
```
kubectl -n istio-system get controlplanerevision
```
  Die Ausgabe sieht in etwa so aus:
```
NAME                AGE
asm-managed         6d7h
asm-managed-rapid   6d7h
```
  In der Ausgabe ist der Wert in der NAME-Spalte das Überarbeitungslabel, das dem verfügbaren Release-Kanal für die Anthos Service Mesh-Version entspricht.
2. Wenden Sie das Überarbeitungslabel auf den Namespace an.
```
kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
  istio-injection- istio.io/rev=REVISION_LABEL --overwrite
```
Clusterintern
1. Verwenden Sie den folgenden Befehl, um das Überarbeitungslabel 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 Überarbeitungslabel auf den Namespace an. Im folgenden Befehl ist REVISION der Wert des Überarbeitungslabels istiod, den Sie im vorherigen Schritt notiert haben.
```
kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
  istio-injection- istio.io/rev=REVISION --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 Dienst ingressgateway 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 das Deployment ingressgateway für die Labelaffinität der Ingress-Gateway-Knoten.

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.

Portinformationen des `Service`-Ports für eingehenden Traffic 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}

Externes Lastenausgleichsmodul konfigurieren

Verwenden Sie den 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 dem 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 Systemstatus-API des Ingress-Gateways verfügbar gemacht wird. Sie können diese Informationen aus dem vorherigen Schritt kopieren. Sie 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 dem 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 die NodePort, über die der HTTP-Traffic des Ingress-Gateways freigegeben wird. Sie können diese Informationen aus dem vorherigen Schritt kopieren. Sie ist für jeden Knoten im Cluster gleich.
- HTTPS_INGRESS_PORT ist der NodePort, über den der HTTPS-Traffic des Ingress-Gateways freigegeben wird. Sie können diese Informationen aus dem vorherigen Schritt kopieren. Sie ist für jeden Knoten im Cluster gleich.

Prüfen Sie zur Überprüfung Ihrer Einrichtung, ob die Systemdiagnosen Ihres Load-Balancers erfolgreich sind.

Nächste Schritte

Gateways installieren und aktualisieren