Diese Seite wurde von der Cloud Translation API übersetzt.

Docker für Edge Microgateway verwenden

Sie sehen die Dokumentation zu Apigee Edge.
Zur Apigee X-Dokumentation weitere Informationen

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

Voraussetzungen

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

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 in Teil 1: Edge Microgateway konfigurieren.
Suchen Sie nach den Konfigurationsschritten die Konfigurationsdatei. Der Standardspeicherort ist hier:
```
$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 müssen die Key- und Secret-Anmeldedaten haben, 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, die für authentifizierte API-Proxyaufrufe erforderlich sind. Diese Entitäten umfassen einen Edge Microgateway-fähigen Proxy, ein API-Produkt, einen Entwickler und eine Entwickleranwendung. 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, prüfen Sie, ob Sie alle Schritte im Abschnitt Voraussetzungen ausgeführt haben.
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 beim Ausführen des Befehls edgemicro config verwendet haben.

Denken Sie daran, um den Befehl Graviszeichen (`) 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 in der Befehlszeile an Docker übergeben, wie im folgenden Schritt gezeigt. Wenn Sie Kubernetes verwenden, können Sie die Konfigurationsdatei in einer Kubernetes Secrets-Entität speichern.

Edge Microgateway als Container ausführen Der Befehl legt mehrere Umgebungsvariablen fest, die von der Containerlaufzeit 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 "LOG_CONSOLE_OUTPUT_TO_FILE=false" \
-e SERVICE_NAME=edgemicro \
--security-opt=no-new-privileges \
--cap-drop=ALL \
gcr.io/apigee-microgateway/edgemicro:latest

Parameter

  <tr>
    <td><code>SERVICE_NAME</code></td>
    <td>If you are on Kubernetes, this parameter is auto-populated. Otherwise,
      you can set it to anything you wish. If you specify nothing, the service
      name is set to <code>default</code>.</td>
  </tr>
  <tr>
    <tr>
    <td><code>DEBUG</code></td>
    <td>Set to <code>*</code> to enable debugging. </td>
  </tr>
  <tr>
    <td><code>HTTP_PROXY</code>
        <code>HTTPS_PROXY</code></td>
    <td>Use when Edge Microgateway is
      running behind a firewall and the gateway cannot communicate with Apigee
      Edge. For more
      information, see <a href="operation-and-configuration-reference-edge-microgateway#settingupedgemicrogatewaybehindacompanyfirewall">Setting up Edge Microgateway behind a company firewall</a>. 
      <p>For example: <code>HTTP_PROXY=http://10.203.0.1:5187/</code></p></td>
  </tr>
  <tr>
    <td><code>NO_PROXY</code></td>
    <td>A comma delimited list of domains that Edge Microgateway should not proxy to. 
      For more information, see <a href="operation-and-configuration-reference-edge-microgateway#settingupedgemicrogatewaybehindacompanyfirewall">Setting up Edge Microgateway behind a company firewall</a>.
      <p>For example: <code>localhost,127.0.0.1,localaddress,.localdomain.com</code></p></td>
  </tr>
  <tr>
  <tr>
    <tr>
    <td><code>NODE_EXTRA_CA_CERTS</code></td>
    <td>(Optional) Use this parameter if you are using a CA that's not trusted
      by default by Node.js. Set the value of this parameter to the path to a
      file containing one or more trusted certificates in PEM format. For
      details, see <a href="#tls_certificates">TLS certificates</a>.</td>
  </tr>
  <tr>
    <td><code>--security-opt</code></td>
    <td>(Optional) Sets desired Docker security options. See <a href="https://docs.docker.com/engine/reference/run/#security-configuration">Security configuration</a> in the Docker documentation.</td>
  </tr>
  <tr>
    <td><code>--cap-drop</code></td>
    <td>(Optional) Sets limits on Linux capabilities permitted in the container. See <a href="https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities">Runtime privilege and Linux capabilities</a> in the Docker documentation.</td>
  </tr>
</tbody>

Parameter	Beschreibung
`-P`	Veröffentlichen Sie alle freigegebenen Ports auf dem Host. Siehe auch Referenz zur Docker-Ausführung.
`-p`	Ordnen Sie explizit einen einzelnen Port oder einen Portbereich zu. Siehe auch Referenz zur Docker-Ausführung.
`-d`	Im getrennten Modus ausführen. Siehe auch 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 bereitstellen. Weitere Informationen finden Sie unter VOLUMEN [freigegebene Dateisysteme]. Weitere Informationen finden Sie unter TLS im Docker-Container verwenden.
`-w, -- workdir`	(Optional) Gibt den Pfad zu dem Verzeichnis an, in dem die Dateien `edgemicro.sock` und `edgemicro.pid` erstellt werden sollen. Sie können den Dateinamen „root“ `edgemicro` nicht ändern. Die Standardeinstellung ist der aktuelle Arbeitsverzeichnispfad. Beispiel: docker run -P -p 8000:8000 -d -w /tmp --name edgemicro ...
`EDGEMICRO_ORG`	Der Name der Apigee-Organisation, mit der Sie Edge Microgateway konfiguriert 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 beim Konfigurieren von Edge Microgateway zurückgegeben wurde.
`EDGEMICRO_SECRET`	Das Secret, das beim Konfigurieren von Edge Microgateway zurückgegeben wurde.
`EDGEMICRO_CONFIG`	Eine Variable, die die base64-codierte Edge Microgateway-Konfigurationsdatei enthält.
`LOG_CONSOLE_OUTPUT_TO_FILE`	(Boolesch) Hiermit können Sie festlegen, wohin die Protokollausgabe gesendet wird. Weitere Informationen finden Sie unter Optionen für Logdateien angeben.

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

Optionen für die Logdateiausgabe angeben

Mit dem Edge Microgateway-Konfigurationsparameter to_console können Sie festlegen, dass Protokollinformationen an die Standardausgabe statt an eine Protokolldatei gesendet werden. Wenn Sie die Schritte zum Ausführen von Edge Microgateway in einem Docker-Container ausführen, leitet der Container die stdout- und Fehlerausgabe standardmäßig an eine Datei weiter, die sich im Container an folgendem Speicherort befindet: ${APIGEE_ROOT}/logs/edgemicro.log.

Wenn Sie verhindern möchten, dass Loginformationen an edgemicro.log gesendet werden, verwenden Sie beim Ausführen des Containers die Variable LOG_CONSOLE_OUTPUT_TO_FILE.

In der folgenden Tabelle wird das Verhalten der Logausgabe bei Verwendung von LOG_CONSOLE_OUTPUT_TO_FILE mit to_console beschrieben:

`to_console: true` `LOG_CONSOLE_OUTPUT_TO_FILE=false`	Es werden keine Protokolle an die Edge Microgateway-Protokolldatei gesendet, wie unter Protokolldateien verwalten beschrieben. Protokolle werden nicht an die Datei `edgemicro.log` gesendet.
`to_console: true` `LOG_CONSOLE_OUTPUT_TO_FILE=true`	Es werden keine Protokolle an die Edge Microgateway-Protokolldatei gesendet, wie unter Protokolldateien verwalten beschrieben. Protokolle werden an die Datei `edgemicro.log` gesendet.
`to_console: false` `LOG_CONSOLE_OUTPUT_TO_FILE=true`	Logs werden an die Edge Microgateway-Protokolldatei gesendet, wie unter Protokolldateien verwalten beschrieben. Protokolle werden an die Datei `edgemicro.log` gesendet.

API-Aufruf testen

Nachdem Sie Edge Microgateway im Container gestartet haben, können Sie API-Aufrufe an den Container ausführen. Wenn der Basispfad Ihrer API beispielsweise /hello lautet:

http://localhost:8000/hello

Beispielausgabe:

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

Wenn diese Antwort angezeigt wird, wurde der API-Aufruf von Edge Microgateway erfolgreich verarbeitet. 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 Schlüssel.

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

Gehen Sie in der Edge-Benutzeroberfläche zur Entwickler-App, die Sie zuvor erstellt haben. Zeigen Sie auf der Seite der Entwickler-App den Consumer-Key an 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 Header x-api-key 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 so übergeben:

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 zu authentifizierten API-Aufrufen über Edge Microgateway mit API-Schlüsseln und OAuth-Tokens finden Sie unter Teil 4: Secure Edge Microgateway.

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 erläutert, 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 er TLS für eingehende Anfragen (Richtung Norden) verwendet. Außerdem können Sie Edge Microgateway als TLS-Client für ausgehende Anfragen an Zielendpunkte (Richtung Süden) konfigurieren.

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

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

Wenn Sie eine Zertifizierungsstelle nutzen, 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.

Geben Sie in diesem Parameter den Pfad zu einer Datei an, die ein oder mehrere vertrauenswürdige Zertifikate im PEM-Format enthält. Informationen zur Verwendung dieses Parameters finden Sie in den Beispielen für TLS nach Norden konfigurieren und TLS für Süden 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

In einigen Fällen möchten Sie möglicherweise die TLS-Validierung für die Ausführung von Edge Microgateway in einem Container deaktivieren, obwohl dies nicht empfohlen wird. Die Funktion zum Deaktivieren von TLS ist nicht standardmäßig in den Docker-Container von Edge Microgateway eingebunden. Damit Sie die Aufgabe ausführen können, müssen Sie ein benutzerdefiniertes Docker-Image für Edge Microgateway erstellen. Im Folgenden finden Sie eine allgemeine Anleitung zum Erstellen des benutzerdefinierten Images und Deaktivieren der TLS-Validierung.

Klonen Sie das Edge Microgateway-Quell-Repository oder laden Sie es aus 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. Wenn Sie den Container später ausführen, geben Sie einen Wert für diese Variable an.
Erstellen Sie den Docker-Container:
```
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: TLS für Norden konfigurieren

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

1. Erste Schritte zur Einrichtung

Suchen Sie die Datei openssl.cnf in 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. Die Datei sollte beispielsweise folgende Informationen 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

Führen Sie die Schritte im Abschnitt Voraussetzungen aus, um Edge Microgateway zu initialisieren und zu konfigurieren, falls Sie dies noch nicht getan haben. Wenn Sie fertig sind, sollten Sie einen Edge Microgateway-fähigen Proxy, ein API-Produkt, einen Entwickler und eine Entwickleranwendung 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

Generieren Sie als Nächstes die Zertifikate und Schlüssel, die Sie zum Einrichten 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, Informationen zum Zertifikat einzugeben. Achten Sie darauf, localhost als Common Name zu verwenden.
Überprü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. Beachten Sie, dass Sie Änderungen an den Attributen port und ssl vornehmen:

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 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 beim Ausführen des Befehls edgemicro config verwendet haben.

Denken Sie daran, um den Befehl 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

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, dass die folgenden Parameter im Befehl verwendet werden. Sie unterscheiden sich von dem grundlegenden 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 Zertifizierungsstelle hinzugefügt (nach Bedarf bei selbst signierten Zertifikaten).

5. TLS-Konfiguration testen

Führen Sie den folgenden cURL-Befehl aus, um die Einrichtung zu testen. Ersetzen Sie im Befehl den Basispfad und den API-Schlüssel. 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-Handshakes. Wenn Sie eine HTTP 200-Antwort erhalten, 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 für Süden konfigurieren

In diesem Abschnitt wird erläutert, wie Sie eine südliche (ausgehende) TLS-Verbindung zwischen dem Edge Microgateway-Server und einer Back-End-Zielanwendung einrichten. Im folgenden Beispiel werden selbst signierte Zertifikate verwendet.

1. Ersteinrichtung

Suchen Sie die Datei openssl.cnf in 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. Die Datei sollte beispielsweise folgende Informationen 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 in Teil 1: Edge Microgateway konfigurieren.

Kopieren Sie die Key- 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, Informationen zum Zertifikat einzugeben. Achten Sie darauf, hellworld als Common Name zu verwenden.
Überprü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 ein neues Dockerfile im selben Verzeichnis wie server.js, wobei WORKDIR der Pfad zum Stammverzeichnis Ihrer Node.js-Anwendung ist:
```
FROM node:8-alpine
WORKDIR path-to-your-node-app
COPY package*.json ./

RUN npm install
COPY . .
EXPOSE 9443
CMD [ "npm", "start" ]
```
Erstellen Sie das Docker-Image:
```
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-fähigen API-Proxy in Edge erstellen.
- Proxy-Name: edgemicro_local
- Version: 1
- Basispfad: /local
- Ziel: https://helloworld:9443
Erstellen Sie ein API-Produkt. Weitere Informationen finden Sie unter Produkte 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. Beachten Sie, dass Sie Änderungen an den Attributen port und ssl vornehmen:

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 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 beim Ausführen des Befehls edgemicro config verwendet haben.

Denken Sie daran, um den Befehl Graviszeichen (`) 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-Aware Proxy verwendet haben, und den API-Schlüssel aus der Entwickleranwendung, die Sie in Apigee Edge erstellt haben. Beispiel:

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

Sie sollten diesen Fehler 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"}

Führen Sie Edge Microgateway noch einmal aus, aber fügen Sie diesmal 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 dabei den Basispfad und den API-Schlüssel wie zuvor. Beispiel:
```
curl https://localhost:8443/local -k -H "x-api-key: xxxx" -v
```

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

...
> 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 Features und Funktionen hinzufügen, indem Sie benutzerdefinierte Plug-ins schreiben. Mit benutzerdefinierten Plug-ins können Sie programmatisch mit den Anfragen und Antworten interagieren, die über das Mikrogateway gesendet werden.

Sie haben zwei Möglichkeiten, Plug-ins für eine Edge Microgateway-Instanz bereitzustellen, 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 von Plug-ins für eine standardmäßige Edge Microgateway-Einrichtung vertraut sind. Ist dies nicht der Fall, lesen Sie den Abschnitt Benutzerdefinierte Plug-ins entwickeln.

Option A: Das Plug-in-Verzeichnis 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 (dem Volume) auf dem Containerbereitstellungspunkt /opt/apigee/plugins bereitstellen. Anschließend geben Sie das lokale Volume-Verzeichnis in der Konfigurationsdatei von Edge Microgateway an.

In den folgenden Schritten wird gezeigt, wie Sie mit einem Docker-Bereitstellungspunkt benutzerdefinierte Plug-ins einbinden.

Beenden Sie Edge Microgateway:
```
edgemicro stop
```
Erstellen Sie ein Verzeichnis für Ihre benutzerdefinierten Plug-ins. Erstellen Sie beispielsweise
```
$HOME/edgemicro/custom/plugins
```

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

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

Schreiben und testen Sie das Plug-in gemäß der Anleitung unter Einfaches Plug-in schreiben. Achten Sie darauf, den Plug-in-Code in der richtigen Verzeichnisstruktur zu platzieren. Beispiel:
```
custom
  |
  |-- plugins
    |
    |- response-uppercase
    |     |- index.js
    |     |- package.json
    |- request-headers
    |     | - index.js
          | - package.json
```

Führen Sie den Docker-Container mit einem Befehl wie dem folgenden aus, wobei Sie die Option -v verwenden, um das Verzeichnis „plugins“ auf dem Docker-Volume bereitzustellen. 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 die API auf, um das Plug-in zu testen.

Weitere Informationen finden Sie unter VOLUME [freigegebene Dateisysteme].

Option B: Plug-ins in den Container integrieren

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

1. Plug-ins verpacken

Schreiben und testen Sie das 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 festgelegten Struktur folgen. Das folgende Beispiel zeigt die Struktur, die Sie befolgen müssen, wobei response-uppercase und request-headers die Namen von Ordnern sind, 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 zum 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 den Plug-in-Code einem Edge Microgateway-Image hinzuzufügen.

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

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

Erstellen Sie mit Ihren Plug-ins ein neues Edge Microgateway-Docker-Image:
```
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 der Konfigurationsdatei Edge Microgateway hinzufügen.

Öffnen Sie die Konfigurationsdatei von Edge Microgateway in einem Editor:
```
$HOME/.edgemicro/org-env-config.yaml
```
Beispiel:
```
vi $HOME/.edgemicro/myorg-test-config.yaml
```
Fügen Sie das Plug-in-Verzeichnis zur Konfigurationsdatei hinzu. Im folgenden Beispiel gibt das Attribut dir den Speicherort des Plug-in-Codes an, den Sie im Dockerfile angegeben haben. Außerdem müssen Sie den Namen des Plug-in-Verzeichnisses angeben. Im folgenden Beispiel lautet er response-uppercase.
```
edgemicro:
  ...
  plugins:
    dir: /opt/apigee/plugins
    sequence:
      - oauth
      - response-uppercase
```

4. Mikrogateway starten

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

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 beim Ausführen des Befehls edgemicro config verwendet haben.

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

Edge Microgateway als Container ausführen Der Befehl legt mehrere Umgebungsvariablen fest, die von der Containerlaufzeit 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 die API auf, um das Plug-in zu testen:

Testen Sie, ob der Plug-in-Code ausgeführt wird. Rufen Sie dazu die API auf und prüfen Sie, ob die Ausgabe wie erwartet funktioniert:
```
curl -i http://localhost:8000/hello -H "x-api-key:apikey"
```
Das response-uppercase-Plug-in könnte beispielsweise eine Antwort wie diese zurückgeben:
```
curl -i http://localhost:8000/hello -H "x-api-key:PydUKRDGIXRqF2xh4usn1FLHbhGKVIz"
  HELLO, WORLD!
```