Erste Schritte mit Endpoints für GKE mit ESPv2

In dieser Anleitung wird beschrieben, wie Sie einen einfachen gRPC-Beispieldienst mit dem Extensible Service Proxy V2 (ESPv2) in Google Kubernetes Engine (GKE) bereitstellen. Dafür wird hier die Python-Version des Beispiels bookstore-grpc verwendet. gRPC-Beispiele in anderen Sprachen finden Sie unter Weitere Informationen.

In der Anleitung werden vorkonfigurierte Container-Images des Beispielcodes und des ESPv2 verwendet, die in Container Registry gespeichert sind. Wenn Sie nicht mit Containern vertraut sind, finden Sie im Folgenden weitere Informationen:

Eine Übersicht über Cloud Endpoints finden Sie in den Abschnitten Über Cloud Endpoints und Architekturübersicht zu Cloud Endpoints.

Ziele

Orientieren Sie sich beim Durcharbeiten der Anleitung an der folgenden Aufgabenliste. Alle Aufgaben sind erforderlich, um Anfragen sicher an die API senden zu können.

  1. Ein Google Cloud-Projekt einrichten und die erforderliche Software herunterladen. Siehe Vorbereitung.
  2. Dateien aus dem Beispiel bookstore-grpc kopieren und konfigurieren. Siehe Endpoints konfigurieren.
  3. Die Endpoints-Konfiguration bereitstellen, um einen Endpoints-Dienst zu erstellen: Siehe Endpoints-Konfiguration bereitstellen.
  4. Ein Back-End für die API erstellen und die API bereitstellen. Siehe API-Back-End bereitstellen.
  5. Rufen Sie die externe IP-Adresse des Diensts ab. Siehe Externe IP-Adresse des Diensts abrufen.
  6. Senden Sie eine Anfrage an die API. Siehe Anfrage an die API senden.
  7. Vermeiden Sie Gebühren, die Ihrem Google Cloud-Konto in Rechnung gestellt werden. Siehe Bereinigen.

Kosten

In dieser Anleitung werden die folgenden kostenpflichtigen Komponenten von Google Cloud verwendet:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss dieser Anleitung können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

  1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.
  2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  4. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  5. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  6. Notieren Sie sich die Google Cloud-Projekt-ID, da sie später benötigt wird.
  7. Installieren und initialisieren Sie das Cloud SDK.
  8. Aktualisieren Sie das Cloud SDK und installieren Sie die Endpoints-Komponenten.
    gcloud components update
  9. Das Cloud SDK (gcloud) muss berechtigt sein, auf Ihre Daten und Dienste auf Google Cloud zuzugreifen:
    gcloud auth login
    Ein neuer Browsertab wird geöffnet und Sie werden aufgefordert, ein Konto auszuwählen.
  10. Legen Sie für das Standardprojekt Ihre Projekt-ID fest:
    gcloud config set project YOUR_PROJECT_ID

    Ersetzen Sie YOUR_PROJECT_ID durch Ihre Projekt-ID.

    Wenn Sie weitere Google Cloud-Projekte mit gcloud verwalten möchten, lesen Sie Cloud SDK-Konfigurationen verwalten.

  11. Installieren Sie kubectl:
    gcloud components install kubectl
  12. Rufen Sie neue Nutzeranmeldedaten ab, die als Standardanmeldedaten für die Anwendung verwendet werden sollen. Die Nutzeranmeldedaten werden zur Autorisierung von kubectl benötigt.
    gcloud auth application-default login
    Ein neuer Browsertab wird geöffnet. Wählen Sie dort ein Konto aus.
  13. Installieren Sie gRPC und die gRPC-Tools. Informationen dazu finden Sie in der Schnellstartanleitung für gRPC Python.

Endpoints konfigurieren

Das Beispiel bookstore-grpc enthält die Dateien, die Sie lokal kopieren und konfigurieren müssen.

  1. Erstellen Sie aus der Datei .proto Ihres Dienstes eine abgeschlossene protobuf-Deskriptordatei:
    1. Speichern Sie eine Kopie von bookstore.proto aus dem Beispiel-Repository. Diese Datei definiert die API für den Bookstore-Dienst.
    2. Erstellen Sie das folgende Verzeichnis: mkdir generated_pb2
    3. Erstellen Sie die Deskriptordatei api_descriptor.pb mit dem Protokollpuffercompiler protoc. Führen Sie den folgenden Befehl in dem Verzeichnis aus, in dem Sie bookstore.proto gespeichert haben:
      python -m grpc_tools.protoc \
          --include_imports \
          --include_source_info \
          --proto_path=. \
          --descriptor_set_out=api_descriptor.pb \
          --python_out=generated_pb2 \
          --grpc_python_out=generated_pb2 \
          bookstore.proto
      

      Im vorherigen Befehl ist --proto_path auf das aktuelle Arbeitsverzeichnis festgelegt. Wenn Sie in Ihrer gRPC-Build-Umgebung ein anderes Verzeichnis für .proto-Eingabedateien verwenden, ändern Sie --proto_path entsprechend, sodass der Compiler das Verzeichnis mit der gespeicherten bookstore.proto-Datei durchsucht.

  2. Erstellen Sie eine gRPC API-Konfigurationsdatei in YAML:
    1. Speichern Sie eine Kopie der Datei api_config.yaml. Diese Datei definiert die gRPC API-Konfiguration für den Bookstore-Dienst.
    2. Ersetzen Sie MY_PROJECT_ID in Ihrer Datei api_config.yaml durch Ihre Google Cloud-Projekt-ID. Beispiel:
      #
      # Name of the service configuration.
      #
      name: bookstore.endpoints.example-project-12345.cloud.goog
      

      Beachten Sie, dass der Wert des Feldes apis.name in dieser Datei exakt mit dem vollständig qualifizierten API-Namen aus der Datei .proto übereinstimmt. Andernfalls würde die Bereitstellung nicht funktionieren. Der Bookstore-Dienst ist in bookstore.proto im Paket endpoints.examples.bookstore definiert. Der vollständig qualifizierte API-Name lautet endpoints.examples.bookstore.Bookstore, genau wie er in der Datei api_config.yaml angezeigt wird.

      apis:
        - name: endpoints.examples.bookstore.Bookstore
      

Weitere Informationen finden Sie unter Cloud Endpoints konfigurieren.

Endpoints-Konfiguration bereitstellen

Die Endpoints-Konfiguration wird mit dem Befehl gcloud endpoints services deploy bereitgestellt. Dieser Befehl erstellt mithilfe von Service Management einen verwalteten Dienst.

  1. Sie müssen sich in dem Verzeichnis befinden, in dem die Dateien api_descriptor.pb und api_config.yaml liegen.
  2. Vergewissern Sie sich, dass das aktuell vom gcloud-Befehlszeilentool verwendete Standardprojekt das Google Cloud-Projekt ist, für das Sie die Endpoints-Konfiguration bereitstellen möchten. Überprüfen Sie anhand der vom folgenden Befehl zurückgegebenen Projekt-ID, ob der Dienst im richtigen Projekt erstellt wird.
    gcloud config list project
    

    Wenn Sie das Standardprojekt ändern müssen, führen Sie den folgenden Befehl aus:

    gcloud config set project YOUR_PROJECT_ID
    
  3. Stellen Sie die Datei proto descriptor und die Konfigurationsdatei mithilfe des Befehlszeilentools gcloud bereit:
    gcloud endpoints services deploy api_descriptor.pb api_config.yaml
    

    Beim Erstellen und Konfigurieren des Diensts gibt Service Management Informationen an das Terminal aus. Nach Abschluss der Bereitstellung erhalten Sie eine Meldung, die in etwa so aussieht:

    Service Configuration [CONFIG_ID] uploaded for service [bookstore.endpoints.example-project.cloud.goog]

    CONFIG_ID ist die eindeutige Endpoints-Dienstkonfigurations-ID, die von der Bereitstellung erstellt wird. Beispiel:

    Service Configuration [2017-02-13r0] uploaded for service [bookstore.endpoints.example-project.cloud.goog]
    

    Im obigen Beispiel ist 2017-02-13r0 die Dienstkonfigurations-ID und bookstore.endpoints.example-project.cloud.goog der Dienstname. Die Dienstkonfigurations-ID besteht aus einem Datumsstempel und einer Überarbeitungsnummer. Wenn Sie die Endpoints-Konfiguration am selben Tag noch einmal bereitstellen, erhöht sich die Überarbeitungsnummer in der Dienstkonfigurations-ID.

Erforderliche Dienste prüfen

Für Endpoints und ESP müssen mindestens die folgenden Google-Dienste aktiviert sein:
Name Titel
servicemanagement.googleapis.com Service Management API
servicecontrol.googleapis.com Service Control API
endpoints.googleapis.com Google Cloud Endpoints

In der Regel werden die erforderlichen Dienste mit dem Befehl gcloud endpoints services deploy aktiviert. Unter folgenden Umständen kann es vorkommen, dass der Befehl gcloud erfolgreich ausgeführt wird, die erforderlichen Dienste jedoch nicht aktiviert werden:

  • Wenn Sie eine Drittanbieteranwendung wie Terraform verwendet haben und Sie diese Dienste nicht hinzufügen.

  • Wenn Sie die Endpoints-Konfiguration für ein vorhandenes Google Cloud-Projekt bereitgestellt haben, in dem diese Dienste explizit deaktiviert wurden.

Prüfen Sie mit dem folgenden Befehl, ob die erforderlichen Dienste aktiviert sind:

gcloud services list

Wenn die erforderlichen Dienste nicht aufgeführt sind, müssen Sie sie aktivieren:

gcloud services enable servicemanagement.googleapis.com
gcloud services enable servicecontrol.googleapis.com
gcloud services enable endpoints.googleapis.com

Aktivieren Sie auch Ihren Endpoints-Dienst:

gcloud services enable ENDPOINTS_SERVICE_NAME

Zum Ermitteln des ENDPOINTS_SERVICE_NAME haben Sie folgende Möglichkeiten:

  • Rufen Sie nach der Bereitstellung der Endpoints-Konfiguration die Seite Endpoints in der Cloud Console auf. Die Liste der möglichen ENDPOINTS_SERVICE_NAME wird in der Spalte Dienstname angezeigt.

  • Bei OpenAPI ist ENDPOINTS_SERVICE_NAME der Wert, den Sie im Feld host Ihrer OpenAPI-Spezifikation angegeben haben. Bei gRPC ist der ENDPOINTS_SERVICE_NAME das, was Sie im Feld name Ihrer gRPC-Endpoints-Konfiguration angegeben haben.

Weitere Informationen zu den gcloud-Befehlen finden Sie unter gcloud-Dienste.

Wenn Sie eine Fehlermeldung erhalten, lesen Sie Fehlerbehebung bei der Cloud Endpoints-Konfigurationsbereitstellung.

Weitere Informationen finden Sie unter Endpoints-Konfiguration bereitstellen.

API-Back-End bereitstellen

Bisher haben Sie die API-Konfiguration für Service Management, aber noch nicht den Code für das API-Back-End bereitgestellt. In diesem Abschnitt werden die Schritte zum Erstellen eines GKE-Clusters beschrieben, mit dem das API-Back-End gehostet und die API bereitgestellt wird.

Containercluster erstellen

Der Cluster benötigt einen IP-Alias, um das containernative Load-Balancing zu verwenden. So erstellen Sie einen Containercluster mit einem IP-Alias für unser Beispiel:

gcloud container clusters create espv2-demo-cluster \
    --enable-ip-alias \
    --create-subnetwork="" \
    --network=default \
    --zone=us-central1-a

Mit dem obigen Befehl wird der Cluster espv2-demo-cluster mit einem automatisch bereitgestellten Subnetzwerk in der Zone us-central1-a erstellt.

kubectl beim Container-Cluster authentifizieren

Wenn Sie Clusterressourcen mit kubectl erstellen und verwalten möchten, müssen Sie Clusteranmeldedaten anfordern und in kubectl angeben. Dazu führen Sie folgenden Befehl aus und ersetzen NAME durch den neuen Clusternamen und ZONE durch dessen Clusterzone.

gcloud container clusters get-credentials NAME --zone ZONE

Erforderliche Berechtigungen prüfen

ESP und ESPv2 ruft Google-Dienste auf, die mit IAM prüfen, ob die aufrufende Identität ausreichende Berechtigungen für den Zugriff auf die verwendeten IAM-Ressourcen hat. Die aufrufende Identität ist das angehängte Dienstkonto, das ESP und ESPv2 bereitstellt.

Bei Bereitstellung im GKE-Pod ist das angehängte Dienstkonto das Knoten-Dienstkonto. Normalerweise ist dies das Compute Engine-Standarddienstkonto. Folgen Sie dieser Berechtigungsempfehlung, um ein geeignetes Knotendienstkonto auszuwählen.

Wenn Workload Identity verwendet wird, kann ein anderes Dienstkonto als das Knoten-Dienstkonto verwendet werden, um mit Google-Diensten zu kommunizieren. Sie können ein Kubernetes-Dienstkonto für den Pod erstellen, um ESP und ESPv2 auszuführen, ein Google-Dienstkonto erstellen und das Kubernetes-Dienstkonto dem Google-Dienstkonto zuordnen.

Folgen Sie dieser Anleitung, um ein Kubernetes-Dienstkonto mit einem Google-Dienstkonto zu verknüpfen. Dieses Google-Dienstkonto ist das angehängte Dienstkonto.

Wenn das angehängte Dienstkonto das Compute Engine-Standarddienstkonto des Projekts ist und die Konfiguration des Endpunktdienstes im selben Projekt bereitgestellt wird, sollte das Dienstkonto genügend Berechtigungen für den Zugriff auf die IAM-Ressourcen haben und der folgende Einrichtungsschritt für IAM-Rollen kann übersprungen werden. Andernfalls sollten Sie dem angehängten Dienstkonto folgende IAM-Rollen hinzufügen.

Erforderliche IAM-Rollen hinzufügen:

In diesem Abschnitt werden die von ESP und ESPv2 verwendeten IAM-Ressourcen beschrieben, sowie die IAM-Rollen, die das angehängte Dienstkonto benötigt, um auf diese Ressourcen zuzugreifen.

Endpoint-Dienstkonfiguration

ESP und ESPv2 rufen Service Control auf (nutzt die Endpunktdienst-Konfiguration). Die Endpunktdienst-Konfiguration ist eine IAM-Ressource. ESP und ESPv2 benötigen die Rolle Dienstüberwacher, um auf sie zuzugreifen.

Die IAM-Rolle gilt für die Endpunktdienst-Konfiguration, nicht für das Projekt. Ein Projekt kann mehrere Endpunktdienst-Konfigurationen haben.

Verwenden Sie folgenden gcloud-Befehl, um die Rolle dem angehängten Dienstkonto für die Endpunktdienst-Konfiguration hinzuzufügen.

gcloud endpoints services add-iam-policy-binding SERVICE_NAME \
                --member serviceAccount:SERVICE_ACCOUNT_NAME@DEPLOY_PROJECT_ID.iam.gserviceaccount.com \
                --role roles/servicemanagement.serviceController

Dabei ist
* SERVICE_NAME der Endpunkt-Dienstname
* SERVICE_ACCOUNT_NAME@DEPLOY_PROJECT_ID.iam.gserviceaccount.com das angehängte Dienstkonto.

Cloud Trace

ESP und ESPv2 rufen den Cloud Trace-Dienst auf, um Trace in ein Projekt zu exportieren. Dieses Projekt wird als Tracing-Projekt bezeichnet. In ESP sind das Tracing-Projekt und das Projekt, zu dem die Endpunktdienstkonfiguration gehört, identisch. In ESPv2 kann das Tracing-Projekt mit dem Flag --tracing_project_id angegeben werden und entspricht standardmäßig dem Bereitstellungsprojekt.

ESP und ESPv2 benötigen die Rolle Cloud Trace-Agent, um Cloud Trace zu aktivieren.

Verwenden Sie den folgenden gcloud-Befehl, um die Rolle dem angehängten Dienstkonto hinzuzufügen:

gcloud projects add-iam-policy-binding TRACING_PROJECT_ID \
                --member serviceAccount:SERVICE_ACCOUNT_NAME@DEPLOY_PROJECT_ID.iam.gserviceaccount.com \
                --role roles/cloudtrace.agent

Dabei ist
* TRACING_PROJECT_ID die Tracing-Projekt-ID
* SERVICE_ACCOUNT_NAME@DEPLOY_PROJECT_ID.iam.gserviceaccount.com ist das angehängte Dienstkonto. Weitere Informationen finden Sie unter Was sind Rollen und Berechtigungen?

SSL-Schlüssel und -Zertifikate konfigurieren

Das containernative Load-Balancing verwendet HTTP2-Load-Balancing, das TLS-verschlüsselt sein muss. Dazu muss ein TLS-Zertifikat für den GKE-Ingress und ESPv2 bereitgestellt werden. Sie können Ihr eigenes Zertifikat verwenden oder ein selbst signiertes Zertifikat verwenden.

  1. Mit openssl ein selbst signiertes Zertifikat und einen Schlüssel erstellen. Achten Sie darauf, dass Sie denselben FQDN bookstore.endpoints.MY_PROJECT_ID.cloud.goog eingegeben haben, wenn Sie nach "Common Name(CN)" gefragt werden. Dieser Name wird von den Clients verwendet, um das Serverzertifikat zu verifizieren.

    openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
    -keyout ./server.key -out ./server.crt
  2. Erstellen Sie mit Ihrem SSL-Schlüssel und -Zertifikat einen Kubernetes-Schlüssel: Beachten Sie, dass das Zertifikat an zwei Stellen kopiert wird, server.crt und tls.crt, da das Secret sowohl für GKE Ingress als auch für ESPv2 bereitgestellt wird. GKE Ingress sucht nach dem Zertifikatpfad tls.crt und ESPv2 sucht nach dem Zertifikatpfad server.crt.

    kubectl create secret generic esp-ssl \
    --from-file=server.crt=./server.crt --from-file=server.key=./server.key \
    --from-file=tls.crt=./server.crt --from-file=tls.key=./server.key

Beispiel-API und ESPv2 im Cluster bereitstellen

So stellen Sie den gRPC-Beispieldienst im Cluster bereit, damit Clients ihn verwenden können:

  1. git clone dieses Repository und öffnen Sie die Manifestdatei des Deployments grpc-bookstore.yaml, um sie zu bearbeiten.
  2. Ersetzen Sie SERVICE_NAME durch den Namen Ihres Endpoint-Dienstes für eingehenden Traffic und ESPv2-Container. Dies ist der Name, den Sie in der Datei api_config.yaml im Feld name konfiguriert haben.
    # Copyright 2016 Google Inc.
    #
    # Licensed under the Apache License, Version 2.0 (the "License");
    # you may not use this file except in compliance with the License.
    # You may obtain a copy of the License at
    #
    #     http://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing, software
    # distributed under the License is distributed on an "AS IS" BASIS,
    # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    # See the License for the specific language governing permissions and
    # limitations under the License
    
    # Use this file to deploy the container for the grpc-bookstore sample
    # and the container for the Extensible Service Proxy (ESP) to
    # Google Kubernetes Engine (GKE).
    
    apiVersion: networking.k8s.io/v1beta1
    kind: Ingress
    metadata:
      name: esp-grpc-bookstore
      annotations:
        kubernetes.io/ingress.class: "gce"
        kubernetes.io/ingress.allow-http: "false"
    spec:
      tls:
      - hosts:
        - SERVICE_NAME
        secretName: esp-ssl
      backend:
        serviceName: esp-grpc-bookstore
        servicePort: 443
    ---
    apiVersion: cloud.google.com/v1
    kind: BackendConfig
    metadata:
      name: esp-grpc-bookstore
    spec:
      healthCheck:
        type: HTTP2
        requestPath: /healthz
        port: 9000
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: esp-grpc-bookstore
      annotations:
        service.alpha.kubernetes.io/app-protocols: '{"esp-grpc-bookstore":"HTTP2"}'
        cloud.google.com/neg: '{"ingress": true, "exposed_ports": {"443":{}}}'
        cloud.google.com/backend-config: '{"default": "esp-grpc-bookstore"}'
    spec:
      ports:
      # Port that accepts gRPC and JSON/HTTP2 requests over TLS.
      - port: 443
        targetPort: 9000
        protocol: TCP
        name: esp-grpc-bookstore
      selector:
        app: esp-grpc-bookstore
      type: ClusterIP
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: esp-grpc-bookstore
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: esp-grpc-bookstore
      template:
        metadata:
          labels:
            app: esp-grpc-bookstore
        spec:
          volumes:
          - name: esp-ssl
            secret:
              secretName: esp-ssl
          containers:
          - name: esp
            image: gcr.io/endpoints-release/endpoints-runtime:2
            args: [
              "--listener_port=9000",
              "--service=SERVICE_NAME",
              "--rollout_strategy=managed",
              "--backend=grpc://127.0.0.1:8000",
              "--healthz=/healthz",
              "--ssl_server_cert_path=/etc/esp/ssl",
            ]
            ports:
              - containerPort: 9000
            volumeMounts:
            - mountPath: /etc/esp/ssl
              name:  esp-ssl
              readOnly: true
          - name: bookstore
            image: gcr.io/endpointsv2/python-grpc-bookstore-server:1
            ports:
              - containerPort: 8000
    

    Mit der Option --rollout_strategy=managed legen Sie fest, dass der ESPv2 die zuletzt bereitgestellte Dienstkonfiguration verwendet. Wenn Sie diese Option angeben, erkennt der ESPv2 innerhalb einer Minute nach Bereitstellung einer neuen Dienstkonfiguration die Änderung und verwendet automatisch die neue Konfiguration. Wir empfehlen, diese Option festzulegen, anstatt eine bestimmte Konfigurations-ID anzugeben, die von ESPv2 verwendet werden soll. Weitere Informationen zu ESPv2-Argumenten finden Sie unter ESPv2-Startoptionen.

    Beispiel:

        spec:
          containers:
          - name: esp
            image: gcr.io/endpoints-release/endpoints-runtime:2
            args: [
              "--listener_port=9000",
              "--service=bookstore.endpoints.example-project-12345.cloud.goog",
              "--rollout_strategy=managed",
              "--backend=grpc://127.0.0.1:8000"
            ]
    
  3. Dienst starten:
    kubectl create -f grpc-bookstore.yaml
    

Wenn Sie eine Fehlermeldung erhalten, lesen Sie die Informationen unter Fehlerbehebung bei Endpoints in GKE.

Externe IP-Adresse des Diensts abrufen

Sie benötigen die externe IP-Adresse des Diensts, um Anfragen an die Beispiel-API senden zu können. Nach dem Start Ihres Diensts im Container kann es einige Minuten dauern, bevor die externe IP-Adresse bereit ist.

  1. Rufen Sie die externe IP-Adresse auf:

    kubectl get ingress

  2. Notieren Sie sich den Wert für EXTERNAL-IP und speichern Sie ihn in der Umgebungsvariablen SERVER_IP. Die externe IP-Adresse wird verwendet, um Anforderungen an die Beispiel-API zu senden.

    export SERVER_IP=YOUR_EXTERNAL_IP
    

Anfrage an die API senden

Zum Senden von Requests an die Beispiel-API können Sie einen gRPC-Beispielclient verwenden, der in Python geschrieben wurde.

  1. Klonen Sie das Git-Repository an dem Ort, an dem der gRPC-Clientcode gehostet wird:

    git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
       

  2. Ändern Sie Ihr Arbeitsverzeichnis:

    cd python-docs-samples/endpoints/bookstore-grpc/
      

  3. Installieren Sie die Abhängigkeiten:

    pip install virtualenv
    virtualenv env
    source env/bin/activate
    python -m pip install -r requirements.txt
    

  4. Stamm-CA für das selbst signierte Zertifikat erstellen

    openssl x509 -in server.crt -out client.pem -outform PEM
      

  5. Senden Sie eine Anfrage an die Beispiel-API:

    python bookstore_client.py --host SERVER_IP --port 443 \
    --servername bookstore.endpoints.MY_PROJECT_ID.cloud.goog --use_tls true --ca_path=client.pem
    
    • Sehen Sie sich auf der Seite Endpoints > Dienste die Aktivitätsgrafiken für Ihre API an.

      Endpoints-Dienste aufrufen

      Es kann einige Momente dauern, bis die Anfrage in den Grafiken angezeigt wird.

    • Sehen Sie sich auf der Seite "Log-Anzeige" die Anfrage-Logs an.

      Zur Seite „Log-Explorer“

Wenn Sie als Antwort einen Fehler erhalten haben, lesen Sie die Informationen unter Fehlerbehebung bei Antwortfehlern.

Sie haben gerade eine API in Cloud Endpoints bereitgestellt und getestet!

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

  1. Löschen Sie die API:

    gcloud endpoints services delete SERVICE_NAME
    

    Ersetzen Sie SERVICE_NAME durch den Namen der API.

  2. Löschen Sie den GKE-Cluster:

    gcloud container clusters delete NAME --zone ZONE
    

Weitere Informationen

  • Erfahren Sie, wie Sie für Cloud Endpoints Ihren eigenen gRPC API-Dienst konfigurieren.
  • Bookstore-Beispiel auf GitHub genauer ansehen. Sowohl der Client als auch der Server sind in Python und Java verfügbar.
  • Das Beispiel getting-started-grpc ist auf GitHub in den folgenden Sprachen verfügbar: