Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Docker für Edge Microgateway verwenden

Sie lesen gerade die Dokumentation zu Apigee Edge.
Apigee X-Dokumentation aufrufen info

In diesem Thema wird erläutert, wie Sie Edge Microgateway in einem Docker-Container ausführen. Bei den in diesem Thema beschriebenen Schritten werden grundlegende Kenntnisse von Docker, Docker-Befehlen sowie der Einrichtung und Konfiguration von Edge Microgateway vorausgesetzt. Weitere Informationen finden Sie in der Dokumentation zu Docker und Edge Microgateway.

Vorbereitung

Bevor Sie Edge Microgateway in einem Docker-Container ausführen können, müssen Sie die folgenden Aufgaben ausführen:

Edge Microgateway für Ihre Apigee-Organisation/Umgebung konfigurieren:
```
edgemicro configure -o your_org -e your_env -u your_username
```
Weitere Informationen zur Konfiguration finden Sie unter Teil 1: Edge Microgateway konfigurieren.
Suchen Sie nach der Konfigurationsdatei, nachdem Sie die Konfigurationsschritte ausgeführt haben. Der standardmäßige Standort ist:
```
$HOME/.edgemicro/your_org-your_env-config.yaml
```
Dabei sind your_org und your_env die Organisation und Umgebung, die Sie beim Ausführen des Befehls edgemicro config verwendet haben. Sie benötigen diese Datei, wenn Sie Edge Microgateway in einem Docker-Container starten.

Sie benötigen die Schlüssel- und Secret-Anmeldedaten, die beim Ausführen des Befehls edgemicro config zurückgegeben wurden. 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 die Apigee Edge-Entitäten erstellen (oder erstellt haben), die für authentifizierte API-Proxy-Aufrufe erforderlich sind. Zu diesen Entitäten gehören ein Edge Microgateway-kompatibler Proxy, ein API-Produkt, ein Entwickler und eine Entwickler-App. Eine vollständige Anleitung finden Sie unter Entitäten in Apigee Edge erstellen.

Edge Micro als Docker-Container ausführen

Laden Sie das Docker-Image für Edge Microgateway herunter:
```
docker pull gcr.io/apigee-microgateway/edgemicro:latest
```
Mit einem Tag können Sie eine bestimmte Edge Microgateway-Version angeben. Beispiel: docker pull gcr.io/apigee-microgateway/edgemicro:3.0.2
Bevor Sie mit den nächsten Schritten fortfahren, müssen Sie alle Schritte im Abschnitt Voraussetzungen ausgeführt haben.
Führen Sie den folgenden Befehl aus, um die Edge Microgateway-Konfigurationsdatei unter $HOME/.edgemicro 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 beim Ausführen des Befehls edgemicro config verwendet haben.

Denken Sie daran, das Befehlssymbol (`) um den Befehl zu setzen. Beispiel:
```
export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/docs-test-config.yaml`
```
Die Version von Docker, die zum Erstellen des Edge Microgateway-Images verwendet wird, akzeptiert die Konfigurationsdatei als base64-codierten String. Durch die Codierung können Sie die Konfigurationsdatei über die Befehlszeile an Docker übergeben, wie im nächsten Schritt gezeigt. Wenn Sie Kubernetes verwenden, können Sie die Konfigurationsdatei in einem Kubernetes-Secret speichern.

Führen Sie Edge Microgateway als Container aus. Mit dem Befehl werden mehrere Umgebungsvariablen festgelegt, die von der Container-Laufzeit zum Starten von Edge Microgateway verwendet werden:

chown -R 100:101 ~/.edgemicro/ \
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`	Alle freigelegten Ports auf dem Host veröffentlichen. Weitere Informationen finden Sie in der Referenz zur Docker-Ausführung.
`-p`	Ordnen Sie einen einzelnen Port oder einen Portbereich explizit zu. Weitere Informationen finden Sie in der Referenz zur Docker-Ausführung.
`-d`	Im getrennten Modus ausführen Weitere Informationen finden Sie in der Referenz zur Docker-Ausführung.
`-v, --volume`	Gibt eine Volume-Bereitstellung an. Wenn Sie Edge Microgateway für die Verwendung von TLS im Docker-Container konfigurieren, müssen Sie Port 8443 freigeben, wenn Sie das Logdateiverzeichnis einbinden. Siehe auch VOLUME [freigegebene Dateisysteme]. Weitere Informationen finden Sie unter 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 zurückgegeben wurde, als Sie Edge Microgateway konfiguriert haben.
`EDGEMICRO_SECRET`	Das Secret, das zurückgegeben wurde, als Sie Edge Microgateway konfiguriert haben.
`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 einen beliebigen Wert festlegen. Wenn Sie nichts angeben, wird der Dienstname auf `default` festgelegt.
`DEBUG`	Setzen Sie den Wert auf `*`, um das Debugging zu aktivieren.
`HTTP_PROXY` `HTTPS_PROXY`	Verwenden Sie diese Option, wenn Edge Microgateway hinter einer Firewall ausgeführt wird und das Gateway nicht mit Apigee Edge kommunizieren kann. 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 keine Proxyverbindung herstellen 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 Zertifizierungsstelle verwenden, die von Node.js nicht standardmäßig als vertrauenswürdig eingestuft wird. Legen Sie den Wert dieses Parameters auf den Pfad zu einer Datei fest, die ein oder mehrere vertrauenswürdige Zertifikate im PEM-Format enthält. Weitere Informationen finden Sie unter TLS-Zertifikate.
`--security-opt`	Optional: Legt die gewünschten Docker-Sicherheitsoptionen fest. Weitere Informationen finden Sie in der Docker-Dokumentation unter Security configuration.
`--cap-drop`	Optional: Legt Limits für Linux-Funktionen fest, die im Container zulässig sind. Weitere Informationen finden Sie in der Docker-Dokumentation unter Runtime privilege and Linux capabilities.

Beispiel:

chown -R 100:101 ~/.edgemicro/ \
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

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 das Gateway 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 das, dass Edge Microgateway den API-Aufruf erfolgreich verarbeitet hat. 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

Rufen Sie in der Edge-Benutzeroberfläche die zuvor erstellte Entwickler-App auf. Lassen Sie auf der Seite „Entwickler-App“ den Consumer-Key anzeigen und kopieren Sie ihn. Dieser Wert ist der API-Schlüssel. Sie verwenden diesen Schlüssel für authentifizierte API-Aufrufe.

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

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

Beispiel:

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

Weitere Informationen zum Ausführen authentifizierter API-Aufrufe über Edge Microgateway mit API-Schlüsseln und OAuth-Tokens finden Sie unter Teil 4: Edge Microgateway sichern.

Edge Microgateway beenden

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 beschrieben, wie Sie TLS für Edge Microgateway konfigurieren, das in einem Docker-Container ausgeführt wird. Sie können den Edge Microgateway-Server so konfigurieren, dass TLS für eingehende Anfragen (Northbound-Richtung) verwendet wird. Außerdem können Sie Edge Microgateway als TLS-Client für ausgehende Anfragen an Zielendpunkte (Southbound-Richtung) konfigurieren.

Speicherort von Zertifikatsdateien

Der Docker-Container, in dem Edge Microgateway ausgeführt wird, hat einen Bereitstellungspunkt unter /opt/apigee/.edgemicro. Wenn Sie Edge Microgateway für die Verwendung von TLS-Zertifikaten konfigurieren, können Sie die Zertifikatsdateien an diesem Bereitstellungspunkt verfügbar machen und in der Edge Microgateway-Konfigurationsdatei darauf verweisen. Diese Konfigurationsdatei befindet sich normalerweise im Verzeichnis $HOME/.edgemicro 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
...

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

Wenn Sie eine Zertifizierungsstelle (Certificate Authority, CA) verwenden, die von Node.js nicht standardmäßig als vertrauenswürdig eingestuft wird (z. B. bei einem selbst signierten Zertifikat), sollten Sie beim Ausführen des Containers den Parameter NODE_EXTRA_CA_CERTS verwenden.

Legen Sie diesen Parameter auf den Pfad zu einer Datei fest, die ein oder mehrere vertrauenswürdige Zertifikate im PEM-Format enthält. Informationen zur Verwendung dieses Parameters finden Sie in den Beispielen Northbound-TLS konfigurieren und Southbound-TLS konfigurieren.

Beispiel:

chown -R 100:101 ~/.edgemicro/ \
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

Obwohl es nicht empfohlen wird, kann es in einigen Fällen sinnvoll sein, die TLS-Validierung für Edge Microgateway zu deaktivieren, wenn es in einem Container ausgeführt wird. Die Möglichkeit, TLS zu deaktivieren, ist standardmäßig nicht in den Edge Microgateway-Docker-Container integriert. Dazu müssen Sie ein benutzerdefiniertes Docker-Image für Edge Microgateway erstellen. Unten finden Sie eine allgemeine Anleitung zum Erstellen des benutzerdefinierten Images und zum Deaktivieren der TLS-Validierung.

Klonen oder laden Sie das Edge Microgateway-Quell-Repository von https://github.com/apigee-internal/microgateway herunter.
cd zum Verzeichnis microgateway/kubernetes/docker/edgemicro im Quellcodeverzeichnis.

Beispiel:
```
cd $HOME/git/microgateway/kubernetes/docker/edgemicro
```
Öffnen Sie die Datei entrypoint.sh und ändern Sie den Code so, dass die Umgebungsvariable NODE_TLS_REJECT_UNAUTHORIZED akzeptiert wird. Später, wenn Sie den Container ausführen, geben Sie einen Wert für diese Variable an.
Docker-Container erstellen:
```
docker build -t edgemicro .
```
Geben Sie beim Ausführen des Containers die Option -e NODE_TLS_REJECT_UNAUTHORIZED = 1 an. Beispiel:

chown -R 100:101 ~/.edgemicro/ \
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: Northbound-TLS konfigurieren

In diesem Abschnitt wird beschrieben, wie Sie eine Northbound-TLS-Verbindung (eingehend) auf dem Edge Microgateway-Server einrichten. Mit Northbound-TLS können Clients HTTPS verwenden, wenn sie API-Aufrufe an Edge Microgateway senden. Im folgenden Beispiel werden selbstsignierte Zertifikate verwendet.

1. Ersteinrichtung

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

Achten Sie darauf, dass die req_extensions in Ihrer Konfigurationsdatei vorhanden sind. Ihre Datei sollte beispielsweise Informationen wie die folgenden enthalten:

[ req ]
...
req_extensions          = v3_req
...

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

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

Folgen Sie der Anleitung im Abschnitt Voraussetzungen, um Edge Microgateway zu initialisieren und zu konfigurieren, falls Sie dies noch nicht getan haben. Wenn Sie die Anleitung befolgt haben, sollten Sie einen Edge Microgateway-fähigen Proxy, ein API-Produkt, einen Entwickler und eine Entwickler-App erstellt haben. Außerdem sollten Sie den Befehl edgemicro configure ausgeführt und einen Schlüssel und ein Secret erhalten haben.

2. Selbst signierte Zertifikate generieren

Als Nächstes generieren Sie die Zertifikate und Schlüssel, die Sie für die Einrichtung von TLS benötigen:

cd zum Verzeichnis $HOME/.edgemicro.

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

Prüfen Sie in der Bash-Datei, ob der Pfad zur Datei openssl.cnf korrekt ist.
Führen Sie die Bash-Datei aus. Sie werden aufgefordert, Zertifikatsinformationen anzugeben. Verwenden Sie localhost für den allgemeinen Namen.
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

Öffnen Sie die Edge Micro-Konfigurationsdatei in einem Editor. Beispiel:
```
vi $HOME/.edgemicro/myorg-test-config.yaml
```

Bearbeiten Sie die edgemicro-Stanza so: Sie nehmen Änderungen an den Attributen port und ssl vor:

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:
...

Führen Sie den folgenden Befehl aus, um die Edge Microgateway-Konfigurationsdatei unter $HOME/.edgemicro 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 beim Ausführen des Befehls edgemicro config verwendet haben.

Denken Sie daran, das Befehlssymbol (`) um den Befehl 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

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

chown -R 100:101 ~/.edgemicro/ \
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

Beachten Sie die folgenden Parameter, die im Befehl verwendet werden. Sie unterscheiden sich vom einfachen Befehl, der unter Edge Micro als Docker-Container ausführen beschrieben wird.
- port ist auf 8443 festgelegt.
- Eine Volume-Bereitstellung wird verwendet, um die Schlüssel- und Zertifikatsdateien bereitzustellen.
- Mit der Variablen NODE_EXTRA_CA_CERTS wird eine benutzerdefinierte CA hinzugefügt (erforderlich bei selbst signierten Zertifikaten).

5. TLS-Konfiguration testen

Führen Sie den folgenden cURL-Befehl aus, um die Einrichtung zu testen. Ersetzen Sie den Basispfad und den API-Schlüssel im Befehl. Im folgenden Beispiel wird davon ausgegangen, dass Sie sich in dem Verzeichnis befinden, in dem sich rootca.pem befindet, und dass der von Ihnen erstellte Proxy den Basispfad /hello hat:
```
curl -v https://localhost:8443/hello --cacert rootca.pem \
-H "x-api-key: Az82fdnfONVCOOE4NKhajxAboDgA3FAo"
```

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: Southbound-TLS konfigurieren

In diesem Abschnitt wird beschrieben, wie Sie eine Southbound-TLS-Verbindung (ausgehend) zwischen dem Edge Microgateway-Server und einer Backend-Zielanwendung einrichten. Im folgenden Beispiel werden selbstsignierte Zertifikate verwendet.

1. Ersteinrichtung

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

Achten Sie darauf, dass die req_extensions in Ihrer Konfigurationsdatei vorhanden sind. Ihre Datei sollte beispielsweise Informationen wie die folgenden enthalten:

[ req ]
...
req_extensions          = v3_req
...

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

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

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.

Kopieren Sie die Schlüssel- und Secret-Anmeldedaten, die von edgemicro configure zurückgegeben wurden. 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

cd zum Verzeichnis .edgemicro.

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

Prüfen Sie in der Bash-Datei, ob der Pfad zur Datei openssl.cnf korrekt ist.
Führen Sie die Bash-Datei aus. Sie werden aufgefordert, Zertifikatsinformationen anzugeben. Verwenden Sie hellworld für den allgemeinen Namen.
Prüfen Sie, ob die folgenden Dateien erstellt wurden:
- rootca.key
- rootca.pem
- tls.key
- tls.csr
- rootca.srl
- tls.crt

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);

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"
  }
}

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

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

FROM node:8-alpine
WORKDIR path-to-your-node-app
COPY package*.json ./

RUN npm install
COPY . .
EXPOSE 9443
CMD [ "npm", "start" ]

Docker-Image erstellen:
```
docker build -t helloworld . 
```

Starten Sie die Beispiel-App:

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

3. Entitäten in Apigee Edge erstellen

Erstellen Sie einen Edge Microgateway-fähigen Proxy mit diesen Einstellungen. Weitere Informationen finden Sie unter Edge Microgateway-kompatiblen API-Proxy in Edge erstellen.
- Proxy-Name: edgemicro_local
- Revision: 1
- Basispfad: /local
- Ziel: https://helloworld:9443
Erstellen Sie ein API-Produkt. Weitere Informationen finden Sie unter Produkt erstellen.
Erstellen Sie einen Entwickler. Weitere Informationen finden Sie unter Entwickler erstellen.
Erstellen Sie eine Entwickler-App. Weitere Informationen finden Sie unter Entwickler-App erstellen.

4. Container ausführen

Öffnen Sie die Edge Micro-Konfigurationsdatei in einem Editor. Beispiel:
```
vi $HOME/.edgemicro/myorg-test-config.yaml
```

Bearbeiten Sie die edgemicro-Stanza so: Sie nehmen Änderungen an den Attributen port und ssl vor:

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:
...

Führen Sie den folgenden Befehl aus, um die Edge Microgateway-Konfigurationsdatei unter $HOME/.edgemicro 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 beim Ausführen des Befehls edgemicro config verwendet haben.

Denken Sie daran, das Befehlssymbol (`) um den Befehl zu setzen. Beispiel:
```
export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/docs-test-config.yaml`
```

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

chown -R 100:101 ~/.edgemicro/ \
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

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

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

Es sollte folgender Fehler angezeigt werden:

...
*  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"}

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

chown -R 100:101 ~/.edgemicro/ \
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

Führen Sie den folgenden cURL-Befehl aus. Ersetzen Sie wie zuvor Ihren Basispfad und API-Schlüssel. Beispiel:
```
curl https://localhost:8443/local -k -H "x-api-key: xxxx" -v
```

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 benutzerdefinierte Plug-ins schreiben. Mit benutzerdefinierten Plug-ins können Sie programmatisch mit den Anfragen und Antworten interagieren, die durch das Microgateway fließen.

Sie haben zwei Möglichkeiten, Plugins für eine Edge Microgateway-Instanz bereitzustellen, die in einem Docker-Container ausgeführt wird:

Option A: Das Verzeichnis „plugins“ auf einem Volume bereitstellen
Option B: Plugins in den Container einbauen

Im Rest dieses Abschnitts wird davon ausgegangen, dass Sie mit dem Schreiben und Konfigurieren von Plug-ins für eine Standardkonfiguration von Edge Microgateway vertraut sind. Wenn nicht, lesen Sie den Abschnitt Benutzerdefinierte Plug-ins entwickeln.

Option A: Das Verzeichnis „plugins“ auf einem Volume bereitstellen

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

In den folgenden Schritten wird veranschaulicht, wie Sie einen Docker-Bereitstellungspunkt verwenden, um benutzerdefinierte Plug-ins einzubinden.

Edge Microgateway beenden:
```
edgemicro stop
```
Erstellen Sie ein Verzeichnis für Ihre benutzerdefinierten Plugins. Erstellen Sie beispielsweise
```
$HOME/edgemicro/custom/plugins
```

Fügen Sie das benutzerdefinierte Plug‑in-Verzeichnis der Edge Microgateway-Konfigurationsdatei hinzu. Beispiel:

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

Schreiben und testen Sie Ihr Plug-in gemäß der Anleitung unter Einfaches Plug-in schreiben. Achten Sie darauf, dass sich der Plug-in-Code in der richtigen Verzeichnisstruktur befindet. Beispiel:

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

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

chown -R 100:101 ~/.edgemicro/ \
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

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

Weitere Informationen finden Sie unter VOLUME [shared filesystems].

Option B: Plugins in den Container einbauen

Bei dieser Option werden die Plug-ins in den Container eingebunden.

1. Plug-ins verpacken

Schreiben und testen Sie Ihr Plug-in gemäß der Anleitung unter Einfaches Plug-in schreiben.
Platzieren Sie den Plug‑in-Code in der richtigen Verzeichnisstruktur. Plug-in-Verzeichnisse müssen einer bestimmten Struktur folgen. Im folgenden Beispiel sehen Sie die Struktur, die Sie verwenden müssen. response-uppercase und request-headers sind die Namen von Ordnern, die benutzerdefinierten Plug-in-Code enthalten. Diese Namen sind nur Beispiele, Ihre Ordnernamen können abweichen:
```
plugin
  |
  |-- plugins
    |
    |- response-uppercase
    |     |- index.js
    |     |- package.json
    |- request-headers
    |     | - index.js
          | - package.json
```
cd in den Ordner plugin.
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 Ihrem Edge Microgateway-Image den Plug-in-Code hinzuzufügen.

Erstellen Sie im selben Verzeichnis wie die ZIP-Datei eine neue Datei mit dem Namen Dockerfile.

Fügen Sie den folgenden Code in Dockerfile ein 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"]

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 verpackt wurden, müssen Sie sie der Edge Microgateway-Konfigurationsdatei hinzufügen.

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

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

Beispiel:

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

Fügen Sie der Konfigurationsdatei das Plug‑in-Verzeichnis hinzu. Im folgenden Beispiel gibt das Attribut dir den Speicherort des Plug-in-Codes an, den Sie im Dockerfile angegeben haben. Sie müssen auch den Namen des Plug-in-Verzeichnisses angeben, der im Beispiel unten response-uppercase ist.
```
edgemicro:
  ...
  plugins:
    dir: /opt/apigee/plugins
    sequence:
      - oauth
      - response-uppercase
```

4. Microgateway starten

Schließlich müssen Sie das Microgateway im Container starten.

Führen Sie den folgenden Befehl aus, um die Edge Microgateway-Konfigurationsdatei unter $HOME/.edgemicro 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 beim Ausführen des Befehls edgemicro config verwendet haben.

Denken Sie daran, das Befehlssymbol (`) um den Befehl zu setzen. Beispiel:
```
export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/docs-test-config.yaml`
```

Führen Sie Edge Microgateway als Container aus. Mit dem Befehl werden mehrere Umgebungsvariablen festgelegt, die von der Container-Laufzeit zum Starten von Edge Microgateway verwendet werden:

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

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 wie erwartet ist:
```
curl -i http://localhost:8000/hello -H "x-api-key:apikey"
```
Das response-uppercase-Plug-in gibt möglicherweise eine Antwort wie diese zurück:
```
curl -i http://localhost:8000/hello -H "x-api-key:PydUKRDGIXRqF2xh4usn1FLHbhGKVIz"
  HELLO, WORLD!
```