TLS-Terminierung im Ingress-Gateway einrichten

Übersicht

Auf dieser Seite wird gezeigt, wie Sie eine TLS-Terminierung im Ingress-Gateway in Cloud Service Mesh einrichten, um externen HTTPS-Traffic zu Ihren Diensten zu verwalten. Sie erfahren, wie Sie das Gateway für die sichere Kommunikation mit TLS konfigurieren, um einen verschlüsselten Zugriff auf Ihre Anwendungen zu ermöglichen. Dabei werden Cloud Service Mesh-Funktionen genutzt, um Dienste wie sicher bereitzustellen.

Hinweise

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

  • Einen Kubernetes-Cluster mit installiertem Cloud Service Mesh.

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.

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

  2. Die in Ihrem Cluster bereitgestellte Anwendung „foo“. Sie können es mit folgenden Tools installieren:

    apiVersion: v1
kind: Service
metadata:
  name: foo
  namespace: foo
spec:
  selector:
    app: test-backend
  ports:
  - port: 8080
    targetPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: foo
  namespace: foo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: test-backend
  template:
    metadata:
      labels:
        app: test-backend
    spec:
      containers:
      - name: whereami
        image: gcr.io/google-samples/whereami:v1.2.23
        ports:
        - containerPort: 8080
EOF

  3. Zertifikate und Schlüssel generieren

Zum Schützen Ihres Ingress-Gateways benötigen Sie TLS-Zertifikate und ‑Schlüssel. Sie können ein beliebiges Zertifikatgenerierungstool verwenden oder mit openssl die erforderlichen Anmeldedaten erstellen.

  • Root-Zertifikat und ‑Schlüssel der Zertifizierungsstelle erstellen

    mkdir example_certs
openssl req -x509 -sha256 -nodes -days 365 -newkey rsa:2048 -subj '/O=Example Corp/CN=example.com' \
  -keyout example.com.key -out example.com.crt

  • Zertifikat und Schlüssel für Ingress generieren

    openssl req -out foo.example.com.csr -newkey rsa:2048 -nodes \
  -keyout foo.example.com.key -subj "/CN=foo.example.com/O=Foo Org"

openssl x509 -req -sha256 -days 365 -CA example.com.crt \
  -CAkey example.com.key -set_serial 0 \
  -in foo.example.com.csr -out foo.example.com.crt

TLS-Ingress-Gateway einrichten

Bevor Sie mit der Anleitung in diesem Abschnitt fortfahren, müssen Sie die Implementierung Ihrer Kontrollebene festlegen. Folgen Sie dazu der Anleitung unter Steuerungsebene identifizieren.

  1. Erstellen Sie den Namespace. Dieser Namespace wird zum Bereitstellen des Ingress-Gateways verwendet.

    kubectl create namespace ${ASM_INGRESSGATEWAY_NAMESPACE}

  2. Wenden Sie das Standard-Injektionslabel auf den Namespace an:

    kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
    istio.io/rev- istio-injection=enabled --overwrite

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

  4. Speichern Sie die TLS-Anmeldedaten in einem Kubernetes-Secret:

    kubectl create -n ${ASM_INGRESSGATEWAY_NAMESPACE} secret tls foo-credential \
  --key=example_certs/foo.example.com.key \
  --cert=example_certs/foo.example.com.crt

  5. Ingress-Gateway definieren: Erstellen Sie eine Gateway-Ressource, um HTTPS-Traffic über Port 443 zu verarbeiten:

    cat <<EOF | kubectl apply -f -
apiVersion: networking.istio.io/v1
kind: Gateway
metadata:
  name: secure-gateway
  namespace: ${ASM_INGRESSGATEWAY_NAMESPACE}
spec:
  selector:
    app: asm-ingressgateway
    istio: ingressgateway
  servers:
  - port:
      number: 443
      name: https
      protocol: HTTPS
    tls:
      mode: SIMPLE
      credentialName: foo-credential
    hosts:
    - "foo.example.com"
EOF

  6. Traffic an den Dienst „foo“ weiterleiten: Definieren Sie einen VirtualService, um Traffic an die Bereitstellung „foo“ weiterzuleiten:

    cat <<EOF | kubectl apply -f -
apiVersion: networking.istio.io/v1
kind: VirtualService
metadata:
  name: foo-routing
  namespace: ${ASM_INGRESSGATEWAY_NAMESPACE}
spec:
  hosts:
  - "foo.example.com"
  gateways:
  - secure-gateway
  http:
  - match:
    - uri:
        prefix: /status
    - uri:
        prefix: /delay
    route:
    - destination:
        host: foo
        port:
          number: 8080
EOF

  7. Externen Load Balancer einrichten, um eine Verbindung zum Ingress-Gateway aus dem Cluster herzustellen

  8. Sichere Verbindung testen: Verwende curl, um die Einrichtung zu überprüfen:

    export EXTERNAL_LB_IP_ADDRESS=EXTERNAL_LB_IP_ADDRESS
curl -v -H "Host: foo.example.com" --resolve "foo.example.com:443:$EXTERNAL_LB_IP_ADDRESS" \
  --cacert example_certs/example.com.crt "https://foo.example.com:443/ping"

Ersetzen Sie EXTERNAL_LB_IP_ADDRESS durch die IP-Adresse des externen Load Balancers.

Die Ausgabe sieht etwa so aus:

    {
      "cluster_name": "gke-us",
      "host_header": "34.120.175.141",
      "pod_name": "whereami-deployment-954cbf78-mtlpf",
      "pod_name_emoji": "😎",
      "project_id": "my-project",
      "timestamp": "2021-11-29T17:01:59",
      "zone": "us-central1-b"
    }

Nächste Schritte