Korzystanie z Dockera dla Edge Microgateway

Przeglądasz dokumentację Apigee Edge.
Przejdź do Dokumentacja Apigee X. informacje.

Z tego artykułu dowiesz się, jak uruchomić Edge Microgateway w kontenerze Dockera. Czynności Zakładamy w nim, że znajomość technologii Docker, poleceń Dockera i Edge Microgateway z konfiguracją i konfiguracją. Dla: 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: zadania:

  • Skonfiguruj Edge Microgateway na potrzeby organizacji lub środowiska Apigee:

    edgemicro configure -o your_org -e your_env -u your_username

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

  • Po wykonaniu kroków konfiguracji znajdź konfigurację . Domyślna lokalizacja to:

    $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. Potrzebujesz ten plik po uruchomieniu Edge Microgateway w kontenerze Dockera.

  • Upewnij się, że masz klucz i tajne dane logowania, które zostały zwrócone podczas uruchamiania 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ć Wymagane (lub utworzone) encje Apigee Edge do wykonywania uwierzytelnionych wywołań interfejsu API przez serwer proxy. Do tych jednostek należą m.in. rozwiązanie Edge Microgateway serwer proxy, Usługa API, Programista i Aplikacja programisty. Pełne instrukcje znajdziesz w materiałach na temat Utwórz encje w Apigee Edge.

Uruchamianie Edge Micro jako kontenera Dockera

  1. Pobierz obraz Dockera na potrzeby 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 następujące polecenie, aby zakodować plik konfiguracji Edge Microgateway w formacie base64 znajduje 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 uruchomił(a) polecenie edgemicro config.

    Pamiętaj, by wokół polecenia umieścić znacznik wyboru (`). 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żywane przez środowisko wykonawcze kontenera do uruchamiania Edge Microgateway:

    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 SERVICE_NAME=edgemicro \
--security-opt=no-new-privileges \
--cap-drop=ALL \
gcr.io/apigee-microgateway/edgemicro:latest

    Parametry

    Parametr Opis
    -P Opublikuj wszystkie ujawnione porty na hoście. Zapoznaj się też z dokumentacją uruchomienia Dockera.
    -p Wyraźnie zmapuj pojedynczy port lub zakres portów. Zapoznaj się też z dokumentacją uruchomienia Dockera.
    -d Uruchom w trybie odłączonym. Zapoznaj się też z dokumentacją uruchomienia Dockera.
    -v, --volume Określa punkt montowania woluminu. Pamiętaj, że jeśli skonfigurujesz Edge Microgateway, aby używać protokołu TLS w kontenerze Dockera, musisz udostępnić port 8443, jeśli i podłączyć katalog z plikami dziennika. Zobacz też VOLUME [shared filesystems]. Zapoznaj się też z artykułem Używanie TLS w kontenerze Dockera.
    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, które mają zostać uruchomione.
    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 base64.
    SERVICE_NAME W Kubernetes ten parametr jest wypełniany automatycznie. W przeciwnym razie i wybrać dowolną opcję. Jeśli nic nie określisz, usługa nazwa jest ustawiona na default.
    DEBUG Aby włączyć debugowanie, ustaw wartość *.
    HTTP_PROXY HTTPS_PROXY Używaj, gdy Edge Microgateway jest działająca za zaporą sieciową, przez co brama nie może komunikować się z Apigee Edge. Więcej Więcej informacji zawiera artykuł Konfigurowanie Edge Microgateway za firmową zaporą sieciową.

    Na przykład: HTTP_PROXY=http://10.203.0.1:5187/
    NO_PROXY Lista rozdzielonych przecinkami domen, do których Edge Microgateway nie powinien używać serwera proxy. Więcej informacji znajdziesz w artykule Konfigurowanie Edge Microgateway za firmową zaporą sieciową.

    Na przykład: localhost,127.0.0.1,localaddress,.localdomain.com
    NODE_EXTRA_CA_CERTS (Opcjonalnie) Użyj tego parametru, jeśli używasz niezaufanego urzędu certyfikacji domyślnie w Node.js. Jako wartość tego parametru podaj ścieżkę do plik zawierający co najmniej 1 zaufany certyfikat w formacie PEM. Dla: Więcej informacji znajdziesz w artykule Certyfikaty TLS.
    --security-opt (Opcjonalnie) Ustawia odpowiednie opcje zabezpieczeń Dockera. Zapoznaj się z sekcją Konfiguracja zabezpieczeń w dokumentacji Dockera.
    --cap-drop (Opcjonalnie) Określa limity możliwości systemu Linux dozwolone w kontenerze. Zapoznaj się z sekcją Uprawnienia czasu działania i możliwości systemu Linux w dokumentacji Dockera.

    Na przykład:

    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

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

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 usługa Edge Microgateway została obsługiwana. wywołaniem API. Domyślnie jednak Edge Microgateway wymaga 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 API

W interfejsie Edge przejdź do utworzonej wcześniej aplikacji dla programistów. Na stronie programisty na stronie aplikacji, pokaż klucz klienta i skopiuj go. Ta wartość jest kluczem interfejsu API. Czego używasz ten klucz do wykonywania uwierzytelnionych wywołań interfejsu API.

Wywołaj ten interfejs API, używając nagłówka x-api-key w następujący sposób. Wartość klucza klienta, skopiowany z aplikacji jest kluczem interfejsu API. Domyślnie Edge Microgateway oczekuje, że przekażesz klucz w nagłówku o nazwie x-api-key w następujący 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 kluczami interfejsu API i tokenami OAuth można znaleźć w artykule Część 4. Secure 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 uruchomić ją ponownie za pomocą tego polecenia Dockera:

docker start edgemicro

Używanie protokołu TLS w kontenerze Dockera

Ta sekcja wyjaśnia, jak skonfigurować protokół TLS na potrzeby uruchomionej usługi Edge Microgateway w kontenerze Dockera. Możesz skonfigurować serwer Edge Microgateway, aby używać protokołu TLS dla żądań przychodzących (w kierunku północnym). Możesz też skonfigurować Microgateway, aby być klientem TLS dla żądań wychodzących do docelowych punktów końcowych (kierunek południowy).

Gdzie umieszczać pliki certyfikatów

Kontener Dockera, na którym działa Edge Microgateway, ma punkt podłączania w systemie /opt/apigee/.edgemicro. Podczas konfigurowania Edge Microgateway pod kątem korzystania z certyfikatów TLS możesz skonfigurować certyfikatów dostępnych w tym punkcie podłączania i odwołać się do nich w Plik konfiguracji Edge Microgateway. Ten plik konfiguracyjny znajduje się zwykle w folderze $HOME/.edgemicro i nazywa się 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 domyślnie nie jest zaufany Node.js (np. w przypadku certyfikatu z podpisem własnym), rozważ użycie parametr NODE_EXTRA_CA_CERTS po uruchomieniu kontenera.

Ustaw ten parametr na ścieżkę do pliku zawierającego co najmniej 1 aplikację zaufanych certyfikatów w formacie PEM. Aby dowiedzieć się, jak jest używany ten parametr, zobacz Przykłady: Jak skonfigurować TLS południowy i Jak skonfigurować protokół TLS południowy.

Na przykład:

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

Zapoznaj się też z artykułem Uruchamianie Edge Micro jako kontenera Dockera.

Wyłączam weryfikację 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 wbudowany w kontener Dockera Edge Microgateway. Do osiągnięcia musisz utworzyć dostosowany obraz Dockera na potrzeby Edge Microgateway. Poniżej to ogólne instrukcje tworzenia obrazu niestandardowego i wyłączania sprawdzania poprawności TLS.

  1. Klonowanie lub pobieranie repozytorium źródłowego 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 zmień kod, aby zaakceptować NODE_TLS_REJECT_UNAUTHORIZED zmiennej środowiskowej. Później, po uruchomieniu kontenera, .

  4. Utwórz kontener Dockera:

    docker build -t edgemicro .

  5. Przy uruchamianiu kontenera wybierz opcję -e NODE_TLS_REJECT_UNAUTHORIZED = 1. Na przykład:

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 w kierunku północnym

Ta sekcja wyjaśnia, jak skonfigurować przychodzące (przychodzące) połączenie TLS w Edge Microgateway serwera. Protokół TLS związany z północą umożliwia klientom używanie protokołu HTTPS podczas wykonywania wywołań interfejsu API do Edge Microgateway. W przykładzie poniżej użyto samodzielnie podpisanych certyfikatów.

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 plik konfiguracyjny zawiera req_extensions. Na przykład: 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. Dodaj tę strofę 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 opisane w sekcji Wymagania wstępne, aby zainicjować skonfigurować Edge Microgateway, jeśli nie zostało to jeszcze zrobione. Po zakończeniu powinien utworzyć serwer proxy obsługujący Edge Microgateway, Usługę API, Programistę, i Aplikacja dewelopera. Dodatkowo musisz uruchomić polecenie edgemicro configure i otrzymają klucz i tajny klucz.

2. Generowanie samodzielnie podpisanych certyfikatów

Następnie wygeneruj certyfikaty i klucze, których potrzebujesz do ustanowienia TLS:

  1. cd do katalogu $HOME/.edgemicro.

  2. Utwórz następujący 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. Sprawdź, czy ś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 użyć localhost dla wspólnej nazwy.

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

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

3. Edytuj plik konfiguracyjny Edge Microgateway

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

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

  2. Edytuj strofę edgemicro w następujący sposób. Pamiętaj, że wprowadzasz zmiany do atrybutów 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 poniższe polecenie, aby zakodować plik konfiguracji Edge Microgateway w formacie base64 znajduje 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 uruchomił(a) polecenie edgemicro config.

    Pamiętaj, by wokół polecenia umieścić znacznik wyboru (`). Na przykład:

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

Zapoznaj się też z artykułem Uruchamianie Edge Micro jako kontenera Dockera.

4. Uruchom kontener

  1. Wykonaj to polecenie, aby uruchomić kontener Dockera za pomocą Edge Microgateway:

    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ę od podstawowych, opisane w artykule Uruchamianie Edge Micro jako kontener Dockera.

    • port ma wartość 8443.
    • Punkt montowania woluminu jest używany do podłączania plików kluczy i certyfikatów.
    • Zmienna NODE_EXTRA_CA_CERTS służy do dodawania niestandardowego urzędu certyfikacji (w razie potrzeby samodzielnie podpisanych certyfikatów).

5. Testowanie konfiguracji TLS

  1. Aby przetestować konfigurację, uruchom poniższe polecenie cURL. Zamień ścieżki podstawowej i klucza interfejsu API. W przykładzie poniżej zakładamy, że jesteś 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. Szczegółowe dane wyjściowe cURL pokazują każdy krok polecenia Uzgadnianie połączenia TLS. Jeśli pojawia się odpowiedź HTTP 200, oznacza to, że konfiguracja jest prawidłowa:

    *   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ć południowe (wychodzące) połączenie TLS między między serwerem Edge Microgateway i aplikacją docelową backendu. W przykładzie poniżej użyto samodzielnie podpisanych certyfikatów.

1. Konfiguracja początkowa

  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 plik konfiguracyjny zawiera req_extensions. Na przykład: 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. Dodaj tę strofę 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 o konfiguracji znajdziesz w artykule Część 1. Konfigurowanie Edge Microgateway.

  6. Skopiuj klucz i tajne dane logowania, które zostały zwrócone z edgemicro configure Wartości te 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 Node.js

  1. cd do katalogu .edgemicro.

  2. Utwórz następujący skrypt bash. Możesz nazwać ją dowolnie. 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. Sprawdź, czy ś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 użyć hellworld dla wspólnej nazwy.

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

    • 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. Uruchom npm install, aby pobrać zależności.

  9. Utwórz nowy plik Dockerfile w tym samym katalogu, w którym znajduje się katalog 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 współpracujący z Edge Microgateway z tymi ustawieniami. Aby dowiedzieć się więcej, Więcej informacji znajdziesz w artykule na temat tworzenia serwera proxy interfejsu API Edge Microgateway na Edge.

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

  2. Tworzenie usługi API. Więcej informacji znajdziesz w artykule Tworzenie usługi.

  3. Utwórz programistę. Szczegółowe informacje znajdziesz w artykule Tworzenie konta dewelopera.

  4. Utwórz aplikację dewelopera. Więcej informacji znajdziesz w artykule Tworzenie aplikacji dewelopera.

4. Uruchom kontener

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

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

  2. Edytuj strofę edgemicro w następujący sposób. Pamiętaj, że wprowadzasz zmiany do atrybutów 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 regionie $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 uruchomił(a) polecenie edgemicro config.

    Pamiętaj, by wokół polecenia umieścić znacznik wyboru (`). Na przykład:

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

  4. Uruchom następujące polecenie, aby uruchomić Edge Microgateway w kontenerze Dockera.

    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 poniższe polecenie cURL. Zamień ścieżkę bazową użytą w serwerze proxy rozpoznawanym przez mikrobramy, a moduł Klucz interfejsu API uzyskany z aplikacji dewelopera utworzonej przez Ciebie 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.

    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. Zamień ścieżki podstawowej i klucza interfejsu API. 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 dodać do mikrobramy nowe funkcje i możliwości, wpisując custom Wtyczki niestandardowe umożliwiają automatyczną interakcję z żądaniami i odpowiedzi, które przechodzą przez mikrobramy.

Masz 2 opcje wdrażania wtyczek w Edge Microgateway instancja działająca w kontenerze Dockera:

W pozostałej części tej sekcji zakładamy, które potrafisz pisać i konfigurować, do standardowej konfiguracji Edge Microgateway. W przeciwnym razie przeczytaj artykuł Tworzenie wtyczek niestandardowych.

Opcja A. Zamontuj katalog wtyczek w woluminie

(Dodano w wersji 2.5.27) Instrukcje dodawania wtyczek za pomocą punktu montowania woluminu są następujące: podobnie jak w przypadku dodawania niestandardowej wtyczki do Edge Microgateway. Kiedy po uruchomieniu kontenera Dockera, możesz podłączyć katalog wtyczek system (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 dołączyć niestandardowy

  1. Zatrzymywanie Edge Microgateway:

    edgemicro stop

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

    $HOME/edgemicro/custom/plugins

  3. Dodaj katalog niestandardowej wtyczki do pliku konfiguracyjnego Edge Microgateway. Na przykład:

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

  4. Utwórz i przetestuj wtyczkę, postępując zgodnie ze wskazówkami podanymi w artykule Pisanie prostej wtyczki. Koniecznie umieść kod wtyczki we właściwej 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 Za pomocą opcji -v możesz podłączyć katalog wtyczek w wolumencie Dockera. W to przykładowe polecenie, katalog wtyczek $HOME/edgemicro/custom/plugins (gdzie znajduje się wtyczka niestandardowa) jest zmapowana na punkt podłączania kontenera /opt/apigee/plugins:

    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 sekcji VOLUME [współdzielone systemy plików].

Opcja B. Umieść wtyczki w kontenerze

W tej opcji skonfigurujesz w kontenerze wtyczki.

1. Pakowanie wtyczek

  1. Utwórz i przetestuj wtyczkę, postępując 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ć. response-uppercase i request-headers to wartości nazwy folderów zawierających kod wtyczki niestandardowej (te nazwy są tylko przykładami, 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 spakuj 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 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 za pomocą wtyczek:

    docker build -t image-name .

    Na przykład:

    docker build -t edgemicroplugins .

3. Aktualizowanie konfiguracji Edge Microgateway

Po spakowaniu wtyczek musisz je dodać do 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 (podanego przez Ciebie), w pliku Dockerfile). Musisz też podać nazwę katalogu wtyczki, w poniższym przykładzie to response-uppercase. 

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

4. Uruchom mikrobramę

Na koniec musisz uruchomić w kontenerze mikrobramę.

  1. Uruchom następujące polecenie, aby zakodować plik konfiguracji Edge Microgateway w formacie base64 znajduje 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 uruchomił(a) polecenie edgemicro config.

    Pamiętaj, by wokół polecenia umieścić znacznik wyboru (`). 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żywane 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 interfejs API:

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

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

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

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