මෙම ලිපියෙන්, Nginx Inc විසින් වැඩි දියුණු කරන ලද Nginx සඳහා JavaScript පරිවර්තකයෙකු වන NJS සමඟ මගේ අත්දැකීම් බෙදා ගැනීමට මට අවශ්‍යය, එහි ප්‍රධාන ලක්ෂණ සැබෑ උදාහරණයක් භාවිතා කරමින් විස්තර කරයි. NJS යනු ඔබට Nginx හි ක්‍රියාකාරීත්වය දීර්ඝ කිරීමට ඉඩ සලසන JavaScript හි උප කුලකයකි. ප්රශ්නය Dmitry Volyntsev විස්තරාත්මකව පිළිතුරු දුන්නේය. කෙටියෙන් කිවහොත්: NJS යනු nginx-way වන අතර JavaScript යනු Lua මෙන් නොව වඩා ප්‍රගතිශීලී, "දේශීය" සහ GC නොමැතිව ය.
බොහෝ කලකට පෙර…
මගේ අවසාන රැකියාවේදී, මට ඩොකර්-කොම්පෝස්, ඩින්ඩ් සහ අනෙකුත් ඩිලයිට් සහිත මොට්ලි සීඅයි / සීඩී නල මාර්ග ගණනාවක් සමඟින් කනිකෝ රේල් පීලි වෙත මාරු කරන ලද ගිට්ලැබ් උරුම විය. CI හි කලින් භාවිතා කරන ලද පින්තූර ඒවායේ මුල් ස්වරූපයෙන් ගෙන ගොස් ඇත. අපේ gitlab එකේ IP එක වෙනස් කරලා CI එක වට්ටක්කා ගෙඩියක් වෙන දවස වෙනකම්ම ඒවා හරියට වැඩ කළා. ගැටලුව වූයේ CI සඳහා සහභාගී වූ එක් ඩොකර් රූපයක ssh හරහා Python මොඩියුල ඇද ගන්නා git අඩංගු වීමයි. ssh හට පුද්ගලික යතුරක් අවශ්ය වන අතර ... එය දන්නා_ධාරක සමඟ රූපයේ විය. තවද ඕනෑම CI එකක් අවසන් වූයේ සැබෑ IP සහ දන්නා_hosts හි නිශ්චිතව දක්වා ඇති නොගැලපීම හේතුවෙන් යතුරු සත්‍යාපන දෝෂයකිනි. පවතින ඩොක්ෆයිල්ස් වලින් නව රූපයක් ඉක්මනින් එකලස් කරන ලද අතර විකල්පය එක් කරන ලදී StrictHostKeyChecking no. නමුත් අප්රසන්න පසු රසය පැවති අතර පුද්ගලික PyPI ගබඩාවකට ගොනු මාරු කිරීමට ආශාවක් ඇති විය. පුද්ගලික PyPI වෙත මාරු වීමෙන් පසු අමතර ප්‍රසාද දීමනාවක්, සරල නල මාර්ගයක් සහ අවශ්‍යතා පිළිබඳ සාමාන්‍ය විස්තරයකි.
තේරීම සිදු කර ඇත, මහත්වරුනි!
අපි වලාකුළු සහ Kubernetes හි සෑම දෙයක්ම කරකැවෙන අතර, අවසානයේදී අපට අවශ්ය වූයේ බාහිර ගබඩාවක් සහිත ස්ථාවර බහාලුමක් වූ කුඩා සේවාවක් ලබා ගැනීමටය. හොඳයි, අපි S3 භාවිතා කරන නිසා, ප්රමුඛත්වය එය පිටුපසින් විය. තවද, හැකි නම්, gitlab හි සත්යාපනය සමඟ (අවශ්ය නම් ඔබට එය එකතු කළ හැක).
ඉක්මන් සෙවුමකින් s3pypi, pypicloud සඳහා ප්‍රතිඵල කිහිපයක් සහ turnips සඳහා "manual" html ගොනු නිර්මාණය කිරීමේ විකල්පය ලැබිණි. අවසාන විකල්පය තනිවම අතුරුදහන් විය.
s3pypi: මෙය S3 සත්කාරකත්වය භාවිතා කිරීම සඳහා වන cli වේ. ගොනු උඩුගත කරන්න, html උත්පාදනය කර එම බාල්දියට උඩුගත කරන්න. නිවසේ භාවිතය සඳහා සුදුසු වේ.
pypicloud: රසවත් ව්‍යාපෘතියක් ලෙස පෙනුනද, ලේඛන කියවීමෙන් පසු එය කලකිරීමට පත් විය. හොඳ ලියකියවිලි සහ ඔබේ කාර්යයන්ට ගැලපෙන පරිදි පුළුල් කිරීමේ හැකියාව තිබියදීත්, ඇත්ත වශයෙන්ම එය අතිරික්ත සහ වින්‍යාස කිරීමට අපහසු විය. ඔබගේ කාර්යයන් සඳහා කේතය නිවැරදි කිරීම, එවකට ඇස්තමේන්තු අනුව, දින 3-5 ක් ගතවනු ඇත. සේවාවට දත්ත සමුදායක් ද අවශ්ය වේ. වෙන දෙයක් හොයාගන්න බැරි උනොත් අපි ඒක දාලා ගියා.
වඩාත් ගැඹුරු සෙවුමකින් Nginx, ngx_aws_auth සඳහා මොඩියුලයක් ලැබුණි. ඔහුගේ පරීක්‍ෂණයේ ප්රතිඵලය වූයේ S3 බාල්දියේ අන්තර්ගතය පෙන්වූ බ්රවුසරයේ XML දර්ශනය වීමයි. අවසාන කැපවීම, සෙවීමේදී, වසරකට පෙරය. ගබඩාව අතහැර දමා ඇති බවක් පෙනෙන්නට තිබුණි.
මුල් මූලාශ්රය වෙත හැරී කියවීම XML පියාසර කරන විට HTML බවට පරිවර්තනය කර pip වෙත ලබා දිය හැකි බව අවබෝධ විය. Nginx සහ S3 අනුව තව ටිකක් ගූගල් කර බැලීමේදී, Nginx සඳහා JS හි ලියා ඇති S3 හි සත්යාපනය පිළිබඳ උදාහරණයක් මට හමු විය. එහෙම තමයි මම NJS ගැන දැනගත්තේ.
මෙම උදාහරණය පාදක කර ගනිමින්, පැයකට පසුව මම ngx_aws_auth මොඩියුලය භාවිතා කරන විට මගේ බ්රවුසරයේ එකම XML නිරීක්ෂණය කළෙමි, නමුත් සියල්ල දැනටමත් JS හි ලියා ඇත.
මම ඇත්තටම nginx විසඳුමට කැමතියි. පළමුව, හොඳ ලියකියවිලි සහ බොහෝ උදාහරණ, දෙවනුව, අපි ගොනු (කොටුවෙන් පිටත) සමඟ වැඩ කිරීම සඳහා සියලුම Nginx ගුඩිස් ලබා ගනිමු, තෙවනුව, Nginx වින්‍යාසය ලියන්නේ කෙසේදැයි දන්නා ඕනෑම කෙනෙකුට කුමක් දැයි සොයා ගැනීමට හැකි වේ. Python හෝ Go (මුල සිට ලියා ඇත්නම්) සමඟ සසඳන විට, nexus ගැන සඳහන් නොකර, Minimalism ද මට ප්ලස් වේ.
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 Sign 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, එය නාමාවලි වලට අනුරූප වන සියලුම CommonPrefixes xml මූලද්රව්ය ලැයිස්තුවක් ලබා දෙනු ඇත (PyPI නම්, සියලුම පැකේජ ලැයිස්තුවක්). ඔබට නිශ්චිත නාමාවලියක අන්තර්ගත ලැයිස්තුවක් ලබා ගැනීමට අවශ්ය නම් (සියලු පැකේජ අනුවාද ලැයිස්තුවක්), එවිට uri ඉල්ලීමෙහි නාමාවලියෙහි නම සහිත උපසර්ග ක්ෂේත්‍රයක් තිබිය යුතුය (පැකේජය) slash / සමඟ අවසන් විය යුතුය. එසේ නොමැති නම්, උදාහරණයක් ලෙස නාමාවලියක අන්තර්ගතය ඉල්ලා සිටින විට ගැටුම් ඇති විය හැක. aiohttp-request සහ aiohttp-requests නාමාවලි ඇත, සහ ඉල්ලීම සඳහන් කරන්නේ නම් /?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>"00000000000000000000000000000000-1"</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>"b2d76df4aeb4493c5456366748218093"</ETag>
<Size>93183</Size>
<Owner>
<ID>02d6176db174dc93cb1b899f7c6078f08654445fe8cf1b6ce98d8855f66bdbf4</ID>
<DisplayName></DisplayName>
</Owner>
<StorageClass>STANDARD</StorageClass>
</Contents>
</ListBucketResult>ගොනු ලැයිස්තුවෙන් මූලද්රව්ය පමණක් ගන්න Key.
අන්තර්ගත-වර්ග ශීර්ෂය පෙළ/html සමඟ ප්‍රතිස්ථාපනය කිරීමෙන් පසුව ලැබෙන 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="/si/${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:8080CI හි, පැකේජයක් සෑදීම සහ පැටවීම මේ වගේ ය:
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 හි කියවීමට-පමණක් root ගොනු පද්ධති ප්‍රතිපත්තිය භාවිතා කරන්නේ නම්, මෙය configmap හරහා nginx.conf ප්‍රතිස්ථාපනය කිරීමේදී වඩාත් සංකීර්ණ බවක් එක් කරයි. වෙළුම් (pvc) සහ කියවීමට පමණක් root ගොනු පද්ධතිය (මෙයද සිදු වේ) සම්බන්ධ කිරීම තහනම් කරන ප්‍රතිපත්ති භාවිතා කරන අතරතුර configmap හරහා Nginx වින්‍යාස කිරීම සම්පූර්ණයෙන්ම කළ නොහැක්කකි.
NJS අතරමැදි භාවිතා කරමින්, පරිසර විචල්‍යයන් භාවිතා කර nginx config හි නිශ්චිත පරාමිති වෙනස් කිරීමට සහ ස්ක්‍රිප්ටයේ යම් චෙක්පත් කිරීමට අපට හැකියාව ලැබේ (උදාහරණයක් ලෙස, වැරදි ලෙස සඳහන් කර ඇති 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 යන ක්‍රම 3ක් භාවිතා කළ හැක. මම Chrome (v8) හෝ njs කොන්සෝල මෙවලමෙහි සමහර ස්ක්‍රිප්ට් දෝෂහරණය කිරීමට උත්සාහ කරමි, නමුත් එහි සියල්ල පරීක්ෂා කළ නොහැක. කේතය නිදොස් කිරීමේදී, එනම් ක්‍රියාකාරී පරීක්ෂණය, ඉතිහාසය මේ වගේ දෙයක් පෙනේ:
docker-compose restart nginx
curl localhost:8080/
docker-compose logs --tail 10 nginxසහ එවැනි අනුපිළිවෙල සිය ගණනක් තිබිය හැක.
ඒවා සඳහා උප විමසුම් සහ විචල්‍යයන් භාවිතා කරමින් කේතය ලිවීම පැටලිලි පටලැවිල්ලක් බවට පත්වේ. සමහර විට ඔබ ඔබේ කේතයේ ක්‍රියා අනුපිළිවෙල හඳුනා ගැනීමට උත්සාහ කරමින් විවිධ IDE කවුළු වටා දුවන්න පටන් ගනී. එය අපහසු නැත, නමුත් සමහර විට ඉතා කරදරකාරී ය.
ES6 සඳහා පූර්ණ සහායක් නොමැත.
තවත් අඩුපාඩු තියෙන්න පුළුවන්, ඒත් මට වෙන කිසිම දෙයක් හමුවෙලා නැහැ. ඔබට NJS සමඟ ඍණාත්මක අත්දැකීමක් තිබේ නම් තොරතුරු බෙදා ගන්න.
නිගමනය
NJS යනු ඔබට Nginx හි විවිධ JavaScript ස්ක්‍රිප්ට් ක්රියාත්මක කිරීමට ඉඩ සලසන සැහැල්ලු විවෘත මූලාශ්‍ර පරිවර්තකයකි. එහි සංවර්ධනය අතරතුර, කාර්ය සාධනය කෙරෙහි විශාල අවධානයක් යොමු විය. ඇත්ත වශයෙන්ම, එහි බොහෝ දේ තවමත් අතුරුදහන් වී ඇත, නමුත් ව්‍යාපෘතිය කුඩා කණ්ඩායමක් විසින් සංවර්ධනය කරනු ලබන අතර ඔවුන් ක්‍රියාකාරීව නව විශේෂාංග එකතු කරමින් දෝෂ නිවැරදි කරයි. යම් දවසක NJS ඔබට බාහිර මොඩියුල සම්බන්ධ කිරීමට ඉඩ දෙනු ඇතැයි මම බලාපොරොත්තු වෙමි, එමඟින් Nginx හි ක්‍රියාකාරිත්වය පාහේ අසීමිත වේ. නමුත් NGINX ප්ලස් ඇති අතර බොහෝ විට විශේෂාංග කිසිවක් නොතිබෙනු ඇත!
и
/ Saint HighLoad++ 2019 දී Dmitry Volniev විසින් කරන ලද කථාව
/ HighLoad++ 2019 හි Vasily Soshnikov විසින් ඉදිරිපත් කිරීම
මූලාශ්රය: www.habr.com