Wie Sie Ihre API mit Google Cloud Endpoints in Terraform bereitstellen

In diesem Blog konfigurieren wir Google Cloud Endpoints in Terraform, um API-Verwaltungsfunktionen wie Sicherheit, Überwachung und Quotenbegrenzung für die API unserer Anwendung bereitzustellen. Wir verwenden Terraform, um Ihnen zu helfen, die beteiligten Komponenten zu verstehen und die Endpunkte in Aktion zu sehen.
Es gibt zwei Möglichkeiten, wie wir Cloud Endpoints nutzen können: Zum einen können wir die APIs direkt in Google App Engine erstellen, zum anderen können wir eine bestehende Anwendung mit dem Google Cloud Endpoints Proxy, auch bekannt als Extensible Service Proxy, vorschalten. In diesem Blog stellen wir unsere Beispielanwendung mit einer Open API-Spezifikation unter Verwendung dieses Proxys dar.

Unsere API über Google Cloud Endpunkte zugänglich machen

Um unsere API über Google Cloud Endpoints zugänglich zu machen, müssen wir nur Folgendes tun:

1. Erstellen Sie die Open API-Spezifikation
2. Erstellen Sie einen Google-Dienst-Endpunkt
3. Konfigurieren Sie den Proxy für unser Backend
   

Erstellen Sie die Open API-Spezifikation

Zunächst erstellen wir die offene API-Spezifikation für unser Backend. Diese Datei ist besser bekannt als Swagger-Datei. Sie gibt alle HTTP-Operationen, Pfade sowie Anfrage- und Antworttypen an, die von der Schnittstelle unterstützt werden. Eine der einfachsten Möglichkeiten, dies zu tun, ist die Verwendung des Swagger-Editors.

Erstellen Sie einen Google-Dienst-Endpunkt

Als nächstes erstellen wir einen API-Dienst-Endpunkt. Der Dienst benötigt einen weltweit eindeutigen DNS-Namen. Wir können unseren eigenen verwenden oder einen im Format .endpoints..cloud.goog. Im letzteren Fall fügt Google unseren Endpunkt in die von Google verwaltete, gehostete Zone von .cloud.goog ein.

resource "Google_endpoints_service" "paas-monitor" {
  service_name   = "paas-monitor.endpoints.${var.project}.cloud.goog"
  openapi_config = "${data.template_file.open-api-specification.rendered}"
}

Damit das Endpoints Developer Portal funktioniert, müssen der Servicename und die globale IP-Adresse des Load Balancers in der Swagger-Datei im Feld host und im Objekt x-Google-endpoints angegeben werden:

swagger: "2.0"
host: ${service_name}
x-Google-endpoints:
    - name: ${service_name}
      target: ${ip_address}

Die eigentlichen Werte werden mit dem Terraform-Vorlagenkonstrukt übergeben:

data "template_file" "open-api-specification" {
  template = "${file("paas-monitor-api.yaml")}"

  vars {
    service_name = "paas-monitor.endpoints.${var.project}.cloud.goog"
    ip_address = "${Google_compute_global_address.paas-monitor.address}"
  }
}

Konfigurieren Sie den Proxy für unser Backend

Schließlich konfigurieren wir den Proxy für unser Backend. Dazu starten wir den Proxy auf dem ursprünglichen Listen-Port 1337 und geben das ursprüngliche Backend für den Service-Endpunkt an, wie unten im Startskript der VMs gezeigt.

docker network create --driver bridge app-net

docker run -d 
        --net app-net 
        --name paas-monitor 
        --env 'MESSAGE=gcp at ${region}' 
        --env RELEASE=v3.1.0 
        --restart unless-stopped 
        mvanholsteijn/paas-monitor:3.1.0

docker run -d 
        --net app-net 
        -p 1337:8080 
        --restart unless-stopped 
        gcr.io/endpoints-release/endpoints-runtime:1 
                --service=${service_name} 
                --rollout_strategy=managed 
                --backend=paas-monitor:1337

Es wird ein separates Docker-Netzwerk verwendet, damit der Proxy die Backend-Anwendung über ihren DNS-Namen finden kann, ohne den paas-monitor selbst offenzulegen.

Hinzufügen einer Frontend-Anwendung

Jetzt, wo der Proxy dem Backend vorangestellt ist, schlagen normale HTTP-Server-Anfragen fehl. Nur Anfragen, die der Open API-Spezifikation entsprechen, sind erlaubt:

curl localhost:1337/index.html
{
 "code": 5,
 "message": "Method does not exist.",
 "details": [
  {
   "@type": "type.Googleapis.com/Google.rpc.DebugInfo",
   "stackEntries": [],
   "detail": "service_control"
  }
 ]
}

Um dieses Problem zu lösen, legen wir den Inhalt der Website in einem Google-Speicher-Bucket ab, wie unten abgebildet.

Die Frontend-Anwendung wird über das Google Content Delivery Network bereitgestellt, wie in unserem vorherigen Blog beschrieben.

Installation

Um diese Anwendung zu installieren, installieren Sie terraform, erstellen Sie ein Google-Projekt und konfigurieren Sie Ihr gcloud SDK so, dass es darauf verweist.
Führen Sie dann die folgenden Befehle aus:

git clone https://github.com/binxio/blog-how-to-expose-your-api-using-google-cloud-endpoints.git
cd blog-how-to-expose-your-api-using-google-cloud-endpoints

GOOGLE_PROJECT=$(gcloud config get-value project)
terraform init
terraform apply -auto-approve
open http://$(terraform output ip-address)

Es kann ein paar Minuten dauern, bis der Datenverkehr die Anwendung erreicht. Bis dahin können http 404 und 502 Fehler auftreten.

Service-Übersicht

In der Google Cloud Console finden wir die Übersicht über die Nutzung der API:

Entwickler-Konsole

Wenn die Google Endpoints-Entwicklerkonsole aktiviert ist, können Nutzer der API die Dokumentation lesen und die einzelnen Methoden ausprobieren.

Fazit

Die Verwendung von Google Cloud Endpoints ist eine sehr einfache Möglichkeit, benutzerdefinierten APIs Sicherheit, Überwachung und Kontingentbegrenzung hinzuzufügen. Alles, was Sie brauchen, ist ein Upload der Definition der Anwendungsschnittstelle und der Google Cloud Endpoint Proxy vor Ihrer Anwendung.
Wir haben eine Backend-Anwendung mit einer Open API-Spezifikation ausgesetzt, die in Google Compute Engine läuft. Der Prozess für Kubernetes und Google App Engine ist etwas anders. Lesen Sie die Dokumentation für weitere Details.
Beim nächsten Mal werden wir unsere API mit einer Authentifizierung versehen.