Korzystanie z Dockera dla Edge Microgateway

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

Z tego artykułu dowiesz się, jak uruchomić Edge Microgateway w kontenerze Dockera. Czynności opisane w tym temacie zakładają podstawową znajomość Dockera, poleceń Dockera oraz konfiguracji i ustawień 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 lub środowiska Apigee:

    edgemicro configure -o your_org -e your_env -u your_username

    Więcej informacji o konfiguracji znajdziesz w części 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, których użyto podczas wykonywania polecenia edgemicro config. Ten plik będzie potrzebny, gdy uruchomisz Edge Microgateway w kontenerze Docker.

  • Upewnij się, że masz klucz i klucz tajny 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 Docker, musisz utworzyć (lub mieć już utworzone) jednostki Apigee Edge, które są wymagane do wykonywania uwierzytelnionych wywołań serwera proxy interfejsu API. Te jednostki to serwer proxy obsługujący Edge Microgateway, usługa API, deweloper i aplikacja dewelopera. Pełne instrukcje znajdziesz w artykule Tworzenie jednostek 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 następnych kroków, wykonaj wszystkie czynności opisane w sekcji Wymagania wstępne.

  3. Uruchom to polecenie, aby zakodować w formacie base64 plik konfiguracyjny 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 odwrotnych apostrofach (`). 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órych środowisko wykonawcze kontenera używa 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 udostępnione porty na hoście. Zobacz też dokumentację polecenia Docker run.
    -p Wyraźnie 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]. 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 modyfikować głównej części nazwy pliku edgemicro. Domyślnie jest to ścieżka do 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 Obiekt tajny zwrócony podczas konfigurowania Edge Microgateway.
    EDGEMICRO_CONFIG Zmienna zawierająca zakodowany w formacie Base64 plik konfiguracyjny Edge Microgateway.
    LOG_CONSOLE_OUTPUT_TO_FILE (Wartość logiczna) Umożliwia określenie, gdzie mają być wysyłane dane wyjściowe logu. 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 jest uruchomiony:

      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 wyjścia zamiast do pliku dziennika. Jeśli wykonasz czynności, aby uruchomić Edge Microgateway w kontenerze Dockera, kontener domyślnie przekieruje stdout i wyjście błędów 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 opisujemy działanie danych wyjściowych dziennika, gdy używasz funkcji LOG_CONSOLE_OUTPUT_TO_FILE z funkcją to_console:

    to_console: true

    LOG_CONSOLE_OUTPUT_TO_FILE=false

    • Żadne logi nie będą wysyłane do pliku logu Edge Microgateway, jak opisano w sekcji Zarządzanie plikami logu.
    • 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 logu Edge Microgateway, jak opisano w sekcji Zarządzanie plikami logu.
    • Dzienniki zostaną wysł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 zostaną wysłane do pliku edgemicro.log.

    Testowanie wywołania interfejsu API

    Po uruchomieniu Edge Microgateway w kontenerze możesz wykonywać do niego 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 zobaczysz tę odpowiedź, oznacza to, że Edge Microgateway prawidłowo 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 za pomocą prawidłowego klucza interfejsu API.

    Testowanie interfejsu API za pomocą prawidłowego klucza interfejsu API

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

    Wywołaj interfejs API z nagłówkiem x-api-key w ten 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, np. w ten sposób:

    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 za pomocą Edge Microgateway z użyciem kluczy 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 ponownie uruchomić go za pomocą tego polecenia Dockera:

    docker start edgemicro

    Używanie TLS w kontenerze Dockera

    Z tej sekcji dowiesz się, jak skonfigurować TLS dla Edge Microgateway działającego w kontenerze Docker. Możesz skonfigurować serwer Edge Microgateway tak, aby używał TLS w przypadku przychodzących żądań (kierunek północny), a także skonfigurować Edge Microgateway jako klienta TLS w przypadku wychodzących żądań 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 skonfigurujesz Edge Microgateway do używania certyfikatów protokołu 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 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 ten parametr jest używany, zapoznaj się z przykładami Konfigurowanie protokołu TLS w kierunku północnym i Konfigurowanie protokołu 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 weryfikacji TLS

    W niektórych przypadkach możesz wyłączyć weryfikację TLS w Edge Microgateway działającym w kontenerze, ale nie jest to zalecane. 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 dotyczące 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, aby akceptował zmienną środowiskową NODE_TLS_REJECT_UNAUTHORIZED. Później, gdy uruchomisz kontener, 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: konfigurowanie protokołu TLS dla ruchu wychodzącego

    W tej sekcji opisujemy, jak skonfigurować połączenie TLS w kierunku północnym (przychodzące) na serwerze Edge Microgateway. Protokół TLS w kierunku północnym umożliwia klientom korzystanie z protokołu HTTPS podczas wywoływania interfejsu API w Edge Microgateway. W przykładzie poniżej użyto certyfikatów z podpisem własnym.

    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. Sprawdź, czy w pliku konfiguracyjnym znajdują się znaki req_extensions. W pliku powinny się znajdować na przykład te informacje:

      [ 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 elementu openssl.cnf ten fragment kodu:

      [ 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 tego nie zrobiono, wykonaj czynności opisane w sekcji Wymagania wstępne, aby zainicjować i skonfigurować Edge Microgateway. Po zakończeniu tych czynności powinny zostać utworzone proxy obsługujące Edge Microgateway, produkt API, deweloper i aplikacja dewelopera. Dodatkowo należy uruchomić polecenie edgemicro configure i otrzymać klucz oraz hasło.

    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. W pliku bash sprawdź, czy ścieżka do pliku openssl.cnf jest prawidłowa.

    4. Uruchom plik bash. Pojawi się prośba o podanie informacji o certyfikacie. W przypadku nazwy zwyczajowej używaj localhost.

    5. Sprawdź, czy utworzono 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 ten 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ć w formacie base64 plik konfiguracyjny 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 odwrotnych apostrofach (`). 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. Aby uruchomić kontener Dockera z Edge Microgateway, wykonaj to polecenie:

      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 parametrów podstawowego polecenia opisanego w artykule Uruchamianie Edge Micro jako kontenera Dockera.

      • Wartość port to 8443.
      • Do zamontowania plików klucza i certyfikatu używany jest wolumin.
      • 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. W poleceniu zastąp ścieżkę podstawową i klucz interfejsu API. W przykładzie poniżej założono, ż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 etap uzgadniania TLS. Jeśli zobaczysz odpowiedź HTTP 200, konfiguracja została przeprowadzona prawidłowo:

      *   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: konfigurowanie protokołu TLS dla ruchu wychodzącego

    W tej sekcji opisujemy, jak skonfigurować połączenie TLS wychodzące między serwerem Edge Microgateway a docelową aplikacją backendu. W przykładzie poniżej użyto certyfikatów z podpisem własnym.

    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. Sprawdź, czy w pliku konfiguracyjnym znajdują się znaki req_extensions. W pliku powinny się znajdować na przykład te informacje:

      [ 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 elementu openssl.cnf ten fragment kodu:

      [ 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 części 1: Konfigurowanie Edge Microgateway.

    6. Skopiuj klucz i tajne dane logowania zwrócone przez usługę 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 docelowej aplikacji 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. W pliku bash sprawdź, czy ścieżka do pliku openssl.cnf jest prawidłowa.

    4. Uruchom plik bash. Pojawi się prośba o podanie informacji o certyfikacie. W przypadku nazwy zwyczajowej używaj 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 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. 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 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 jednostek w Apigee Edge

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

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

    2. Utwórz usługę 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ę związaną z programistą. Więcej informacji znajdziesz w artykule Tworzenie aplikacji związanej z programistą.

    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 ten 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ć w formacie base64 plik konfiguracyjny Edge Microgateway znajdujący się w katalogu $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 odwrotnych apostrofach (`). Na przykład:

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

    4. Aby uruchomić Edge Microgateway w kontenerze Dockera, wykonaj to polecenie:

      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ą używaną w proxy obsługującym mikrobramę i 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 wyświetlić 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ć do mikrobramy nowe funkcje i możliwości, pisząc własne wtyczki. Własne wtyczki umożliwiają programowe interakcje z żądaniami i odpowiedziami przepływającymi przez mikrobramę.

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

    W pozostałej części tej sekcji zakłada się, że znasz sposób pisania i konfigurowania wtyczek w przypadku standardowej konfiguracji Edge Microgateway. Jeśli nie, przeczytaj artykuł Tworzenie wtyczek niestandardowych.

    Opcja A. Zamontuj katalog wtyczek na woluminie

    (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. Gdy uruchomisz kontener Dockera, możesz zamontować katalog wtyczek w systemie lokalnym (wolumin) w punkcie podłączania kontenera, czyli /opt/apigee/plugins. Następnie w pliku konfiguracyjnym Edge Microgateway określasz katalog woluminu lokalnego.

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

    1. Zatrzymaj Edge Microgateway:

      edgemicro stop

    2. Utwórz katalog dla wtyczek niestandardowych. Możesz na przykład utworzyć

      $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 z instrukcjami w sekcji 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 tego poniżej, w którym używasz opcji -v, aby zamontować katalog wtyczek na woluminie Dockera. W poniższym przykładzie polecenia 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 artykule VOLUME [shared filesystems] (VOLUME [współdzielone systemy plików]).

    Opcja B. Wbuduj wtyczki w kontenerze

    W tej opcji wtyczki są wbudowywane w kontener.

    1. Pakowanie wtyczek

    1. Napisz i przetestuj wtyczkę zgodnie z instrukcjami w sekcji Pisanie prostej wtyczki.

    2. Umieść kod wtyczki w odpowiedniej strukturze katalogów. Katalogi wtyczek muszą mieć określoną strukturę. W przykładzie poniżej pokazujemy strukturę, której musisz użyć. Symbole response-uppercase i request-headers oznaczają nazwy folderów zawierających kod wtyczki niestandardowej (są to tylko przykłady, nazwy folderów mogą być inne):

      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:

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

      docker build -t image-name .

      Na przykład:

      docker build -t edgemicroplugins .

    3. Aktualizowanie konfiguracji Edge Microgateway

    Wtyczki są już spakowane, teraz 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 wtyczek do pliku konfiguracji. W tym przykładzie atrybut dir określa lokalizację kodu wtyczki (który został określony w pliku Dockerfile). Musisz też podać nazwę katalogu wtyczek, która w poniższym przykładzie 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 konfiguracyjny 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 odwrotnych apostrofach (`). 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órych środowisko wykonawcze kontenera używa 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. Wywołaj interfejs API, aby przetestować wtyczkę:

      Sprawdź, czy kod wtyczki jest wykonywany, wywołując interfejs API i weryfikują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!