Docker für Edge Microgateway verwenden

<ph type="x-smartling-placeholder"></ph> Sie sehen die Dokumentation zu Apigee Edge.
Gehen Sie zur Apigee X-Dokumentation. Weitere Informationen

In diesem Thema wird erläutert, wie Sie Edge Microgateway in einem Docker-Container ausführen. Die Schritte Die in diesem Thema behandelten Themen setzen ein grundlegendes Verständnis von Docker, Docker-Befehlen und Edge Microgateway voraus. Einrichtung und Konfiguration. Für Weitere Informationen finden Sie in der Dokumentation zu Docker. und Edge Microgateway

Vorbereitung

Bevor Sie Edge Microgateway in einem Docker-Container ausführen, müssen Sie Folgendes tun Aufgaben:

• Konfigurieren Sie Edge Microgateway für Ihre Apigee-Organisation/-Umgebung:

  edgemicro configure -o your_org -e your_env -u your_username

  Weitere Informationen zur Konfiguration finden Sie unter Teil 1: Edge Microgateway konfigurieren.

• Nachdem Sie die Konfigurationsschritte ausgeführt haben, suchen Sie die Konfiguration -Datei. Das ist der Standardspeicherort:

  $HOME/.edgemicro/your_org-your_env-config.yaml

  wobei your_org und your_env die Organisation sind und die Umgebung, die Sie beim Ausführen des Befehls edgemicro config verwendet haben. Sie benötigen wenn Sie Edge Microgateway in einem Docker-Container starten.

• Sie benötigen den Schlüssel und die geheimen Anmeldedaten, die bei der Ausführung des edgemicro config-Befehl. Beispiel:

  The following credentials are required to start edge micro
    key: d9c34e1aff68ed969273c016699eabf48780e4f652242e72fc88a43e21252cb0
    secret: 3bc95a71c86a3c8ce04537fbcb788158731t51dfc6cdec13b7c05aa0bd969430
  

• Bevor Sie Edge Microgateway in einem Docker-Container starten, müssen Sie (oder erstellt haben) die erforderlichen Apigee Edge-Entitäten für authentifizierte API-Proxy-Aufrufe. Zu diesen Entitäten gehört ein Edge Microgateway-fähiges Proxy, ein API-Produkt, einen Entwickler und eine Entwickler-App. Eine ausführliche Anleitung finden Sie unter Entitäten in Apigee Edge erstellen

Edge Micro als Docker-Container ausführen

1. Laden Sie das Docker-Image für Edge Microgateway herunter:

   docker pull gcr.io/apigee-microgateway/edgemicro:latest

2. Bevor Sie mit den nächsten Schritten fortfahren, müssen Sie alle Schritte in im Abschnitt Voraussetzungen.

3. Führen Sie den folgenden Befehl aus, um die Edge Microgateway-Konfigurationsdatei mit base64 zu codieren in $HOME/.edgemicro:

   export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/your_org-your_env-config.yaml`

   Dabei sind your_org und your_env die Organisation und Umgebung, die Sie verwendet haben, als Sie den Befehl edgemicro config ausgeführt.

   Denken Sie daran, den Befehl in Graviszeichen (`) zu setzen. Beispiel:

   export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/docs-test-config.yaml`

4. Edge Microgateway als Container ausführen. Der Befehl legt mehrere Umgebungsvariablen fest die von der Containerlaufzeit verwendet werden, um Edge Microgateway zu starten:

   docker run -P -p 8000:8000 -d --name edgemicro \
   -v /var/tmp:/opt/apigee/logs \
   -e EDGEMICRO_PROCESSES=1 \
   -e EDGEMICRO_ORG=your_org \
   -e EDGEMICRO_ENV=your_env \
   -e EDGEMICRO_KEY=your_key \
   -e EDGEMICRO_SECRET=your_secret \
   -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
   -e SERVICE_NAME=edgemicro \
   --security-opt=no-new-privileges \
   --cap-drop=ALL \
   gcr.io/apigee-microgateway/edgemicro:latest

   Parameter

   Parameter	Beschreibung
   -P	Veröffentlichen Sie alle freigegebenen Ports auf dem Host. Siehe auch Docker-Ausführungsreferenz.
   -p	Ordnen Sie einen einzelnen Port oder einen Portbereich explizit zu. Siehe auch Docker-Ausführungsreferenz.
   -d	Im getrennten Modus ausführen. Siehe auch Docker-Ausführungsreferenz.
   -v, --volume	Gibt eine Volume-Bereitstellung an. Wenn Sie Edge Microgateway konfigurieren, Wenn Sie TLS im Docker-Container verwenden möchten, müssen Sie Port 8443 verfügbar machen, wenn Sie das Protokolldateiverzeichnis bereitstellen. Siehe auch VOLUMEN [freigegebene Dateisysteme]. Siehe auch TLS im Docker-Container verwenden
   EDGEMICRO_ORG	Der Name der Apigee-Organisation, die Sie zum Konfigurieren von Edge Microgateway verwendet haben.
   EDGEMICRO_ENV	Der Name der Apigee-Umgebung, die Sie zum Konfigurieren von Edge Microgateway verwendet haben.
   EDGEMICRO_PROCESSES	Die Anzahl der zu startenden Prozesse.
   EDGEMICRO_KEY	Der Schlüssel, der bei der Konfiguration von Edge Microgateway zurückgegeben wurde.
   EDGEMICRO_SECRET	Das Secret, das bei der Konfiguration von Edge Microgateway zurückgegeben wurde.
   EDGEMICRO_CONFIG	Eine Variable, die die base64-codierte Edge Microgateway-Konfigurationsdatei enthält.
   SERVICE_NAME	Wenn Sie Kubernetes verwenden, wird dieser Parameter automatisch ausgefüllt. Andernfalls können Sie beliebig festlegen. Wenn Sie keine Angabe machen, Name ist auf default festgelegt.
   DEBUG	Legen Sie * fest, um das Debugging zu aktivieren.
   HTTP_PROXY HTTPS_PROXY	Verwenden, wenn Edge Microgateway die hinter einer Firewall ausgeführt wird und das Gateway nicht mit Apigee kommunizieren kann Edge Weitere Informationen Weitere Informationen finden Sie unter Edge Microgateway hinter einer Unternehmensfirewall einrichten. Beispiel: HTTP_PROXY=http://10.203.0.1:5187/
   NO_PROXY	Eine durch Kommas getrennte Liste von Domains, an die Edge Microgateway nicht weiterleiten soll. Weitere Informationen finden Sie unter Edge Microgateway hinter einer Unternehmensfirewall einrichten. Beispiel: localhost,127.0.0.1,localaddress,.localdomain.com
   NODE_EXTRA_CA_CERTS	(Optional) Verwenden Sie diesen Parameter, wenn Sie eine nicht vertrauenswürdige Zertifizierungsstelle verwenden. Node.js erstellt. Legen Sie für den Wert dieses Parameters den Pfad zu einem Datei mit einem oder mehreren vertrauenswürdigen Zertifikaten im PEM-Format. Für Weitere Informationen
   --security-opt	(Optional) Legt die gewünschten Docker-Sicherheitsoptionen fest. Weitere Informationen finden Sie in der Docker-Dokumentation unter Sicherheitskonfiguration.
   --cap-drop	(Optional) Legt Limits für die im Container zulässigen Linux-Funktionen fest. Weitere Informationen finden Sie in der Docker-Dokumentation unter Laufzeitprivileg und Linux-Berechtigungen.

   Beispiel:

   docker run -P -p 8000:8000 -d --name edgemicro \
   -v /var/tmp:/opt/apigee/logs \
   -e EDGEMICRO_PROCESS=1 \
   -e EDGEMICRO_ORG=docs \
   -e EDGEMICRO_ENV=test \
   -e EDGEMICRO_KEY=d9c34e1aff68ed969273b016699eabf48780e4f652242e72fc88a23e21252cb0 \
   -e EDGEMICRO_SECRET=3bc95a71c86a3c8ce04137fbcb788158731t51dfc6cdec13b7c05aa0bd969430 \
   -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
   -e SERVICE_NAME=edgemicro \
   --security-opt=no-new-privileges \
   --cap-drop=ALL \
   gcr.io/apigee-microgateway/edgemicro

5. So prüfen Sie, ob der Container ausgeführt wird:

   docker ps

   Die Ausgabe sollte in etwa so aussehen:

   CONTAINER ID    IMAGE         COMMAND                CREATED          STATUS          PORTS                                             NAMES
   8b92e082ea9c    edgemicro    "/tmp/entrypoint.sh"   12 minutes ago   Up 12 minutes    0.0.0.0:8000->8000/tcp, 0.0.0.0:32775->8443/tcp    edgemicro
   

API-Aufruf testen

Nachdem Sie Edge Microgateway im Container gestartet haben, können Sie API-Aufrufe an ihn senden. Wenn der Basispfad Ihrer API beispielsweise /hello ist:

http://localhost:8000/hello

Beispielausgabe:

{"error":"missing_authorization","error_description":"Missing Authorization header"}

Wenn Sie diese Antwort sehen, bedeutet dies, dass Edge Microgateway erfolgreich verarbeitet wurde. den API-Aufruf an. Standardmäßig erfordert Edge Microgateway jedoch einen API-Schlüssel für die Authentifizierung. Im nächsten Abschnitt testen Sie die API mit einem gültigen API-Schlüssel.

API mit einem gültigen API-Schlüssel testen

Navigieren Sie in der Edge-Benutzeroberfläche zu der Entwickler-App, die Sie zuvor erstellt haben. In der Developer Console App-Seite, zeige den Consumer Key und kopiere ihn. Dieser Wert ist der API-Schlüssel. Sie nutzen um authentifizierte API-Aufrufe durchzuführen.

Rufen Sie die API mit dem Header x-api-key so auf. Der Consumer Key-Wert, den Sie kopiert haben, ist der API-Schlüssel. Standardmäßig Edge Microgateway erwartet, dass Sie den Schlüssel so in einem Header namens x-api-key übergeben:

curl -i http://localhost:8000/hello -H "x-api-key:apikey"

Beispiel:

curl -i http://localhost:8000/hello -H "x-api-key:PydUKRDGIXRqF2xh4usn1FLHbhGKVIz"

Wenn Sie mehr über authentifizierte API-Aufrufe über Edge Microgateway erfahren möchten mit API-Schlüsseln und OAuth-Tokens finden Sie in Teil 4: Secure Edge Microgateway.

Edge Microgateway anhalten

Verwenden Sie den folgenden Docker-Befehl, um Edge Microgateway zu beenden:

docker stop edgemicro

Edge Microgateway neu starten

Nachdem Sie Edge Microgateway beendet haben, können Sie es mit diesem Docker-Befehl neu starten:

docker start edgemicro

TLS im Docker-Container verwenden

In diesem Abschnitt wird erläutert, wie Sie TLS für ausgeführtes Edge Microgateway konfigurieren in einem Docker-Container. Sie können den Edge Microgateway-Server für die Verwendung von TLS konfigurieren für eingehende Anfragen (Richtung Norden) und Sie können Edge Microgateway wird zu einem TLS-Client für ausgehende Anfragen an Zielendpunkte Richtung Süden.

Speicherort der Zertifikatsdateien

Der Docker-Container, auf dem Edge Microgateway ausgeführt wird, hat einen Bereitstellungspunkt auf /opt/apigee/.edgemicro. Wenn Sie Edge Microgateway für die Verwendung von TLS-Zertifikaten konfigurieren, können Sie den und auf sie verweisen. Edge Microgateway-Konfigurationsdatei Diese Konfigurationsdatei befindet sich normalerweise im Verzeichnis $HOME/.edgemicro Verzeichnis und heißt your_org-your_env-config.yaml. Beispiel:

...
edgemicro:
  ssl:
   key: /opt/apigee/.edgemicro/southbound/tls.key
   cert: /opt/apigee/.edgemicro/southbound/tls.crt
...

Zertifizierungsstelle verwenden, die von Node.js nicht als vertrauenswürdig eingestuft wird

Wenn Sie eine Zertifizierungsstelle (Certificate Authority, CA) verwenden, die standardmäßig nicht Node.js (z. B. bei einem selbst signierten Zertifikat) empfiehlt sich die Verwendung von NODE_EXTRA_CA_CERTS, wenn Sie den Container ausführen.

Legen Sie diesen Parameter auf den Pfad zu einer Datei fest, die mindestens ein Element enthält. vertrauenswürdigen Zertifikaten im PEM-Format. Informationen zur Verwendung dieses Parameters finden Sie in der Beispiele: Konfigurieren von TLS in nördlicher Richtung und Konfigurieren von TLS in Richtung Süden

Beispiel:

docker run -P -p 8443:8443 -d --name edgemicro \
-v $HOME/.edgemicro:/opt/apigee/.edgemicro \
-v $HOME/.edgemicro:/opt/apigee/logs \
-e NODE_EXTRA_CA_CERTS=/opt/apigee/.edgemicro/rootca.pem \
-e EDGEMICRO_PORT=8443 \
-e EDGEMICRO_ORG=docs \
-e EDGEMICRO_ENV=test \
-e EDGEMICRO_KEY=ac36574905fb54fdae65fc5433e831bec2680efb98220a355f2e917e52973c \
-e EDGEMICRO_SECRET=aac81dff6c326eaa222d53c15c8841fa78ea863bf4472568c9ce2d80a3bc56 \
-e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
--link helloworld:helloworld gcr.io/apigee-microgateway/edgemicro

Weitere Informationen finden Sie unter Edge Micro als Docker-Container ausführen.

TLS-Validierung deaktivieren

In einigen Fällen kann es jedoch sinnvoll sein, die TLS-Validierung zu deaktivieren, auch wenn dies nicht empfohlen wird. für Edge Microgateway, das in einem Container ausgeführt wird. Die Funktion zum Deaktivieren von TLS ist standardmäßig nicht in den Edge Microgateway-Docker-Container integriert. Um das müssen Sie ein benutzerdefiniertes Docker-Image für Edge Microgateway erstellen. Darunter finden Sie allgemeine Anweisungen zum Erstellen des benutzerdefinierten Images und zum Deaktivieren der TLS-Validierung.

1. Edge Microgateway-Quell-Repository klonen oder herunterladen aus https://github.com/apigee-internal/microgateway

2. cd in das Verzeichnis microgateway/kubernetes/docker/edgemicro im Quellcodeverzeichnis.

   Beispiel:

   cd $HOME/git/microgateway/kubernetes/docker/edgemicro
   

3. Öffne die Datei entrypoint.sh und ändere den Code, um die NODE_TLS_REJECT_UNAUTHORIZED zu akzeptieren Umgebungsvariable ein. Später, wenn Sie den Container ausführen, geben Sie einen Wert dafür an. .

4. Erstellen Sie den Docker-Container:

   docker build -t edgemicro .
   

5. Geben Sie beim Ausführen des Containers die Option -e NODE_TLS_REJECT_UNAUTHORIZED = 1 an. Beispiel:

docker run -P -p 8443:8443 -d --name edgemicro \
-v $HOME/.edgemicro:/opt/apigee/.edgemicro \
-v $HOME/.edgemicro:/opt/apigee/logs \
-e NODE_TLS_REJECT_UNAUTHORIZED = 1 \
-e EDGEMICRO_PORT=8443 \
-e EDGEMICRO_ORG=docs \
-e EDGEMICRO_ENV=test \
-e EDGEMICRO_KEY=ac36574905fb54fdae65fc5433e831bec2680efb98220a355f2e917e52973c \
-e EDGEMICRO_SECRET=aac81dff6c326eaa222d53c15c8841fa78ea863bf4472568c9ce2d80a3bc56 \
-e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
--link helloworld:helloworld gcr.io/apigee-microgateway/edgemicro

Beispiel: TLS in nördlicher Richtung konfigurieren

In diesem Abschnitt wird erläutert, wie Sie eine eingehende TLS-Verbindung nach Norden auf dem Edge Microgateway einrichten Server. Mit Northbound TLS können Clients HTTPS verwenden, wenn API-Aufrufe an Edge Microgateway gesendet werden. Im folgenden Beispiel werden selbst signierte Zertifikate verwendet.

1. Erste Einrichtungsschritte

1. Suchen Sie die Datei openssl.cnf auf Ihrem System. Beispiel: /etc/ssl/openssl.cnf.
2. Öffnen Sie die Datei opensssl.cnf zur Bearbeitung.

3. Achten Sie darauf, dass die req_extensions in Ihrer Konfigurationsdatei vorhanden sind. Zum Beispiel haben Sie Ihre Datei sollte Informationen wie diese enthalten:

   [ req ]
   ...
   req_extensions          = v3_req
   ...
   
   [ v3_req ]
   extendedKeyUsage = serverAuth, clientAuth, codeSigning, emailProtection
   basicConstraints = CA:FALSE
   keyUsage = nonRepudiation, digitalSignature, keyEncipherment
   

4. Fügen Sie openssl.cnf die folgende Stanza hinzu, um die richtigen SNI-Attribute zu generieren:

   [ alt_names ]
   DNS.1 = www.example.com
   DNS.2 = example.com
   DNS.3 = localhost
   DNS.4 = localhost.localdomain
   DNS.5 = 127.0.0.1
   DNS.6 = ::1
   DNS.7 = fe80::1
   

   opensssl.cnf-Beispieldatei:

   [ req ]
   distinguished_name      = req_distinguished_name
   attributes              = req_attributes
   req_extensions          = v3_req
   
   [ v3_req ]
   extendedKeyUsage = serverAuth, clientAuth, codeSigning, emailProtection
   basicConstraints = CA:FALSE
   keyUsage = nonRepudiation, digitalSignature, keyEncipherment
   
   [ req_distinguished_name ]
   countryName                     = Country Name (2 letter code)
   countryName_min                 = 2
   countryName_max                 = 2
   stateOrProvinceName             = State or Province Name (full name)
   localityName                    = Locality Name (eg, city)
   0.organizationName              = Organization Name (eg, company)
   organizationalUnitName          = Organizational Unit Name (eg, section)
   commonName                      = Common Name (eg, fully qualified host name)
   commonName_max                  = 64
   emailAddress                    = Email Address
   emailAddress_max                = 64
   
   [ req_attributes ]
   challengePassword               = A challenge password
   challengePassword_min           = 4
   challengePassword_max           = 20
   
   [ alt_names ]
   DNS.1 = www.example.com
   DNS.2 = example.com
   DNS.3 = localhost
   DNS.4 = localhost.localdomain
   DNS.5 = 127.0.0.1
   DNS.6 = ::1
   DNS.7 = fe80::1
   

5. Folgen Sie den Schritten im Abschnitt Voraussetzungen, um die Konfigurieren Sie Edge Microgateway, falls Sie dies noch nicht getan haben. Wenn Sie fertig sind, einen Edge Microgateway-fähigen Proxy, ein API-Produkt, einen Entwickler, und eine Entwickler-App. Außerdem sollten Sie den Befehl edgemicro configure ausgeführt haben, und einen Key und ein Secret erhalten.

2. Selbst signierte Zertifikate generieren

Generieren Sie als Nächstes die Zertifikate und Schlüssel, die Sie zum Einrichten von TLS benötigen:

1. cd in das Verzeichnis $HOME/.edgemicro.

2. Erstellen Sie das folgende Bash-Skript. Sie können ihm einen beliebigen Namen geben. Beispiel: keygen.sh.

   #!/bin/bash
   # generate ca
   openssl genrsa -out rootca.key 2048
   openssl req -x509 -new -nodes -key rootca.key -sha256 -days 1024 -out rootca.pem
   # generate key
   openssl genrsa -out tls.key 2048
   openssl req -new -key tls.key -out tls.csr
   # sign cert
   openssl x509 -req -in tls.csr -CA rootca.pem -CAkey rootca.key -CAcreateserial -out tls.crt -days 1024 -sha256 -extensions 'v3_req' -extfile path/openssl.cnf
   

3. Achten Sie darauf, dass der Pfad zur Datei openssl.cnf in der Bash-Datei korrekt ist.

4. Führen Sie die Bash-Datei aus. Sie werden aufgefordert, die Zertifikatsinformationen einzugeben. Achten Sie darauf, localhost für den allgemeinen Namen.

5. Prüfen Sie, ob die folgenden Dateien erstellt wurden:

   • rootca.key
   • rootca.pem
   • tls.key
   • tls.csr
   • rootca.srl
   • tls.crt

3. Edge Microgateway-Konfigurationsdatei bearbeiten

1. Öffnen Sie die Edge Micro-Konfigurationsdatei in einem Editor. Beispiel:

   vi $HOME/.edgemicro/myorg-test-config.yaml
   

2. Bearbeiten Sie die edgemicro-Stanza so. Sie nehmen Änderungen vor, zu den Attributen port und ssl hinzu:

   edge_config:
   ...
   edgemicro:
     port: 8443
     max_connections: 1000
     config_change_poll_interval: 600
     ssl:
       key: /opt/apigee/.edgemicro/tls.key
       cert: /opt/apigee/.edgemicro/tls.crt
       passphrase: admin123
       rejectUnauthorized: true
       requestCert: false
     logging:
   ...
   

3. Führen Sie den folgenden Befehl aus, um die Edge Microgateway-Konfigurationsdatei mit base64 zu codieren in $HOME/.edgemicro:

   export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/your_org-your_env-config.yaml`

   Dabei sind your_org und your_env die Organisation und Umgebung, die Sie verwendet haben, als Sie den Befehl edgemicro config ausgeführt.

   Denken Sie daran, den Befehl in Graviszeichen (`) zu setzen. Beispiel:

   export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/docs-test-config.yaml`

Weitere Informationen finden Sie unter Edge Micro als Docker-Container ausführen.

4. Container ausführen

1. Führen Sie den folgenden Befehl aus, um den Docker-Container mit Edge Microgateway auszuführen:

   docker run -P -p 8443:8443 -d --name edgemicro \
   -v path_to_your_edgemicro_dir:/opt/apigee/.edgemicro \
   -v path_to_your_logs_dir:/opt/apigee/logs \
   -e NODE_EXTRA_CA_CERTS=/opt/apigee/.edgemicro/rootca.pem \
   -e EDGEMICRO_PORT=8443 \
   -e EDGEMICRO_ORG=$EDGEMICRO_ORG \
   -e EDGEMICRO_ENV=$EDGEMICRO_ENV \
   -e EDGEMICRO_KEY=$EDGEMICRO_KEY \
   -e EDGEMICRO_SECRET=$EDGEMICRO_SECRET \
   -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
   gcr.io/apigee-microgateway/edgemicro:latest
   

2. Beachten Sie die folgenden Parameter, die in dem Befehl verwendet werden: unterscheiden sie sich von den den unter Edge Micro als Docker-Container ausführen beschriebenen Befehl.

   • port ist auf 8443 festgelegt.
   • Eine Volume-Bereitstellung wird verwendet, um die Schlüssel- und Zertifikatsdateien bereitzustellen.
   • Die Variable NODE_EXTRA_CA_CERTS wird verwendet, um eine benutzerdefinierte Zertifizierungsstelle hinzuzufügen (wie im Fall erforderlich). von selbst signierten Zertifikaten).

5. TLS-Konfiguration testen

1. Führen Sie den folgenden cURL-Befehl aus, um die Einrichtung zu testen. Ersetzen Basispfad und API-Schlüssel in den Befehl einfügen. Im folgenden Beispiel wird davon ausgegangen, dass Sie sich in dem Verzeichnis befinden, in dem rootca.pem befindet und der von Ihnen erstellte Proxy den Basispfad /hello hat:

   curl -v https://localhost:8443/hello --cacert rootca.pem \
   -H "x-api-key: Az82fdnfONVCOOE4NKhajxAboDgA3FAo"
   

2. Die ausführliche cURL-Ausgabe zeigt jeden Schritt des TLS-Handshake. Wenn Sie eine HTTP 200-Antwort sehen, war die Konfiguration erfolgreich:

   *   Trying ::1...ey:Az82fdnfONVCOOE4NKhajxAboDgA3FAo"
   * TCP_NODELAY set
   * Connected to localhost (::1) port 8443 (#0)
   * ALPN, offering h2
   * ALPN, offering http/1.1
   * Cipher selection: ALL:!EXPORT:!EXPORT40:!EXPORT56:!aNULL:!LOW:!RC4:@STRENGTH
   * successfully set certificate verify locations:
   *   CAfile: rootca.pem
     CApath: none
   * TLSv1.2 (OUT), TLS handshake, Client hello (1):
   * TLSv1.2 (IN), TLS handshake, Server hello (2):
   * TLSv1.2 (IN), TLS handshake, Certificate (11):
   * TLSv1.2 (IN), TLS handshake, Server key exchange (12):
   * TLSv1.2 (IN), TLS handshake, Server finished (14):
   * TLSv1.2 (OUT), TLS handshake, Client key exchange (16):
   * TLSv1.2 (OUT), TLS change cipher, Client hello (1):
   * TLSv1.2 (OUT), TLS handshake, Finished (20):
   * TLSv1.2 (IN), TLS change cipher, Client hello (1):
   * TLSv1.2 (IN), TLS handshake, Finished (20):
   * SSL connection using TLSv1.2 / ECDHE-RSA-AES128-GCM-SHA256
   * ALPN, server accepted to use http/1.1
   * Server certificate:
   *  subject: C=US; ST=CO; L=Boulder; O=Docs; OU=Docs; CN=localhost; emailAddress=docs@apigee.com
   *  start date: Dec 14 22:35:28 2018 GMT
   *  expire date: Oct  3 22:35:28 2021 GMT
   *  common name: localhost (matched)
   *  issuer: C=US; ST=CO; L=Boulder; O=Docs; OU=Docs; CN=localhost; emailAddress=docs@apigee.com
   *  SSL certificate verify ok.
   > GET /hello HTTP/1.1
   > Host: localhost:8443
   > User-Agent: curl/7.54.0
   > Accept: */*
   > x-api-key:Az82fdnfaONVCOE4NKhajxAboDA3FAo
   >
   < HTTP/1.1 200 OK
   < x-powered-by: Apigee
   < access-control-allow-origin: *
   < x-frame-options: ALLOW-FROM RESOURCE-URL
   < x-xss-protection: 1
   < x-content-type-options: nosniff
   < content-type: text/plain; charset=utf-8
   < etag: W/"d-GHB1ZrJKk/wdVTdB/jgBsw"
   < date: Fri, 14 Dec 2018 22:43:13 GMT
   < via: 1.1 google
   < alt-svc: clear
   < x-response-time: 1325
   < Connection: keep-alive
   < Transfer-Encoding: chunked
   <
   * Connection #0 to host localhost left intact
   Hello, Guest!
   

Beispiel: TLS in Richtung Süden konfigurieren

In diesem Abschnitt wird erläutert, wie Sie eine TLS-Verbindung nach Süden zwischen dem Edge Microgateway-Server und einer Back-End-Zielanwendung. Im folgenden Beispiel werden selbstsignierte Zertifikate.

1. Ersteinrichtung

1. Suchen Sie die Datei openssl.cnf auf Ihrem System. Beispiel: /etc/ssl/openssl.cnf.
2. Öffnen Sie die Datei opensssl.cnf zur Bearbeitung.

3. Achten Sie darauf, dass die req_extensions in Ihrer Konfigurationsdatei vorhanden sind. Zum Beispiel haben Sie Ihre Datei sollte Informationen wie diese enthalten:

   [ req ]
   ...
   req_extensions          = v3_req
   ...
   
   [ v3_req ]
   extendedKeyUsage = serverAuth, clientAuth, codeSigning, emailProtection
   basicConstraints = CA:FALSE
   keyUsage = nonRepudiation, digitalSignature, keyEncipherment
   

4. Fügen Sie openssl.cnf die folgende Stanza hinzu, um die richtigen SNI-Attribute zu generieren:

   [ alt_names ]
   DNS.1 = helloworld
   DNS.2 = localhost
   DNS.3 = localhost.localdomain
   DNS.4 = 127.0.0.1
   DNS.5 = ::1
   DNS.6 = fe80::1
   

   opensssl.cnf-Beispieldatei:

   [ req ]
   distinguished_name      = req_distinguished_name
   attributes              = req_attributes
   req_extensions          = v3_req
   
   [ v3_req ]
   extendedKeyUsage = serverAuth, clientAuth, codeSigning, emailProtection
   basicConstraints = CA:FALSE
   keyUsage = nonRepudiation, digitalSignature, keyEncipherment
   
   [ req_distinguished_name ]
   countryName                     = Country Name (2 letter code)
   countryName_min                 = 2
   countryName_max                 = 2
   stateOrProvinceName             = State or Province Name (full name)
   localityName                    = Locality Name (eg, city)
   0.organizationName              = Organization Name (eg, company)
   organizationalUnitName          = Organizational Unit Name (eg, section)
   commonName                      = Common Name (eg, fully qualified host name)
   commonName_max                  = 64
   emailAddress                    = Email Address
   emailAddress_max                = 64
   
   [ req_attributes ]
   challengePassword               = A challenge password
   challengePassword_min           = 4
   challengePassword_max           = 20
   
   [ alt_names ]
   DNS.1 = helloworld
   DNS.2 = localhost
   DNS.3 = localhost.localdomain
   DNS.4 = 127.0.0.1
   DNS.5 = ::1
   DNS.6 = fe80::1
   

5. Führen Sie den Befehl edgemicro configure aus:

   edgemicro configure -o your_org -e your_env -u your_username

   Weitere Informationen zur Konfiguration finden Sie unter Teil 1: Edge Microgateway konfigurieren.

6. Kopieren Sie den Schlüssel und die geheimen Anmeldedaten, die von zurückgegeben wurden. edgemicro configure Sie benötigen diese Werte, um den Container auszuführen. Beispiel:

   The following credentials are required to start edge micro
     key: d9c34e1aff68ed969273c016699eabf48780e4f652242e72fc88a43e21252cb0
     secret: 3bc95a71c86a3c8ce04537fbcb788158731t51dfc6cdec13b7c05aa0bd969430
   

2. Node.js-Zielanwendung erstellen

1. cd in das Verzeichnis .edgemicro.

2. Erstellen Sie das folgende Bash-Skript. Sie können ihm einen beliebigen Namen geben. Beispiel: keygen.sh.

   #!/bin/bash
   # generate ca
   openssl genrsa -out rootca.key 2048
   openssl req -x509 -new -nodes -key rootca.key -sha256 -days 1024 -out rootca.pem
   # generate key
   openssl genrsa -out tls.key 2048
   openssl req -new -key tls.key -out tls.csr
   # sign cert
   openssl x509 -req -in tls.csr -CA rootca.pem -CAkey rootca.key -CAcreateserial -out tls.crt -days 1024 -sha256 -extensions 'v3_req' -extfile path/openssl.cnf
   

3. Achten Sie darauf, dass der Pfad zur Datei openssl.cnf in der Bash-Datei korrekt ist.

4. Führen Sie die Bash-Datei aus. Sie werden aufgefordert, die Zertifikatsinformationen einzugeben. Achten Sie darauf, hellworld für den allgemeinen Namen.

5. Prüfen Sie, ob die folgenden Dateien erstellt wurden:

   • rootca.key
   • rootca.pem
   • tls.key
   • tls.csr
   • rootca.srl
   • tls.crt

6. Erstellen Sie eine neue Datei mit dem Namen server.js:

   'use strict';
   
   const express = require('express');
   const https = require('https');
   const fs = require('fs');
   
   const options = {
     key: fs.readFileSync("tls.key"),
     cert: fs.readFileSync("tls.crt")
   };
   
   // Constants
   const PORT = 9443;
   const HOST = '0.0.0.0';
   
   // App
   const app = express();
   app.get('/', (req, res) => {
     res.send('Hello world\n');
   });
   
   https.createServer(options, app).listen(PORT);
   

7. Erstellen Sie eine package.json-Datei im selben Verzeichnis wie server.js. Beispiel:

   {
     "name": "helloworld",
     "version": "1.0.0",
     "description": "",
     "main": "server.js",
     "scripts": {
       "test": "echo \"Error: no test specified\" && exit 1",
       "start": "node server.js"
     },
     "author": "",
     "license": "ISC",
     "dependencies": {
       "express": "^4.16.4",
       "fs": "0.0.1-security",
       "https": "^1.0.0"
     }
   }
   

8. Führen Sie npm install aus, um die Abhängigkeiten abzurufen.

9. Erstellen Sie im selben Verzeichnis wie server.js ein neues Dockerfile, wobei WORKDIR ist der Pfad zum Stammverzeichnis Ihrer Node.js-Anwendung:

   FROM node:8-alpine
   WORKDIR path-to-your-node-app
   COPY package*.json ./
   
   RUN npm install
   COPY . .
   EXPOSE 9443
   CMD [ "npm", "start" ]
   

10. Docker-Image erstellen:

    docker build -t helloworld . 
    

11. Starten Sie die Beispielanwendung:

    docker run -P -p 9443:9443 --name helloworld helloworld
    

3. Entitäten in Apigee Edge erstellen

1. Erstellen Sie einen Edge Microgateway-fähigen Proxy mit diesen Einstellungen. Weitere Informationen Siehe Edge Microgateway-aware API-Proxy auf Edge erstellen.

   • Proxy-Name: edgemicro_local
   • Version: 1
   • Basispfad: /local
   • Ziel: https://helloworld:9443

2. Erstellen Sie ein API-Produkt. Weitere Informationen finden Sie unter Produkt erstellen.

3. Erstellen Sie einen Entwickler. Weitere Informationen finden Sie unter Entwickler erstellen.

4. Entwickler-App erstellen Weitere Informationen finden Sie unter Entwickler-App erstellen.

4. Container ausführen

1. Öffnen Sie die Edge Micro-Konfigurationsdatei in einem Editor. Beispiel:

   vi $HOME/.edgemicro/myorg-test-config.yaml
   

2. Bearbeiten Sie die edgemicro-Stanza so. Sie nehmen Änderungen vor, zu den Attributen port und ssl hinzu:

   edge_config:
   ...
   edgemicro:
     port: 8443
     max_connections: 1000
     config_change_poll_interval: 600
     ssl:
       key: /opt/apigee/.edgemicro/tls.key
       cert: /opt/apigee/.edgemicro/tls.crt
       passphrase: admin123
       rejectUnauthorized: true
       requestCert: false
     logging:
   ...
   

3. Führen Sie den folgenden Befehl aus, um die Edge Microgateway-Konfigurationsdatei in $HOME/.edgemicro mit base64 zu codieren:

   export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/your_org-your_env-config.yaml`

   Dabei sind your_org und your_env die Organisation und Umgebung, die Sie verwendet haben, als Sie den Befehl edgemicro config ausgeführt.

   Denken Sie daran, den Befehl in Graviszeichen (`) zu setzen. Beispiel:

   export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/docs-test-config.yaml`

4. Führen Sie den folgenden Befehl aus, um Edge Microgateway im Docker-Container zu starten.

   docker run -P -p 8443:8443 -d --name edgemicro \
   -v path_to_your_edgemicro_dir:/opt/apigee/.edgemicro \
   -v path_to_your_logs_dir:/opt/apigee/logs \
   -e EDGEMICRO_PORT=8443 \
   -e EDGEMICRO_ORG=$EDGEMICRO_ORG \
   -e EDGEMICRO_ENV=$EDGEMICRO_ENV \
   -e EDGEMICRO_KEY=$EDGEMICRO_KEY \
   -e EDGEMICRO_SECRET=$EDGEMICRO_SECRET \
   -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
   --link helloworld:helloworld gcr.io/apigee-microgateway/edgemicro
   

5. TLS-Konfiguration testen

1. Führen Sie den folgenden cURL-Befehl aus, um die Einrichtung zu testen. Ersetzen Ihren Basispfad, den Sie im Microgateway-Aware Proxy verwendet haben, und API-Schlüssel aus der Entwickler-App, die Sie in Apigee Edge erstellt haben. Beispiel:

   curl https://localhost:8443/local -k -H "x-api-key: xxxx" -v
   

   Sie sollten diese Fehlermeldung sehen:

   ...
   *  subject: C=CA; ST=Ontario; L=Toronto; O=Google Canada; OU=Google Cloud Platform; CN=edgemicro; emailAddress=srinandans@google.com
   *  start date: Dec 10 02:12:22 2018 GMT
   *  expire date: Sep 29 02:12:22 2021 GMT
   *  issuer: C=CA; ST=Ontario; L=Toronto; O=Google Canada; OU=Google Cloud Platform; CN=edgemicro; emailAddress=srinandans@google.com
   *  SSL certificate verify result: unable to get local issuer certificate (20), continuing anyway.
   > GET /local HTTP/1.1
   > Host: localhost:8443
   > User-Agent: curl/7.54.0
   > Accept: */*
   > x-api-key: 9fVC65pFj8LrmlPmVyxFjx4KgAHTxqSd
   >
   < HTTP/1.1 502 Bad Gateway
   < Date: Wed, 12 Dec 2018 05:25:01 GMT
   < Connection: keep-alive
   < Content-Length: 93
   <
   * Connection #0 to host localhost left intact
   {"message":"unable to verify the first certificate","code":"UNABLE_TO_VERIFY_LEAF_SIGNATURE"}
   

2. Führen Sie Edge Microgateway noch einmal aus, aber fügen Sie diesmal die Variable NODE_EXTRA_CA_CERTS hinzu.

   docker run -P -p 8443:8443 -d --name edgemicro \
   -v path_to_your_edgemicro_dir:/opt/apigee/.edgemicro \
   -v path_to_your_logs_dir:/opt/apigee/logs \
   -e NODE_EXTRA_CA_CERTS=/opt/apigee/.edgemicro/rootca.pem \
   -e EDGEMICRO_PORT=8443 \
   -e EDGEMICRO_ORG=$EDGEMICRO_ORG \
   -e EDGEMICRO_ENV=$EDGEMICRO_ENV \
   -e EDGEMICRO_KEY=$EDGEMICRO_KEY \
   -e EDGEMICRO_SECRET=$EDGEMICRO_SECRET \
   -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
   --link helloworld:helloworld gcr.io/apigee-microgateway/edgemicro
   

3. Führen Sie den folgenden cURL-Befehl aus. Ersetzen Basispfad und API-Schlüssel wie zuvor. Beispiel:

   curl https://localhost:8443/local -k -H "x-api-key: xxxx" -v
   

4. Prüfen Sie die Ausgabe. Bei Erfolg erhalten Sie eine HTTP 200-Statusantwort:

   ...
   > GET /local HTTP/1.1
   > Host: localhost:8443
   > User-Agent: curl/7.54.0
   > Accept: */*
   > x-api-key: 9fVC65pFj8LrmlPmVyxFjx4KgAHTxqSd
   >
   < HTTP/1.1 200 OK
   < x-powered-by: Express
   < content-type: text/html; charset=utf-8
   < etag: W/"c-M6tWOb/Y57lesdjQuHeB1P/qTV0"
   < date: Wed, 12 Dec 2018 05:49:28 GMT
   < x-response-time: 421
   < Connection: keep-alive
   < Transfer-Encoding: chunked
   <
   Hello world
   

Benutzerdefiniertes Plug-in hinzufügen

Sie können dem Microgateway neue Funktionen hinzufügen, indem Sie custom . Mit benutzerdefinierten Plug-ins können Sie programmatisch mit den Anfragen interagieren. und Antworten, die durch das Microgateway fließen.

Sie haben zwei Möglichkeiten, Plug-ins in einem Edge Microgateway bereitzustellen Instanz, die in einem Docker-Container ausgeführt wird:

• Option A: Plug-in-Verzeichnis auf einem Volume bereitstellen
• Option B: Plug-ins im Container erstellen

Im weiteren Verlauf dieses Abschnitts wird davon ausgegangen, dass Sie mit dem Schreiben und Konfigurieren für eine Edge Microgateway-Standardeinrichtung. Ist dies nicht der Fall, lesen Sie den Abschnitt Benutzerdefinierte Plug-ins entwickeln.

Option A: Plug-in-Verzeichnis auf einem Volume bereitstellen

(Hinzugefügt in Version 2.5.27) Die Schritte zum Hinzufügen von Plug-ins über eine Volume-Bereitstellung sind ähnlich wie beim Hinzufügen eines benutzerdefinierten Plug-ins zu Edge Microgateway. Wann? Wenn Sie den Docker-Container ausführen, können Sie das Plug-in-Verzeichnis auf Ihrem lokalen Computer bereitstellen System (Volume) am Container-Bereitstellungspunkt, in diesem Fall /opt/apigee/plugins. Anschließend geben Sie das lokale Volume-Verzeichnis in der Edge Microgateway-Konfigurationsdatei an.

Die folgenden Schritte veranschaulichen, wie Sie mit einem Docker-Bereitstellungspunkt benutzerdefinierte Plug-ins.

1. Beenden Sie Edge Microgateway:

   edgemicro stop
   

2. Erstellen Sie ein Verzeichnis für Ihre benutzerdefinierten Plug-ins. Erstellen Sie beispielsweise

   $HOME/edgemicro/custom/plugins
   

3. Fügen Sie der Edge Microgateway-Konfigurationsdatei das Verzeichnis des benutzerdefinierten Plug-ins hinzu. Beispiel:

     plugins:
       dir: $HOME/edgemicro/custom/plugins
       sequence:
         - oauth
         - response-uppercase
     ````
   

4. Schreiben und testen Sie das Plug-in gemäß der Anleitung unter Einfaches Plug-in schreiben. Achten Sie darauf, und platzieren Sie den Plug-in-Code in der richtigen Verzeichnisstruktur. Beispiel:

   custom
     |
     |-- plugins
       |
       |- response-uppercase
       |     |- index.js
       |     |- package.json
       |- request-headers
       |     | - index.js
             | - package.json
   

5. Führen Sie den Docker-Container mit einem Befehl ähnlich dem folgenden aus, wobei Sie Verwenden Sie die Option -v, um das Plug-in-Verzeichnis auf dem Docker-Volume bereitzustellen. Im folgenden Beispielbefehl, das Plug-in-Verzeichnis $HOME/edgemicro/custom/plugins (wo sich das benutzerdefinierte Plug-in befindet) dem Bereitstellungspunkt /opt/apigee/plugins des Containers zugeordnet ist:

   docker run -P -p 8000:8000 -d --name edgemicro \
   -v /var/tmp:/opt/apigee/logs \
   -v $HOME/edgemicro/custom/plugins:/opt/apigee/plugins \
   -e EDGEMICRO_PROCESSES=1 \
   -e EDGEMICRO_ORG=jdoe \
   -e EDGEMICRO_ENV=test \
   -e EDGEMICRO_KEY=39c4b561100cd7f258768d1072f3e1d7c17b5f36a18fe89972bb5c9ce7e58fb \
   -e EDGEMICRO_SECRET=f5f9e239a38b4e6cc99c2aa067716a84aebdcff9580a7925fc500e402b1a5fa \
   -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
   -e SERVICE_NAME=edgemicro \
   --security-opt=no-new-privileges \
   --cap-drop=ALL gcr.io/apigee-microgateway/edgemicro:latest
   

6. Rufen Sie Ihre API auf, um das Plug-in zu testen.

Weitere Informationen finden Sie unter VOLUMEN [freigegebene Dateisysteme].

Option B: Plug-ins im Container erstellen

Bei dieser Option binden Sie die Plug-ins in Ihren Container ein.

1. Plug-ins verpacken

1. Schreiben und testen Sie das Plug-in gemäß der Anleitung unter Einfaches Plug-in schreiben.

2. Platzieren Sie den Plug-in-Code in der richtigen Verzeichnisstruktur. Plug-in-Verzeichnisse müssen einer festgelegten Struktur folgen. Das folgende Beispiel zeigt die Struktur, die Sie befolgen müssen, wobei response-uppercase und request-headers der Wert Namen von Ordnern mit benutzerdefiniertem Plug-in-Code (diese Namen sind nur Beispiele, Ihre Ordnernamen können abweichen):

   plugin
     |
     |-- plugins
       |
       |- response-uppercase
       |     |- index.js
       |     |- package.json
       |- request-headers
       |     | - index.js
             | - package.json
   

3. cd in den Ordner plugin.

4. Komprimieren Sie im Ordner plugin den gesamten Ordner plugins:

   zip -r plugins.zip plugins/

2. Docker-Image erstellen

Erstellen Sie als Nächstes ein Dockerfile, um den Plug-in-Code einem Edge Microgateway-Image hinzuzufügen.

1. Erstellen Sie im selben Verzeichnis, in dem sich die ZIP-Datei befindet, eine neue Datei mit dem Namen Dockerfile.

2. Fügen Sie Dockerfile den folgenden Code hinzu und speichern Sie die Datei:

   USER root
   RUN apk update && \
       apk upgrade && \
       apk add zipapk add zip && \
       mkdir /opt/apigee/customplugins && \
       chown apigee:apigee /opt/apigee/customplugins
   COPY plugins.zip /opt/apigee/customplugins
   RUN su - apigee -c "unzip /opt/apigee/customplugins/plugins.zip -d /opt/apigee/customplugins"
   EXPOSE 8000
   EXPOSE 8443
   USER apigee
   ENTRYPOINT ["entrypoint"]
   

3. Erstellen Sie ein neues Edge Microgateway-Docker-Image mit Ihren Plug-ins:

   docker build -t image-name .
   

   Beispiel:

   docker build -t edgemicroplugins .
   

3. Edge Microgateway-Konfiguration aktualisieren

Nachdem die Plug-ins gepackt sind, müssen Sie sie dem Edge Microgateway hinzufügen Konfigurationsdatei.

1. Öffnen Sie die Edge Microgateway-Konfigurationsdatei in einem Editor:

   $HOME/.edgemicro/org-env-config.yaml
   

   Beispiel:

   vi $HOME/.edgemicro/myorg-test-config.yaml

2. Fügen Sie der Konfigurationsdatei das Plug-in-Verzeichnis hinzu. Im folgenden Beispiel Das Attribut dir gibt den Speicherort des Plug-in-Codes an (den Sie angegeben haben). im Dockerfile). Außerdem müssen Sie den Namen des Plug-in-Verzeichnisses angeben, im folgenden Beispiel ist response-uppercase.

   edgemicro:
     ...
     plugins:
       dir: /opt/apigee/plugins
       sequence:
         - oauth
         - response-uppercase
   

4. Microgateway starten

Abschließend müssen Sie das Microgateway im Container starten.

1. Führen Sie den folgenden Befehl aus, um die Edge Microgateway-Konfigurationsdatei mit base64 zu codieren in $HOME/.edgemicro:

   export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/your_org-your_env-config.yaml`

   Dabei sind your_org und your_env die Organisation und Umgebung, die Sie verwendet haben, als Sie den Befehl edgemicro config ausgeführt.

   Denken Sie daran, den Befehl in Graviszeichen (`) zu setzen. Beispiel:

   export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/docs-test-config.yaml`

2. Edge Microgateway als Container ausführen. Der Befehl legt mehrere Umgebungsvariablen fest die von der Containerlaufzeit verwendet werden, um Edge Microgateway zu starten:

   docker run -P -p 8000:8000 -d --name edgemicroplugins \
   -e EDGEMICRO_PLUGIN_DIR=/opt/apigee/customplugins/plugins \
   -e EDGEMICRO_ORG=your_org \
   -e EDGEMICRO_ENV=your_env \
   -e EDGEMICRO_KEY=your_key \
   -e EDGEMICRO_SECRET=your_secret \
   -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
   -e SERVICE_NAME=edgemicroplugins image_name

   Beispiel:

   docker run -P -p 8000:8000 -d --name edgemicroplugins \
   -e EDGEMICRO_PLUGIN_DIR=/opt/apigee/customplugins/plugins \
   -e EDGEMICRO_ORG=docs \
   -e EDGEMICRO_ENV=test \
   -e EDGEMICRO_KEY=d9c34e1aff68ed969273b016699eabf48780e4f652242e72fc88a23e21252cb0 \
   -e EDGEMICRO_SECRET=3bc95a71c86a3c8ce04137fbcb788158731t51dfc6cdec13b7c05aa0bd969430 \
   -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
   -e SERVICE_NAME=edgemicroplugins edgemicroplugins

3. Rufen Sie Ihre API auf, um das Plug-in zu testen:

   Testen Sie, ob der Plug-in-Code ausgeführt wird, indem Sie Ihre API aufrufen und prüfen, ob die Ausgabe ist wie erwartet:

   curl -i http://localhost:8000/hello -H "x-api-key:apikey"

   Das Plug-in response-uppercase kann beispielsweise eine Antwort wie diese zurückgeben:

   curl -i http://localhost:8000/hello -H "x-api-key:PydUKRDGIXRqF2xh4usn1FLHbhGKVIz"
     HELLO, WORLD!