അംഗീകാരവും S3 ഉം ഉപയോഗിച്ച് ഞാൻ എന്റെ സ്വന്തം PyPI ശേഖരം ഉണ്ടാക്കി. Nginx-ൽ

ഈ ലേഖനത്തിൽ, Nginx Inc വികസിപ്പിച്ച Nginx-നുള്ള JavaScript വ്യാഖ്യാതാവായ NJS-മായി എന്റെ അനുഭവം പങ്കിടാൻ ഞാൻ ആഗ്രഹിക്കുന്നു, ഒരു യഥാർത്ഥ ഉദാഹരണം ഉപയോഗിച്ച് അതിന്റെ പ്രധാന കഴിവുകൾ വിവരിക്കുന്നു. Nginx-ന്റെ പ്രവർത്തനം വിപുലീകരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന JavaScript-ന്റെ ഒരു ഉപവിഭാഗമാണ് NJS. എന്ന ചോദ്യത്തിന് എന്തുകൊണ്ടാണ് നിങ്ങളുടെ സ്വന്തം വ്യാഖ്യാതാവ് ??? ദിമിത്രി വോളിന്റ്സെവ് വിശദമായി ഉത്തരം നൽകി. ചുരുക്കത്തിൽ: NJS nginx-way ആണ്, കൂടാതെ JavaScript കൂടുതൽ പുരോഗമനപരവും "നേറ്റീവ്" ആണ്, ലുവായിൽ നിന്ന് വ്യത്യസ്തമായി GC ഇല്ലാത്തതുമാണ്.

വളരെക്കാലം മുമ്പ്…

എന്റെ അവസാന ജോലിയിൽ, ഡോക്കർ-കമ്പോസ്, ഡിൻഡ്, മറ്റ് ഡിലൈറ്റുകൾ എന്നിവയുള്ള നിരവധി മോട്ട്ലി സിഐ/സിഡി പൈപ്പ്ലൈനുകളുള്ള ഗിറ്റ്ലാബ് എനിക്ക് പാരമ്പര്യമായി ലഭിച്ചു, അവ കനിക്കോ റെയിലുകളിലേക്ക് മാറ്റി. CI-യിൽ മുമ്പ് ഉപയോഗിച്ചിരുന്ന ചിത്രങ്ങൾ അവയുടെ യഥാർത്ഥ രൂപത്തിൽ നീക്കി. നമ്മുടെ ഗിറ്റ്‌ലാബ് ഐപി മാറി സിഐ മത്തങ്ങയായി മാറുന്നത് വരെ അവർ ശരിയായി പ്രവർത്തിച്ചു. സിഐയിൽ പങ്കെടുത്ത ഡോക്കർ ചിത്രങ്ങളിലൊന്നിൽ ജിറ്റ് ഉണ്ടായിരുന്നു, അത് പൈത്തൺ മൊഡ്യൂളുകൾ ssh വഴി വലിച്ചു എന്നതാണ് പ്രശ്നം. ssh-ന് നിങ്ങൾക്ക് ഒരു സ്വകാര്യ കീ ആവശ്യമാണ്, കൂടാതെ... അത് known_hosts-നോടൊപ്പം ചിത്രത്തിൽ ഉണ്ടായിരുന്നു. യഥാർത്ഥ IP-യും known_hosts-ൽ വ്യക്തമാക്കിയിട്ടുള്ളതും തമ്മിലുള്ള പൊരുത്തക്കേട് കാരണം ഒരു കീ സ്ഥിരീകരണ പിശക് കാരണം ഏതെങ്കിലും CI പരാജയപ്പെട്ടു. നിലവിലുള്ള ഡോക്ക്ഫയലുകളിൽ നിന്ന് ഒരു പുതിയ ചിത്രം പെട്ടെന്ന് കൂട്ടിച്ചേർക്കുകയും ഓപ്ഷൻ ചേർക്കുകയും ചെയ്തു StrictHostKeyChecking no. എന്നാൽ മോശം രുചി തുടർന്നു, ലിബുകൾ ഒരു സ്വകാര്യ PyPI ശേഖരത്തിലേക്ക് മാറ്റാനുള്ള ആഗ്രഹം ഉണ്ടായിരുന്നു. സ്വകാര്യ PyPI-യിലേക്ക് മാറിയതിന് ശേഷമുള്ള ഒരു അധിക ബോണസ്, ഒരു ലളിതമായ പൈപ്പ് ലൈനും ആവശ്യകതകളുടെ ഒരു സാധാരണ വിവരണവുമായിരുന്നു.

തിരഞ്ഞെടുത്തു, മാന്യരേ!

ഞങ്ങൾ എല്ലാം ക്ലൗഡുകളിലും കുബെർനെറ്റുകളിലും പ്രവർത്തിപ്പിക്കുന്നു, അവസാനം ഒരു ചെറിയ സേവനം ലഭിക്കാൻ ഞങ്ങൾ ആഗ്രഹിച്ചു, അത് ബാഹ്യ സംഭരണമുള്ള ഒരു സ്‌റ്റേറ്റ്‌ലെസ് കണ്ടെയ്‌നർ ആയിരുന്നു. ശരി, ഞങ്ങൾ S3 ഉപയോഗിക്കുന്നതിനാൽ, അതിന് മുൻഗണന നൽകി. കൂടാതെ, സാധ്യമെങ്കിൽ, gitlab-ൽ ആധികാരികതയോടെ (ആവശ്യമെങ്കിൽ നിങ്ങൾക്കത് ചേർക്കാവുന്നതാണ്).

ഒരു ദ്രുത തിരയൽ നിരവധി ഫലങ്ങൾ നൽകി: s3pypi, pypicloud കൂടാതെ ടേണിപ്പുകൾക്കായി html ഫയലുകൾ "മാനുവൽ" സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഓപ്ഷൻ. അവസാന ഓപ്ഷൻ സ്വയം അപ്രത്യക്ഷമായി.

s3pypi: ഇത് S3 ഹോസ്റ്റിംഗ് ഉപയോഗിക്കുന്നതിനുള്ള ഒരു cli ആണ്. ഞങ്ങൾ ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യുകയും html സൃഷ്ടിക്കുകയും അതേ ബക്കറ്റിലേക്ക് അപ്‌ലോഡ് ചെയ്യുകയും ചെയ്യുന്നു. ഗാർഹിക ഉപയോഗത്തിന് അനുയോജ്യം.

pypicloud: ഇതൊരു രസകരമായ പ്രോജക്റ്റ് പോലെ തോന്നി, പക്ഷേ ഡോക്യുമെന്റേഷൻ വായിച്ചതിനുശേഷം ഞാൻ നിരാശനായി. നല്ല ഡോക്യുമെന്റേഷനും നിങ്ങളുടെ ആവശ്യങ്ങൾക്കനുസരിച്ച് വികസിപ്പിക്കാനുള്ള കഴിവും ഉണ്ടായിരുന്നിട്ടും, വാസ്തവത്തിൽ അത് അനാവശ്യവും കോൺഫിഗർ ചെയ്യാൻ ബുദ്ധിമുട്ടുള്ളതുമായി മാറി. നിങ്ങളുടെ ടാസ്‌ക്കുകൾക്ക് അനുയോജ്യമായ രീതിയിൽ കോഡ് ശരിയാക്കാൻ, അക്കാലത്തെ കണക്കുകൾ പ്രകാരം, 3-5 ദിവസമെടുക്കും. സേവനത്തിന് ഒരു ഡാറ്റാബേസും ആവശ്യമാണ്. മറ്റൊന്നും കണ്ടെത്താനാകാത്ത സാഹചര്യത്തിൽ ഞങ്ങൾ അത് ഉപേക്ഷിച്ചു.

കൂടുതൽ ആഴത്തിലുള്ള തിരയൽ Nginx, ngx_aws_auth എന്നതിനായുള്ള ഒരു മൊഡ്യൂൾ നൽകി. അവന്റെ പരിശോധനയുടെ ഫലം ബ്രൗസറിൽ XML പ്രദർശിപ്പിച്ചു, അത് S3 ബക്കറ്റിന്റെ ഉള്ളടക്കം കാണിക്കുന്നു. തിരച്ചിൽ സമയത്ത് അവസാന കമ്മിറ്റ് ഒരു വർഷം മുമ്പായിരുന്നു. ശേഖരം ഉപേക്ഷിക്കപ്പെട്ടതായി കാണപ്പെട്ടു.

ഉറവിടത്തിൽ പോയി വായിച്ചുകൊണ്ട് PEP-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-ലേക്ക് ഒരു അഭ്യർത്ഥന രൂപീകരിക്കുന്നു. നിങ്ങൾക്ക് "റൂട്ടിന്റെ" ഉള്ളടക്കം ലഭിക്കണമെങ്കിൽ, ഡിലിമിറ്റർ സൂചിപ്പിക്കുന്ന ഒരു യൂറി അഭ്യർത്ഥന നിങ്ങൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്. delimiter, ഡയറക്‌ടറികളുമായി ബന്ധപ്പെട്ട എല്ലാ കോമൺപ്രിഫിക്‌സസ് xml ഘടകങ്ങളുടെയും ഒരു ലിസ്റ്റ് തിരികെ നൽകും (PyPI-യുടെ കാര്യത്തിൽ, എല്ലാ പാക്കേജുകളുടെയും ഒരു ലിസ്റ്റ്). ഒരു നിർദ്ദിഷ്‌ട ഡയറക്‌ടറിയിൽ (എല്ലാ പാക്കേജ് പതിപ്പുകളുടെയും ഒരു ലിസ്റ്റ്) നിങ്ങൾക്ക് ഉള്ളടക്കങ്ങളുടെ ഒരു ലിസ്റ്റ് ലഭിക്കണമെങ്കിൽ, 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 ആയി അയയ്‌ക്കുക മാത്രമാണ് ശേഷിക്കുന്നത്, ആദ്യം ഉള്ളടക്ക-തരം തലക്കെട്ട് ടെക്‌സ്‌റ്റ്/എച്ച്‌ടിഎംഎൽ ഉപയോഗിച്ച് മാറ്റി.

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="/ml/${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 നൽകുകയും പാക്കേജിന്റെ അപ്‌ലോഡ്/ഡൗൺലോഡ് അനുവദിക്കുകയും ചെയ്യും. എന്തുകൊണ്ട് ഒരു സബ്ക്വറി ഉപയോഗിച്ച് ഡാറ്റ ഉടൻ തന്നെ Gitlab-ലേക്ക് അയച്ചുകൂടാ? കാരണം, അംഗീകാരത്തിൽ എന്തെങ്കിലും മാറ്റങ്ങൾ വരുത്തുമ്പോഴെല്ലാം ഞങ്ങൾ Nginx കോൺഫിഗറേഷൻ ഫയൽ എഡിറ്റ് ചെയ്യേണ്ടിവരും, ഇത് തികച്ചും മടുപ്പിക്കുന്ന ജോലിയാണ്. കൂടാതെ, Kubernetes ഒരു റീഡ്-ഒൺലി റൂട്ട് ഫയൽസിസ്റ്റം നയമാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, കോൺഫിഗ്മാപ്പ് വഴി nginx.conf മാറ്റിസ്ഥാപിക്കുമ്പോൾ ഇത് കൂടുതൽ സങ്കീർണ്ണത നൽകുന്നു. വോള്യങ്ങളുടെ (pvc) കണക്ഷൻ നിരോധിക്കുന്ന നയങ്ങളും റീഡ്-ഒൺലി റൂട്ട് ഫയൽസിസ്റ്റവും (ഇതും സംഭവിക്കുന്നു) ഒരേസമയം ഉപയോഗിക്കുമ്പോൾ കോൺഫിഗ്മാപ്പ് വഴി Nginx കോൺഫിഗർ ചെയ്യുന്നത് തികച്ചും അസാധ്യമാണ്.

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 = ആവശ്യം('aws-sdk') കൂടാതെ S3 ആധികാരികതയോടെ ഒരു "ബൈക്ക്" എഴുതേണ്ട ആവശ്യമില്ല!

നമുക്ക് പോരായ്മകളിലേക്ക് പോകാം

എന്നെ സംബന്ധിച്ചിടത്തോളം, ബാഹ്യ JS മൊഡ്യൂളുകൾ ഇറക്കുമതി ചെയ്യാനുള്ള കഴിവില്ലായ്മ അസുഖകരവും എന്നാൽ പ്രതീക്ഷിച്ചതുമായ ഒരു സവിശേഷതയായി മാറി. മുകളിലെ ഉദാഹരണത്തിൽ വിവരിച്ചിരിക്കുന്നത് ആവശ്യം ('ക്രിപ്റ്റോ') ആണ് ബിൽറ്റ്-ഇൻ മൊഡ്യൂളുകൾ അവർക്കുവേണ്ടി മാത്രം പ്രവൃത്തികൾ ആവശ്യപ്പെടുന്നു. സ്ക്രിപ്റ്റുകളിൽ നിന്നുള്ള കോഡ് വീണ്ടും ഉപയോഗിക്കുന്നതിന് ഒരു മാർഗവുമില്ല, നിങ്ങൾ അത് വ്യത്യസ്ത ഫയലുകളിലേക്ക് പകർത്തി ഒട്ടിക്കേണ്ടതുണ്ട്. എന്നെങ്കിലും ഈ പ്രവർത്തനം നടപ്പിലാക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

Nginx-ലെ നിലവിലെ പ്രോജക്റ്റിനായി കംപ്രഷൻ പ്രവർത്തനരഹിതമാക്കിയിരിക്കണം gzip off;

NJS-ൽ gzip മൊഡ്യൂൾ ഇല്ലാത്തതിനാൽ അത് കണക്ട് ചെയ്യുന്നത് അസാധ്യമാണ്; അതിനാൽ, കംപ്രസ് ചെയ്ത ഡാറ്റ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ ഒരു മാർഗവുമില്ല. ശരിയാണ്, ഇത് ഈ കേസിന് ശരിക്കും ഒരു മൈനസ് അല്ല. ധാരാളം ടെക്‌സ്‌റ്റ് ഇല്ല, കൈമാറ്റം ചെയ്‌ത ഫയലുകൾ ഇതിനകം കംപ്രസ്സുചെയ്‌തു, അധിക കംപ്രഷൻ അവരെ വളരെയധികം സഹായിക്കില്ല. കൂടാതെ, കുറച്ച് മില്ലിസെക്കൻഡ് വേഗത്തിൽ ഉള്ളടക്കം ഡെലിവർ ചെയ്യുന്നതിൽ നിങ്ങൾക്ക് ബുദ്ധിമുട്ടേണ്ടി വരുന്ന അത്ര ലോഡുചെയ്തതോ നിർണായകമായതോ ആയ സേവനമല്ല ഇത്.

സ്ക്രിപ്റ്റ് ഡീബഗ്ഗിംഗ് വളരെ സമയമെടുക്കും, error.log-ലെ "പ്രിന്റുകൾ" വഴി മാത്രമേ ഇത് സാധ്യമാകൂ. സെറ്റ് ലോഗിംഗ് ലെവൽ ഇൻഫോ, മുന്നറിയിപ്പ് അല്ലെങ്കിൽ പിശക് എന്നിവയെ ആശ്രയിച്ച്, യഥാക്രമം r.log, r.warn, r.error എന്നിങ്ങനെ 3 രീതികൾ ഉപയോഗിക്കാൻ കഴിയും. Chrome (v8) അല്ലെങ്കിൽ njs കൺസോൾ ടൂളിൽ ചില സ്ക്രിപ്റ്റുകൾ ഡീബഗ് ചെയ്യാൻ ഞാൻ ശ്രമിക്കുന്നു, പക്ഷേ എല്ലാം അവിടെ പരിശോധിക്കാൻ കഴിയില്ല. കോഡ് ഡീബഗ്ഗ് ചെയ്യുമ്പോൾ, ഫംഗ്ഷണൽ ടെസ്റ്റിംഗ്, ചരിത്രം ഇതുപോലെയാണ് കാണപ്പെടുന്നത്:

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

അത്തരം നൂറുകണക്കിന് സീക്വൻസുകൾ ഉണ്ടാകാം.

അവയ്‌ക്കായി സബ്‌ക്വറികളും വേരിയബിളുകളും ഉപയോഗിച്ച് കോഡ് എഴുതുന്നത് ഒരു പിണഞ്ഞ കുരുക്കായി മാറുന്നു. നിങ്ങളുടെ കോഡിന്റെ പ്രവർത്തനങ്ങളുടെ ക്രമം കണ്ടുപിടിക്കാൻ ചില സമയങ്ങളിൽ നിങ്ങൾ വ്യത്യസ്ത IDE വിൻഡോകളിൽ ഓടാൻ തുടങ്ങും. ഇത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല, പക്ഷേ ചിലപ്പോൾ ഇത് വളരെ അരോചകമാണ്.

ES6-ന് പൂർണ്ണ പിന്തുണയില്ല.

മറ്റ് ചില പോരായ്മകൾ ഉണ്ടാകാം, പക്ഷേ മറ്റൊന്നും ഞാൻ നേരിട്ടിട്ടില്ല. NJS ഉപയോഗിച്ച് നിങ്ങൾക്ക് നെഗറ്റീവ് അനുഭവം ഉണ്ടെങ്കിൽ വിവരങ്ങൾ പങ്കിടുക.

തീരുമാനം

Nginx-ൽ വിവിധ JavaScript സ്ക്രിപ്റ്റുകൾ നടപ്പിലാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഭാരം കുറഞ്ഞ ഒരു ഓപ്പൺ സോഴ്സ് ഇന്റർപ്രെറ്ററാണ് NJS. അതിന്റെ വികസന സമയത്ത്, പ്രകടനത്തിൽ വലിയ ശ്രദ്ധ ചെലുത്തി. തീർച്ചയായും, ഇനിയും ഒരുപാട് നഷ്‌ടമായിട്ടുണ്ട്, പക്ഷേ ഒരു ചെറിയ ടീമാണ് പ്രോജക്റ്റ് വികസിപ്പിക്കുന്നത്, അവർ സജീവമായി പുതിയ സവിശേഷതകൾ ചേർക്കുകയും ബഗുകൾ പരിഹരിക്കുകയും ചെയ്യുന്നു. ഒരു ദിവസം NJS നിങ്ങളെ ബാഹ്യ മൊഡ്യൂളുകൾ ബന്ധിപ്പിക്കാൻ അനുവദിക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു, ഇത് Nginx പ്രവർത്തനത്തെ ഏതാണ്ട് പരിധിയില്ലാത്തതാക്കും. എന്നാൽ NGINX പ്ലസ് ഉണ്ട്, മിക്കവാറും സവിശേഷതകളൊന്നും ഉണ്ടാകില്ല!

ലേഖനത്തിനായുള്ള പൂർണ്ണ കോഡുള്ള ശേഖരം

AWS സൈൻ v4 പിന്തുണയുള്ള njs-pypi

ngx_http_js_module മൊഡ്യൂളിന്റെ നിർദ്ദേശങ്ങളുടെ വിവരണം

ഔദ്യോഗിക NJS ശേഖരം и പ്രമാണീകരണം

ദിമിത്രി വോളിന്റ്സെവിൽ നിന്നുള്ള NJS ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണങ്ങൾ

njs - nginx-ലെ നേറ്റീവ് JavaScript സ്ക്രിപ്റ്റിംഗ് / സെയിന്റ് ഹൈലോഡ്++ 2019-ൽ ദിമിത്രി വോൾനെവ് നടത്തിയ പ്രസംഗം

നിർമ്മാണത്തിൽ എൻ.ജെ.എസ് / ഹൈലോഡ്++ 2019-ൽ വാസിലി സോഷ്നിക്കോവ് നടത്തിയ പ്രസംഗം

AWS-ൽ REST അഭ്യർത്ഥനകൾ ഒപ്പിടുകയും പ്രാമാണീകരിക്കുകയും ചെയ്യുന്നു

അവലംബം: www.habr.com