יצרתי מאגר PyPI משלי עם הרשאה ו-S3. על Nginx

במאמר זה ברצוני לחלוק את הניסיון שלי עם NJS, מתורגמן JavaScript עבור Nginx שפותח על ידי Nginx Inc, המתאר את היכולות העיקריות שלו באמצעות דוגמה אמיתית. NJS היא תת-קבוצה של JavaScript המאפשרת לך להרחיב את הפונקציונליות של Nginx. לשאלה למה מתורגמן משלך??? דמיטרי וולינסב ענה בפירוט. בקיצור: NJS הוא בדרך nginx, ו-JavaScript יותר פרוגרסיבי, "מקורי" וללא GC, בניגוד ל-Lua.

לפני זמן רב…

בעבודה האחרונה שלי, ירשתי את gitlab עם מספר צינורות CI/CD ססגוניים עם docker-compose, dind ותענוגות אחרים, שהועברו ל-kaniko rails. התמונות ששימשו בעבר ב-CI הועברו בצורתן המקורית. הם עבדו כמו שצריך עד היום שבו ה-IP של gitlab שלנו השתנה ו-CI הפך לדלעת. הבעיה הייתה שלאחת מתמונות ה-docker שהשתתפו ב-CI הייתה git, שמשכה מודולים של Python דרך ssh. עבור ssh אתה צריך מפתח פרטי ו... זה היה בתמונה יחד עם ידועים_מארחים. וכל CI נכשל עם שגיאת אימות מפתח עקב אי התאמה בין ה-IP האמיתי לזה שצוין ב-known_hosts. תמונה חדשה הורכבה במהירות מה-Dockfiles הקיימים והאפשרות נוספה StrictHostKeyChecking no. אבל הטעם הרע נשאר והיה רצון להעביר את ה-libs למאגר PyPI פרטי. בונוס נוסף, לאחר המעבר ל-PyPI הפרטי, היה צינור פשוט יותר ותיאור רגיל של requirements.txt

הבחירה נעשתה, רבותי!

אנחנו מריצים הכל בעננים וב-Kubernetes, ובסופו של דבר רצינו לקבל שירות קטן שהוא קונטיינר חסר מדינה עם אחסון חיצוני. ובכן, מכיוון שאנו משתמשים ב-S3, ניתנה לו עדיפות. ואם אפשר, עם אימות ב-gitlab (תוכל להוסיף את זה בעצמך במידת הצורך).

חיפוש מהיר הניב מספר תוצאות: s3pypi, pypicloud ואפשרות עם יצירה "ידנית" של קבצי html עבור לפת. האפשרות האחרונה נעלמה מעצמה.

s3pypi: זהו CLI לשימוש באחסון S3. אנחנו מעלים את הקבצים, יוצרים את ה-html ומעלים אותו לאותו דלי. מתאים לשימוש ביתי.

pypicloud: זה נראה כמו פרויקט מעניין, אבל אחרי שקראתי את התיעוד התאכזבתי. למרות התיעוד הטוב והיכולת להתרחב כדי להתאים לצרכים שלך, במציאות התברר שזה מיותר וקשה להגדיר. תיקון הקוד כך שיתאים למשימות שלך, על פי ההערכות באותו זמן, היה לוקח 3-5 ימים. השירות זקוק גם למסד נתונים. השארנו אותו למקרה שלא מצאנו שום דבר אחר.

חיפוש מעמיק יותר הניב מודול עבור Nginx, ngx_aws_auth. תוצאת הבדיקה שלו הייתה XML שהוצג בדפדפן, שהראה את התוכן של דלי S3. ההתחייבות האחרונה בזמן החיפוש הייתה לפני שנה. המאגר נראה נטוש.

על ידי מעבר למקור וקריאה PEP-503 הבנתי שניתן להמיר XML ל-HTML תוך כדי תנועה ולתת ל-pip. לאחר שגוגלתי עוד קצת על Nginx ו-S3, נתקלתי בדוגמה של אימות ב-S3 שנכתב ב-JS עבור Nginx. כך פגשתי את NJS.

אם לוקחים את הדוגמה הזו כבסיס, שעה לאחר מכן ראיתי בדפדפן שלי את אותו XML כמו בעת השימוש במודול ngx_aws_auth, אבל הכל כבר היה כתוב ב-JS.

מאוד אהבתי את פתרון nginx. ראשית, תיעוד טוב ודוגמאות רבות, שנית, אנחנו מקבלים את כל הטוב של Nginx לעבודה עם קבצים (מהקופסה), שלישית, כל מי שיודע לכתוב הגדרות עבור Nginx יוכל להבין מה זה מה. מינימליזם הוא גם יתרון עבורי, בהשוואה לפייתון או גו (אם נכתב מאפס), שלא לדבר על nexus.

TL;DR לאחר יומיים, גרסת הבדיקה של PyPi כבר הייתה בשימוש ב-CI.

איך זה עובד?

המודול נטען לתוך Nginx ngx_http_js_module, כלול בתמונת הדוקר הרשמית. אנו מייבאים את הסקריפט שלנו באמצעות ההנחיה js_importלתצורת Nginx. הפונקציה נקראת על ידי הוראה 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, נוצר סוג מסוים של מחרוזת, אשר נחתמת (HMAC_SHA1) באמצעות SECRET_KEY. הבא שורה כמו 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: זהו משתנה אשר בהתאם לאורי ההתחלתי, יוצר בקשה ל-S3. אם אתה צריך לקבל את התוכן של ה"שורש", אז אתה צריך ליצור בקשת uri המציינת את המפריד delimiter, שיחזיר רשימה של כל רכיבי ה-xml של CommonPrefixes, התואמים לספריות (במקרה של PyPI, רשימה של כל החבילות). אם אתה צריך לקבל רשימת תוכן בספרייה ספציפית (רשימה של כל גרסאות החבילה), אזי בקשת ה-uri חייבת להכיל שדה קידומת עם שם הספרייה (חבילה) שמסתיים בהכרח בקו נטוי /. אחרת, התנגשות אפשרית בעת בקשה לתוכן של ספרייה, למשל. יש ספריות aiohttp-request ו-aiohttp-requests ואם הבקשה מציינת /?prefix=aiohttp-request, אז התגובה תכיל את התוכן של שתי הספריות. אם יש קו נטוי בסוף, /?prefix=aiohttp-request/, אז התגובה תכיל רק את הספרייה הנדרשת. ואם נבקש קובץ, אז האורי המתקבל לא צריך להיות שונה מהמקורי.

שמור והפעל מחדש את 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, לאחר שהחלפת תחילה את הכותרת Content-Type ב-text/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="/iw/${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 לאימות/הרשאה של שירותים חיצוניים. באמצעות ההנחיה auth_request ב-Nginx, ננתב את נתוני האימות ל-subrequest המכילה קריאת פונקציה בסקריפט. הסקריפט יבצע בקשת משנה נוספת לכתובת ה-URL של Gitlab ואם נתוני האימות צוינו כהלכה, אז Gitlab תחזיר קוד 200 והעלאה/הורדה של החבילה תתאפשר. למה לא להשתמש בשאילתת משנה אחת ולשלוח מיד את הנתונים ל-Gitlab? כי אז נצטרך לערוך את קובץ התצורה של Nginx בכל פעם שנבצע שינויים כלשהם בהרשאה, וזו משימה די מייגעת. כמו כן, אם Kubernetes משתמש במדיניות מערכת בסיס לקריאה בלבד, הדבר מוסיף עוד יותר מורכבות בעת החלפת nginx.conf באמצעות configmap. וזה הופך לבלתי אפשרי לחלוטין להגדיר את Nginx באמצעות configmap תוך שימוש בו-זמנית במדיניות האוסרת חיבור של אמצעי אחסון (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 חיצוניים הפך לתכונה לא נעימה, אך צפויה. המתואר בדוגמה לעיל require('crypto') is מודולים מובנים ודורשים רק עבודות עבורם. אין גם דרך לעשות שימוש חוזר בקוד מסקריפטים ויש להעתיק ולהדביק אותו בקבצים שונים. אני מקווה שיום אחד הפונקציונליות הזו תיושם.

יש להשבית את הדחיסה גם עבור הפרויקט הנוכחי ב-Nginx gzip off;

מכיוון שאין מודול gzip ב-NJS ואי אפשר לחבר אותו; לכן, אין דרך לעבוד עם נתונים דחוסים. נכון, זה לא ממש מינוס למקרה הזה. אין הרבה טקסט, והקבצים המועברים כבר דחוסים ודחיסה נוספת לא תעזור להם הרבה. כמו כן, זה לא שירות כל כך טעון או קריטי שאתה צריך להתעסק באספקת תוכן כמה אלפיות שנייה מהר יותר.

איתור באגים בסקריפט לוקח זמן רב ומתאפשר רק באמצעות "הדפסות" ב- error.log. בהתאם לפרטי רמת הרישום המוגדרים, אזהרה או שגיאה, אפשר להשתמש ב-3 שיטות r.log, r.warn, r.error בהתאמה. אני מנסה לנפות באגים בכמה סקריפטים בכרום (v8) או בכלי הקונסול של njs, אבל לא הכל ניתן לבדוק שם. בעת איתור באגים בקוד, כלומר בדיקות פונקציונליות, ההיסטוריה נראית בערך כך:

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

ויכולים להיות מאות רצפים כאלה.

כתיבת קוד באמצעות שאילתות משנה ומשתנים עבורן הופכת לסבך סבוך. לפעמים אתה מתחיל למהר סביב חלונות IDE שונים בניסיון להבין את רצף הפעולות של הקוד שלך. זה לא קשה, אבל לפעמים זה מאוד מעצבן.

אין תמיכה מלאה ב-ES6.

אולי יש עוד כמה חסרונות, אבל לא נתקלתי בשום דבר אחר. שתף מידע אם יש לך ניסיון שלילי בשימוש ב-NJS.

מסקנה

NJS הוא מתורגמן קל משקל בקוד פתוח המאפשר לך ליישם סקריפטים שונים של JavaScript ב-Nginx. במהלך פיתוחו הוקדשה תשומת לב רבה לביצועים. כמובן שעדיין חסר הרבה, אבל הפרויקט מפותח על ידי צוות קטן והם מוסיפים תכונות חדשות באופן פעיל ומתקנים באגים. אני מקווה שמתישהו NJS יאפשר לכם לחבר מודולים חיצוניים, מה שיהפוך את הפונקציונליות של Nginx לכמעט בלתי מוגבלת. אבל יש NGINX Plus וסביר להניח שלא יהיו תכונות!

מאגר עם קוד מלא למאמר

njs-pypi עם תמיכה ב-AWS Sign v4

תיאור ההנחיות של מודול ngx_http_js_module

מאגר NJS רשמי и תיעוד

דוגמאות לשימוש ב-NJS של דמיטרי וולינטסב

njs - סקריפטים מקוריים של JavaScript ב-nginx / נאום של דמיטרי וולנייב ב-Saint HighLoad++ 2019

NJS בייצור / נאום מאת וסילי סושניקוב ב-HighLoad++ 2019

חתימה ואימות של בקשות REST ב-AWS

מקור: www.habr.com