મેં અધિકૃતતા અને S3 સાથે મારી PyPI રીપોઝીટરી બનાવી છે. Nginx પર

આ લેખમાં હું NJS સાથે મારો અનુભવ શેર કરવા માંગુ છું, Nginx Inc દ્વારા વિકસિત Nginx માટે JavaScript દુભાષિયા, વાસ્તવિક ઉદાહરણનો ઉપયોગ કરીને તેની મુખ્ય ક્ષમતાઓનું વર્ણન કરે છે. NJS એ JavaScript નો સબસેટ છે જે તમને Nginx ની કાર્યક્ષમતાને વિસ્તારવા દે છે. પ્રશ્ન માટે શા માટે તમારા પોતાના દુભાષિયા??? દિમિત્રી વોલિન્ટસેવે વિગતવાર જવાબ આપ્યો. ટૂંકમાં: NJS એ nginx-વે છે, અને JavaScript વધુ પ્રગતિશીલ છે, "મૂળ" અને GC વિના, લુઆથી વિપરીત.

ઘણાં સમય પહેલા…

મારી છેલ્લી નોકરી પર, મને ડોકર-કંપોઝ, ડીંડ અને અન્ય આનંદ સાથે સંખ્યાબંધ મોટલી CI/CD પાઇપલાઇન્સ સાથે ગિટલેબ વારસામાં મળી હતી, જે કનિકો રેલ્સમાં ટ્રાન્સફર કરવામાં આવી હતી. CI માં અગાઉ ઉપયોગમાં લેવાતી છબીઓ તેમના મૂળ સ્વરૂપમાં ખસેડવામાં આવી હતી. તેઓ તે દિવસ સુધી યોગ્ય રીતે કામ કરતા હતા જ્યાં સુધી અમારું ગિટલેબ IP બદલાયું અને CI કોળામાં ફેરવાઈ ગયું. સમસ્યા એ હતી કે CI માં ભાગ લેતી ડોકર ઇમેજમાંની એક પાસે git હતી, જે Python મોડ્યુલોને ssh દ્વારા ખેંચે છે. ssh માટે તમારે ખાનગી કીની જરૂર છે અને... તે જાણીતા_હોસ્ટની સાથે ઈમેજમાં હતી. અને વાસ્તવિક IP અને જાણીતા_હોસ્ટમાં ઉલ્લેખિત એક વચ્ચે મેળ ખાતી ન હોવાને કારણે કોઈપણ CI મુખ્ય ચકાસણી ભૂલ સાથે નિષ્ફળ થયું. હાલની ડોકફાઈલ્સમાંથી એક નવી ઈમેજ ઝડપથી એસેમ્બલ કરવામાં આવી હતી અને વિકલ્પ ઉમેરવામાં આવ્યો હતો StrictHostKeyChecking no. પરંતુ ખરાબ સ્વાદ રહ્યો અને લિબ્સને ખાનગી PyPI રિપોઝીટરીમાં ખસેડવાની ઇચ્છા હતી. એક વધારાનું બોનસ, ખાનગી PyPI પર સ્વિચ કર્યા પછી, એક સરળ પાઇપલાઇન અને જરૂરિયાતોનું સામાન્ય વર્ણન હતું.txt

પસંદગી થઈ ગઈ છે, સજ્જનો!

અમે બધું ક્લાઉડ્સ અને કુબરનેટ્સમાં ચલાવીએ છીએ અને અંતે અમે એક નાની સેવા મેળવવા માગીએ છીએ જે બાહ્ય સ્ટોરેજ સાથે સ્ટેટલેસ કન્ટેનર હતું. ઠીક છે, કારણ કે અમે S3 નો ઉપયોગ કરીએ છીએ, તેને પ્રાથમિકતા આપવામાં આવી હતી. અને, જો શક્ય હોય તો, ગિટલેબમાં પ્રમાણીકરણ સાથે (જો જરૂરી હોય તો તમે તેને જાતે ઉમેરી શકો છો).

ઝડપી શોધથી ઘણા પરિણામો મળ્યા: s3pypi, pypicloud અને સલગમ માટે html ફાઇલોની "મેન્યુઅલ" રચના સાથેનો વિકલ્પ. છેલ્લો વિકલ્પ પોતે જ અદૃશ્ય થઈ ગયો.

s3pypi: S3 હોસ્ટિંગનો ઉપયોગ કરવા માટેની આ ક્લિ છે. અમે ફાઇલો અપલોડ કરીએ છીએ, html જનરેટ કરીએ છીએ અને તેને સમાન બકેટમાં અપલોડ કરીએ છીએ. ઘર વપરાશ માટે યોગ્ય.

pypicloud: તે એક રસપ્રદ પ્રોજેક્ટ જેવું લાગતું હતું, પરંતુ દસ્તાવેજીકરણ વાંચ્યા પછી હું નિરાશ થયો. સારા દસ્તાવેજીકરણ અને તમારી જરૂરિયાતોને અનુરૂપ વિસ્તરણ કરવાની ક્ષમતા હોવા છતાં, વાસ્તવમાં તે નિરર્થક અને રૂપરેખાંકિત કરવું મુશ્કેલ બન્યું. તમારા કાર્યોને અનુરૂપ કોડને સુધારવામાં, તે સમયેના અંદાજ મુજબ, 3-5 દિવસનો સમય લાગશે. સેવાને ડેટાબેઝની પણ જરૂર છે. અમને બીજું કંઈ ન મળે તો અમે તેને છોડી દીધું.

વધુ ઊંડાણપૂર્વકની શોધમાં Nginx, ngx_aws_auth માટે મોડ્યુલ મળ્યું. તેના પરીક્ષણનું પરિણામ XML બ્રાઉઝરમાં પ્રદર્શિત થયું હતું, જે S3 બકેટની સામગ્રી દર્શાવે છે. શોધ સમયે છેલ્લી કમિટ એક વર્ષ પહેલા હતી. ભંડાર ત્યજી ગયેલો દેખાતો હતો.

સ્ત્રોત પર જઈને વાંચવું પીઈપી -503 મને સમજાયું કે XML ને ફ્લાય પર HTML માં રૂપાંતરિત કરી શકાય છે અને pip ને આપી શકાય છે. Nginx અને S3 વિશે થોડું વધુ ગૂગલિંગ કર્યા પછી, મને Nginx માટે JS માં લખેલા S3 માં પ્રમાણીકરણનું ઉદાહરણ મળ્યું. આ રીતે હું NJS ને મળ્યો.

આ ઉદાહરણને આધાર તરીકે લેતા, એક કલાક પછી મેં મારા બ્રાઉઝરમાં ngx_aws_auth મોડ્યુલનો ઉપયોગ કરતી વખતે સમાન XML જોયું, પરંતુ બધું પહેલેથી જ JS માં લખેલું હતું.

મને ખરેખર nginx સોલ્યુશન ગમ્યું. પ્રથમ, સારા દસ્તાવેજો અને ઘણા ઉદાહરણો, બીજું, અમને ફાઇલો (બૉક્સની બહાર) સાથે કામ કરવા માટે Nginx ની બધી ગૂડીઝ મળે છે, ત્રીજું, Nginx માટે રૂપરેખાઓ કેવી રીતે લખવી તે જાણનાર કોઈપણ વ્યક્તિ શું છે તે શોધી શકશે. પાયથોન અથવા ગો (જો તમે શરૂઆતથી લખો છો) ની તુલનામાં, મારા માટે એક વત્તા મિનિમલિઝમ છે, નેક્સસનો ઉલ્લેખ ન કરવો.

TL;DR 2 દિવસ પછી, PyPi નું પરીક્ષણ સંસ્કરણ CI માં પહેલેથી જ ઉપયોગમાં લેવાયું હતું.

તે કેવી રીતે કામ કરે છે?

મોડ્યુલ Nginx માં લોડ થયેલ છે ngx_http_js_module, સત્તાવાર ડોકર ઇમેજમાં શામેલ છે. અમે ડાયરેક્ટિવનો ઉપયોગ કરીને અમારી સ્ક્રિપ્ટ આયાત કરીએ છીએ js_importNginx રૂપરેખાંકન માટે. કાર્યને નિર્દેશન દ્વારા કહેવામાં આવે છે js_content. ડાયરેક્ટિવનો ઉપયોગ ચલો સેટ કરવા માટે થાય છે js_set, જે ફક્ત સ્ક્રિપ્ટમાં વર્ણવેલ કાર્યને દલીલ તરીકે લે છે. પરંતુ અમે NJS માં માત્ર Nginx નો ઉપયોગ કરીને સબક્વેરીઝ એક્ઝિક્યુટ કરી શકીએ છીએ, કોઈ XMLHttpRequest નહીં. આ કરવા માટે, અનુરૂપ સ્થાન Nginx રૂપરેખાંકનમાં ઉમેરવું આવશ્યક છે. અને સ્ક્રિપ્ટે આ સ્થાન માટે સબ-રિક્વેસ્ટનું વર્ણન કરવું આવશ્યક છે. Nginx રૂપરેખામાંથી ફંક્શનને ઍક્સેસ કરવામાં સક્ષમ થવા માટે, ફંક્શનનું નામ સ્ક્રિપ્ટમાં જ નિકાસ કરવું આવશ્યક છે export default.

nginx.conf

load_module modules/ngx_http_js_module.so;
http {
  js_import   imported_name  from script.js;

server {
  listen 8080;
  ...
  location = /sub-query {
    internal;

    proxy_pass http://upstream;
  }

  location / {
    js_content imported_name.request;
  }
}

script.js

function request(r) {
  function call_back(resp) {
    // handler's code
    r.return(resp.status, resp.responseBody);
  }

  r.subrequest('/sub-query', { method: r.method }, call_back);
}

export default {request}

જ્યારે બ્રાઉઝરમાં વિનંતી કરવામાં આવે છે http://localhost:8080/ અમે પ્રવેશ કરીએ છીએ location /જેમાં નિર્દેશ js_content ફંક્શનને બોલાવે છે request અમારી સ્ક્રિપ્ટમાં વર્ણવેલ છે script.js. બદલામાં, કાર્યમાં request માટે સબક્વેરી કરવામાં આવે છે location = /sub-query, દલીલમાંથી મેળવેલ પદ્ધતિ (વર્તમાન ઉદાહરણમાં GET) સાથે (r), જ્યારે આ ફંક્શનને બોલાવવામાં આવે ત્યારે ગર્ભિત રીતે પસાર થાય છે. સબ-રિક્વેસ્ટ પ્રતિસાદ ફંક્શનમાં પ્રક્રિયા કરવામાં આવશે call_back.

ચાલો S3 અજમાવીએ

ખાનગી S3 સ્ટોરેજ માટે વિનંતી કરવા માટે, અમને જરૂર છે:

ACCESS_KEY

SECRET_KEY

S3_BUCKET

વપરાયેલ http પદ્ધતિથી, વર્તમાન તારીખ/સમય, S3_NAME અને URI, ચોક્કસ પ્રકારની સ્ટ્રિંગ જનરેટ થાય છે, જે SECRET_KEY નો ઉપયોગ કરીને (HMAC_SHA1) હસ્તાક્ષરિત થાય છે. આગળ એક લીટી જેવી છે AWS $ACCESS_KEY:$HASH, અધિકૃતતા હેડરમાં વાપરી શકાય છે. અગાઉના પગલામાં સ્ટ્રિંગ જનરેટ કરવા માટે ઉપયોગમાં લેવાતી સમાન તારીખ/સમય હેડરમાં ઉમેરવી આવશ્યક છે X-amz-date. કોડમાં તે આના જેવો દેખાય છે:

nginx.conf

load_module modules/ngx_http_js_module.so;
http {
  js_import   s3      from     s3.js;

  js_set      $s3_datetime     s3.date_now;
  js_set      $s3_auth         s3.s3_sign;

server {
  listen 8080;
  ...
  location ~* /s3-query/(?<s3_path>.*) {
    internal;

    proxy_set_header    X-amz-date     $s3_datetime;
    proxy_set_header    Authorization  $s3_auth;

    proxy_pass          $s3_endpoint/$s3_path;
  }

  location ~ "^/(?<prefix>[w-]*)[/]?(?<postfix>[w-.]*)$" {
    js_content s3.request;
  }
}

s3.js(AWS સાઇન v2 અધિકૃતતા ઉદાહરણ, નાપસંદ સ્થિતિમાં બદલાઈ)

var crypt = require('crypto');

var s3_bucket = process.env.S3_BUCKET;
var s3_access_key = process.env.S3_ACCESS_KEY;
var s3_secret_key = process.env.S3_SECRET_KEY;
var _datetime = new Date().toISOString().replace(/[:-]|.d{3}/g, '');

function date_now() {
  return _datetime
}

function s3_sign(r) {
  var s2s = r.method + 'nnnn';

  s2s += `x-amz-date:${date_now()}n`;
  s2s += '/' + s3_bucket;
  s2s += r.uri.endsWith('/') ? '/' : r.variables.s3_path;

  return `AWS ${s3_access_key}:${crypt.createHmac('sha1', s3_secret_key).update(s2s).digest('base64')}`;
}

function request(r) {
  var v = r.variables;

  function call_back(resp) {
    r.return(resp.status, resp.responseBody);
  }

  var _subrequest_uri = r.uri;
  if (r.uri === '/') {
    // root
    _subrequest_uri = '/?delimiter=/';

  } else if (v.prefix !== '' && v.postfix === '') {
    // directory
    var slash = v.prefix.endsWith('/') ? '' : '/';
    _subrequest_uri = '/?prefix=' + v.prefix + slash;
  }

  r.subrequest(`/s3-query${_subrequest_uri}`, { method: r.method }, call_back);
}

export default {request, s3_sign, date_now}

વિશે થોડી સમજૂતી _subrequest_uri: આ એક ચલ છે જે, પ્રારંભિક uri પર આધાર રાખીને, S3 ને વિનંતી કરે છે. જો તમારે "રુટ" ની સામગ્રી મેળવવાની જરૂર હોય, તો તમારે સીમાંકન દર્શાવતી uri વિનંતી બનાવવાની જરૂર છે. delimiter, જે ડિરેક્ટરીઓ (PyPI ના કિસ્સામાં, બધા પેકેજોની સૂચિ) ને અનુરૂપ, તમામ CommonPrefixes xml ઘટકોની સૂચિ પરત કરશે. જો તમારે ચોક્કસ નિર્દેશિકામાં સમાવિષ્ટોની સૂચિ મેળવવાની જરૂર હોય (બધા પેકેજ સંસ્કરણોની સૂચિ), તો પછી uri વિનંતીમાં ડિરેક્ટરી (પેકેજ) ના નામ સાથેનો ઉપસર્ગ ફીલ્ડ હોવો આવશ્યક છે જે સ્લેશ / સાથે સમાપ્ત થાય છે. નહિંતર, ઉદાહરણ તરીકે, ડિરેક્ટરીના સમાવિષ્ટોની વિનંતી કરતી વખતે અથડામણ શક્ય છે. ત્યાં ડિરેક્ટરીઓ aiohttp-request અને aiohttp-વિનંતી છે અને જો વિનંતી સ્પષ્ટ કરે છે /?prefix=aiohttp-request, પછી પ્રતિભાવમાં બંને ડિરેક્ટરીઓની સામગ્રી હશે. જો અંતે સ્લેશ હોય, /?prefix=aiohttp-request/, પછી પ્રતિભાવમાં માત્ર જરૂરી ડિરેક્ટરી હશે. અને જો આપણે ફાઇલની વિનંતી કરીએ, તો પરિણામી uri મૂળથી અલગ ન હોવી જોઈએ.

Nginx સાચવો અને પુનઃપ્રારંભ કરો. બ્રાઉઝરમાં અમે અમારા Nginx નું સરનામું દાખલ કરીએ છીએ, વિનંતીનું પરિણામ XML હશે, ઉદાહરણ તરીકે:

ડિરેક્ટરીઓની સૂચિ

<?xml version="1.0" encoding="UTF-8"?>
<ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
  <Name>myback-space</Name>
  <Prefix></Prefix>
  <Marker></Marker>
  <MaxKeys>10000</MaxKeys>
  <Delimiter>/</Delimiter>
  <IsTruncated>false</IsTruncated>
  <CommonPrefixes>
    <Prefix>new/</Prefix>
  </CommonPrefixes>
  <CommonPrefixes>
    <Prefix>old/</Prefix>
  </CommonPrefixes>
</ListBucketResult>

ડિરેક્ટરીઓની સૂચિમાંથી તમારે ફક્ત ઘટકોની જરૂર પડશે CommonPrefixes.

બ્રાઉઝરમાં અમારા સરનામામાં જરૂરી નિર્દેશિકા ઉમેરીને, અમે XML સ્વરૂપમાં તેની સામગ્રી પણ પ્રાપ્ત કરીશું:

ડિરેક્ટરીમાં ફાઇલોની સૂચિ

<?xml version="1.0" encoding="UTF-8"?>
<ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
  <Name> myback-space</Name>
  <Prefix>old/</Prefix>
  <Marker></Marker>
  <MaxKeys>10000</MaxKeys>
  <Delimiter></Delimiter>
  <IsTruncated>false</IsTruncated>
  <Contents>
    <Key>old/giphy.mp4</Key>
    <LastModified>2020-08-21T20:27:46.000Z</LastModified>
    <ETag>&#34;00000000000000000000000000000000-1&#34;</ETag>
    <Size>1350084</Size>
    <Owner>
      <ID>02d6176db174dc93cb1b899f7c6078f08654445fe8cf1b6ce98d8855f66bdbf4</ID>
      <DisplayName></DisplayName>
    </Owner>
    <StorageClass>STANDARD</StorageClass>
  </Contents>
  <Contents>
    <Key>old/hsd-k8s.jpg</Key>
    <LastModified>2020-08-31T16:40:01.000Z</LastModified>
    <ETag>&#34;b2d76df4aeb4493c5456366748218093&#34;</ETag>
    <Size>93183</Size>
    <Owner>
      <ID>02d6176db174dc93cb1b899f7c6078f08654445fe8cf1b6ce98d8855f66bdbf4</ID>
      <DisplayName></DisplayName>
    </Owner>
    <StorageClass>STANDARD</StorageClass>
  </Contents>
</ListBucketResult>

ફાઈલોની યાદીમાંથી આપણે ફક્ત તત્વો લઈશું Key.

જે બાકી છે તે પરિણામી XML ને પાર્સ કરવાનું છે અને તેને HTML તરીકે મોકલવાનું છે, પ્રથમ સામગ્રી-પ્રકાર હેડરને ટેક્સ્ટ/html સાથે બદલ્યા પછી.

function request(r) {
  var v = r.variables;

  function call_back(resp) {
    var body = resp.responseBody;

    if (r.method !== 'PUT' && resp.status < 400 && v.postfix === '') {
      r.headersOut['Content-Type'] = "text/html; charset=utf-8";
      body = toHTML(body);
    }

    r.return(resp.status, body);
  }
  
  var _subrequest_uri = r.uri;
  ...
}

function toHTML(xml_str) {
  var keysMap = {
    'CommonPrefixes': 'Prefix',
    'Contents': 'Key',
  };

  var pattern = `<k>(?<v>.*?)</k>`;
  var out = [];

  for(var group_key in keysMap) {
    var reS;
    var reGroup = new RegExp(pattern.replace(/k/g, group_key), 'g');

    while(reS = reGroup.exec(xml_str)) {
      var data = new RegExp(pattern.replace(/k/g, keysMap[group_key]), 'g');
      var reValue = data.exec(reS);
      var a_text = '';

      if (group_key === 'CommonPrefixes') {
        a_text = reValue.groups.v.replace(///g, '');
      } else {
        a_text = reValue.groups.v.split('/').slice(-1);
      }

      out.push(`<a href="/gu/${reValue.groups.v}">${a_text}</a>`);
    }
  }

  return '<html><body>n' + out.join('</br>n') + 'n</html></body>'
}

PyPI અજમાવી રહ્યાં છીએ

અમે તપાસીએ છીએ કે કામ કરવા માટે જાણીતા પેકેજો પર ક્યાંય પણ કંઈ તૂટતું નથી.

# Создаем для тестов новое окружение
python3 -m venv venv
. ./venv/bin/activate

# Скачиваем рабочие пакеты.
pip download aiohttp

# Загружаем в приватную репу
for wheel in *.whl; do curl -T $wheel http://localhost:8080/${wheel%%-*}/$wheel; done

rm -f *.whl

# Устанавливаем из приватной репы
pip install aiohttp -i http://localhost:8080

અમે અમારી લિબ્સ સાથે પુનરાવર્તન કરીએ છીએ.

# Создаем для тестов новое окружение
python3 -m venv venv
. ./venv/bin/activate

pip install setuptools wheel
python setup.py bdist_wheel
for wheel in dist/*.whl; do curl -T $wheel http://localhost:8080/${wheel%%-*}/$wheel; done

pip install our_pkg --extra-index-url http://localhost:8080

CI માં, પેકેજ બનાવવું અને લોડ કરવું આના જેવું દેખાય છે:

pip install setuptools wheel
python setup.py bdist_wheel

curl -sSfT dist/*.whl -u "gitlab-ci-token:${CI_JOB_TOKEN}" "https://pypi.our-domain.com/${CI_PROJECT_NAME}"

પ્રમાણીકરણ

Gitlab માં બાહ્ય સેવાઓના પ્રમાણીકરણ/અધિકૃતતા માટે JWT નો ઉપયોગ કરવો શક્ય છે. Nginx માં auth_request ડાયરેક્ટિવનો ઉપયોગ કરીને, અમે પ્રમાણીકરણ ડેટાને સ્ક્રિપ્ટમાં ફંક્શન કૉલ ધરાવતી સબ-રિક્વેસ્ટ પર રીડાયરેક્ટ કરીશું. સ્ક્રિપ્ટ Gitlab url ને બીજી સબ-રિક્વેસ્ટ કરશે અને જો પ્રમાણીકરણ ડેટા યોગ્ય રીતે ઉલ્લેખિત હશે, તો Gitlab કોડ 200 પરત કરશે અને પેકેજને અપલોડ/ડાઉનલોડ કરવાની મંજૂરી આપવામાં આવશે. શા માટે એક સબક્વેરીનો ઉપયોગ ન કરો અને તરત જ ગિટલેબને ડેટા મોકલો? કારણ કે પછી આપણે જ્યારે પણ અધિકૃતતામાં કોઈપણ ફેરફાર કરીએ ત્યારે Nginx રૂપરેખાંકન ફાઇલને સંપાદિત કરવી પડશે, અને આ એક ખૂબ જ કંટાળાજનક કાર્ય છે. ઉપરાંત, જો Kubernetes માત્ર-વાંચી શકાય તેવી રૂટ ફાઇલસિસ્ટમ નીતિનો ઉપયોગ કરે છે, તો nginx.conf ને configmap દ્વારા બદલતી વખતે આ વધુ જટિલતા ઉમેરે છે. અને configmap દ્વારા Nginx ને રૂપરેખાંકિત કરવું એકદમ અશક્ય બની જાય છે જ્યારે એકસાથે પોલિસીનો ઉપયોગ કરવામાં આવે છે જે વોલ્યુમ્સ (pvc) અને ફક્ત વાંચવા માટેના રૂટ ફાઇલસિસ્ટમના જોડાણને પ્રતિબંધિત કરે છે (આ પણ થાય છે).

NJS ઇન્ટરમીડિયેટનો ઉપયોગ કરીને, અમને પર્યાવરણ ચલોનો ઉપયોગ કરીને nginx રૂપરેખામાં ઉલ્લેખિત પરિમાણો બદલવાની અને સ્ક્રિપ્ટમાં કેટલીક તપાસ કરવાની તક મળે છે (ઉદાહરણ તરીકે, ખોટી રીતે ઉલ્લેખિત URL).

nginx.conf

location = /auth-provider {
  internal;

  proxy_pass $auth_url;
}

location = /auth {
  internal;

  proxy_set_header Content-Length "";
  proxy_pass_request_body off;
  js_content auth.auth;
}

location ~ "^/(?<prefix>[w-]*)[/]?(?<postfix>[w-.]*)$" {
  auth_request /auth;

  js_content s3.request;
}

s3.js

var env = process.env;
var env_bool = new RegExp(/[Tt]rue|[Yy]es|[Oo]n|[TtYy]|1/);
var auth_disabled  = env_bool.test(env.DISABLE_AUTH);
var gitlab_url = env.AUTH_URL;

function url() {
  return `${gitlab_url}/jwt/auth?service=container_registry`
}

function auth(r) {
  if (auth_disabled) {
    r.return(202, '{"auth": "disabled"}');
    return null
  }

  r.subrequest('/auth-provider',
                {method: 'GET', body: ''},
                function(res) {
                  r.return(res.status, "");
                });
}

export default {auth, url}

મોટે ભાગે પ્રશ્ન ઉકાળવામાં આવે છે: -શા માટે તૈયાર મોડ્યુલોનો ઉપયોગ કરશો નહીં? ત્યાં બધું પહેલેથી જ થઈ ગયું છે! ઉદાહરણ તરીકે, var AWS = require('aws-sdk') અને S3 પ્રમાણીકરણ સાથે "સાયકલ" લખવાની જરૂર નથી!

ચાલો વિપક્ષ તરફ આગળ વધીએ

મારા માટે, બાહ્ય JS મોડ્યુલોને આયાત કરવામાં અસમર્થતા એક અપ્રિય, પરંતુ અપેક્ષિત લક્ષણ બની ગયું. ઉપરના ઉદાહરણમાં વર્ણવેલ, જરૂરી ('ક્રિપ્ટો') છે બિલ્ડ-ઇન મોડ્યુલો અને તેમના માટે માત્ર કામની જરૂર છે. સ્ક્રિપ્ટમાંથી કોડનો ફરીથી ઉપયોગ કરવાની કોઈ રીત પણ નથી અને તમારે તેને અલગ-અલગ ફાઇલોમાં કૉપિ કરીને પેસ્ટ કરવી પડશે. હું આશા રાખું છું કે કોઈ દિવસ આ કાર્યક્ષમતા અમલમાં આવશે.

Nginx માં વર્તમાન પ્રોજેક્ટ માટે કમ્પ્રેશન પણ અક્ષમ હોવું આવશ્યક છે gzip off;

કારણ કે NJS માં કોઈ gzip મોડ્યુલ નથી અને તેને કનેક્ટ કરવું અશક્ય છે; તેથી, સંકુચિત ડેટા સાથે કામ કરવાની કોઈ રીત નથી. સાચું, આ કેસ માટે આ ખરેખર માઈનસ નથી. ત્યાં ઘણા બધા ટેક્સ્ટ નથી, અને સ્થાનાંતરિત ફાઇલો પહેલેથી જ સંકુચિત છે અને વધારાના કમ્પ્રેશન તેમને વધુ મદદ કરશે નહીં. ઉપરાંત, આ એવી લોડ કરેલી અથવા જટિલ સેવા નથી કે તમારે સામગ્રીને થોડા મિલિસેકન્ડ્સ ઝડપથી પહોંચાડવાની ચિંતા કરવી પડે.

સ્ક્રિપ્ટને ડીબગ કરવામાં લાંબો સમય લાગે છે અને તે ફક્ત error.log માં "પ્રિન્ટ્સ" દ્વારા જ શક્ય છે. સેટ લૉગિંગ લેવલની માહિતી, ચેતવણી અથવા ભૂલના આધારે, અનુક્રમે r.log, r.warn, r.errorનો ઉપયોગ કરવો શક્ય છે. હું Chrome (v3) અથવા njs કન્સોલ ટૂલમાં કેટલીક સ્ક્રિપ્ટ્સને ડીબગ કરવાનો પ્રયાસ કરું છું, પરંતુ ત્યાં બધું જ તપાસી શકાતું નથી. કોડ ડીબગ કરતી વખતે, ઉર્ફે કાર્યાત્મક પરીક્ષણ, ઇતિહાસ કંઈક આના જેવો દેખાય છે:

docker-compose restart nginx
curl localhost:8080/
docker-compose logs --tail 10 nginx

અને આવા સેંકડો સિક્વન્સ હોઈ શકે છે.

તેમના માટે સબક્વેરીઝ અને વેરિયેબલ્સનો ઉપયોગ કરીને કોડ લખવાથી ગૂંચવણભરી ગૂંચમાં ફેરવાય છે. કેટલીકવાર તમે તમારા કોડની ક્રિયાઓનો ક્રમ શોધવાનો પ્રયાસ કરીને વિવિધ IDE વિન્ડોની આસપાસ દોડવાનું શરૂ કરો છો. તે મુશ્કેલ નથી, પરંતુ કેટલીકવાર તે ખૂબ જ હેરાન કરે છે.

ES6 માટે કોઈ સંપૂર્ણ સમર્થન નથી.

કેટલીક અન્ય ખામીઓ હોઈ શકે છે, પરંતુ મને બીજું કંઈપણ મળ્યું નથી. જો તમને NJS નો ઉપયોગ કરવાનો નકારાત્મક અનુભવ હોય તો માહિતી શેર કરો.

નિષ્કર્ષ

NJS એ હળવા વજનના ઓપન-સોર્સ દુભાષિયા છે જે તમને Nginx માં વિવિધ JavaScript સ્ક્રિપ્ટો અમલમાં મૂકવાની મંજૂરી આપે છે. તેના વિકાસ દરમિયાન, પ્રદર્શન પર ખૂબ ધ્યાન આપવામાં આવ્યું હતું. અલબત્ત, હજી પણ ઘણું ખૂટે છે, પરંતુ પ્રોજેક્ટ એક નાની ટીમ દ્વારા વિકસાવવામાં આવી રહ્યો છે અને તેઓ સક્રિયપણે નવી સુવિધાઓ ઉમેરી રહ્યા છે અને ભૂલોને ઠીક કરી રહ્યાં છે. હું આશા રાખું છું કે કોઈ દિવસ NJS તમને બાહ્ય મોડ્યુલોને કનેક્ટ કરવાની મંજૂરી આપશે, જે Nginx કાર્યક્ષમતાને લગભગ અમર્યાદિત બનાવશે. પરંતુ ત્યાં એનજીઆઈએનએક્સ પ્લસ છે અને સંભવતઃ ત્યાં કોઈ સુવિધાઓ હશે નહીં!

લેખ માટે સંપૂર્ણ કોડ સાથે ભંડાર

AWS સાઇન v4 સપોર્ટ સાથે njs-pypi

ngx_http_js_module મોડ્યુલના નિર્દેશોનું વર્ણન

સત્તાવાર NJS ભંડાર и દસ્તાવેજીકરણ

દિમિત્રી વોલિન્ટસેવ તરફથી NJS નો ઉપયોગ કરવાના ઉદાહરણો

njs - nginx માં મૂળ JavaScript સ્ક્રિપ્ટીંગ / સેન્ટ હાઇલોડ++ 2019 ખાતે દિમિત્રી વોલ્નીવ દ્વારા વક્તવ્ય

ઉત્પાદનમાં NJS / HighLoad++ 2019 પર વેસિલી સોશ્નિકોવ દ્વારા વક્તવ્ય

AWS માં REST વિનંતીઓ પર હસ્તાક્ષર અને પ્રમાણીકરણ

સોર્સ: www.habr.com