Korzystanie z Dockera dla Edge Microgateway

Wyświetlasz dokumentację Apigee Edge.
Otwórz dokumentację Apigee X.
info

W tym artykule wyjaśniamy, jak uruchomić Edge Microgateway w kontenerze Dockera. Kroki opisane w tym temacie zakładają podstawową znajomość Dockera, poleceń Dockera oraz konfiguracji Edge Microgateway. Więcej informacji znajdziesz w dokumentacji Dockera i Edge Microgateway.

Wymagania wstępne

Zanim uruchomisz Edge Microgateway w kontenerze Dockera, musisz wykonać te czynności:

  • Skonfiguruj Edge Microgateway dla organizacji/środowiska Apigee:

    edgemicro configure -o your_org -e your_env -u your_username

    Więcej informacji o konfiguracji znajdziesz w sekcji Część 1. Konfigurowanie Edge Microgateway.

  • Po wykonaniu czynności konfiguracyjnych znajdź plik konfiguracji. Domyślna lokalizacja:

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

    gdzie your_org i your_env to organizacja i środowisko użyte podczas uruchamiania polecenia edgemicro config. Ten plik będzie potrzebny podczas uruchamiania Edge Microgateway w kontenerze Dockera.

  • Upewnij się, że masz dane logowania klucza i klucza tajnego, które zostały zwrócone po uruchomieniu polecenia edgemicro config. Na przykład:

    The following credentials are required to start edge micro
      key: d9c34e1aff68ed969273c016699eabf48780e4f652242e72fc88a43e21252cb0
      secret: 3bc95a71c86a3c8ce04537fbcb788158731t51dfc6cdec13b7c05aa0bd969430
    
  • Zanim uruchomisz Edge Microgateway w kontenerze Dockera, musisz utworzyć (lub mieć już utworzone) encje Apigee Edge, które są wymagane do wykonywania uwierzytelnionych wywołań serwera proxy interfejsu API. Te elementy obejmują serwer proxy obsługujący Edge Microgateway, usługę API, programistę i aplikację programisty. Pełne instrukcje znajdziesz w artykule Tworzenie elementów w Apigee Edge.

Uruchamianie Edge Micro jako kontenera Dockera

  1. Pobierz obraz Dockera dla Edge Microgateway:

    docker pull gcr.io/apigee-microgateway/edgemicro:latest
  2. Zanim przejdziesz do kolejnych kroków, upewnij się, że zostały wykonane wszystkie czynności opisane w sekcji Wymagania wstępne.

  3. Uruchom to polecenie, aby zakodować w formacie base64 plik konfiguracji Edge Microgateway znajdujący się w $HOME/.edgemicro:

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

    gdzie your_org i your_env to organizacja i środowisko użyte podczas uruchamiania polecenia edgemicro config.

    Pamiętaj, aby umieścić polecenie w grawisach (`). Na przykład:

    export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/docs-test-config.yaml`
  4. Uruchom Edge Microgateway jako kontener. Polecenie ustawia kilka zmiennych środowiskowych, które są używane przez środowisko wykonawcze kontenera do uruchomienia Edge Microgateway:

    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

    Parametry

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

    Parametr Opis
    -P Opublikuj wszystkie udostępnione porty na hoście. Zobacz też dokumentację polecenia docker run.
    -p Zmapuj pojedynczy port lub zakres portów. Zobacz też dokumentację polecenia docker run.
    -d Uruchom w trybie odłączonym. Zobacz też dokumentację polecenia docker run.
    -v, -- volume Określa punkt montowania woluminu. Pamiętaj, że jeśli skonfigurujesz Edge Microgateway do korzystania z TLS w kontenerze Dockera, musisz udostępnić port 8443, jeśli zamontujesz katalog plików dziennika. Zobacz też VOLUME [shared filesystems] (Wolumin [udostępnione systemy plików]). Zobacz też Korzystanie z TLS w kontenerze Dockera.
    -w, -- workdir (Opcjonalnie) Określa ścieżkę do katalogu, w którym mają zostać utworzone pliki edgemicro.sock i edgemicro.pid. Nie możesz zmienić katalogu głównego nazwy pliku edgemicro. Domyślnie jest to ścieżka bieżącego katalogu roboczego.

    Przykład:

    docker run -P -p 8000:8000 -d -w /tmp --name edgemicro 
    ...
    EDGEMICRO_ORG Nazwa organizacji Apigee użytej do skonfigurowania Edge Microgateway.
    EDGEMICRO_ENV Nazwa środowiska Apigee użytego do skonfigurowania Edge Microgateway.
    EDGEMICRO_PROCESSES Liczba procesów do uruchomienia.
    EDGEMICRO_KEY Klucz zwrócony podczas konfigurowania Edge Microgateway.
    EDGEMICRO_SECRET Klucz tajny zwrócony podczas konfigurowania Edge Microgateway.
    EDGEMICRO_CONFIG Zmienna zawierająca plik konfiguracji Edge Microgateway zakodowany w formacie base64.
    LOG_CONSOLE_OUTPUT_TO_FILE (Wartość logiczna) Pozwala określić, gdzie mają być wysyłane dane wyjściowe logów. Więcej informacji znajdziesz w artykule na temat określania opcji pliku dziennika.

    Na przykład:

    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. Aby sprawdzić, czy kontener działa:

      docker ps

      Zostaną wyświetlone dane wyjściowe podobne do tych:

      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
      

    Określanie opcji wyjściowych pliku dziennika

    Parametr konfiguracji Edge Microgateway to_console umożliwia wysyłanie informacji z dziennika do standardowego strumienia wyjścia zamiast do pliku dziennika. Jeśli wykonasz czynności opisane w sekcji dotyczącej uruchamiania Edge Microgateway w kontenerze Dockera, kontener domyślnie przekieruje standardowe wyjście i wyjście błędu do pliku znajdującego się w kontenerze w lokalizacji: ${APIGEE_ROOT}/logs/edgemicro.log.

    Aby zapobiec wysyłaniu informacji z dziennika do edgemicro.log, podczas uruchamiania kontenera użyj zmiennej LOG_CONSOLE_OUTPUT_TO_FILE.

    W tabeli poniżej opisano zachowanie danych wyjściowych logu, gdy używasz LOG_CONSOLE_OUTPUT_TO_FILE z to_console:

    to_console: true

    LOG_CONSOLE_OUTPUT_TO_FILE=false

    • Do pliku dziennika Edge Microgateway nie będą wysyłane żadne dzienniki, jak opisano w artykule Zarządzanie plikami dziennika.
    • Dzienniki nie będą wysyłane do pliku edgemicro.log.
    to_console: true

    LOG_CONSOLE_OUTPUT_TO_FILE=true

    • Do pliku dziennika Edge Microgateway nie będą wysyłane żadne dzienniki, jak opisano w artykule Zarządzanie plikami dziennika.
    • Dzienniki będą wysyłane do pliku edgemicro.log.
    to_console: false

    LOG_CONSOLE_OUTPUT_TO_FILE=true

    • Dzienniki będą wysyłane do pliku dziennika Edge Microgateway, jak opisano w artykule Zarządzanie plikami dziennika.
    • Dzienniki będą wysyłane do pliku edgemicro.log.

    Testowanie wywołania interfejsu API

    Po uruchomieniu Edge Microgateway w kontenerze możesz wykonywać wywołania interfejsu API. Jeśli na przykład ścieżka podstawowa interfejsu API to /hello:

    http://localhost:8000/hello

    Przykładowe dane wyjściowe:

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

    Jeśli widzisz tę odpowiedź, oznacza to, że Edge Microgateway pomyślnie obsłużył wywołanie interfejsu API. Domyślnie Edge Microgateway wymaga jednak klucza interfejsu API do uwierzytelniania. W następnej sekcji przetestujesz interfejs API z prawidłowym kluczem interfejsu API.

    Testowanie interfejsu API z prawidłowym kluczem interfejsu API

    W interfejsie Edge przejdź do utworzonej wcześniej aplikacji dewelopera. Na stronie aplikacji dewelopera wyświetl klucz klienta i skopiuj go. Ta wartość to klucz interfejsu API. Użyjesz tego klucza do uwierzytelniania wywołań interfejsu API.

    Wywołaj interfejs API z nagłówkiem x-api-key w następujący sposób. Wartość klucza klienta skopiowana z aplikacji dewelopera to klucz interfejsu API. Domyślnie Edge Microgateway oczekuje, że klucz zostanie przekazany w nagłówku o nazwie x-api-key, na przykład:

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

    Na przykład:

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

    Jeśli chcesz dowiedzieć się więcej o wykonywaniu uwierzytelnionych wywołań interfejsu API przez Edge Microgateway za pomocą kluczy interfejsu API i tokenów OAuth, przeczytaj część 4: Zabezpieczanie Edge Microgateway.

    Zatrzymywanie Edge Microgateway

    Aby zatrzymać Edge Microgateway, użyj tego polecenia Dockera:

    docker stop edgemicro
    

    Ponowne uruchamianie Edge Microgateway

    Po zatrzymaniu Edge Microgateway możesz go ponownie uruchomić za pomocą tego polecenia Dockera:

    docker start edgemicro
    

    Używanie TLS w kontenerze Dockera

    W tej sekcji opisano, jak skonfigurować TLS dla Edge Microgateway działającego w kontenerze Dockera. Możesz skonfigurować serwer Edge Microgateway tak, aby używał protokołu TLS w przypadku żądań przychodzących (kierunek północny), oraz skonfigurować Edge Microgateway jako klienta TLS w przypadku żądań wychodzących do docelowych punktów końcowych (kierunek południowy).

    Gdzie umieścić pliki certyfikatów

    Kontener Dockera, w którym działa Edge Microgateway, ma punkt podłączania w /opt/apigee/.edgemicro. Gdy konfigurujesz Edge Microgateway do używania certyfikatów TLS, możesz udostępnić pliki certyfikatów w tym punkcie podłączania i odwoływać się do nich w pliku konfiguracji Edge Microgateway. Ten plik konfiguracji zwykle znajduje się w katalogu $HOME/.edgemicro i ma nazwę your_org-your_env-config.yaml. Na przykład:

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

    Używanie urzędu certyfikacji, który nie jest zaufany dla Node.js

    Jeśli używasz urzędu certyfikacji, który nie jest domyślnie zaufany przez Node.js (jak w przypadku certyfikatu podpisanego samodzielnie), rozważ użycie parametru NODE_EXTRA_CA_CERTS podczas uruchamiania kontenera.

    Ustaw ten parametr na ścieżkę do pliku zawierającego co najmniej 1 zaufany certyfikat w formacie PEM. Aby zobaczyć, jak używany jest ten parametr, zapoznaj się z przykładami Jak skonfigurować TLS northbound i Jak skonfigurować TLS southbound.

    Na przykład:

    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
    

    Zobacz też Uruchamianie Edge Micro jako kontenera Dockera.

    Wyłączanie weryfikacji TLS

    Chociaż nie jest to zalecane, w niektórych przypadkach możesz wyłączyć sprawdzanie poprawności TLS dla Edge Microgateway działającego w kontenerze. Możliwość wyłączenia TLS nie jest domyślnie wbudowana w kontener Dockera Edge Microgateway. Aby wykonać to zadanie, musisz utworzyć dostosowany obraz Dockera dla Edge Microgateway. Poniżej znajdziesz ogólne instrukcje tworzenia obrazu niestandardowego i wyłączania weryfikacji TLS.

    1. Sklonuj lub pobierz repozytorium źródłowe Edge Microgateway z https://github.com/apigee-internal/microgateway.

    2. cd do katalogu microgateway/kubernetes/docker/edgemicro w katalogu z kodem źródłowym.

      Na przykład:

      cd $HOME/git/microgateway/kubernetes/docker/edgemicro
      
    3. Otwórz plik entrypoint.sh i zmodyfikuj kod, aby akceptował zmienną środowiskową NODE_TLS_REJECT_UNAUTHORIZED. Później, podczas uruchamiania kontenera, określisz wartość tej zmiennej.

    4. Utwórz kontener Dockera:

      docker build -t edgemicro .
      
    5. Podczas uruchamiania kontenera określ opcję -e NODE_TLS_REJECT_UNAUTHORIZED = 1. Na przykład:

    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
    

    Przykład: jak skonfigurować TLS dla ruchu wychodzącego

    W tej sekcji wyjaśniamy, jak skonfigurować połączenie TLS northbound (przychodzące) na serwerze Edge Microgateway. Protokół TLS dla ruchu wychodzącego umożliwia klientom używanie protokołu HTTPS podczas wywoływania interfejsu API do Edge Microgateway. W przykładzie poniżej użyto certyfikatów podpisanych samodzielnie.

    1. Kroki konfiguracji początkowej

    1. Znajdź plik openssl.cnf w systemie. Na przykład: /etc/ssl/openssl.cnf.
    2. Otwórz plik opensssl.cnf do edycji.
    3. Upewnij się, że w pliku konfiguracji znajdują się te elementy: req_extensions. Plik powinien zawierać informacje podobne do tych:

      [ req ]
      ...
      req_extensions          = v3_req
      ...
      
      [ v3_req ]
      extendedKeyUsage = serverAuth, clientAuth, codeSigning, emailProtection
      basicConstraints = CA:FALSE
      keyUsage = nonRepudiation, digitalSignature, keyEncipherment
      
    4. Aby wygenerować odpowiednie atrybuty SNI, dodaj do pliku openssl.cnf tę sekcję:

      [ 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
      

      Przykładowy plik opensssl.cnf:

      [ 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. Jeśli jeszcze nie masz zainicjowanej i skonfigurowanej usługi Edge Microgateway, wykonaj czynności opisane w sekcji Wymagania wstępne. Po wykonaniu tych czynności powinny być utworzone: serwer proxy obsługujący Edge Microgateway, usługa API, deweloper i aplikacja dewelopera. Dodatkowo powinno być uruchomione polecenie edgemicro configure i otrzymany klucz oraz tajny klucz.

    2. Generowanie certyfikatów podpisanych samodzielnie

    Następnie wygeneruj certyfikaty i klucze, które będą potrzebne do ustanowienia TLS:

    1. cd do katalogu $HOME/.edgemicro.
    2. Utwórz ten skrypt bash. Możesz nadać mu dowolną nazwę. Na przykład: 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. W pliku bash upewnij się, że ścieżka do pliku openssl.cnf jest prawidłowa.

    4. Wykonaj plik bash. Pojawi się prośba o podanie informacji o certyfikacie. Pamiętaj, aby jako nazwę pospolitą użyć localhost.

    5. Sprawdź, czy zostały utworzone te pliki:

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

    3. Edytowanie pliku konfiguracji Edge Microgateway

    1. Otwórz plik konfiguracji Edge Micro w edytorze. Na przykład:

      vi $HOME/.edgemicro/myorg-test-config.yaml
      
    2. Zmodyfikuj sekcję edgemicro w następujący sposób. Pamiętaj, że wprowadzasz zmiany w atrybutach port i ssl:

      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. Uruchom to polecenie, aby zakodować w formacie base64 plik konfiguracji Edge Microgateway znajdujący się w $HOME/.edgemicro:

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

      gdzie your_org i your_env to organizacja i środowisko użyte podczas uruchamiania polecenia edgemicro config.

      Pamiętaj, aby umieścić polecenie w grawisach (`). Na przykład:

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

    Zobacz też Uruchamianie Edge Micro jako kontenera Dockera.

    4. Uruchom kontener

    1. Uruchom to polecenie, aby uruchomić kontener Dockera z Edge Microgateway:

      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. Zwróć uwagę na te parametry użyte w poleceniu. Różnią się one od podstawowego polecenia opisanego w artykule Uruchamianie Edge Micro jako kontenera Dockera.

      • Wartość port jest ustawiona na 8443.
      • Do podłączenia plików klucza i certyfikatu używany jest punkt podłączenia woluminu.
      • Zmienna NODE_EXTRA_CA_CERTS służy do dodawania niestandardowego urzędu certyfikacji (w razie potrzeby w przypadku certyfikatów podpisanych samodzielnie).

    5. Testowanie konfiguracji TLS

    1. Aby przetestować konfigurację, uruchom to polecenie cURL. Zastąp w poleceniu ścieżkę podstawową i klucz interfejsu API. W tym przykładzie zakładamy, że znajdujesz się w katalogu, w którym znajduje się rootca.pem, a utworzony przez Ciebie serwer proxy ma ścieżkę podstawową /hello:

      curl -v https://localhost:8443/hello --cacert rootca.pem \
      -H "x-api-key: Az82fdnfONVCOOE4NKhajxAboDgA3FAo"
      
    2. Szczegółowe dane wyjściowe cURL pokazują każdy krok uzgadniania połączenia TLS. Jeśli zobaczysz odpowiedź HTTP 200, konfiguracja się powiodła:

      *   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!
      

    Przykład: jak skonfigurować TLS dla ruchu wychodzącego

    W tej sekcji wyjaśniamy, jak skonfigurować połączenie TLS southbound (wychodzące) między serwerem Edge Microgateway a aplikacją docelową backendu. W przykładzie poniżej użyto certyfikatów podpisanych samodzielnie.

    1. Kroki konfiguracji początkowej

    1. Znajdź plik openssl.cnf w systemie. Na przykład: /etc/ssl/openssl.cnf.
    2. Otwórz plik opensssl.cnf do edycji.
    3. Upewnij się, że w pliku konfiguracji znajdują się te elementy: req_extensions. Plik powinien zawierać informacje podobne do tych:

      [ req ]
      ...
      req_extensions          = v3_req
      ...
      
      [ v3_req ]
      extendedKeyUsage = serverAuth, clientAuth, codeSigning, emailProtection
      basicConstraints = CA:FALSE
      keyUsage = nonRepudiation, digitalSignature, keyEncipherment
      
    4. Aby wygenerować odpowiednie atrybuty SNI, dodaj do pliku openssl.cnf tę sekcję:

      [ 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
      

      Przykładowy plik opensssl.cnf:

      [ 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. Uruchom polecenie edgemicro configure:

      edgemicro configure -o your_org -e your_env -u your_username

      Więcej informacji o konfiguracji znajdziesz w sekcji Część 1. Konfigurowanie Edge Microgateway.

    6. Skopiuj klucz i tajne dane uwierzytelniające zwrócone przez edgemicro configure. Te wartości będą potrzebne do uruchomienia kontenera. Na przykład:

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

    2. Tworzenie aplikacji docelowej w Node.js

    1. cd do katalogu .edgemicro.

    2. Utwórz ten skrypt bash. Możesz nadać mu dowolną nazwę. Na przykład: 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. W pliku bash upewnij się, że ścieżka do pliku openssl.cnf jest prawidłowa.

    4. Wykonaj plik bash. Pojawi się prośba o podanie informacji o certyfikacie. Pamiętaj, aby jako nazwę pospolitą użyć hellworld.

    5. Sprawdź, czy zostały utworzone te pliki:

      • rootca.key
      • rootca.pem
      • tls.key
      • tls.csr
      • rootca.srl
      • tls.crt
    6. Utwórz nowy plik o nazwie 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. Utwórz plik package.json w tym samym katalogu, w którym znajduje się plik server.js. Na przykład:

      {
        "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. Aby uzyskać zależności, uruchom npm install.

    9. Utwórz nowy plik Dockerfile w tym samym katalogu co server.js, gdzie WORKDIR to ścieżka do katalogu głównego aplikacji Node.js:

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

      docker build -t helloworld . 
      
    11. Uruchom przykładową aplikację:

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

    3. Tworzenie encji w Apigee Edge

    1. Utwórz serwer proxy obsługujący Edge Microgateway z tymi ustawieniami. Więcej informacji znajdziesz w artykule Tworzenie serwera proxy interfejsu API obsługującego Edge Microgateway w Edge.

      • Nazwa serwera proxy: edgemicro_local
      • Wersja: 1
      • Ścieżka podstawowa: /local
      • Cel: https://helloworld:9443
    2. utworzyć usługę interfejsu API, Więcej informacji znajdziesz w artykule Tworzenie produktu.

    3. Utwórz dewelopera. Więcej informacji znajdziesz w artykule Tworzenie konta dewelopera.

    4. Utwórz aplikację dewelopera. Szczegółowe informacje znajdziesz w artykule Tworzenie aplikacji dewelopera.

    4. Uruchom kontener

    1. Otwórz plik konfiguracji Edge Micro w edytorze. Na przykład:

      vi $HOME/.edgemicro/myorg-test-config.yaml
      
    2. Zmodyfikuj sekcję edgemicro w następujący sposób. Pamiętaj, że wprowadzasz zmiany w atrybutach port i ssl:

      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. Uruchom to polecenie, aby zakodować w formacie base64 plik konfiguracji Edge Microgateway znajdujący się w $HOME/.edgemicro:

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

      gdzie your_org i your_env to organizacja i środowisko użyte podczas uruchamiania polecenia edgemicro config.

      Pamiętaj, aby umieścić polecenie w grawisach (`). Na przykład:

      export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/docs-test-config.yaml`
    4. Uruchom to polecenie, aby uruchomić Edge Microgateway w kontenerze Dockera.

      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. Testowanie konfiguracji TLS

    1. Aby przetestować konfigurację, uruchom to polecenie cURL. Zastąp ścieżkę podstawową, której używasz w serwerze proxy obsługującym mikrobramę, oraz klucz interfejsu API uzyskany z aplikacji dewelopera utworzonej w Apigee Edge. Na przykład:

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

      Powinien pojawić się ten błąd:

      ...
      *  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. Uruchom ponownie Edge Microgateway, ale tym razem dodaj zmienną NODE_EXTRA_CA_CERTS.

      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. Uruchom to polecenie cURL. Zastąp ścieżkę podstawową i klucz interfejsu API tak jak wcześniej. Na przykład:

      curl https://localhost:8443/local -k -H "x-api-key: xxxx" -v
      
    4. Sprawdź dane wyjściowe. W przypadku powodzenia otrzymasz odpowiedź o stanie 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
      

    Dodawanie wtyczki niestandardowej

    Możesz dodawać nowe funkcje i możliwości do mikrobramy, pisząc niestandardowe wtyczki. Wtyczki niestandardowe umożliwiają interakcję z żądaniami i odpowiedziami, które przechodzą przez mikrobramę.

    Wtyczki we wdrożonej instancji Edge Microgateway działającej w kontenerze Dockera możesz wdrożyć na 2 sposoby:

    W pozostałej części tej sekcji zakładamy, że wiesz, jak pisać i konfigurować wtyczki do standardowej konfiguracji Edge Microgateway. Jeśli nie, zapoznaj się z artykułem Tworzenie niestandardowych wtyczek.

    Opcja A. Podłącz katalog wtyczek do woluminu

    (Dodano w wersji 2.5.27) Czynności związane z dodawaniem wtyczek przez podłączenie woluminu są podobne do czynności wymaganych do dodania dowolnej wtyczki niestandardowej do Edge Microgateway. Podczas uruchamiania kontenera Dockera możesz podłączyć katalog wtyczek w systemie lokalnym (wolumin) do punktu podłączania kontenera, którym jest /opt/apigee/plugins. Następnie określasz katalog woluminu lokalnego w pliku konfiguracji Edge Microgateway.

    Poniżej opisujemy, jak używać punktu podłączania Dockera do dołączania niestandardowych wtyczek.

    1. Zatrzymaj Edge Microgateway:

      edgemicro stop
      
    2. Utwórz katalog na niestandardowe wtyczki. Na przykład utwórz

      $HOME/edgemicro/custom/plugins
      
    3. Dodaj katalog wtyczki niestandardowej do pliku konfiguracji Edge Microgateway. Na przykład:

        plugins:
          dir: $HOME/edgemicro/custom/plugins
          sequence:
            - oauth
            - response-uppercase
        ````
      
    4. Napisz i przetestuj wtyczkę zgodnie ze wskazówkami podanymi w artykule Pisanie prostej wtyczki. Pamiętaj, aby umieścić kod wtyczki w odpowiedniej strukturze katalogów. Na przykład:

      custom
        |
        |-- plugins
          |
          |- response-uppercase
          |     |- index.js
          |     |- package.json
          |- request-headers
          |     | - index.js
                | - package.json
      
    5. Uruchom kontener Dockera za pomocą polecenia podobnego do poniższego, w którym używasz opcji -v, aby podłączyć katalog wtyczek do woluminu Dockera. W przykładowym poleceniu poniżej katalog wtyczek $HOME/edgemicro/custom/plugins (w którym znajduje się wtyczka niestandardowa) jest mapowany na punkt podłączania kontenera /opt/apigee/plugins:

      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. Wywołaj interfejs API, aby przetestować wtyczkę.

    Więcej informacji znajdziesz w sekcji VOLUME [shared filesystems] (Wolumin [udostępnione systemy plików]).

    Opcja B. Wbudowanie wtyczek w kontener

    W tej opcji wbudowujesz wtyczki w kontener.

    1. Pakowanie wtyczek

    1. Napisz i przetestuj wtyczkę zgodnie ze wskazówkami podanymi w artykule Pisanie prostej wtyczki.

    2. Umieść kod wtyczki w odpowiedniej strukturze katalogów. Katalogi wtyczek muszą mieć określoną strukturę. Poniższy przykład pokazuje strukturę, której należy przestrzegać, gdzie response-uppercase i request-headers to nazwy folderów zawierających niestandardowy kod wtyczki (te nazwy są tylko przykładami, nazwy folderów mogą się różnić):

      plugin
        |
        |-- plugins
          |
          |- response-uppercase
          |     |- index.js
          |     |- package.json
          |- request-headers
          |     | - index.js
                | - package.json
      
    3. cd do folderu plugin.

    4. W folderze plugin skompresuj cały folder plugins:

      zip -r plugins.zip plugins/

    2. Tworzenie obrazu Dockera

    Następnie utwórz plik Dockerfile, aby dodać kod wtyczki do obrazu Edge Microgateway.

    1. W tym samym katalogu, w którym znajduje się plik ZIP, utwórz nowy plik o nazwie Dockerfile.
    2. Dodaj do pliku Dockerfile ten kod i zapisz plik:

      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. Utwórz nowy obraz Dockera Edge Microgateway z wtyczkami:

      docker build -t image-name .

      Na przykład:

      docker build -t edgemicroplugins .

    3. Aktualizowanie konfiguracji Edge Microgateway

    Po spakowaniu wtyczek musisz dodać je do pliku konfiguracji Edge Microgateway.

    1. Otwórz plik konfiguracji Edge Microgateway w edytorze:

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

      Na przykład:

      vi $HOME/.edgemicro/myorg-test-config.yaml
    2. Dodaj katalog wtyczki do pliku konfiguracji. W poniższym przykładzie atrybut dir określa lokalizację kodu wtyczki (określoną w pliku Dockerfile). Musisz też podać nazwę katalogu wtyczki, która w przykładzie poniżej to response-uppercase.

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

    4. Uruchamianie mikrobramy

    Na koniec musisz uruchomić mikrobramę w kontenerze.

    1. Uruchom to polecenie, aby zakodować w formacie base64 plik konfiguracji Edge Microgateway znajdujący się w $HOME/.edgemicro:

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

      gdzie your_org i your_env to organizacja i środowisko użyte podczas uruchamiania polecenia edgemicro config.

      Pamiętaj, aby umieścić polecenie w grawisach (`). Na przykład:

      export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/docs-test-config.yaml`
    2. Uruchom Edge Microgateway jako kontener. Polecenie ustawia kilka zmiennych środowiskowych, które są używane przez środowisko wykonawcze kontenera do uruchomienia Edge Microgateway:

      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

      Na przykład:

      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. Aby przetestować wtyczkę, wywołaj interfejs API:

      Przetestuj, czy kod wtyczki jest wykonywany, wywołując interfejs API i sprawdzając, czy dane wyjściowe są zgodne z oczekiwaniami:

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

      Na przykład wtyczka response-uppercase może zwrócić taką odpowiedź:

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