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

आपको Apigee Edge से जुड़ा दस्तावेज़ दिख रहा है.
Apigee X के दस्तावेज़ पर जाएं.
info

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

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

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

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

    edgemicro configure -o your_org -e your_env -u your_username

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

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

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

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

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

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

Edge Micro को Docker कंटेनर के तौर पर चलाना

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

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

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

    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 Microgateway को कंटेनर के तौर पर चलाना. यह कमांड, कई एनवायरमेंट वैरिएबल सेट करता है. इनका इस्तेमाल, Edge Microgateway को शुरू करने के लिए कंटेनर रनटाइम करता है:

    chown -R 100:101 ~/.edgemicro/ \
    docker run -P -p 8000:8000 -d --name edgemicro \
    -v /var/tmp:/opt/apigee/logs \
    -e EDGEMICRO_PROCESSES=1 \
    -e EDGEMICRO_ORG=your_org \
    -e EDGEMICRO_ENV=your_env \
    -e EDGEMICRO_KEY=your_key \
    -e EDGEMICRO_SECRET=your_secret \
    -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
    -e "LOG_CONSOLE_OUTPUT_TO_FILE=false" \
    -e SERVICE_NAME=edgemicro \
    --security-opt=no-new-privileges \
    --cap-drop=ALL \
    gcr.io/apigee-microgateway/edgemicro:latest

    पैरामीटर

      <tr>
        <td><code>SERVICE_NAME</code></td>
        <td>If you are on Kubernetes, this parameter is auto-populated. Otherwise,
          you can set it to anything you wish. If you specify nothing, the service
          name is set to <code>default</code>.</td>
      </tr>
      <tr>
        <tr>
        <td><code>DEBUG</code></td>
        <td>Set to <code>*</code> to enable debugging. </td>
      </tr>
      <tr>
        <td><code>HTTP_PROXY</code>
            <code>HTTPS_PROXY</code></td>
        <td>Use when Edge Microgateway is
          running behind a firewall and the gateway cannot communicate with Apigee
          Edge. For more
          information, see <a href="operation-and-configuration-reference-edge-microgateway#settingupedgemicrogatewaybehindacompanyfirewall">Setting up Edge Microgateway behind a company firewall</a>. 
          <p>For example: <code>HTTP_PROXY=http://10.203.0.1:5187/</code></p></td>
      </tr>
      <tr>
        <td><code>NO_PROXY</code></td>
        <td>A comma delimited list of domains that Edge Microgateway should not proxy to. 
          For more information, see <a href="operation-and-configuration-reference-edge-microgateway#settingupedgemicrogatewaybehindacompanyfirewall">Setting up Edge Microgateway behind a company firewall</a>.
          <p>For example: <code>localhost,127.0.0.1,localaddress,.localdomain.com</code></p></td>
      </tr>
      <tr>
      <tr>
        <tr>
        <td><code>NODE_EXTRA_CA_CERTS</code></td>
        <td>(Optional) Use this parameter if you are using a CA that's not trusted
          by default by Node.js. Set the value of this parameter to the path to a
          file containing one or more trusted certificates in PEM format. For
          details, see <a href="#tls_certificates">TLS certificates</a>.</td>
      </tr>
      <tr>
        <td><code>--security-opt</code></td>
        <td>(Optional) Sets desired Docker security options. See <a href="https://docs.docker.com/engine/reference/run/#security-configuration">Security configuration</a> in the Docker documentation.</td>
      </tr>
      <tr>
        <td><code>--cap-drop</code></td>
        <td>(Optional) Sets limits on Linux capabilities permitted in the container. See <a href="https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities">Runtime privilege and Linux capabilities</a> in the Docker documentation.</td>
      </tr>
    </tbody>
    

    पैरामीटर ब्यौरा
    -P सभी एक्सपोज़्ड पोर्ट को होस्ट पर पब्लिश करें. Docker रन रेफ़रंस भी देखें.
    -p किसी एक पोर्ट या पोर्ट की रेंज को साफ़ तौर पर मैप करें. Docker रन रेफ़रंस भी देखें.
    -d डिटैच्ड मोड में चलाएं. Docker रन रेफ़रंस भी देखें.
    -v, -- volume इससे वॉल्यूम माउंट के बारे में पता चलता है. ध्यान दें कि अगर आपने Docker कंटेनर में टीएलएस का इस्तेमाल करने के लिए Edge Microgateway को कॉन्फ़िगर किया है, तो लॉग फ़ाइल डायरेक्ट्री को माउंट करने पर आपको पोर्ट 8443 को एक्सपोज़ करना होगा. VOLUME [shared filesystems] भी देखें. डॉकर कंटेनर में टीएलएस का इस्तेमाल करना भी देखें.
    -w, -- workdir (ज़रूरी नहीं) उस डायरेक्ट्री का पाथ तय करता है जहां edgemicro.sock और edgemicro.pid फ़ाइलें बनाई जानी चाहिए. फ़ाइल नाम के रूट edgemicro में बदलाव नहीं किया जा सकता. डिफ़ॉल्ट रूप से, मौजूदा वर्किंग डायरेक्ट्री का पाथ.

    उदाहरण:

    docker run -P -p 8000:8000 -d -w /tmp --name edgemicro 
    ...
    EDGEMICRO_ORG Apigee संगठन का नाम, जिसका इस्तेमाल आपने Edge Microgateway को कॉन्फ़िगर करने के लिए किया था.
    EDGEMICRO_ENV Edge Microgateway को कॉन्फ़िगर करने के लिए इस्तेमाल किए गए Apigee एनवायरमेंट का नाम.
    EDGEMICRO_PROCESSES शुरू की जाने वाली प्रोसेस की संख्या.
    EDGEMICRO_KEY Edge Microgateway को कॉन्फ़िगर करने पर मिली कुंजी.
    EDGEMICRO_SECRET Edge Microgateway को कॉन्फ़िगर करने पर मिला सीक्रेट.
    EDGEMICRO_CONFIG एक वैरिएबल, जिसमें base64-कोड में बदली गई Edge Microgateway कॉन्फ़िगरेशन फ़ाइल शामिल है.
    LOG_CONSOLE_OUTPUT_TO_FILE (बूलियन) इससे यह तय किया जा सकता है कि लॉग आउटपुट कहां भेजा जाए. लॉग फ़ाइल के विकल्पों के बारे में जानकारी देखें.

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

    chown -R 100:101 ~/.edgemicro/ 
    docker run -P -p 8000:8000 -d --name edgemicro
    -v /var/tmp:/opt/apigee/logs
    -e EDGEMICRO_PROCESS=1
    -e EDGEMICRO_ORG=docs
    -e EDGEMICRO_ENV=test
    -e EDGEMICRO_KEY=d9c34e1aff68ed969273b016699eabf48780e4f652242e72fc88a23e21252cb0
    -e EDGEMICRO_SECRET=3bc95a71c86a3c8ce04137fbcb788158731t51dfc6cdec13b7c05aa0bd969430
    -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG"
    -e SERVICE_NAME=edgemicro
    --security-opt=no-new-privileges
    --cap-drop=ALL
    gcr.io/apigee-microgateway/edgemicro

    1. यह देखने के लिए कि कंटेनर चल रहा है या नहीं:

      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 Microgateway के कॉन्फ़िगरेशन पैरामीटर to_console की मदद से, लॉग की जानकारी को लॉग फ़ाइल के बजाय स्टैंडर्ड आउटपुट में भेजा जा सकता है. अगर आपने Docker कंटेनर में Edge Microgateway को चलाने के लिए दिया गया तरीका अपनाया है, तो कंटेनर डिफ़ॉल्ट रूप से stdout और गड़बड़ी के आउटपुट को कंटेनर में मौजूद इस फ़ाइल पर रीडायरेक्ट करता है: ${APIGEE_ROOT}/logs/edgemicro.log.

    edgemicro.log को लॉग की जानकारी भेजने से रोकने के लिए, कंटेनर चलाते समय LOG_CONSOLE_OUTPUT_TO_FILE वैरिएबल का इस्तेमाल करें.

    नीचे दी गई टेबल में, to_console के साथ LOG_CONSOLE_OUTPUT_TO_FILE का इस्तेमाल करने पर, लॉग आउटपुट के काम करने के तरीके के बारे में बताया गया है:

    to_console: true

    LOG_CONSOLE_OUTPUT_TO_FILE=false

    • Edge Microgateway की लॉग फ़ाइल में कोई लॉग नहीं भेजा जाएगा. इसके बारे में लॉग फ़ाइलों को मैनेज करना लेख में बताया गया है.
    • लॉग, edgemicro.log फ़ाइल में नहीं भेजे जाएंगे.
    to_console: true

    LOG_CONSOLE_OUTPUT_TO_FILE=true

    • Edge Microgateway की लॉग फ़ाइल में कोई लॉग नहीं भेजा जाएगा. इसके बारे में लॉग फ़ाइलों को मैनेज करना लेख में बताया गया है.
    • लॉग, edgemicro.log फ़ाइल में भेजे जाएंगे.
    to_console: false

    LOG_CONSOLE_OUTPUT_TO_FILE=true

    • लॉग, Edge Microgateway की लॉग फ़ाइल में भेजे जाएंगे. इसके बारे में लॉग फ़ाइलों को मैनेज करना लेख में बताया गया है.
    • लॉग, edgemicro.log फ़ाइल में भेजे जाएंगे.

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

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

    http://localhost:8000/hello

    आउटपुट का सैंपल:

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

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

    Edge Microgateway को बंद किया जा रहा है

    Edge Microgateway को बंद करने के लिए, इस Docker कमांड का इस्तेमाल करें:

    docker stop edgemicro
    

    Edge Microgateway को रीस्टार्ट करना

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

    docker start edgemicro
    

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

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

    सर्टिफ़िकेट की फ़ाइलें कहां अपलोड करें

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

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

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

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

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

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

    chown -R 100:101 ~/.edgemicro/ \
    docker run -P -p 8443:8443 -d --name edgemicro \
    -v $HOME/.edgemicro:/opt/apigee/.edgemicro \
    -v $HOME/.edgemicro:/opt/apigee/logs \
    -e NODE_EXTRA_CA_CERTS=/opt/apigee/.edgemicro/rootca.pem \
    -e EDGEMICRO_PORT=8443 \
    -e EDGEMICRO_ORG=docs \
    -e EDGEMICRO_ENV=test \
    -e EDGEMICRO_KEY=ac36574905fb54fdae65fc5433e831bec2680efb98220a355f2e917e52973c \
    -e EDGEMICRO_SECRET=aac81dff6c326eaa222d53c15c8841fa78ea863bf4472568c9ce2d80a3bc56 \
    -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
    --link helloworld:helloworld gcr.io/apigee-microgateway/edgemicro
    

    Edge Micro को Docker कंटेनर के तौर पर चलाना भी देखें.

    टीएलएस की पुष्टि करने की सुविधा बंद करना

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

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

    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 विकल्प चुनें. उदाहरण के लिए:

    chown -R 100:101 ~/.edgemicro/ \
    docker run -P -p 8443:8443 -d --name edgemicro \
    -v $HOME/.edgemicro:/opt/apigee/.edgemicro \
    -v $HOME/.edgemicro:/opt/apigee/logs \
    -e NODE_TLS_REJECT_UNAUTHORIZED = 1 \
    -e EDGEMICRO_PORT=8443 \
    -e EDGEMICRO_ORG=docs \
    -e EDGEMICRO_ENV=test \
    -e EDGEMICRO_KEY=ac36574905fb54fdae65fc5433e831bec2680efb98220a355f2e917e52973c \
    -e EDGEMICRO_SECRET=aac81dff6c326eaa222d53c15c8841fa78ea863bf4472568c9ce2d80a3bc56 \
    -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
    --link helloworld:helloworld gcr.io/apigee-microgateway/edgemicro
    

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

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

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

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

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

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

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

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

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

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

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

      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 Microgateway की कॉन्फ़िगरेशन फ़ाइल को base64-encode करने के लिए, यह कमांड चलाएं:

      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`

    Edge Micro को Docker कंटेनर के तौर पर चलाना भी देखें.

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

    1. Edge Microgateway के साथ Docker कंटेनर को चलाने के लिए, यह कमांड चलाएं:

      chown -R 100:101 ~/.edgemicro/ \
      docker run -P -p 8443:8443 -d --name edgemicro \
      -v path_to_your_edgemicro_dir:/opt/apigee/.edgemicro \
      -v path_to_your_logs_dir:/opt/apigee/logs \
      -e 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. कमांड में इस्तेमाल किए गए इन पैरामीटर पर ध्यान दें. ये पैरामीटर, Edge Micro को Docker कंटेनर के तौर पर चलाएं में बताए गए बुनियादी कमांड से अलग हैं.

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

    5. टीएलएस कॉन्फ़िगरेशन की जांच करना

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

      curl -v https://localhost:8443/hello --cacert rootca.pem \
      -H "x-api-key: Az82fdnfONVCOOE4NKhajxAboDgA3FAo"
      
    2. ज़्यादा जानकारी वाले cURL आउटपुट में, टीएलएस हैंडशेक का हर चरण दिखता है. अगर आपको एचटीटीपी 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!
      

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

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

    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. सही एसएनआई एट्रिब्यूट जनरेट करने के लिए, 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

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

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

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

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

    1. cd को .edgemicro डायरेक्ट्री में जोड़ा गया.

    2. यह bash स्क्रिप्ट बनाएं. इसे अपनी पसंद का कोई भी नाम दिया जा सकता है. उदाहरण के लिए: 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. bash फ़ाइल में, पक्का करें कि 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 build -t helloworld . 
      
    11. सैंपल के तौर पर मिला ऐप्लिकेशन शुरू करें:

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

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

    1. इन सेटिंग की मदद से, Edge Microgateway-aware प्रॉक्सी बनाएं. ज़्यादा जानकारी के लिए, Edge पर Edge Microgateway-aware API प्रॉक्सी बनाना लेख पढ़ें.

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

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

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

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

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

      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 Microgateway की कॉन्फ़िगरेशन फ़ाइल को base64-encode करने के लिए, यह कमांड चलाएं:

      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 Microgateway को शुरू करने के लिए, यहां दिया गया कमांड चलाएं.

      chown -R 100:101 ~/.edgemicro/ \
      docker run -P -p 8443:8443 -d --name edgemicro \
      -v path_to_your_edgemicro_dir:/opt/apigee/.edgemicro \
      -v path_to_your_logs_dir:/opt/apigee/logs \
      -e 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. टीएलएस कॉन्फ़िगरेशन की जांच करना

    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 Microgateway को फिर से चलाएं. हालांकि, इस बार NODE_EXTRA_CA_CERTS वैरिएबल जोड़ें.

      chown -R 100:101 ~/.edgemicro/ \
      docker run -P -p 8443:8443 -d --name edgemicro \
      -v path_to_your_edgemicro_dir:/opt/apigee/.edgemicro \
      -v path_to_your_logs_dir:/opt/apigee/logs \
      -e NODE_EXTRA_CA_CERTS=/opt/apigee/.edgemicro/rootca.pem \
      -e EDGEMICRO_PORT=8443 \
      -e EDGEMICRO_ORG=$EDGEMICRO_ORG \
      -e EDGEMICRO_ENV=$EDGEMICRO_ENV \
      -e EDGEMICRO_KEY=$EDGEMICRO_KEY \
      -e EDGEMICRO_SECRET=$EDGEMICRO_SECRET \
      -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
      --link helloworld:helloworld gcr.io/apigee-microgateway/edgemicro
      
    3. यहां दिया गया cURL कमांड चलाएं. पहले की तरह ही, अपना बेसपाथ और एपीआई पासकोड डालें. उदाहरण के लिए:

      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 Microgateway इंस्टेंस में प्लग इन डिप्लॉय करने के लिए, आपके पास दो विकल्प हैं:

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

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

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

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

    1. Edge Microgateway को बंद करना:

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

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

        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 पर मैप किया गया है:

      chown -R 100:101 ~/.edgemicro/ \
      docker run -P -p 8000:8000 -d --name edgemicro \
      -v /var/tmp:/opt/apigee/logs \
      -v $HOME/edgemicro/custom/plugins:/opt/apigee/plugins \
      -e EDGEMICRO_PROCESSES=1 \
      -e EDGEMICRO_ORG=jdoe \
      -e EDGEMICRO_ENV=test \
      -e EDGEMICRO_KEY=39c4b561100cd7f258768d1072f3e1d7c17b5f36a18fe89972bb5c9ce7e58fb \
      -e EDGEMICRO_SECRET=f5f9e239a38b4e6cc99c2aa067716a84aebdcff9580a7925fc500e402b1a5fa \
      -e "EDGEMICRO_CONFIG=$EDGEMICRO_CONFIG" \
      -e SERVICE_NAME=edgemicro \
      --security-opt=no-new-privileges \
      --cap-drop=ALL gcr.io/apigee-microgateway/edgemicro:latest
      
    6. प्लग इन को टेस्ट करने के लिए, अपने एपीआई को कॉल करें.

    ज़्यादा जानकारी के लिए, VOLUME [shared filesystems] देखें.

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

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

    1. अपने प्लगिन पैकेज करना

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

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

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

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

      zip -r plugins.zip plugins/

    2. डॉकर इमेज बनाना

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

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

      FROM gcr.io/apigee-microgateway/edgemicro:latest
      USER root
      RUN apt-get update && \
          apt-get install -y unzip && \
          rm -rf /var/lib/apt/lists/* && \
          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 ["/opt/apigee/entrypoint.sh"]
      
    3. अपने प्लग इन के साथ एक नई Edge Microgateway Docker इमेज बनाएं:

      docker build -t image-name .

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

      docker build -t edgemicroplugins .

    3. Edge Microgateway का कॉन्फ़िगरेशन अपडेट करना

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

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

      $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 Microgateway की कॉन्फ़िगरेशन फ़ाइल को base64-encode करने के लिए, यह कमांड चलाएं:

      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 Microgateway को कंटेनर के तौर पर चलाना. यह कमांड, कई एनवायरमेंट वैरिएबल सेट करता है. इनका इस्तेमाल, 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

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

      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!