SSL für Cloud Endpoints mit ESPv2 aktivieren

OpenAPI | gRPC

Auf dieser Seite wird erläutert, wie Sie einen SSL-Port (Secure Sockets Layer) für die Bereitstellung von Extensible Service Proxy V2 (ESPv2) 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.

Lesen Sie, bevor Sie beginnen, die Anleitungen für den ausgewählten Diensttyp und die ausgewählte Umgebung. Außerdem sollten Sie wissen, wie Sie ESPv2 ohne SSL bereitstellen.

SSL-Schlüssel und -Zertifikate konfigurieren

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

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
```
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 in Kubernetes aktivieren

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

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

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.

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.
Starten Sie ESPv2 wie unter Startoptionen für ESPv2 festlegen beschrieben. Achten Sie jedoch darauf, das Start-Flag --ssl_server_cert_path hinzuzufügen, um den Pfad für die bereitgestellten Zertifikatsdateien anzugeben.
Starten Sie den Dienst mit der aktualisierten Kubernetes-Konfigurationsdatei über den Befehl kubectl.
```
kubectl apply -f echo-ssl.yaml
```
Hinweis: Wenn bereits ein Kubernetes-Deployment vorhanden ist, können Sie es direkt aktualisieren.
Generieren Sie das Root-Zertifikat für den Client mit folgendem OpenSSL-Befehl:
```
   openssl x509 -in ./server.crt -out ./client.pem -outform PEM
 
```
Wenn der Client curl nutzt, kann die Datei client.pem im Flag --caroot verwendet werden. Für gRPC wird client.pem als Root-Zertifikatsdatei der SSL-Anmeldedaten für den gRPC-Kanal verwendet.

SSL-Zertifikate aktualisieren

SSL-Zertifikate sollten regelmäßig aktualisiert werden. Zum Aktualisieren von SSL-Zertifikaten führen Sie die folgenden Schritte aus:

Erstellen Sie wie in Schritt 1 oben beschrieben neue Zertifikate.
Stellen Sie die neuen Zertifikate wie in Schritt 3 oben beschrieben für die Kubernetes-Secrets bereit.
Aktualisieren Sie das ESPv2-Kubernetes-Deployment wie in Schritt 5 beschrieben.
Generieren Sie die Root-Zertifikatsdatei des Clients neu, wie in Schritt 6 oben beschrieben.

SSL für ESPv2 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:

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
```
Stellen Sie mit ssh eine Verbindung zur Instanz her.
```
gcloud compute ssh INSTANCE-NAME
```
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/
```
Verwenden Sie für die Bereitstellung mit Docker die Anleitung für Ihren Diensttyp. Führen Sie den ESPv2-Docker-Container mit diesem 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 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-Port 9000 zugeordnet.
  
  Hinweis: Der ESPv2-Container kann nicht an privilegierte Ports gebunden werden, einschließlich Port 443. Verwenden Sie stattdessen das Flag --publish, um 443 einem privilegierten --listener_port wie 9000 zuzuordnen.

SSL-Zertifikate aktualisieren

SSL-Zertifikate sollten regelmäßig aktualisiert werden. Zum Aktualisieren von SSL-Zertifikaten führen Sie die folgenden Schritte aus:

Erstellen Sie neue Zertifikate und kopieren Sie sie wie in Schritt 1 oben beschrieben nach VM-Instanzen.
Kopieren Sie die neuen Zertifikate wie in Schritt 3 oben beschrieben in das Verzeichnis /etc/esp/ssl.
Beenden Sie den ESPv2-Container mit dem Befehl sudo docker run, wie in Schritt 4 oben beschrieben, und starten Sie ihn neu.

SSL-Port testen

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

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

Hinweis: Bei den folgenden Testbefehlen wird davon ausgegangen, dass der Server noch keinen vollständig qualifizierten Domainnamen (FQDN) hat und dass IP_ADDRESS bei der Generierung als FQDN verwendet wurde. selbst signiertes Zertifikat. Wenn der Server einen FQDN erhält, generieren Sie das Zertifikat mit dem FQDN. Ersetzen Sie dann IP_ADDRESS in den folgenden Beispielbefehlen durch den FQDN.
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