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:

   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 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.
   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.
   SERVICE_NAME	Jeśli korzystasz z Kubernetes, ten parametr jest wypełniany automatycznie. W przeciwnym razie możesz ustawić dowolną wartość. Jeśli nic nie określisz, nazwa usługi zostanie ustawiona na default.
   DEBUG	Aby włączyć debugowanie, ustaw tę wartość na *.
   HTTP_PROXY HTTPS_PROXY	Używaj, gdy Edge Microgateway działa za zaporą sieciową i nie może komunikować się z Apigee Edge. Więcej informacji znajdziesz w artykule Konfigurowanie Edge Microgateway za zaporą sieciową firmy. Na przykład: HTTP_PROXY=http://10.203.0.1:5187/
   NO_PROXY	Lista domen rozdzielonych przecinkami, do których Edge Microgateway nie powinien przekazywać żądań. Więcej informacji znajdziesz w artykule Konfigurowanie Edge Microgateway za zaporą sieciową firmy. Na przykład: localhost,127.0.0.1,localaddress,.localdomain.com
   NODE_EXTRA_CA_CERTS	(Opcjonalnie) Użyj tego parametru, jeśli używasz urzędu certyfikacji, który nie jest domyślnie zaufany przez Node.js. Ustaw wartość tego parametru na ścieżkę do pliku zawierającego co najmniej 1 zaufany certyfikat w formacie PEM. Więcej informacji znajdziesz w artykule Certyfikaty TLS.
   --security-opt	(Opcjonalnie) Ustawia wybrane opcje zabezpieczeń Dockera. Więcej informacji znajdziesz w sekcji Konfiguracja zabezpieczeń w dokumentacji Dockera.
   --cap-drop	(Opcjonalnie) Ustawia limity możliwości Linuksa dozwolonych w kontenerze. Więcej informacji znajdziesz w artykule Runtime privilege and Linux capabilities w dokumentacji platformy Docker.

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

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:

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:

   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:

   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.

   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:

• Opcja A. Zamontuj katalog wtyczek na woluminie
• Opcja B. Wbuduj wtyczki w kontener

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:

   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!