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:

    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 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
    -w, -- workdir (Optional) Gibt den Pfad zum Verzeichnis an, in dem edgemicro.sock- und edgemicro.pid-Dateien müssen folgende Kriterien erfüllen: erstellt. Sie können den Dateinamen Stamm edgemicro nicht ändern. Die Standardeinstellung ist der Pfad des aktuellen Arbeitsverzeichnisses.

    Beispiel: 

    docker run -P -p 8000:8000 -d -w /tmp --name edgemicro 
    
...
    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.
    LOG_CONSOLE_OUTPUT_TO_FILE (Boolesch) Hiermit können Sie angeben, wohin die Logausgabe gesendet werden soll. Siehe Optionen für die Protokolldatei 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

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

    Ausgabeoptionen für die Protokolldatei angeben

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

    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.
    • Logs 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.
    • Logs werden an die Datei edgemicro.log gesendet.
    to_console: false

    LOG_CONSOLE_OUTPUT_TO_FILE=true

    • Protokolle werden an die Edge Microgateway-Protokolldatei gesendet, wie unter Protokolldateien verwalten beschrieben.
    • Logs werden an die Datei edgemicro.log gesendet.

    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:

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

    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 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 in 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 Common Name.

    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:

      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

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

      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

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

      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

    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:

    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:

      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

    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!