Edge माइक्रोगेटवे के लिए Docker का इस्तेमाल करना

Apigee Edge दस्तावेज़ देखा जा रहा है.
Apigee X दस्तावेज़ पर जाएं.
जानकारी

इस विषय में, Docker कंटेनर में Edge माइक्रोगेटवे को चलाने का तरीका बताया गया है. इस विषय में बताए गए चरणों में Docker, Docker कमांड, Edge Microgateway सेटअप और कॉन्फ़िगरेशन की बुनियादी जानकारी दी गई है. ज़्यादा जानकारी के लिए, Docker और Edge Microgateway के दस्तावेज़ देखें

ज़रूरी शर्तें

Docker कंटेनर में Edge माइक्रोगेटवे चलाने से पहले, आपको ये काम करने होंगे:

  • अपने Apigee संगठन/एनवायरमेंट के लिए, Edge माइक्रोगेटवे को कॉन्फ़िगर करें:

    edgemicro configure -o your_org -e your_env -u your_username

    कॉन्फ़िगरेशन के बारे में ज़्यादा जानकारी के लिए, पार्ट 1: Edge माइक्रोगेटवे को कॉन्फ़िगर करें देखें.

  • कॉन्फ़िगरेशन के चरण पूरे करने के बाद, कॉन्फ़िगरेशन फ़ाइल ढूंढें. डिफ़ॉल्ट जगह यहां है:

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

    जहां your_org और your_env संगठन और एनवायरमेंट हैं, जिनका इस्तेमाल आपने edgemicro config कमांड चलाते समय किया था. Docker कंटेनर में Edge माइक्रोगेटवे शुरू करने पर आपको इस फ़ाइल की ज़रूरत होगी.

  • पक्का करें कि आपके पास वे कुंजी और सीक्रेट क्रेडेंशियल हों जो edgemicro config कमांड चलाने पर मिले थे. उदाहरण के लिए:

    The following credentials are required to start edge micro
      key: d9c34e1aff68ed969273c016699eabf48780e4f652242e72fc88a43e21252cb0
      secret: 3bc95a71c86a3c8ce04537fbcb788158731t51dfc6cdec13b7c05aa0bd969430
    
  • Docker कंटेनर में Edge माइक्रोगेटवे शुरू करने से पहले, आपको Apigee Edge की ऐसी इकाइयां बनानी होंगी (या बनानी होंगी), जो पुष्टि किए गए एपीआई प्रॉक्सी कॉल करने के लिए ज़रूरी हैं. इन इकाइयों में EDGE माइक्रोगेटवे-अवेयर प्रॉक्सी, एपीआई प्रॉडक्ट, डेवलपर, और डेवलपर ऐप्लिकेशन शामिल हैं. सभी निर्देशों के लिए, Apigee Edge पर इकाइयां बनाना देखें.

Edge माइक्रो को Docker कंटेनर की तरह चलाएं

  1. Edge माइक्रोगेटवे के लिए Docker इमेज डाउनलोड करें:

    docker pull gcr.io/apigee-microgateway/edgemicro:latest
  2. अगले चरणों पर जाने से पहले, पक्का करें कि आपने ज़रूरी शर्तें सेक्शन में दिए गए सभी चरणों को पूरा कर लिया है.

  3. $HOME/.edgemicro में मौजूद Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल को base64 कोड में बदलने के लिए, नीचे दिए गए निर्देश चलाएं:

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

    जहां your_org और your_env संगठन और एनवायरमेंट हैं. आपने edgemicro config कमांड चलाते समय इनका इस्तेमाल किया था.

    कमांड के आस-पास बैक-टिक (`) लगाना याद रखें. उदाहरण के लिए:

    export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/docs-test-config.yaml`
  4. एज माइक्रोगेटवे को कंटेनर की तरह चलाएं. इस निर्देश में कई एनवायरमेंट वैरिएबल सेट किए जाते हैं, जिनका इस्तेमाल EDGE माइक्रोगेटवे को शुरू करने के लिए कंटेनर रनटाइम करता है:

    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

    पैरामीटर

    पैरामीटर जानकारी
    -P उन सभी पोर्ट को होस्ट पर पब्लिश करें जिनके बारे में दूसरे लोगों को बताया गया है. Docker रन रेफ़रंस भी देखें.
    -p किसी एक पोर्ट या पोर्ट की रेंज को साफ़ तौर पर मैप करें. Docker रन रेफ़रंस भी देखें.
    -d डिटैच्ड मोड में चलाएं. Docker रन रेफ़रंस भी देखें.
    -v, --volume इससे वॉल्यूम माउंट का पता चलता है. ध्यान दें कि अगर Docker कंटेनर में TLS का इस्तेमाल करने के लिए, Edge माइक्रोगेटवे को कॉन्फ़िगर किया जाता है, तो लॉग फ़ाइल डायरेक्ट्री को माउंट करने पर आपको पोर्ट 8443 को सार्वजनिक करना होगा. वॉल्यूम [शेयर किए गए फ़ाइल सिस्टम] भी देखें. Docker कंटेनर में TLS का इस्तेमाल करना भी देखें.
    EDGEMICRO_ORG उस Apigee संगठन का नाम जिसका इस्तेमाल आपने Edge माइक्रोगेटवे को कॉन्फ़िगर करने के लिए किया था.
    EDGEMICRO_ENV उस Apigee एनवायरमेंट का नाम जिसका इस्तेमाल आपने Edge माइक्रोगेटवे को कॉन्फ़िगर करने के लिए किया था.
    EDGEMICRO_PROCESSES शुरू की जाने वाली प्रोसेस की संख्या.
    EDGEMICRO_KEY Edge माइक्रोगेटवे को कॉन्फ़िगर करने पर कुंजी वापस दिखती है.
    EDGEMICRO_SECRET जब आपने Edge माइक्रोगेटवे को कॉन्फ़िगर किया, तो सीक्रेट मिला.
    EDGEMICRO_CONFIG ऐसा वैरिएबल जिसमें base64 कोड में बदली गई Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल है.
    SERVICE_NAME अगर आपने Qubernetes पर किया है, तो यह पैरामीटर अपने-आप भर जाता है. इसके अलावा, इसे अपनी पसंद के हिसाब से सेट किया जा सकता है. अगर आपने कुछ भी तय नहीं किया है, तो सेवा का नाम default पर सेट कर दिया जाता है.
    DEBUG डीबग करने की सुविधा चालू करने के लिए, * पर सेट करें.
    HTTP_PROXY HTTPS_PROXY इसका इस्तेमाल तब करें, जब Edge माइक्रोगेटवे फ़ायरवॉल के पीछे चल रहा हो और गेटवे Apigee Edge से कम्यूनिकेट नहीं कर पा रहा हो. ज़्यादा जानकारी के लिए, कंपनी फ़ायरवॉल के पीछे Edge माइक्रोगेटवे को सेट अप करना देखें.

    उदाहरण के लिए: HTTP_PROXY=http://10.203.0.1:5187/

    NO_PROXY उन डोमेन की कॉमा-डीलिमिटेड सूची जिन्हें Edge माइक्रोगेटवे पर प्रॉक्सी नहीं करना चाहिए. ज़्यादा जानकारी के लिए, कंपनी फ़ायरवॉल के पीछे Edge माइक्रोगेटवे सेट अप करना देखें.

    उदाहरण के लिए: localhost,127.0.0.1,localaddress,.localdomain.com

    NODE_EXTRA_CA_CERTS (ज़रूरी नहीं) अगर किसी ऐसे CA का इस्तेमाल किया जा रहा है जो डिफ़ॉल्ट रूप से Node.js के लिए भरोसेमंद नहीं है, तो इस पैरामीटर का इस्तेमाल करें. इस पैरामीटर की वैल्यू को उस फ़ाइल के पाथ पर सेट करें जिसमें PEM फ़ॉर्मैट में एक या इससे ज़्यादा भरोसेमंद सर्टिफ़िकेट हों. ज़्यादा जानकारी के लिए, TLS सर्टिफ़िकेट देखें.
    --security-opt (ज़रूरी नहीं) डॉकर के लिए सुरक्षा के ज़रूरी विकल्प सेट करता है. Docker दस्तावेज़ में सुरक्षा कॉन्फ़िगरेशन देखें.
    --cap-drop (ज़रूरी नहीं) कंटेनर में इस्तेमाल की जा सकने वाली Linux की क्षमताओं के लिए सीमाएं सेट करता है. Docker दस्तावेज़ में, रनटाइम का खास अधिकार और Linux की सुविधाएं देखें.

    उदाहरण के लिए:

    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. यह देखने के लिए कि कंटेनर चल रहा है या नहीं:

    docker ps

    आपको इसके जैसा आउटपुट दिखेगा:

    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
    

एपीआई कॉल की जांच करना

कंटेनर में Edge माइक्रोगेटवे को शुरू करने के बाद, एपीआई कॉल किए जा सकते हैं. उदाहरण के लिए, अगर आपके एपीआई का बेस पाथ /hello है:

http://localhost:8000/hello

आउटपुट का नमूना:

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

अगर आपको यह जवाब दिखता है, तो इसका मतलब है कि EDGE माइक्रोगेटवे ने एपीआई कॉल को सही तरीके से हैंडल किया है. हालांकि, डिफ़ॉल्ट रूप से, Edge Microgateway की पुष्टि करने के लिए एक एपीआई पासकोड की ज़रूरत होती है. अगले सेक्शन में, आपको मान्य एपीआई पासकोड का इस्तेमाल करके, इस एपीआई की जांच करनी है.

मान्य एपीआई पासकोड का इस्तेमाल करके, एपीआई की जांच करना

Edge के यूज़र इंटरफ़ेस (यूआई) में, उस डेवलपर ऐप्लिकेशन पर जाएं जिसे आपने पहले बनाया था. डेवलपर ऐप्लिकेशन पेज पर, उपभोक्ता कुंजी दिखाएं और उसे कॉपी करें. यह वैल्यू एपीआई पासकोड है. पुष्टि किए गए एपीआई कॉल करने के लिए आपको इस कुंजी का इस्तेमाल करना होगा.

एपीआई को x-api-key हेडर के साथ इस तरह कॉल करें. डेवलपर ऐप्लिकेशन से कॉपी की गई उपभोक्ता कुंजी वैल्यू, एपीआई पासकोड होती है. डिफ़ॉल्ट रूप से, Edge Microgateway चाहता है कि आप कुंजी को x-api-key नाम के हेडर में पास करें. जैसे:

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

उदाहरण के लिए:

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

अगर आपको एपीआई पासकोड और OAuth टोकन के साथ Edge माइक्रोगेटवे से पुष्टि किए गए एपीआई कॉल करने के बारे में ज़्यादा जानना है, तो पार्ट 4: Secure Edge माइक्रोगेटवे देखें.

एज माइक्रोगेटवे को बंद करना

Edge माइक्रोगेटवे को रोकने के लिए, नीचे दिए गए Docker कमांड का इस्तेमाल करें:

docker stop edgemicro

एज माइक्रोगेटवे को रीस्टार्ट किया जा रहा है

एज माइक्रोगेटवे को बंद करने के बाद, इसे इस Docker कमांड से रीस्टार्ट किया जा सकता है:

docker start edgemicro

Docker कंटेनर में TLS का इस्तेमाल करना

इस सेक्शन में, Docker कंटेनर में चल रहे Edge माइक्रोगेटवे के लिए TLS को कॉन्फ़िगर करने का तरीका बताया गया है. आने वाले अनुरोधों (नॉर्थबाउंड दिशा) के लिए TLS का इस्तेमाल करने के लिए, Edge माइक्रोगेटवे सर्वर को कॉन्फ़िगर किया जा सकता है. साथ ही, एज माइक्रोगेटवे को एंडपॉइंट को टारगेट करने वाले आउटगोइंग अनुरोधों के लिए TLS क्लाइंट के तौर पर कॉन्फ़िगर किया जा सकता है.

प्रमाणपत्र फ़ाइलें कहां रखें

एज माइक्रोगेटवे पर चल रहे Docker कंटेनर का माउंट पॉइंट /opt/apigee/.edgemicro है. जब TLS सर्टिफ़िकेट का इस्तेमाल करने के लिए, Edge माइक्रोगेटवे को कॉन्फ़िगर किया जाता है, तो सर्टिफ़िकेट फ़ाइलों को उस माउंट पॉइंट पर उपलब्ध कराया जा सकता है. साथ ही, उन्हें Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल में बताया जा सकता है. आम तौर पर, यह कॉन्फ़िगरेशन फ़ाइल $HOME/.edgemicro डायरेक्ट्री में मौजूद होती है और इसका नाम your_org-your_env-config.yaml होता है. उदाहरण के लिए:

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

ऐसे CA का इस्तेमाल करना जो Node.js के लिए भरोसेमंद न हो

अगर किसी ऐसी सर्टिफ़िकेट अथॉरिटी (CA) का इस्तेमाल किया जा रहा है जो डिफ़ॉल्ट रूप से Node.js (जैसे कि खुद हस्ताक्षर किए गए सर्टिफ़िकेट के मामले में) नहीं है, तो कंटेनर चलाते समय NODE_EXTRA_CA_CERTS पैरामीटर इस्तेमाल करें.

इस पैरामीटर को उस फ़ाइल के पाथ पर सेट करें जिसमें PEM फ़ॉर्मैट में एक या उससे ज़्यादा भरोसेमंद सर्टिफ़िकेट हों. इस पैरामीटर का इस्तेमाल कैसे किया जाता है, यह जानने के लिए, नॉर्थबाउंड TLS को कॉन्फ़िगर करने का तरीका और दक्षिण की सीमा वाले TLS को कॉन्फ़िगर करने का तरीका उदाहरण देखें.

उदाहरण के लिए:

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

डॉकर कंटेनर के तौर पर Edge माइक्रो चलाएं को भी देखें.

TLS की पुष्टि करने की सुविधा बंद की जा रही है

हालांकि, इसका सुझाव नहीं दिया जाता, लेकिन कुछ मामलों में ऐसा हो सकता है कि आप कंटेनर में चलने वाले Edge माइक्रोगेटवे के लिए, TLS की पुष्टि करने की सुविधा बंद करना चाहें. TLS को बंद करने की सुविधा, डिफ़ॉल्ट रूप से Edge माइक्रोगेटवे डॉकर कंटेनर में मौजूद नहीं है. टास्क को पूरा करने के लिए, आपको Edge माइक्रोगेटवे के लिए पसंद के मुताबिक Docker इमेज बनानी होगी. कस्टम इमेज बनाने और TLS पुष्टि को बंद करने के सामान्य निर्देश नीचे दिए गए हैं.

  1. https://github.com/apigee-internal/microgateway से Edge माइक्रोगेटवे सोर्स रिपॉज़िटरी को क्लोन करें या डाउनलोड करें.

  2. cd को सोर्स कोड डायरेक्ट्री की microgateway/kubernetes/docker/edgemicro डायरेक्ट्री में जोड़ें.

    उदाहरण के लिए:

    cd $HOME/git/microgateway/kubernetes/docker/edgemicro
    
  3. entrypoint.sh फ़ाइल खोलें और NODE_TLS_REJECT_UNAUTHORIZED एनवायरमेंट वैरिएबल को स्वीकार करने के लिए, कोड में बदलाव करें. बाद में, कंटेनर चलाते समय इस वैरिएबल के लिए एक वैल्यू तय करें.

  4. Docker कंटेनर बनाएं:

    docker build -t edgemicro .
    
  5. कंटेनर चलाते समय, विकल्प -e NODE_TLS_REJECT_UNAUTHORIZED = 1 तय करें. उदाहरण के लिए:

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

उदाहरण: नॉर्थबाउंड TLS को कॉन्फ़िगर करने का तरीका

इस सेक्शन में बताया गया है कि Edge माइक्रोगेटवे सर्वर पर उत्तर की तरफ़ (इनकमिंग) TLS कनेक्शन कैसे सेट अप करें. नॉर्थबाउंड TLS, Edge माइक्रोगेटवे पर एपीआई कॉल करते समय क्लाइंट को एचटीटीपीएस का इस्तेमाल करने की अनुमति देता है. नीचे दिए गए उदाहरण में, खुद हस्ताक्षर किए गए सर्टिफ़िकेट का इस्तेमाल किया गया है.

1. शुरुआती सेटअप के तरीके

  1. अपने सिस्टम पर openssl.cnf फ़ाइल ढूंढें. उदाहरण के लिए, /etc/ssl/openssl.cnf.
  2. बदलाव करने के लिए, opensssl.cnf फ़ाइल खोलें.
  3. पक्का करें कि आपकी कॉन्फ़िगरेशन फ़ाइल में req_extensions मौजूद हों. उदाहरण के लिए, आपकी फ़ाइल में ऐसी जानकारी होनी चाहिए जो नीचे दी गई हो:

    [ req ]
    ...
    req_extensions          = v3_req
    ...
    
    [ v3_req ]
    extendedKeyUsage = serverAuth, clientAuth, codeSigning, emailProtection
    basicConstraints = CA:FALSE
    keyUsage = nonRepudiation, digitalSignature, keyEncipherment
    
  4. सही SNI एट्रिब्यूट जनरेट करने के लिए, openssl.cnf में यह वाक्य जोड़ें:

    [ 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
    

    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. अगर आपने Edge माइक्रोगेटवे को शुरू और कॉन्फ़िगर नहीं किया है, तो ज़रूरी शर्तें सेक्शन में दिए गए तरीके का पालन करें. अगर आपने यह चरण पूरा नहीं किया है, तो आपको एक Edge माइक्रोगेटवे-अवेयर प्रॉक्सी, एपीआई प्रॉडक्ट, डेवलपर, और डेवलपर ऐप्लिकेशन बनाना होगा. इसके अलावा, आपको edgemicro configure कमांड के साथ-साथ एक कुंजी और सीक्रेट भी मिला होगा.

2. खुद हस्ताक्षर किए गए सर्टिफ़िकेट जनरेट करें

इसके बाद, वे प्रमाणपत्र और कुंजियां जनरेट करें जिनकी आपको TLS स्थापित करने के लिए ज़रूरत होगी:

  1. cd को $HOME/.edgemicro डायरेक्ट्री के लिए.
  2. नीचे दी गई बैश स्क्रिप्ट बनाएं. आप उसे अपनी पसंद का कोई भी नाम दे सकते हैं. उदाहरण के लिए: 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. बैश फ़ाइल में, पक्का करें कि openssl.cnf फ़ाइल का पाथ सही है.

  4. बैश फ़ाइल चलाएं. आपसे सर्टिफ़िकेट की जानकारी मांगी जाएगी. सामान्य नाम के लिए, localhost का इस्तेमाल करना न भूलें.

  5. देखें कि ये फ़ाइलें बनाई गई थीं या नहीं:

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

3. Edge माइक्रोगेटवे की कॉन्फ़िगरेशन फ़ाइल में बदलाव करें

  1. किसी एडिटर में EDGE माइक्रो कॉन्फ़िगरेशन फ़ाइल खोलें. उदाहरण के लिए:

    vi $HOME/.edgemicro/myorg-test-config.yaml
    
  2. edgemicro छंद में इस तरह बदलाव करें. ध्यान दें कि आप port और 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. $HOME/.edgemicro में मौजूद Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल को base64 कोड में बदलने के लिए, नीचे दिए गए निर्देश का इस्तेमाल करें:

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

    जहां your_org और your_env संगठन और एनवायरमेंट हैं. आपने edgemicro config कमांड चलाते समय इनका इस्तेमाल किया था.

    कमांड के आस-पास बैक-टिक (`) लगाना याद रखें. उदाहरण के लिए:

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

यह भी देखें, Doer कंटेनर के तौर पर Edge माइक्रो चलाएं.

4. कंटेनर चलाएं

  1. Docker कंटेनर को Edge माइक्रोगेटवे के साथ चलाने के लिए, नीचे दिया गया कमांड चलाएं:

    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. निर्देश में इस्तेमाल किए गए इन पैरामीटर पर ध्यान दें; वे Run Edge माइक्रो को Docker कंटेनर के रूप में चलाने में बताए गए बुनियादी कमांड से अलग हैं.

    • port को 8443 पर सेट किया गया है.
    • कुंजी और सर्टिफ़िकेट फ़ाइलों को माउंट करने के लिए, वॉल्यूम माउंट का इस्तेमाल किया जाता है.
    • NODE_EXTRA_CA_CERTS वैरिएबल का इस्तेमाल कस्टम सीए जोड़ने के लिए किया जाता है (खुद साइन किए हुए सर्टिफ़िकेट के मामले में, ज़रूरत के मुताबिक).

5. TLS कॉन्फ़िगरेशन की जांच करें

  1. सेटअप की जांच करने के लिए, नीचे दिया गया cURL निर्देश चलाएं. अपने basepath और API कुंजी को कमांड में बदलें. नीचे दिए गए उदाहरण के हिसाब से, आप उस डायरेक्ट्री में हैं जहां rootca.pem मौजूद है और आपने जो प्रॉक्सी बनाया है उसका बेस पाथ /hello है:

    curl -v https://localhost:8443/hello --cacert rootca.pem \
    -H "x-api-key: Az82fdnfONVCOOE4NKhajxAboDgA3FAo"
    
  2. वर्बोस cURL आउटपुट, TLS हैंडशेकिंग के हर चरण को दिखाता है. अगर आपको एचटीटीपी 200 रिस्पॉन्स दिखता है, तो कॉन्फ़िगरेशन लागू हो गया है:

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

उदाहरण: साउथबाउंड TLS को कॉन्फ़िगर करने का तरीका

इस सेक्शन में बताया गया है कि EDGE माइक्रोगेटवे सर्वर और बैकएंड टारगेट ऐप्लिकेशन के बीच, साउथबाउंड (आउटगोइंग) TLS कनेक्शन कैसे सेट अप करें. नीचे दिए गए उदाहरण में, खुद हस्ताक्षर किए गए सर्टिफ़िकेट का इस्तेमाल किया गया है.

1. सेटअप के शुरुआती चरण

  1. अपने सिस्टम पर openssl.cnf फ़ाइल ढूंढें. उदाहरण के लिए, /etc/ssl/openssl.cnf.
  2. बदलाव करने के लिए, opensssl.cnf फ़ाइल खोलें.
  3. पक्का करें कि आपकी कॉन्फ़िगरेशन फ़ाइल में req_extensions मौजूद हों. उदाहरण के लिए, आपकी फ़ाइल में ऐसी जानकारी होनी चाहिए जो नीचे दी गई हो:

    [ req ]
    ...
    req_extensions          = v3_req
    ...
    
    [ v3_req ]
    extendedKeyUsage = serverAuth, clientAuth, codeSigning, emailProtection
    basicConstraints = CA:FALSE
    keyUsage = nonRepudiation, digitalSignature, keyEncipherment
    
  4. सही SNI एट्रिब्यूट जनरेट करने के लिए, openssl.cnf में यह वाक्य जोड़ें:

    [ 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
    

    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. edgemicro configure निर्देश चलाएं:

    edgemicro configure -o your_org -e your_env -u your_username

    कॉन्फ़िगरेशन के बारे में ज़्यादा जानकारी के लिए, पार्ट 1: Edge माइक्रोगेटवे को कॉन्फ़िगर करें देखें.

  6. edgemicro configure से मिले कुंजी और सीक्रेट क्रेडेंशियल कॉपी करें. कंटेनर चलाने के लिए आपको इन वैल्यू की ज़रूरत होगी. उदाहरण के लिए:

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

2. Node.js टारगेट ऐप्लिकेशन बनाना

  1. cd को .edgemicro डायरेक्ट्री के लिए.

  2. नीचे दी गई बैश स्क्रिप्ट बनाएं. आप उसे अपनी पसंद का कोई भी नाम दे सकते हैं. उदाहरण के लिए: 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. बैश फ़ाइल में, पक्का करें कि openssl.cnf फ़ाइल का पाथ सही है.

  4. बैश फ़ाइल चलाएं. आपसे सर्टिफ़िकेट की जानकारी मांगी जाएगी. सामान्य नाम के लिए, hellworld का इस्तेमाल करना न भूलें.

  5. देखें कि ये फ़ाइलें बनाई गई थीं या नहीं:

    • rootca.key
    • rootca.pem
    • tls.key
    • tls.csr
    • rootca.srl
    • tls.crt
  6. 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. server.js वाली डायरेक्ट्री में ही package.json फ़ाइल बनाएं. उदाहरण के लिए:

    {
      "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. डिपेंडेंसी पाने के लिए, npm install चलाएं.

  9. server.js वाली डायरेक्ट्री में एक नई Dockerfile बनाएं. यहां WORKDIR आपके 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. Docker इमेज बनाएं:

    docker build -t helloworld . 
    
  11. सैंपल ऐप्लिकेशन शुरू करें:

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

3. Apigee Edge पर इकाइयां बनाना

  1. इन सेटिंग की मदद से, Edge माइक्रोगेटवे-अवेयर प्रॉक्सी बनाएं. ज़्यादा जानकारी के लिए, Edge पर EDGE माइक्रोगेटवे-अवेयर एपीआई प्रॉक्सी बनाना देखें.

    • प्रॉक्सी का नाम: edgemicro_local
    • बदलाव: 1
    • बेसपाथ: /local
    • टारगेट: https://helloworld:9443
  2. कोई एपीआई प्रॉडक्ट बनाएं. ज़्यादा जानकारी के लिए, प्रॉडक्ट बनाना देखें.

  3. डेवलपर बनाएं. ज़्यादा जानकारी के लिए, डेवलपर बनाना देखें.

  4. डेवलपर ऐप्लिकेशन बनाएं. ज़्यादा जानकारी के लिए, डेवलपर ऐप्लिकेशन बनाना लेख पढ़ें

4. कंटेनर चलाएं

  1. किसी एडिटर में EDGE माइक्रो कॉन्फ़िगरेशन फ़ाइल खोलें. उदाहरण के लिए:

    vi $HOME/.edgemicro/myorg-test-config.yaml
    
  2. edgemicro छंद में इस तरह बदलाव करें. ध्यान दें कि आप port और 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. $HOME/.edgemicro में मौजूद Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल को base64 कोड में बदलने के लिए, नीचे दिए गए निर्देश का इस्तेमाल करें:

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

    जहां your_org और your_env संगठन और एनवायरमेंट हैं. आपने edgemicro config कमांड चलाते समय इनका इस्तेमाल किया था.

    कमांड के आस-पास बैक-टिक (`) लगाना याद रखें. उदाहरण के लिए:

    export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/docs-test-config.yaml`
  4. Docker कंटेनर में Edge माइक्रोगेटवे चालू करने के लिए, नीचे दिए गए कमांड को चलाएं.

    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. TLS कॉन्फ़िगरेशन की जांच करें

  1. सेटअप की जांच करने के लिए, नीचे दिया गया cURL निर्देश चलाएं. माइक्रोगेटवे-अवेयर प्रॉक्सी में इस्तेमाल किए गए अपने बेस पाथ और Apigee Edge पर बनाए गए डेवलपर ऐप्लिकेशन से मिली एपीआई कुंजी की जगह इस्तेमाल करें. उदाहरण के लिए:

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

    आपको यह गड़बड़ी दिखेगी:

    ...
    *  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. Edge माइक्रोगेटवे को फिर से चलाएं, लेकिन इस बार 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. नीचे दिया गया cURL निर्देश चलाएं. पहले की तरह अपने basepath और API कुंजी को बदलें. उदाहरण के लिए:

    curl https://localhost:8443/local -k -H "x-api-key: xxxx" -v
    
  4. आउटपुट देखें. सफल होने पर, आपको एचटीटीपी 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
    

कस्टम प्लगिन जोड़ना

कस्टम प्लगिन लिखकर माइक्रोगेटवे में नई सुविधाएं और क्षमताएं जोड़ी जा सकती हैं. कस्टम प्लग इन आपको माइक्रोगेटवे से आने वाले अनुरोधों और रिस्पॉन्स के साथ प्रोग्राम के हिसाब से इंटरैक्ट करने की सुविधा देते हैं.

डॉकर कंटेनर में चल रहे Edge माइक्रोगेटवे इंस्टेंस में प्लगिन डिप्लॉय करने के लिए आपके पास दो विकल्प हैं:

इस सेक्शन के बाकी हिस्से में यह माना गया है कि आपको स्टैंडर्ड Edge माइक्रोगेटवे सेटअप के लिए प्लगिन लिखने और कॉन्फ़िगर करने के बारे में पता है. यदि नहीं, तो कस्टम प्लग इन डेवलप करें देखें.

पहला विकल्प: प्लगिन डायरेक्ट्री को वॉल्यूम पर माउंट करें

(v.2.5.27 में जोड़ा गया) वॉल्यूम माउंट की मदद से प्लगिन जोड़ने का तरीका, Edge Microgateway में किसी कस्टम प्लगिन को जोड़ने के तरीके जैसा ही है. Docker कंटेनर चलाने पर, प्लगिन डायरेक्ट्री को अपने लोकल सिस्टम (वॉल्यूम) पर, कंटेनर माउंट पॉइंट पर माउंट किया जा सकता है. माउंट पॉइंट, /opt/apigee/plugins है. इसके बाद, Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल में लोकल वॉल्यूम डायरेक्ट्री तय की जा सकती है.

आगे दिए गए चरणों में कस्टम प्लग इन शामिल करने के लिए, Docker माउंट पॉइंट का इस्तेमाल करने का तरीका बताया गया है.

  1. एज माइक्रोगेटवे को बंद करें:

    edgemicro stop
    
  2. अपने कस्टम प्लग इन के लिए एक डायरेक्ट्री बनाएं. उदाहरण के लिए,

    $HOME/edgemicro/custom/plugins
    
  3. कस्टम प्लगिन डायरेक्ट्री को Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल में जोड़ें. उदाहरण के लिए:

      plugins:
        dir: $HOME/edgemicro/custom/plugins
        sequence:
          - oauth
          - response-uppercase
      ````
    
  4. एक आसान प्लगिन लिखें में दिए गए निर्देशों के अनुसार, अपना प्लग इन लिखें और उसकी जांच करें. पक्का करें कि अपने प्लगिन कोड को सही डायरेक्ट्री में डाला गया हो. उदाहरण के लिए:

    custom
      |
      |-- plugins
        |
        |- response-uppercase
        |     |- index.js
        |     |- package.json
        |- request-headers
        |     | - index.js
              | - package.json
    
  5. Docker कंटेनर को नीचे दिए गए कमांड के साथ चलाएं, जहां प्लगिन डायरेक्ट्री को Docker वॉल्यूम पर माउंट करने के लिए -v विकल्प का इस्तेमाल किया जाता है. नीचे दिए गए उदाहरण कमांड में, प्लग इन डायरेक्ट्री $HOME/edgemicro/custom/plugins (जहां कस्टम प्लगिन मौजूद होता है) को कंटेनर के माउंट पॉइंट /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. प्लगिन की जांच करने के लिए, अपने एपीआई को कॉल करें.

ज़्यादा जानकारी के लिए, Volume [शेयर किए गए फ़ाइल सिस्टम] देखें.

दूसरा विकल्प: कंटेनर में प्लगिन बनाना

इस विकल्प में, आपको अपने कंटेनर में प्लगिन बनाने होते हैं.

1. अपने प्लग इन पैकेज करें

  1. एक आसान प्लगिन लिखें में दिए गए निर्देशों के अनुसार, अपना प्लग इन लिखें और उसकी जांच करें.

  2. अपने प्लगिन कोड को सही डायरेक्ट्री में रखें. प्लग इन डायरेक्ट्री को तय स्ट्रक्चर का पालन करना होगा. इस उदाहरण में वह स्ट्रक्चर दिखाया गया है जिसका पालन करना ज़रूरी है. यहां response-uppercase और request-headers कस्टम प्लगिन कोड वाले फ़ोल्डर के नाम हैं (ये नाम सिर्फ़ उदाहरण हैं, आपके फ़ोल्डर के नाम अलग-अलग हो सकते हैं):

    plugin
      |
      |-- plugins
        |
        |- response-uppercase
        |     |- index.js
        |     |- package.json
        |- request-headers
        |     | - index.js
              | - package.json
    
  3. plugin फ़ोल्डर में cd.

  4. plugin फ़ोल्डर में, पूरे plugins फ़ोल्डर को ज़िप करें:

    zip -r plugins.zip plugins/

2. Docker इमेज बनाना

इसके बाद, Edge Microgateway इमेज में अपना प्लगिन कोड जोड़ने के लिए, एक Dockerfile बनाएं.

  1. जिस डायरेक्ट्री में zip फ़ाइल मौजूद है उसी डायरेक्ट्री में, Dockerfile नाम की एक नई फ़ाइल बनाएं.
  2. Dockerfile में यह कोड जोड़ें और फ़ाइल सेव करें:

    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. अपने प्लग इन की मदद से, Edge माइक्रोगेटवे डॉकर की नई इमेज बनाएं:

    docker build -t image-name .
    

    उदाहरण के लिए:

    docker build -t edgemicroplugins .
    

3. Edge माइक्रोगेटवे कॉन्फ़िगरेशन को अपडेट करें

प्लग इन पैकेज हो जाने के बाद, अब आपको उन्हें Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल में जोड़ना होगा.

  1. किसी एडिटर में Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल खोलें:

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

    उदाहरण के लिए:

    vi $HOME/.edgemicro/myorg-test-config.yaml
  2. कॉन्फ़िगरेशन फ़ाइल में प्लगिन डायरेक्ट्री जोड़ें. यहां दिए गए उदाहरण में dir एट्रिब्यूट, प्लगिन कोड (जिसके बारे में आपने Dockerfile में बताया है) की जगह के बारे में बताया है. आपको प्लगिन डायरेक्ट्री का नाम भी बताना होगा, जो नीचे दिए गए उदाहरण में response-uppercase है.

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

4. माइक्रोगेटवे चालू करें

आखिर में, आपको कंटेनर में माइक्रोगेटवे शुरू करना होगा.

  1. $HOME/.edgemicro में मौजूद Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल को base64 कोड में बदलने के लिए, नीचे दिए गए निर्देश चलाएं:

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

    जहां your_org और your_env संगठन और एनवायरमेंट हैं. आपने edgemicro config कमांड चलाते समय इनका इस्तेमाल किया था.

    कमांड के आस-पास बैक-टिक (`) लगाना याद रखें. उदाहरण के लिए:

    export EDGEMICRO_CONFIG=`base64 $HOME/.edgemicro/docs-test-config.yaml`
  2. एज माइक्रोगेटवे को कंटेनर की तरह चलाएं. इस निर्देश में कई एनवायरमेंट वैरिएबल सेट किए जाते हैं, जिनका इस्तेमाल EDGE माइक्रोगेटवे को शुरू करने के लिए कंटेनर रनटाइम करता है:

    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

    उदाहरण के लिए:

    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. प्लगिन की जांच करने के लिए, अपने एपीआई को कॉल करें:

    अपने एपीआई को कॉल करके और पुष्टि करें कि आउटपुट कोड उम्मीद के मुताबिक है या नहीं, यह जांच करके देखें कि प्लगिन कोड काम करता है या नहीं:

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

    उदाहरण के लिए, response-uppercase प्लगिन इस तरह का जवाब दिखा सकता है:

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