Docker für Edge Microgateway verwenden

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

In diesem Thema wird erläutert, wie Sie Edge Microgateway in einem Docker-Container ausführen. Bei den in diesem Thema beschriebenen Schritten wird davon ausgegangen, dass Sie über grundlegende Kenntnisse von Docker, Docker-Befehlen sowie der Einrichtung und Konfiguration von Edge Microgateway verfügen. 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 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 unter 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 die 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 bei der Ausführung 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-fähiger 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

  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 im Abschnitt Voraussetzungen ausgeführt haben.

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

    Denken Sie daran, den Befehl in Backticks (`) 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 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. Weitere Informationen finden Sie in der Docker-Referenz zu „run“.
    -p Einen einzelnen Port oder einen Portbereich explizit zuordnen. Weitere Informationen finden Sie in der Docker-Referenz zu „run“.
    -d Im getrennten Modus ausführen. Weitere Informationen finden Sie in der Docker-Referenz zu „run“.
    -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 Verzeichnis der Logdatei bereitstellen. Siehe auch VOLUME [freigegebene Dateisysteme]. Weitere Informationen finden Sie unter TLS im Docker-Container verwenden.
    -w, -- workdir (Optional) Gibt den Pfad zum Verzeichnis an, in dem die Dateien edgemicro.sock und edgemicro.pid erstellt werden sollen. Sie können den Stamm des Dateinamens 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 (Boolescher Wert) Ermöglicht die Angabe, wohin die Logausgabe gesendet wird. Weitere Informationen finden Sie unter Optionen für Protokolldateien 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 Logdateien angeben

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

    Wenn Sie verhindern möchten, dass Protokollinformationen 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 beschrieben, wenn Sie LOG_CONSOLE_OUTPUT_TO_FILE mit to_console verwenden:

    to_console: true

    LOG_CONSOLE_OUTPUT_TO_FILE=false

    • Es werden keine Logs an die Edge Microgateway-Logdatei gesendet, wie unter Logdateien verwalten beschrieben.
    • Logs werden nicht an die Datei edgemicro.log gesendet.
    to_console: true

    LOG_CONSOLE_OUTPUT_TO_FILE=true

    • Es werden keine Logs an die Edge Microgateway-Logdatei gesendet, wie unter Logdateien verwalten beschrieben.
    • Logs werden an die Datei edgemicro.log gesendet.
    to_console: false

    LOG_CONSOLE_OUTPUT_TO_FILE=true

    • Logs werden an die Edge Microgateway-Logdatei gesendet, wie unter Logdateien 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 Edge Microgateway senden. Wenn der Basispfad Ihrer API beispielsweise /hello lautet:

    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. Rufen Sie die Seite „Developer App“ auf, lassen Sie sich den Consumer-Key anzeigen und kopieren Sie ihn. Dieser Wert ist der API-Schlüssel. Mit diesem Schlüssel können Sie authentifizierte API-Aufrufe ausführen.

    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 übergeben, etwa so:

    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 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 (Northbound-Richtung) verwendet. Außerdem können Sie Edge Microgateway als TLS-Client für ausgehende Anfragen an Zielendpunkte (Southbound-Richtung) konfigurieren.

    Speicherort für 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
    ...
    

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

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

    Legen Sie für diesen Parameter den Pfad zu einer Datei fest, die ein oder mehrere vertrauenswürdige Zertifikate im PEM-Format enthält. Beispiele für die Verwendung dieses Parameters finden Sie unter 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 dies nicht empfohlen wird, kann es in einigen Fällen sinnvoll sein, die TLS-Validierung für Edge Microgateway zu deaktivieren, das 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. Im Folgenden finden Sie eine allgemeine Anleitung zum Erstellen des benutzerdefinierten Images und zum Deaktivieren der TLS-Validierung.

    1. Klonen Sie das Edge Microgateway-Quell-Repository von https://github.com/apigee-internal/microgateway oder laden Sie es herunter.

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

      Beispiel:

      cd $HOME/git/microgateway/kubernetes/docker/edgemicro
      
    3. Ö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.

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

    In diesem Abschnitt wird erläutert, 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 selbst signierte Zertifikate verwendet.

    1. Erste Einrichtungsschritte

    1. Suchen Sie die Datei openssl.cnf auf Ihrem System. Beispiel: /etc/ssl/openssl.cnf.
    2. Öffnen Sie die Datei opensssl.cnf zur Bearbeitung.
    3. Achten Sie darauf, dass die req_extensions in Ihrer Konfigurationsdatei vorhanden sind. 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
      
    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 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 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

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

    1. Wechseln Sie mit cd zum Verzeichnis $HOME/.edgemicro.
    2. Erstellen Sie das folgende Bash-Skript. Sie können einen beliebigen Namen verwenden. 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 nach Zertifikatsinformationen gefragt. Verwenden Sie für den allgemeinen Namen localhost.

    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-Strophe 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:
      ...
      
    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 die Umgebung, die Sie beim Ausführen des Befehls edgemicro config verwendet haben.

      Denken Sie daran, den Befehl in Backticks (`) 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 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.
      • Ein Volume-Mount wird verwendet, um die Schlüssel- und Zertifikatsdateien bereitzustellen.
      • Die Variable NODE_EXTRA_CA_CERTS wird verwendet, um eine benutzerdefinierte Zertifizierungsstelle hinzuzufügen (wie bei selbst signierten Zertifikaten erforderlich).

    5. TLS-Konfiguration testen

    1. 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 im 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"
      
    2. 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: Southbound-TLS konfigurieren

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

    1. Ersteinrichtung

    1. Suchen Sie die Datei openssl.cnf auf Ihrem System. Beispiel: /etc/ssl/openssl.cnf.
    2. Öffnen Sie die Datei opensssl.cnf zur Bearbeitung.
    3. Achten Sie darauf, dass die req_extensions in Ihrer Konfigurationsdatei vorhanden sind. 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
      
    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 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

    1. Wechseln Sie mit cd zum Verzeichnis .edgemicro.

    2. Erstellen Sie das folgende Bash-Skript. Sie können einen beliebigen Namen verwenden. 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, Zertifikatsinformationen einzugeben. Verwenden Sie für den allgemeinen Namen hellworld.

    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 im selben Verzeichnis wie server.js die Datei package.json. 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 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" ]
      
    10. Docker-Image erstellen:

      docker build -t helloworld . 
      
    11. Starten Sie die Beispiel-App:

      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 finden Sie unter Edge Microgateway-fähigen API-Proxy in Edge erstellen.

      • Proxy-Name: edgemicro_local
      • Version: 1
      • Basispfad: /local
      • Ziel: https://helloworld:9443
    2. API-Produkt erstellen Weitere Informationen finden Sie unter Produkt erstellen.

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

    4. Erstellen Sie eine Entwickler-App. 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-Strophe 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:
      ...
      
    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 die Umgebung, die Sie beim Ausführen des Befehls edgemicro config verwendet haben.

      Denken Sie daran, den Befehl in Backticks (`) 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 Sie den Basispfad, den Sie im Microgateway-fähigen 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"}
      
    2. Führen Sie Edge Microgateway noch einmal aus, aber fügen Sie dieses Mal 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 Sie den Basispfad und den 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 die HTTP-Statusantwort 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 Funktionen und Möglichkeiten 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 Microgateway fließen.

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

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

    Option A: 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 (das Volume) am Container-Bereitstellungspunkt /opt/apigee/plugins bereitstellen. Anschließend geben Sie das Verzeichnis des lokalen Volumes in der Edge Microgateway-Konfigurationsdatei an.

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

    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 das benutzerdefinierte Plug-in-Verzeichnis der Edge Microgateway-Konfigurationsdatei hinzu. Beispiel:

        plugins:
          dir: $HOME/edgemicro/custom/plugins
          sequence:
            - oauth
            - response-uppercase
        ````
      
    4. Schreiben und testen Sie Ihr Plug-in gemäß der Anleitung unter Einfaches Plug-in schreiben. Achten Sie darauf, dass Sie den Plug-in-Code in der richtigen Verzeichnisstruktur platzieren. 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 wie dem folgenden aus. Verwenden Sie dabei die Option -v, um das Plug-in-Verzeichnis im 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
      
    6. Rufen Sie Ihre API auf, um das Plug-in zu testen.

    Weitere Informationen finden Sie unter VOLUME [freigegebene Dateisysteme].

    Option B: Plug-ins in den Container einbinden

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

    1. Plug-ins verpacken

    1. Schreiben und testen Sie Ihr 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 bestimmten Struktur folgen. Das folgende Beispiel zeigt die Struktur, die Sie einhalten 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
      
    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 Ihren 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 den folgenden Code in Dockerfile ein und speichern Sie die Datei:

      FROM gcr.io/apigee-microgateway/edgemicro:latest
      USER root
      RUN apt-get update && \
          apt-get install -y unzip && \
          rm -rf /var/lib/apt/lists/* && \
          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 ["/opt/apigee/entrypoint.sh"]
      
    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 wurden, müssen Sie sie der Edge Microgateway-Konfigurationsdatei hinzufügen.

    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 das Plug-in-Verzeichnis der Konfigurationsdatei 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, im Beispiel unten response-uppercase.

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

    4. Microgateway starten

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

    1. 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 die Umgebung, die Sie beim Ausführen des Befehls edgemicro config verwendet haben.

      Denken Sie daran, den Befehl in Backticks (`) 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 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
    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 wie erwartet ist:

      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!