Einfachen API-Proxy erstellen

Diese Seite gilt für Apigee und Apigee Hybrid.

Apigee Edge-Dokumentation aufrufen

Hinweis: In Umgebungen, für die Archivbereitstellungen aktiviert sind, können Sie keine API-Proxys mithilfe der Apigee-UI, der API oder mit gcloud erstellen. Informationen zum Erstellen von API-Proxys für Archivbereitstellungen mit Apigee in VS Code finden Sie unter API-Proxys mit Apigee in VS Code entwickeln.

Mit Apigee können Sie Backend-Dienste mühelos über APIs verfügbar machen. Dazu erstellen Sie einen API-Proxy als Fassade für den Back-End-Dienst, auf den Sie den Zugriff ermöglichen möchten. Sie müssen nur die Netzwerkadresse für den Back-End-Dienst sowie einige Informationen angeben, mit denen Apigee den API-Proxy erstellt, der für Entwickler verfügbar ist.

Der API-Proxy entkoppelt die Implementierung Ihres Back-End-Diensts von der API, die die Entwickler verwenden. Damit sind die Entwickler vor zukünftigen Änderungen an Ihren Back-End-Diensten abgeschirmt. Wenn Sie die Back-End-Dienste aktualisieren, sind die Entwickler von diesen Änderungen nicht betroffen und können die API weiterhin ohne Unterbrechung aufrufen.

Dieses Thema enthält Informationen zu den verschiedenen Proxytypen und den Einstellungen für sie. Schritt-für-Schritt-Anleitungen zum Erstellen von Proxys finden Sie unter folgenden Themen:

• Anleitung: Erstellen Sie Ihren ersten API-Proxy
• API-Proxy erstellen

Hinweis: Das folgende Video zeigt den klassischen Proxy-Editor in der Apigee-UI. Apigee führt eine neue Version des Proxy-Editors ein, die ein anderes Design als die im Video gezeigte klassische Version hat.

API-Proxy mithilfe der Benutzeroberfläche erstellen

Die einfachste Methode zum Erstellen eines API-Proxys ist die Verwendung des Assistenten zum Erstellen von Proxys.

Führen Sie folgende Schritte aus, um über die Apigee-UI auf den Assistenten zum Erstellen von Proxys zuzugreifen:

1. Melden Sie sich bei der Apigee-UI an.
2. Wählen Sie in der Navigationsleiste Entwickeln > API Proxies aus.
3. Klicken Sie auf Neu erstellen.
   

Der Assistent zum Erstellen von Proxys wird angezeigt. Er führt Sie durch die Schritte zum Generieren und Hinzufügen kleiner Features zu einem API-Proxy.

Auf der ersten Seite des Assistenten können Sie einen API-Proxy aus den folgenden Quellen erstellen:

Typ	Beschreibung
Reverse-Proxy (häufigste Quelle)	Ein API-Proxy, der eingehende Anfragen an vorhandene HTTP-Back-End-Dienste weiterleitet. Dies kann eine JSON- oder XML API sein. Weitere Informationen finden Sie weiter unten in diesem Abschnitt unter Reverse Proxy für einen HTTP-Dienst erstellen. Klicken Sie auf OpenAPI-Spezifikation verwenden, um den Proxy aus einer gültigen OpenAPI-Spezifikation zu generieren. Weitere Informationen zu dieser Option finden Sie weiter unten in diesem Abschnitt unter OpenAPI-Spezifikationen zum Generieren von Proxys verwenden.
Kein Ziel	Ein API-Proxy ohne API-Back-End ("kein Ziel"). Ähnlich wie beim Erstellen eines Reverse-Proxys für einen HTTP-Dienst, mit dem Unterschied, dass Sie beim Definieren der API-Proxydetails keine vorhandene API angeben. Klicken Sie auf OpenAPI-Spezifikation verwenden, um den Proxy aus einer gültigen OpenAPI-Spezifikation zu generieren. Weitere Informationen zu dieser Option finden Sie weiter unten in diesem Abschnitt unter OpenAPI-Spezifikationen zum Generieren von Proxys verwenden.
Proxy-Bundle hochladen	Ein vorhandenes API-Proxy-Bundle, z. B. einer der API-Proxys, die auf GitHub verfügbar sind. Siehe API-Proxy aus einem API-Proxy-Bundle importieren.

In den folgenden Abschnitten werden die Details der einzelnen Proxytypen erläutert.

Reverse-Proxy für einen HTTP-Dienst erstellen

Apigee generiert Reverse-Proxys anhand der folgenden Informationen:

• URL des Back-End-Dienstes
• URI-Pfad, durch den sich die API eindeutig identifizieren lässt, die vom API-Proxy für Verbraucheranwendungen verfügbar gemacht wird.

Die Back-End-Dienst-URL stellt in der Regel eine dienstfähige Anwendung dar, die Ihrer Organisation gehört. Sie kann auch auf eine öffentlich verfügbare API verweisen. Die API oder der Dienst kann von Ihnen gesteuert werden (z. B. eine interne HR-Anwendung oder eine Rails-Anwendung in der Cloud) oder eine API bzw. ein Dienst eines Drittanbieters (z. B. Twitter oder Instagram).

Die folgenden Proxydetails sind nach dem Zugriff auf Proxy-Assistenten erstellen und nach der Auswahl eines Proxy-Typs verfügbar:

Feld	Beschreibung
Name	Für Ihre API angezeigter Name. Geben Sie alphanumerische Zeichen, einen Bindestrich (-) oder Unterstrich (_) ein.
Basispfad	URI-Fragment, das nach der Adresse http://[host] oder https://[host] des API-Proxys angezeigt wird. Apigee verwendet den Basispfad-URI, um eingehende Anfragenachrichten mit dem passenden API-Proxy abzugleichen und zu diesem weiterzuleiten. Hinweis: Der API-Proxy-Basispfad ist standardmäßig auf den Wert eingestellt, der für das in Kleinbuchstaben konvertierte Feld Name angegeben ist. Alle zusätzlichen Ressourcen-URLs folgen dem Basispfad. Die vollständige URL-Struktur, mit der Clients Ihren API-Proxy aufrufen, sieht so aus: https://[host]/BASE_PATH/CONDITIONAL_FLOW_PATH Hinweis: Der Basispfad muss eindeutig sein. Sie können nicht zwei API-Proxys mit demselben Basispfad bereitstellen. Wenn Sie einen bereitgestellten API-Proxy bearbeiten und den Basispfad auf denselben Wert wie den Basispfad eines anderen API-Proxys festlegen, wird die Bereitstellung des API-Proxys beim Speichern automatisch von Apigee aufgehoben. Bevor Sie den API-Proxy wieder bereitstellen können, müssen Sie den Basispfad so ändern, dass er eindeutig ist. Platzhalter in Basispfaden verwenden Verwenden Sie einen oder mehrere /*/-Platzhalter in API-Proxy-Basispfaden, um Ihre API-Proxys zukunftssicher zu machen. Mit dem Basispfad /team/*/members können Clients beispielsweise https://[host]/team/blue/members und https://[host]/team/green/members aufrufen, ohne neue API-Proxys zur Unterstützung neuer Teams erstellen zu müssen. Beachten Sie, dass /**/ nicht unterstützt wird.
Beschreibung	Optional: Beschreibung der API.
Ziel (vorhandene API)	URL des Back-End-Dienstes, der von diesem API-Proxy aufgerufen wird.

API-Proxy aus einem API-Proxy-Set importieren

Hinweis: Beim Importieren eines API-Proxys aus einem API-Proxy-Bundle sind Sie für die Konfiguration der Sicherheit im Bundle und das Hinzufügen von Richtlinien zu diesem verantwortlich. In der Benutzeroberfläche werden Sie beim Importieren des Bundles nicht aufgefordert, Sicherheitsfunktionen oder Richtlinien hinzuzufügen. Weitere Informationen finden Sie weiter unten im Abschnitt Sicherheit erhöhen.

API-Proxys werden häufig zusammen mit einer Sammlung von XML-Dateien und weiteren unterstützenden Dateien definiert. Wenn Sie Ihre API-Proxys als eine Reihe von Dateien außerhalb von Apigee definieren, können Sie sie in einem Versionsverwaltungssystem verwalten und dann zum Testen und Bereitstellen in Apigee importieren.

Führen Sie die folgenden Schritte aus, um API-Proxys aus einem API-Proxy-Bundle zu importieren:

1. Greifen Sie auf den Assistenten zum Assistenten zum Erstellen von Proxys zu, wie unter API-Proxy mit der Benutzeroberfläche erstellen weiter oben in diesem Abschnitt beschrieben.
2. Klicken Sie auf Proxy-Bundle hochladen.

3. Geben Sie auf der Seite Proxy-Bundle hochladen im Proxy-Assistenten die folgenden Informationen ein.

   Feld	Beschreibung
   ZIP-Paket	ZIP-Datei mit der API-Proxy-Konfiguration. Sie können die Datei per Drag-and-drop einfügen oder die Datei mit einem Klick ansteuern.
   Name	Für Ihre API angezeigter Name. Standardmäßig der Name der ZIP-Datei ohne Erweiterung.

4. Klicken Sie auf Next (Weiter).

5. Wählen Sie auf der Seite Zusammenfassung die gewünschte Umgebung aus und klicken Sie auf Erstellen und bereitstellen.

   Es wird eine Bestätigung angezeigt, dass der neue API-Proxy erfolgreich erstellt wurde.

6. Klicken Sie auf Proxy bearbeiten, um die Detailseite für den API-Proxy aufzurufen.

gRPC API-Proxys erstellen

Zusätzlich zu den REST API-Proxys unterstützt Apigee aktuell nur gRPC API-Proxys mit Passthrough-Support. Im Passthrough-Support ist die gRPC-Nutzlast selbst in Apigee undurchsichtig und der Traffic wird vom gRPC-Client an den in der Zielkonfiguration vorkonfigurierten gRPC-Zielserver weitergeleitet.

Aktuell haben Apigee gRPC API-Proxys folgende Eigenschaften:

• Unterstützen unäre gRPC-Anfragen.
• Können keine Richtlinien verwenden, die sich auf die Nutzlast auswirken.
• Kann in API-Produkten verwendet werden, die nicht mit GraphQL- oder REST-Proxys verknüpft sind. API-produktspezifische Kontingente und andere Vorgangseinstellungen gelten für alle Proxys im Produkt.
• Werden in Apigee Hybrid nicht unterstützt.
• Verwenden zwei gRPC-spezifische Ablaufvariablen: request.grpc.rpc.name und request.grpc.service.name.
• Können mit folgenden gRPC-spezifischen Apigee Analytics-Variablen überwacht werden: x_apigee_grpc_rpc_name, x_apigee_grpc_service_name und x_apigee_grpc_status.
• Geben gRPC-Statuscodes zurück.

Sie müssen außerdem den Load-Balancer so konfigurieren, dass er gRPC unterstützt. Weitere Informationen finden Sie unter gRPC mit Ihren Anwendungen verwenden und gcloud CLI-Befehle zum Erstellen von Routing für gRPC verwenden.

Um einen gRPC API-Proxy zu erstellen, definieren Sie zuerst einen gRPC-Zielserver (siehe Zielserver erstellen) und geben dann diesen Zielserver bei der Erstellung des neuen Proxys an.

Hinweis: Die gRPC-Proxy-Konfiguration über die Apigee-UI wird nur über die Apigee-UI in der Cloud Console und nicht über andere Apigee-Konsolen unterstützt.

Routings für gRPC mit gcloud CLI-Befehlen erstellen

In diesem Abschnitt werden Beispielbefehle für das Erstellen von Routings für gRPC-Proxys mit der gcloud-CLI gezeigt. Die Anleitung umfasst das Einrichten von Load-Balancern, Zielserver und einer MIG.

Dieser Abschnitt ist keine umfassende Anleitung zum Erstellen des Routings. Die Beispiele sind möglicherweise nicht für alle Anwendungsfälle geeignet. Außerdem wird in dieser Anleitung davon ausgegangen, dass Sie mit dem externen Routing (MIG) und der gRPC-Konfiguration des Cloud-Load-Balancers vertraut sind.

Umgebungsvariablen festlegen

Diese Umgebungsvariablen werden in den Befehlen der Unterabschnitte verwendet.

PROJECT_ID=YOUR_PROJECT_ID
MIG_NAME=YOUR_MIG_NAME
VPC_NAME=default
VPC_SUBNET=default
REGION=REGION_NAME
APIGEE_ENDPOINT=ENDPOINT
CERTIFICATE_NAME=CERTIFICATE_NAME
DOMAIN_HOSTNAME=DOMAIN_HOSTNAME

Beispielbefehle der gcloud CLI zum Erstellen von Routings für gRPC-Proxys mit neuen Load-Balancern

In diesem Abschnitt finden Sie Beispielbefehle zum Erstellen von gRPC-Proxys mit der gcloud CLI und einem neuen Load-Balancer. In der Anleitung werden der Load-Balancer, ein Zielserver und eine MIG eingerichtet.

Instanzvorlage erstellen

gcloud compute instance-templates create $MIG_NAME \
--project $PROJECT_ID \
--region $REGION \
--network $VPC_NAME \
--subnet $VPC_SUBNET \
--tags=https-server,apigee-mig-proxy,gke-apigee-proxy \
--machine-type e2-medium --image-family debian-10 \
--image-project debian-cloud --boot-disk-size 20GB \
--no-address \
--metadata ENDPOINT=$APIGEE_ENDPOINT,startup-script-url=gs://apigee-5g-saas/apigee-envoy-proxy-release/latest/conf/startup-script.sh

Verwaltete Instanzgruppe erstellen

gcloud compute instance-groups managed create $MIG_NAME \
--project $PROJECT_ID --base-instance-name apigee-mig \
--size 2 --template $MIG_NAME --region $REGION

Autoscaling konfigurieren

gcloud compute instance-groups managed set-autoscaling $MIG_NAME \
--project $PROJECT_ID --region $REGION --max-num-replicas 50 \
--target-cpu-utilization 0.75 --cool-down-period 90

Benannten Port definieren

gcloud compute instance-groups managed set-named-ports $MIG_NAME \
--project $PROJECT_ID --region $REGION --named-ports https:443

Von Google verwaltetes SSL-Zertifikat und Schlüssel für den Load-Balancer erstellen

gcloud compute ssl-certificates create $CERTIFICATE_NAME \
--domains=$DOMAIN_HOSTNAME \
--project $PROJECT_ID \
--global

Prüfen, ob das Zertifikat bereitgestellt wurde

gcloud compute ssl-certificates describe $CERTIFICATE_NAME \
--global \
--format="get(name,managed.status, managed.Status)"

Globalen Cloud-Load-Balancer (GCLB) erstellen

1. Systemdiagnose erstellen
   

   gcloud compute health-checks create https hc-apigee-envoy-443 \
   --project $PROJECT_ID --port 443 --global \
   --request-path /healthz/ingress

2. Backend-Dienst für http1
   erstellen

   gcloud compute backend-services create YOUR_BACKEND_1 \
   --project $PROJECT_ID \
   --protocol HTTPS \
   --health-checks hc-apigee-envoy-443 \
   --port-name https \
   --timeout 302s \
   --connection-draining-timeout 300s \
   --global

3. Backend-Dienst für http2
   erstellen

   gcloud compute backend-services create YOUR_BACKEND_2 \
   --project $PROJECT_ID \
   --protocol HTTP2 \
   --health-checks hc-apigee-envoy-443 \
   --port-name https \
   --timeout 302s \
   --connection-draining-timeout 300s \
   --global

4. Fügen Sie dem Backend-Dienst MIGs hinzu. In diesem Beispiel wird die MIG wiederverwendet. Sie können jedoch auch ein neues MIG-Paar erstellen.
   

   gcloud compute backend-services add-backend YOUR_BACKEND_1 \
   --project $PROJECT_ID --instance-group $MIG_NAME \
   --instance-group-region $REGION \
   --balancing-mode UTILIZATION --max-utilization 0.8 --global

   gcloud compute backend-services add-backend YOUR_BACKEND_2 \
   --project $PROJECT_ID --instance-group $MIG_NAME \
   --instance-group-region $REGION \
   --balancing-mode UTILIZATION --max-utilization 0.8 --global

5. Erstellen Sie eine URL-Zuordnung für das Load-Balancing. Prüfen Sie zuerst, ob Sie bereits eine URL-Zuordnung haben. In diesem Fall müssen Sie diese Zuordnung gemäß den unten aufgeführten Anforderungen ändern, statt sie zu überschreiben.
   

   Erstellen Sie eine YAML-Datei oder verwenden Sie Ihre vorhandene Datei unter /tmp/apigee-map.yaml mit dieser Konfiguration. Beachten Sie, dass das HTTP1-Backend der URL-Zuordnung standardmäßig vorhanden ist.

   defaultService: projects/$PROJECT_ID/global/backendServices/YOUR_BACKEND_1
   name: matcher1
   routeRules:
   - matchRules:
   - headerMatches:
   - headerName: Content-Type
   prefixMatch: application/grpc
   prefixMatch: /
   priority: 100
   routeAction:
   weightedBackendServices:
   - backendService: projects/$PROJECT_ID/global/backendServices/YOUR_BACKEND_2
   weight: 100

   Validieren Sie die URL-Zuordnung.

   gcloud compute url-maps validate --source /tmp/apigee-map.yaml --project $PROJECT_ID

   Erstellen Sie die URL-Zuordnung mit headerbasiertem Routing:

   gcloud compute url-maps import apigee-http1-http2 \
   --source /tmp/apigee-map.yaml  \
   --global --project $PROJECT_ID

HTTPS-Proxy für das Load-Balancing erstellen

gcloud compute target-https-proxies create apigee-envoy-https-proxy \
--project $PROJECT_ID --url-map apigee-envoy-proxy-map \
--ssl-certificates $CERTIFICATE_NAME

Externe IPv4-Adresse reservieren und Firewallregeln für den Load-Balancer erstellen

gcloud compute addresses create lb-ipv4-vip-1 \
--project $PROJECT_ID \
--network-tier=PREMIUM \
--ip-version=IPV4 \
--global

  gcloud compute addresses describe lb-ipv4-vip-1 \
--project $PROJECT_ID --format="get(address)" --global

  gcloud compute forwarding-rules create apigee-envoy-https-lb-rule \
--project $PROJECT_ID --address lb-ipv4-vip-1 --global \
--target-https-proxy apigee-envoy-https-proxy --ports 443

Firewallregel erstellen

gcloud compute firewall-rules create k8s-allow-lb-to-apigee-envoy \
--description "Allow incoming from GLB on TCP port 443 to Apigee Proxy" \
--project $PROJECT_ID --network $VPC_NAME --allow=tcp:443 \
--source-ranges=130.211.0.0/22,35.191.0.0/16 --target-tags=gke-apigee-proxy

Beispiele für die gcloud-CLI-Befehle zum Erstellen von Routings für gRPC-Proxys für vorhandene Load-Balancer

In diesem Abschnitt finden Sie Beispielbefehle zum Erstellen von gRPC-Proxys mit der gcloud CLI und einem vorhandenen Load-Balancer. In der Anleitung werden der Load-Balancer, ein Zielserver und eine MIG eingerichtet.

Weiteren Backend-Dienst für http2 erstellen

# Create backend service for http2
    gcloud compute backend-services create YOUR_BACKEND_2 \
--project $PROJECT_ID \
--protocol HTTP2 \
--health-checks hc-apigee-envoy-443 \
--port-name https \
--timeout 302s \
--connection-draining-timeout 300s \
--global

Zweiten Backend-Dienst an die MIG anhängen

gcloud compute backend-services add-backend YOUR_BACKEND_2 \
--project $PROJECT_ID --instance-group $MIG_NAME \
--instance-group-region $REGION \
--balancing-mode UTILIZATION --max-utilization 0.8 --global

URL-Zuordnung für die vorhandene Apigee-GCLB auflisten

gcloud compute url-maps list -project $PROJECT_ID

Richtigen URL-Zuordnungsnamen für Apigee Load-Balancing übernehmen

gcloud compute url-maps export APIGEE_URL_MAP_NAME -project $PROJECT_ID

YAML-Datei für Load-Balancing-URL-Zuordnung erstellen

Wenn Sie bereits eine URL-Zuordnung haben, führen Sie diese Konfiguration mit jener zusammen. Erstellen Sie andernfalls eine YAML-Datei unter /tmp/apigee-map.yaml mit dieser Konfiguration.

defaultService: projects/dg-runtime-test1/global/backendServices/YOUR_BACKEND_1
name: matcher1
routeRules:
- matchRules:
- headerMatches:
- headerName: Content-Type
prefixMatch: application/grpc
prefixMatch: /
priority: 100
routeAction:
weightedBackendServices:
- backendService: projects/dg-runtime-test1/global/backendServices/YOUR_BACKEND_2
weight: 100

Neue YAML-Datei für gRPC-Routing anwenden

gcloud compute url-maps import APIGEE_URL_MAP_NAME\
--source /tmp/apigee-map.yaml  \
--global -project $PROJECT_ID

Sicherheit erhöhen

Wählen Sie auf der Seite Allgemeine Richtlinien des Assistenten Proxy erstellen den Typ der Sicherheitsautorisierung aus, die Sie hinzufügen möchten. In der folgenden Tabelle sind die verfügbaren Optionen zusammengefasst:

Sicherheitsautorisierung	Beschreibung
API-Schlüssel	Fügt dem von Ihnen definierten API-Proxy eine einfache API-Schlüsselüberprüfung hinzu. Als Antwort fügt die API-Plattform dem API-Proxy eine VerifyAPIKey-Richtlinie und eine AssignMessage-Richtlinie hinzu. Die VerifyAPIKey-Richtlinie validiert API-Schlüssel, die durch Anfragen für Anwendungen bereitgestellt werden. Die AssignMessage-Richtlinie entfernt den API-Schlüssel, der im API-Aufruf als Abfrageparameter bereitgestellt wird, von der Anfrage, die an den Back-End-Server weitergeleitet wird.
oauth 2.0	Fügt Ihrem OAuth-Proxy eine OAuth 2.0-basierte Authentifizierung hinzu. Apigee fügt Ihrem API-Proxy automatisch die folgenden Richtlinien hinzu: eine Richtlinie für die Überprüfung eines Zugriffstokens und eine weitere Richtlinie, um das Zugriffstoken aus der Nachricht zu entfernen, bevor es an den Back-End-Dienst weitergeleitet wird. Informationen zum Abrufen eines Zugriffstokens finden Sie unter OAuth.
Pass-Through (keine Autorisierung)	Keine Autorisierung erforderlich. Anfragen werden ohne Sicherheitsprüfungen von Apigee an das Back-End weitergeleitet.

Unterstützung für CORS hinzufügen

Cross-Origin Resource Sharing (CORS) ist ein Standardmechanismus, mit dem ein Webbrowser direkte Anfragen an eine andere Domain senden kann. Der CORS-Standard definiert eine Reihe von HTTP-Headern, die Webbrowser und Server für die Implementierung der domainübergreifenden Kommunikation verwenden.

Sie können CORS unterstützen, indem Sie eine der folgenden Aktionen ausführen:

• Hinzufügen der CORS-Richtlinie zum Anfrage-PreFlow des ProxyEndpoint
• Wählen Sie CORS-Header hinzufügen auf der Seite Allgemeine Richtlinien des Assistenten Proxy erstellen aus.

Weitere Informationen zur CORS-Unterstützung, einschließlich dem Hinzufügen von CORS-Preflight-Unterstützung zu einem Proxy, finden Sie unter CORS-Unterstützung zu einem API-Proxy hinzufügen.

Kontingente hinzufügen

Kontingente schützen den Back-End-Dienst vor hohem Traffic unter Kontingent. Siehe Kontingente (Diese Option ist nicht verfügbar, wenn die Passthrough-Autorisierung ausgewählt ist.)

Proxy-Spezifikationen zum Generieren von Proxys verwenden

In diesem Abschnitt wird die Verwendung der OpenAPI-Option erläutert, die zum Generieren aus einer OpenAPI-Spezifikation zu den folgenden Typen von API-Proxys verfügbar ist: Reverse oder kein Ziel:

Was ist eine OpenAPI-Spezifikation?

   „Die Open API-Initiative (OAI) konzentriert sich auf das Erstellen, Entwickeln und Bewerben eines neutralen API-Beschreibungsformats basierend auf der Swagger-Spezifikation.“ Weitere Informationen finden Sie unter OpenAPI-Initiative.

Eine OpenAPI-Spezifikation verwendet ein Standardformat zur Beschreibung einer RESTful API. Eine OpenAPI-Spezifikation, im JSON- oder YAML-Format geschrieben, ist maschinenlesbar, aber auch leicht für Menschen lesbar und verständlich. Die Spezifikation beschreibt API-Elemente wie den Basispfad, Pfade und Verben, Header, Abfrageparameter, Vorgänge, Inhaltstypen, Antwortbeschreibungen und mehr. Außerdem werden OpenAPI-Spezifikationen häufig zum Generieren von API-Dokumentationen verwendet.

Das folgende Fragment aus einer OpenAPI-Spezifikation beschreibt den simulierten Zieldienst von Apigee, http://mocktarget.apigee.net. Weitere Informationen finden Sie unter OpenAPI-Spezifikation für das Beispiel helloworld.

openapi: 3.0.0
info:
  description: OpenAPI Specification for the Apigee mock target service endpoint.
  version: 1.0.0
  title: Mock Target API
paths:
  /:
    get:
      summary: View personalized greeting
      operationId: View a personalized greeting
      description: View a personalized greeting for the specified or guest user.
      parameters:
        - name: user
          in: query
          description: Your user name.
          required: false
          schema:
            type: string
      responses:
        "200":
          description: Success
  /help:
    get:
      summary: Get help
      operationId: Get help
      description: View help information about available resources in HTML format.
      responses:
        "200":
          description: Success
...

Mit dem Assistenten zum Erstellen von Proxys können Sie eine OpenAPI-Spezifikation importieren und diese verwenden, um einen API-Proxy zu generieren. Nachdem der Proxy generiert wurde, können Sie ihn über die Apigee-UI weiterentwickeln. Dazu fügen Sie Richtlinien hinzu, implementieren benutzerdefinierten Code usw. wie bei jedem Apigee-Proxy.

API-Proxy aus einer OpenAPI-Spezifikation erstellen

Erstellen Sie Ihre API-Proxys aus einer OpenAPI-Spezifikation. Mit nur wenigen Klicks erhalten Sie einen API-Proxy mit automatisch generierten Pfaden, Parametern, bedingten Abläufen und Zielendpunkten. Anschließend können Sie Funktionen wie OAuth-Sicherheit, Ratenbegrenzung und Caching hinzufügen.

Klicken Sie im Assistenten Proxy erstellen auf OpenAPI-Spezifikation erstellen und folgen Sie den Anweisungen des Assistenten, um einen umgekehrten oder keinen Zielproxy aus einer OpenAPI-Spezifikation zu erstellen. Weitere Informationen finden Sie unter API-Proxy aus einer OpenAPI-Spezifikation erstellen.

Neue Überarbeitung eines API-Proxys erstellen

Erstellen Sie wie unten beschrieben eine neue Überarbeitung eines API-Proxys.

Führen Sie die folgenden Schritte aus, um eine neue Überarbeitung eines API-Proxys zu erstellen:

1. Melden Sie sich bei der Apigee-UI an.
2. Wählen Sie in der Navigationsleiste Entwickeln > API Proxies aus.
3. Klicken Sie in der Liste auf den API-Proxy, den Sie kopieren möchten.

4. Klicken Sie auf den Tab Entwickeln.

5. Klicken Sie auf Speichern und wählen Sie Als neue Überarbeitung speichern aus.

API-Proxy sichern

Sie können einen bestehenden API-Proxy als Reihe von XML-Dateien in einem API-Proxy-Bundle sichern. Nach dem Export in ein Bundle können Sie den API-Proxy in einen neuen Proxy importieren, wie weiter oben im Abschnitt API-Proxy eines API-Proxy-Bundles importieren beschrieben. Weitere Informationen finden Sie unter API-Proxys herunterladen.

API-Proxy mit der API erstellen

Informationen zum Erstellen eines API-Proxys mithilfe der API finden Sie unter API-Proxy erstellen.