SSL für Cloud Endpoints mit ESPv2 Beta aktivieren

Auf dieser Seite wird erläutert, wie Sie einen SSL-Port (Secure Sockets Layer) für die Bereitstellung von Extensible Service Proxy V2 Beta (ESPv2 Beta) mit Google Kubernetes Engine, Kubernetes oder Compute Engine aktivieren. Möglicherweise möchten Sie für einige Anwendungsfälle einen SSL-Port für den bereitgestellten Endpoints-Dienst aktivieren.

Sie sollten jedoch die Anleitungen für den ausgewählten Diensttyp und die ausgewählte Umgebung gelesen haben und wissen, wie Sie ESPv2 Beta ohne SSL bereitstellen.

SSL-Schlüssel und -Zertifikate konfigurieren

So konfigurieren Sie den SSL-Port für die Bereitstellung von HTTPS-Anfragen:

  1. Prüfen Sie, ob die SSL-Schlüsseldatei den Namen server.key hat und die Zertifikatdatei den Namen server.crt hat. Zu Testzwecken können Sie mithilfe von OpenSSL mit dem folgenden Befehl ein selbst signiertes server.key und server.crt generieren:

    openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
    -keyout ./server.key -out ./server.crt
  2. Geben Sie in Ihrem Serverzertifikat CN und subjectAltName an. Der Wert dieser Attribute sollte mit dem DNS oder der IP-Adresse übereinstimmen, die von Clients zum Aufrufen Ihres Dienstes verwendet wird. Andernfalls schlägt der SSL-Handshake fehl.

SSL für ESPv2 Beta in Kubernetes aktivieren

So aktivieren Sie den SSL-Port für ESPv2 Beta in Kubernetes:

  1. Erstellen Sie mit Ihrem SSL-Schlüssel und -Zertifikat ein Kubernetes-Secret:

    kubectl create secret generic esp-ssl \
      --from-file=./server.crt --from-file=./server.key
  2. Bearbeiten Sie die Kubernetes-Konfigurationsdateien, z. B. echo-ssl.yaml, wie im folgenden Snippet dargestellt:

    template:
      metadata:
        labels:
          app: esp-echo
      spec:
        volumes:
        - name: esp-ssl
          secret:
            secretName: esp-ssl
        containers:
        - name: esp
          image: gcr.io/endpoints-release/endpoints-runtime:2
          args: [
            "--listener_port", "9000",
            "--backend", "127.0.0.1:8081",
            "--service", "SERVICE_NAME",
            "--rollout_strategy", "managed",
            "--ssl_server_cert_path", "/etc/esp/ssl",
          ]
          ports:
            - containerPort: 9000
          volumeMounts:
          - mountPath: /etc/esp/ssl
            name: esp-ssl
            readOnly: true
        - name: echo
          image: gcr.io/endpoints-release/echo:latest
          ports:
            - containerPort: 8081

    Hinweis: Sie sehen in dem Konfigurationsbeispiel die zu bearbeitenden Zeilen. Zur Bereitstellung der Datei in Cloud Endpoints ist die vollständige Konfigurationsdatei erforderlich.

  3. Stellen Sie die generierten Kubernetes-Schlüssel als Volumes bereit. Dabei können Sie sich an den Anweisungen zu Volumes auf der Kubernetes-Seite orientieren.

  4. Starten Sie ESPv2 Beta wie unter Startoptionen für ESPv2 Beta festlegen beschrieben. Achten Sie jedoch darauf, das Start-Flag --ssl_server_cert_path hinzuzufügen, um den Pfad für die bereitgestellten Zertifikatsdateien anzugeben.

  5. Starten Sie den Dienst mit der aktualisierten Kubernetes-Konfigurationsdatei über den Befehl kubectl.

    kubectl apply -f echo-ssl.yaml

SSL für ESPv2 Beta in Compute Engine aktivieren

Zum Aktivieren von SSL in Compute Engine kopieren Sie zuerst die Dateien server.key und server.crt in den Ordner /etc/nginx/ssl der Compute Engine-Instanz. Gehen Sie dabei so vor:

  1. Führen Sie den folgenden Befehl aus und ersetzen Sie INSTANCE_NAME durch den Namen Ihrer Compute Engine-Instanz:

    gcloud compute scp server.* INSTANCE-NAME
    
  2. Stellen Sie mit ssh eine Verbindung zur Instanz her.

    gcloud compute ssh INSTANCE-NAME
    
  3. Geben Sie im Feld für die Instanz-VM das Verzeichnis an und kopieren Sie die Dateien:

      sudo mkdir -p /etc/esp/ssl
      sudo cp server.* /etc/esp/ssl/
    
  4. Verwenden Sie für die Bereitstellung mit Docker die Anleitung für Ihren Diensttyp. Führen Sie den ESPv2 Beta-Docker-Container mit folgendem Befehl aus:

    sudo docker run --name=esp \
     --detach \
     --publish=443:9000 \
     --net=esp_net \
     --volume=/etc/esp/ssl:/etc/esp/ssl \
      gcr.io/endpoints-release/endpoints-runtime:2 \
     --service=SERVICE_NAME \
     --rollout_strategy=managed \
     --backend=echo:8080 \
     --ssl_server_cert_path=/etc/esp/ssl \
     --listener_port=9000

    Im Vergleich zum Befehl docker run ohne SSL erstellt die SSL-Version des Befehls eine andere Konfiguration. Beispiel für den SSL-Befehl:

    • Der Ordner mit den Schlüssel- und CRT-Dateien wird mit --volume im Container bereitgestellt.
    • Verwendet --ssl_server_cert_path=/etc/esp/ssl, um ESPv2 Beta mitzuteilen, dass die Serverzertifikatsdateien server.key und server.crt im Ordner /etc/esp/ssl gefunden werden.
    • Ändert das Flag --publish für die Portzuordnung. Eingehende Anfragen an den HTTPS-Port 443 werden dem ESPv2 Beta-Port 9000 zugeordnet.

SSL-Port testen

Legen Sie die folgenden Umgebungsvariablen fest, um das Testen des SSL-Ports zu erleichtern:

  1. Legen Sie für IP_ADDRESS die IP-Adresse der Compute Engine-Instanz mit dem neuen SSL-Zertifikat fest.

  2. Legen Sie für ENDPOINTS_KEY einen gültigen API-Schlüssel fest.

Nachdem Sie den SSL-Port aktiviert haben, können Sie mithilfe von HTTPS Anfragen an den Extensible Service Proxy senden: Wenn Sie ein selbst signiertes Zertifikat verwenden, aktivieren Sie die unsichere Option in curl mit -k.

curl -k -d '{"message":"hello world"}' -H "content-type:application/json" \
https://IP_ADDRESS:443/echo?key=ENDPOINTS_KEY

Alternativ können Sie das Zertifikat im Format pem generieren und das selbst signierte Zertifikat mithilfe der Option --cacert wie unten dargestellt in curl verwenden:

  openssl x509 -in server.crt -out client.pem -outform PEM
  curl --cacert "./client.pem" -d '{"message":"hello world"}' -H "content-type:application/json" \
  https://IP_ADDRESS:443/echo?key=ENDPOINTS_KEY
  

SSL mit von Google verwalteten SSL-Zertifikaten aktivieren

Der GKE-Support für von Google verwaltete SSL-Zertifikate befindet sich in der Betaphase. Folgen Sie der Anleitung in Von Google verwaltete SSL-Zertifikate verwenden, um SSL zu konfigurieren.

Wenn Sie sich nicht auf Betadienste verlassen möchten, können Sie Ihren ESP direkt in eine GKE-Bereitstellung mit einer Zertifizierungsstelle integrieren.

Sie können Folgendes angeben:

Weitere Informationen finden Sie in der Anleitung Let's Encrypt on GKE auf GitHub.