Korzystanie z Dockera dla Edge Microgateway

Przeglądasz dokumentację Apigee Edge.
Otwórz dokumentację Apigee X. Informacje

W tym temacie dowiesz się, jak uruchomić Edge Microgateway w kontenerze Dockera. W instrukcjach omówionych w tym temacie założono, że podstawowe informacje o Dockerze, poleceniach Dockera oraz konfiguracji Edge Microgateway Więcej informacji znajdziesz w dokumentacji Dockera i Edge Microgateway.

Wymagania wstępne

Przed uruchomieniem Edge Microgateway w kontenerze Dockera musisz wykonać te czynności:

  • Skonfiguruj Edge Microgateway dla swojej organizacji/środowiska Apigee:

    edgemicro configure -o your_org -e your_env -u your_username

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

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

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

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

  • Sprawdź, czy masz klucz i hasło do danych logowania, które zostały zwrócone podczas uruchamiania 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 utworzyć) encje Apigee Edge wymagane do wykonywania uwierzytelnionych wywołań serwera proxy interfejsu API. Te elementy to serwer proxy obsługujący Edge Microgateway, produkt API, dewelopera i aplikację dewelopera. Pełne instrukcje znajdziesz w artykule o tworzeniu 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, sprawdź, czy zostały wykonane wszystkie czynności opisane w sekcji Wymagania wstępne.

  3. Uruchom to polecenie, aby zakodować plik konfiguracji Edge Microgateway znajdujący się w lokalizacji $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żywane podczas uruchamiania polecenia edgemicro config.

    Pamiętaj, aby umieścić znak lewy (`) wokół polecenia. Na przykład:

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

  4. Uruchom Edge Microgateway jako kontener. Polecenie to ustawia kilka zmiennych środowiskowych używanych przez środowisko wykonawcze kontenera do uruchamiania 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 ujawnione porty na hoście. Zobacz też dokumentację Docker Run.
    -p Wyraźnie zmapuj pojedynczy port lub zakres portów. Zobacz też dokumentację Docker Run.
    -d Uruchom w trybie odłączonym. Zobacz też dokumentację Docker Run.
    -v, -- volume Wskazuje punkt montowania woluminu. Pamiętaj, że jeśli skonfigurujesz Edge Microgateway tak, aby używała protokołu TLS w kontenerze Docker, musisz udostępnić port 8443, jeśli podłączysz katalog pliku logu. Zobacz też VOLUME [współdzielone systemy plików]. Zobacz też Używanie 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żna zmienić nazwy pliku root edgemicro. Domyślnie jest to bieżąca ścieżka katalogu roboczego.

    Przykład: 

    docker run -P -p 8000:8000 -d -w /tmp --name edgemicro 
    
...
    EDGEMICRO_ORG Nazwa organizacji Apigee, która została użyta 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 Obiekt 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) Umożliwia określenie, dokąd mają być wysyłane dane wyjściowe logów. Zobacz Określanie 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 dziennika do standardowych danych wyjściowych zamiast do pliku dziennika. Jeśli uruchomisz Edge Microgateway w kontenerze Dockera, kontener domyślnie przekierowuje stdout i wyniki błędów do pliku znajdującego się w kontenerze w tej lokalizacji: ${APIGEE_ROOT}/logs/edgemicro.log.

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

    Ta tabela opisuje dane wyjściowe dzienników, gdy używasz metody LOG_CONSOLE_OUTPUT_TO_FILE z dyrektywą to_console:

    to_console: true

    LOG_CONSOLE_OUTPUT_TO_FILE=false

    • Żadne logi nie będą wysyłane do pliku dziennika Edge Microgateway zgodnie z opisem w sekcji Zarządzanie plikami dziennika.
    • Dzienniki nie będą wysyłane do pliku edgemicro.log.
    to_console: true

    LOG_CONSOLE_OUTPUT_TO_FILE=true

    • Żadne logi nie będą wysyłane do pliku dziennika Edge Microgateway zgodnie z opisem w sekcji 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 zgodnie z opisem w sekcji 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 bazowa 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 prawidłowo obsługuje wywołanie interfejsu API. Domyślnie Edge Microgateway wymaga klucza interfejsu API do uwierzytelniania. W następnej sekcji przetestujesz interfejs API z użyciem prawidłowego klucza API.

    Testowanie interfejsu API z użyciem prawidłowego klucza interfejsu API

    W interfejsie użytkownika Edge otwórz wcześniej utworzoną aplikację dewelopera. Na stronie aplikacji dewelopera pokaż klucz klienta i skopiuj go. Ta wartość to klucz interfejsu API. Będziesz używać tego klucza do uwierzytelnionych wywołań interfejsu API.

    Wywołaj interfejs API z nagłówkiem x-api-key w podany niżej sposób. Wartość klucza klienta skopiowana z aplikacji dewelopera to klucz interfejsu API. Domyślnie Edge Microgateway wymaga, aby przekazać klucz 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 tworzeniu uwierzytelnionych wywołań interfejsu API przez Edge Microgateway z użyciem kluczy interfejsu API i tokenów OAuth, zapoznaj się z sekcją Część 4. Zabezpieczenie Edge Microgateway.

    Zatrzymuję mikrobramę Edge

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

    docker stop edgemicro

    Ponownie uruchamiam Edge Microgateway

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

    docker start edgemicro

    Używanie TLS w kontenerze Dockera

    W tej sekcji dowiesz się, jak skonfigurować protokół TLS dla Edge Microgateway uruchomionego w kontenerze Docker. Możesz skonfigurować serwer Edge Microgateway tak, aby używał TLS dla żądań przychodzących (kierunek północny), a Edge Microgateway możesz skonfigurować jako klienta TLS dla żądań wychodzących do docelowych punktów końcowych (w kierunku południowym).

    Gdzie umieszczać pliki certyfikatów

    Kontener Dockera, na którym działa Edge Microgateway, ma punkt podłączania w: /opt/apigee/.edgemicro. Po skonfigurowaniu 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 konfiguracyjny 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 przez Node.js

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

    Ustaw ten parametr na ścieżkę do pliku zawierającego co najmniej 1 zaufany certyfikat w formacie PEM. Aby dowiedzieć się, jak jest używany ten parametr, zapoznaj się z przykładami Jak skonfigurować protokół TLS kierowany na północ i Jak skonfigurować protokół TLS w kierunku południowym.

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

    Chociaż nie jest to zalecane, w niektórych przypadkach możesz chcieć wyłączyć weryfikację TLS dla Edge Microgateway uruchomionej w kontenerze. Możliwość wyłączenia protokołu TLS nie jest domyślnie wbudowana w kontenerze Dockera Edge Microgateway. Aby wykonać to zadanie, musisz utworzyć niestandardowy obraz Dockera dla Edge Microgateway. Poniżej znajdziesz ogólne instrukcje tworzenia obrazu niestandardowego i wyłączania weryfikacji TLS.

    1. Skopiuj 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 kodu źródłowego.

      Na przykład:

      cd $HOME/git/microgateway/kubernetes/docker/edgemicro

    3. Otwórz plik entrypoint.sh i zmodyfikuj kod tak, 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 wybierz 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ć protokół TLS kierowany na północ

    Ta sekcja wyjaśnia, jak skonfigurować połączenie TLS kierowane na północ na serwerze Edge Microgateway. Protokół TLS w kierunku północnym umożliwia klientom korzystanie z protokołu HTTPS podczas wykonywania wywołań interfejsu API w Edge Microgateway. W przykładzie poniżej użyto certyfikatów podpisanych samodzielnie.

    1. Początkowe kroki konfiguracji

    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 konfiguracyjnym znajdują się req_extensions. W pliku powinny na przykład 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. Dodaj ten fragment do openssl.cnf, aby wygenerować odpowiednie atrybuty SNI:

      [ 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. Wykonaj czynności podane w sekcji Wymagania wstępne, aby zainicjować i skonfigurować Edge Microgateway, jeśli jeszcze tego nie zrobiłeś. Gdy to zrobisz, musisz utworzyć serwer proxy obsługujący Edge Microgateway, usługę API, programistę i aplikację programisty. Dodatkowo należy uruchomić polecenie edgemicro configure oraz otrzymać klucz i tajny klucz.

    2. Generowanie certyfikatów podpisanych samodzielnie

    Następnie wygeneruj certyfikaty i klucze potrzebne do ustanowienia protokołu TLS:

    1. cd do katalogu $HOME/.edgemicro.

    2. Utwórz ten skrypt bash. Nazwa może być dowolna. 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. Upewnij się, że ścieżka do pliku openssl.cnf w pliku bash jest prawidłowa.

    4. Uruchom plik bash. Pojawi się prośba o podanie informacji o certyfikacie. Pamiętaj, aby we wspólnej nazwie użyć localhost.

    5. Sprawdź, czy utworzono te pliki:

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

    3. Edytuj plik konfiguracyjny Edge Microgateway

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

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

    2. Edytuj 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. Wykonaj to polecenie, aby zakodować plik konfiguracji Edge Microgateway znajdujący się w lokalizacji $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żywane podczas uruchamiania polecenia edgemicro config.

      Pamiętaj, aby umieścić znak lewy (`) wokół polecenia. Na przykład:

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

    Zobacz też uruchamianie Edge Micro jako kontenera Dockera.

    4. Uruchamianie kontenera

    1. Uruchom to polecenie, aby uruchomić kontener Dockera za pomocą 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 wymienione poniżej parametry użyte w poleceniu. Różnią się one od podstawowego polecenia opisanego w sekcji Uruchamianie Edge Micro jako kontenera Dockera.

      • Pole port jest ustawione na 8443.
      • Uchwyt woluminu służy do podłączania plików klucza i certyfikatów.
      • Zmienna NODE_EXTRA_CA_CERTS służy do dodawania niestandardowego urzędu certyfikacji (w razie potrzeby w przypadku samodzielnie podpisanych certyfikatów).

    5. Testowanie konfiguracji TLS

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

      curl -v https://localhost:8443/hello --cacert rootca.pem \
-H "x-api-key: Az82fdnfONVCOOE4NKhajxAboDgA3FAo"

    2. Pełne dane wyjściowe cURL pokazują każdy etap uzgadniania połączenia TLS. Jeśli zobaczysz odpowiedź HTTP 200, oznacza to, że konfiguracja zakończyła się powodzeniem:

      *   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ć protokół TLS w kierunku południowym

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

    1. Wstępna konfiguracja

    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 konfiguracyjnym znajdują się req_extensions. W pliku powinny na przykład 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. Dodaj ten fragment do openssl.cnf, aby wygenerować odpowiednie atrybuty SNI:

      [ 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 na temat konfiguracji znajdziesz w sekcji Część 1. Konfigurowanie Edge Microgateway.

    6. Skopiuj klucz i tajne dane logowania zwrócone przez edgemicro configure. Te wartości są niezbędne 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. Nazwa może być dowolna. 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. Upewnij się, że ścieżka do pliku openssl.cnf w pliku bash jest prawidłowa.

    4. Uruchom plik bash. Pojawi się prośba o podanie informacji o certyfikacie. Pamiętaj, aby we wspólnej nazwie użyć hellworld.

    5. Sprawdź, czy utworzono 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 co 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. Uruchom npm install, aby pobrać zależności.

    9. Utwórz nowy plik Dockerfile w tym samym katalogu co server.js, gdzie WORKDIR to ścieżka do katalogu głównego Twojej 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. Utwórz 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 o tworzeniu serwera proxy interfejsu Edge Microgateway API w przeglądarce Edge.

      • Nazwa serwera proxy: edgemicro_local
      • Wersja: 1
      • Ścieżka bazowa: /local
      • Cel: https://helloworld:9443

    2. utworzyć produkt API, Więcej informacji znajdziesz w artykule Tworzenie produktu.

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

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

    4. Uruchamianie kontenera

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

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

    2. Edytuj 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ć plik konfiguracji Edge Microgateway znajdujący się w lokalizacji $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żywane podczas uruchamiania polecenia edgemicro config.

      Pamiętaj, aby umieścić znak lewy (`) wokół polecenia. Na przykład:

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

    4. Uruchom poniższe polecenie, aby uruchomić Edge Microgateway w kontenerze Docker.

      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ę, wykonaj poniższe polecenie cURL. Zastąp ścieżkę bazową użytą w serwerze proxy rozpoznającym mikrobramę oraz klucz interfejsu API uzyskany z aplikacji dla programistów 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. Ponownie uruchom 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. Wykonaj poniższe polecenie cURL. Zastąp ścieżkę bazową 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. Jeśli operacja się uda, 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 niestandardowej wtyczki

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

    Są 2 sposoby wdrażania wtyczek w instancji Edge Microgateway uruchomionej w kontenerze Docker:

    W pozostałej części tej sekcji zakładamy, że umiesz pisać i konfigurować wtyczki w standardowej konfiguracji Edge Microgateway. Jeśli nie jest, przeczytaj artykuł o tworzeniu wtyczek niestandardowych.

    Opcja A. Podłącz katalog wtyczek na woluminie

    (Dodano w wersji 2.5.27) Czynności dodawania wtyczek za pomocą punktu montowania woluminu są podobne do czynności wymaganych w przypadku dodawania dowolnej niestandardowej wtyczki do Edge Microgateway. Po uruchomieniu kontenera Dockera możesz podłączyć katalog wtyczek w systemie lokalnym (wolumin) w punkcie podłączania kontenera, czyli /opt/apigee/plugins. Następnie określ katalog woluminu lokalnego w pliku konfiguracji Edge Microgateway.

    Poniższe kroki pokazują, jak użyć punktu podłączania Dockera, aby dodać niestandardowe wtyczki.

    1. Zatrzymać Edge Microgateway:

      edgemicro stop

    2. Utwórz katalog dla wtyczek niestandardowych. Na przykład utwórz

      $HOME/edgemicro/custom/plugins

    3. Dodaj niestandardowy katalog wtyczek do pliku konfiguracyjnego Edge Microgateway. Na przykład:

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

    4. Napisz i przetestuj wtyczkę zgodnie ze wskazówkami z artykułu Tworzenie prostej wtyczki. Pamiętaj, aby umieścić kod wtyczki w odpowiedniej strukturze katalogu. 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 tego poniżej. Użyj opcji -v, aby podłączyć katalog wtyczek w woluminie Dockera. W tym przykładowym poleceniu katalog wtyczek $HOME/edgemicro/custom/plugins (gdzie znajduje się niestandardowa wtyczka) 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 swój interfejs API, aby przetestować wtyczkę.

    Więcej informacji znajdziesz w artykule VOLUME [współdzielone systemy plików].

    Opcja B. Wbudowanie wtyczek w kontenerze

    W tej opcji kompilujesz wtyczki do swojego kontenera.

    1. Pakowanie wtyczek

    1. Napisz i przetestuj wtyczkę zgodnie ze wskazówkami z artykułu Tworzenie prostej wtyczki.

    2. Umieść kod wtyczki w odpowiedniej strukturze katalogu. 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 ten kod do pliku Dockerfile i zapisz plik:

      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. Utwórz nowy obraz Dockera Edge Microgateway za pomocą wtyczek:

      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 wtyczek – w przykładzie poniżej jest to response-uppercase. 

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

    4. Uruchom mikrobramę

    Na koniec musisz uruchomić mikrobramę w kontenerze.

    1. Uruchom to polecenie, aby zakodować plik konfiguracji Edge Microgateway znajdujący się w lokalizacji $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żywane podczas uruchamiania polecenia edgemicro config.

      Pamiętaj, aby umieścić znak lewy (`) wokół polecenia. Na przykład:

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

    2. Uruchom Edge Microgateway jako kontener. Polecenie to ustawia kilka zmiennych środowiskowych używanych przez środowisko wykonawcze kontenera do uruchamiania 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 swój interfejs API:

      Sprawdź, czy kod wtyczki jest wykonywany. W tym celu wywołaj interfejs API i sprawdź, czy wynik jest zgodny z oczekiwaniami:

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

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

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