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 माइक्रोगेटवे को शुरू करने के लिए कंटेनर रनटाइम करता है:

    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 कंटेनर में TLS का इस्तेमाल करने के लिए, Edge माइक्रोगेटवे को कॉन्फ़िगर किया जाता है, तो लॉग फ़ाइल डायरेक्ट्री को माउंट करने पर आपको पोर्ट 8443 को सार्वजनिक करना होगा. वॉल्यूम [शेयर किए गए फ़ाइल सिस्टम] भी देखें. Docker कंटेनर में TLS का इस्तेमाल करना भी देखें.
    -w, -- workdir (ज़रूरी नहीं) उस डायरेक्ट्री के पाथ के बारे में बताता है जहां edgemicro.sock और edgemicro.pid फ़ाइलें बनाई जानी चाहिए. आप फ़ाइल नाम रूट edgemicro को संशोधित नहीं कर सकते हैं. डिफ़ॉल्ट तौर पर, यह मौजूदा वर्किंग डायरेक्ट्री पाथ पर सेट होता है.

    उदाहरण: 

    docker run -P -p 8000:8000 -d -w /tmp --name edgemicro 
    
...
    EDGEMICRO_ORG उस Apigee संगठन का नाम जिसका इस्तेमाल आपने Edge माइक्रोगेटवे को कॉन्फ़िगर करने के लिए किया था.
    EDGEMICRO_ENV उस Apigee एनवायरमेंट का नाम जिसका इस्तेमाल आपने Edge माइक्रोगेटवे को कॉन्फ़िगर करने के लिए किया था.
    EDGEMICRO_PROCESSES शुरू की जाने वाली प्रोसेस की संख्या.
    EDGEMICRO_KEY Edge माइक्रोगेटवे को कॉन्फ़िगर करने पर कुंजी वापस दिखती है.
    EDGEMICRO_SECRET जब आपने Edge माइक्रोगेटवे को कॉन्फ़िगर किया, तो सीक्रेट मिला.
    EDGEMICRO_CONFIG ऐसा वैरिएबल जिसमें base64 कोड में बदली गई Edge माइक्रोगेटवे कॉन्फ़िगरेशन फ़ाइल है.
    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 माइक्रोगेटवे कॉन्फ़िगरेशन पैरामीटर to_console की मदद से, आपको लॉग फ़ाइल के बजाय स्टैंडर्ड आउटपुट में लॉग की जानकारी भेजने का विकल्प मिलता है. अगर Docker कंटेनर में Edge माइक्रोगेटवे चलाने के लिए दिए गए तरीके का पालन किया जाता है, तो डिफ़ॉल्ट रूप से कंटेनर, 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 माइक्रोगेटवे की लॉग फ़ाइल में कोई लॉग नहीं भेजा जाएगा.
    • edgemicro.log फ़ाइल पर लॉग नहीं भेजे जाएंगे.
    to_console: true

    LOG_CONSOLE_OUTPUT_TO_FILE=true

    • लॉग फ़ाइलें मैनेज करना सेक्शन में बताए गए तरीके के मुताबिक, Edge माइक्रोगेटवे की लॉग फ़ाइल में कोई लॉग नहीं भेजा जाएगा.
    • edgemicro.log फ़ाइल पर लॉग भेजे जाएंगे.
    to_console: false

    LOG_CONSOLE_OUTPUT_TO_FILE=true

    • लॉग, लॉग फ़ाइलें मैनेज करना में बताए गए तरीके के मुताबिक, Edge माइक्रोगेटवे की लॉग फ़ाइल में भेजे जाएंगे.
    • edgemicro.log फ़ाइल पर लॉग भेजे जाएंगे.

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

    कंटेनर में 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 को कॉन्फ़िगर करने का तरीका उदाहरण देखें.

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

    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 माइक्रो चलाएं को भी देखें.

    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 तय करें. उदाहरण के लिए:

    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

    उदाहरण: नॉर्थबाउंड 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 माइक्रोगेटवे के साथ चलाने के लिए, नीचे दिया गया कमांड चलाएं:

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

      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. 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 वैरिएबल जोड़ें.

      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 निर्देश चलाएं. पहले की तरह अपने 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 से मैप किया गया है:

      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 [शेयर किए गए फ़ाइल सिस्टम] देखें.

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

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

    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!