نگاهی به معماری جدید ذخیره‌سازی Git در GitHub

معماری جدید ذخیره‌سازی Git در GitHub طوری ساخته شده که هزاران عامل بتوانند هم‌زمان به یک مخزن push کنند. در ادامه می‌بینید که این معماری چطور کار می‌کند.

هفتهٔ گذشته در رویداد GitHub Universe، معماری جدید ذخیره‌سازی Git خود را معرفی کردیم؛ معماری‌ای که می‌تواند هزاران نوشتن در ثانیه را پشتیبانی کند و خواندن‌ها را بر اساس تقاضا مقیاس‌پذیر کند. در آزمون‌های داخلی نشان داده‌ایم که می‌توانیم ۵٬۰۰۰ عامل هم‌زمان را که روی یک مخزن کار می‌کنند پشتیبانی کنیم و ۷٬۲۰۰ push در ثانیه به یک مخزن بفرستیم، در حالی که ترافیک خواندن نیز با تأخیر پایدار و کم سرو می‌شود. این معماری جدید پایه‌ای است که GitHub بر آن توسعهٔ عامل‌محور را برای صدها میلیون توسعه‌دهنده ممکن می‌کند؛ و آن را در دل GitHub ساخته‌ایم، در حالی که GitHub همچنان در حال کار بود.

در طول یک سال گذشته، عامل‌ها تصویر یک مخزن پرترافیک در GitHub را تغییر داده‌اند. در نخستین مطلب این مجموعه، دو اصل پشت معماری نسل بعدی ذخیره‌سازی Git را توضیح دادیم: کمینه‌کردن هماهنگی و جدا کردن ذخیره‌سازی از محاسبات. در مطلب قبلی، به مرحلهٔ میانی پرداختیم: انتقال ۹۹٫۹۹۹۹۹٪ مخزن‌ها به Azure، محدود کردن حد نصاب نوشتن به هر مرجع به‌صورت جداگانه، و راه‌اندازی replicaهای مجازی که داده‌شان روی Azure Blob Storage نگهداری می‌شود.

در پایان مطلب قبلی هم به نکته‌ای اشاره کردیم: بخش بسیار کوچکی از یک نوشتن نیاز به ترتیب دارد. اشیای Git تغییرناپذیرند و نامشان از محتوایشان گرفته می‌شود؛ یعنی دو نویسنده می‌توانند هم‌زمان آن‌ها را ذخیره کنند بدون آنکه لازم باشد دربارهٔ چیزی به توافق برسند. بخشی از push که به توافق نیاز دارد، به‌روزرسانی مرجع است و به‌روزرسانی مرجع در مقایسه با بقیهٔ کارها بسیار کوچک است. replicaهای مجازی نخستین گام برای ساختن سیستم بر همین پایه بودند و ابزاری که با آن مخزن‌ها را به معماری جدید منتقل می‌کنیم.

بقیهٔ معماری هم بر همین نکته بنا شده است: فقط به‌روزرسانی مرجع‌ها به توافق نیاز دارد. همین موضوع اجازه می‌دهد بخش‌هایی از زیرساخت Git که پیش‌تر به‌شدت به هم وابسته بودند (ذخیرهٔ داده، سرو درخواست‌ها و نگهداری مخزن‌ها) مستقل از هم مقیاس بگیرند. برای توسعه‌دهنده‌ها، Git همان Git می‌ماند: مثل قبل push و fetch می‌کنند و شاخه می‌سازند، و همان محافظت‌ها برقرار است. در ادامه، نیازمندی‌های پشت این طراحی را مرور می‌کنیم، مسیر یک درخواست را در سیستم دنبال می‌کنیم و به دو جزء آن عمیق‌تر می‌پردازیم.

طراحی برای مقیاس عامل‌ها

مقیاس پلتفرم GitHub را در دو محور در نظر می‌گیریم:

- مقیاس افقی یعنی چند توسعه‌دهنده و عامل می‌توانند روی مخزن‌های متعدد کار کنند. بسیاری از رویکردهای فعلی GitHub در این محور طی سال‌ها در عمل آزموده شده‌اند و به معماری جدید هم منتقل می‌شوند: تقسیم مستأجرها میان بخش‌های زیرساخت، اعمال جداسازی و/یا انصاف در ترافیک هر مستأجر، و مسیریابی آگاه از بار، تنها چند نمونه از آن‌هاست.

- مقیاس عمودی یعنی چند توسعه‌دهنده و عامل می‌توانند روی یک مخزن کار کنند. با نوشتن کد بیشتر توسط عامل‌ها، انتظار داریم مخزن‌های تک‌تک بزرگ‌تر و پرترافیک‌تر شوند؛ به همین دلیل بیشتر نیازمندی‌های ما از محور عمودی آمده است.

امروز پرترافیک‌ترین مخزن‌های GitHub.com حداکثر چند ده نوشتن در یک ثانیه دریافت می‌کنند که معمولاً در بازه‌های کوتاه و انفجاری رخ می‌دهد. با جابه‌جا شدن بیشتر این کار به عامل‌هایی که به‌صورت موازی و شبانه‌روزی اجرا می‌شوند، انتظار داریم این انفجارها در سال آینده به نرخ پیوسته تبدیل شوند. هر push خواندن‌های بیشتری به دنبال دارد: اجرای CI، سیستم‌های استقرار که commit جدید را می‌کشند، و عامل‌های دیگری که آن را برای زمینه می‌گیرند. این پخش خواندن باعث تقویت چشمگیر کل ترافیک می‌شود که با نوشتن‌ها بالا می‌رود.

این روند را همین حالا هم در مخزن‌های بالای منحنی می‌بینیم. نمودار زیر درخواست‌های روزانه به یکی از مخزن‌های GitHub را از مارس تا مه نشان می‌دهد؛ بازه‌ای که ترافیک آن حدود ۴ برابر شد. رشد این مخزن از آن زمان تاکنون با شیب نمایی ادامه داشته است.

باید برای دنیایی برنامه‌ریزی کنیم که در آن توسعهٔ عامل‌محور با همین سرعت شتاب می‌گیرد. به جای برنامه‌ریزی برای گام بعدی، هدفی دست‌کم دو مرتبهٔ بزرگی بیشتر تعیین کردیم. برای یک مخزن، این یعنی معماری جدید باید:

- هزاران نوشتن در ثانیه را بپذیرد.

- از چند گرهٔ نویسنده پشتیبانی کند. دو دلیل برای این کار داریم:

- تجربه به ما آموخته است که ایندکس کردن packهای ورودی و بررسی اتصال اشیا، پرهزینه‌ترین بخش‌های یک نوشتن از نظر CPU هستند و این هزینه با اندازهٔ نوشتن بالا می‌رود؛ بنابراین یک گره به‌سرعت به محدودیت محاسباتی می‌خورد.

- پخش این کار میان چند گره، تحمل خطا را بهتر می‌کند و زمان بازیابی هنگام خرابی یک گره را کوتاه‌تر می‌کند.

- تأخیر commit را کمینه کند. یک عامل پیش از رفتن به گام بعدی منتظر هر push می‌ماند.

- تغییرات هر مرجع را به ترتیب ثبت کند و بتواند به‌سرعت میان مرجع‌ها ترتیب خطی برقرار کند. replica مجازی‌ای که عقب افتاده باید فقط با دانلود داده‌ای که برای سرو درخواست ورودی لازم دارد، خود را به‌روز کند.

- وقتی چیزی تغییر نکرده، خواندن‌ها را ارزان نگه دارد؛ با توجه به نسبت خواندن به نوشتن، این حالت معمول است.

- بگذارد هر جزء مستقل از بقیه مقیاس بگیرد.

علاوه بر این، سیستم باید بتواند قابلیت اطمینان کلی را بهبود دهد و در سطح جهانی مقیاس بگیرد.

معرفی «Project Rubicon»

در مه ۲۰۲۶، بلافاصله پس از انتقال اولیه به Azure، کار روی طراحی‌ای را آغاز کردیم که بتواند این نیازها را برآورده کند. چند رویکرد را امتحان کردیم. در همهٔ آن‌ها دادهٔ pack در Azure Blob Storage قرار داشت و در برخی هم نگهداری وضعیت مرجع‌ها در همان‌جا را آزمایش کردیم. در ادامه به برخی از این بده‌بستان‌ها می‌پردازیم، اما در نهایت طراحی‌ای را انتخاب کردیم که به نظرمان بیشترین توان عبور را حفظ می‌کند و در عین حال تضمین‌های درستی، دوام، دسترس‌پذیری و تأخیر را که پلتفرمی مثل GitHub نیاز دارد، نگه می‌دارد. نامش را «Rubicon» گذاشتیم؛ اشاره‌ای به نقطهٔ بی‌بازگشتی که صنعت با توسعهٔ عامل‌محور از آن عبور کرد.

Rubicon را از بالا به پایین مرور می‌کنیم. بسیاری از چیزها همان‌طور مانده‌اند: درخواست‌های کلاینت‌های Git، API و رابط وب به Spokes می‌رسند که همچنان مسیریابی و توازن بار را انجام می‌دهد و API داخلی‌ای را سرو می‌کند که بقیهٔ GitHub برای خواندن و نوشتن دادهٔ مخزن از آن استفاده می‌کند. Spokes همچنین نقش خود را به‌عنوان سرویس جای‌گذاری و توازن حفظ می‌کند و تقسیم‌بندی، جداسازی و انصاف میان مستأجرها را که برای مقیاس افقی لازم است، نگه می‌دارد. در مقابل، لایهٔ داده زیر Spokes تازه است.

Spokes هر درخواست را به یکی از گروه کوچکی از replicaهای مجازی که به آن مخزن اختصاص یافته‌اند می‌فرستد. replicaهای مجازی مجموعه‌ای واحد از محاسبات موقت‌اند که خواندن، نوشتن یا هر دو را سرو می‌کنند. دیسک محلی هر replica مجازی یک کش است که هر زمان می‌توان آن را از نو ساخت.

Spokes تا جایی که ممکن است ترافیک یک مخزن را به همان replicaهای مجازی می‌فرستد تا کش‌هایشان گرم بماند و تأخیر پایین باشد، اما درستی کار به این وابسته نیست که درخواست به replica مجازی خاصی برسد. وقتی یک replica مجازی از دسترس خارج می‌شود، بقیهٔ replicaهای مجازی آن مخزن به سرو ادامه می‌دهند و جایگزینش با رسیدن ترافیک، کش خود را پر می‌کند.

وقتی مخزنی پرترافیک می‌شود، replicaهای مجازی بیشتری اضافه می‌کنیم. جدا از این، مجموعه‌ای از گره‌های compaction در پس‌زمینه و مستقیماً روی Blob Storage و Ref-CAS کار می‌کنند تا packهای هر مخزن را ادغام کنند و اشیای غیرقابل‌دسترس را حذف کنند. این کار هرگز روی replica مجازی اجرا نمی‌شود؛ یعنی CPU و حافظهٔ آن‌ها تقریباً به‌طور کامل صرف سرو درخواست‌ها می‌شود.

وضعیت پایدار در دو جا نگهداری می‌شود:

- اشیای Git، در قالب packها و داده‌های کمکی تسریع خواندن، در Azure Blob Storage قرار دارند.

- مرجع‌ها و فهرست packهایی که مخزن را می‌سازند (مانیفست pack) در سرویس لاگ تکرارشدهٔ جداگانه‌ای به نام Ref-CAS (مخفف «Reference Compare-and-Swap») قرار دارند.

معماری را از دید یک نوشتن و یک خواندن مرور می‌کنیم:

- نوشتن: یک replica مجازی pack ورودی را ایندکس می‌کند و آن را در Blob Storage بارگذاری می‌کند، سپس یک تراکنش در Ref-CAS ثبت می‌کند که pack را در مانیفست فهرست می‌کند و مرجع‌ها را به‌روز می‌کند. بعداً یک گرهٔ compaction آن pack را با بقیه ادغام می‌کند تا خواندن‌ها سریع بمانند.

- خواندن: یک replica مجازی نسخهٔ مرجع خود را با Ref-CAS بررسی می‌کند، packهای مورد نیازش را از Blob Storage به کش خود می‌کشد و خواندن را از همان‌جا سرو می‌کند.

رویکردهای متفاوت زیادی در معماری جدید به کار گرفته‌ایم؛ از پشتهٔ نرم‌افزاری روی replicaهای مجازی تا نحوهٔ تنظیم مسیریابی ترافیک و زمان‌بندی بار کاری برای موارد استفادهٔ مختلف (مثلاً مخزن‌های کوچک و متعدد در برابر یک مخزن بزرگ). در ادامه به دو جزء این معماری عمیق‌تر می‌پردازیم و داستانشان را حول دو اصل طراحی تعریف می‌کنیم.

کمینه‌کردن هماهنگی: تغییر وضعیت مرجع با توان عبور بالا

سرویس‌های ذخیره‌سازی شیئی مثل Azure Blob Storage در کار خود فوق‌العاده‌اند و برای بسیاری از برنامه‌های داده‌محور مانند ذخیرهٔ کد منبع انتخاب طبیعی‌اند. بادوام و تکرارشده‌اند، هر قدر که لازم داشته باشیم در خود جای می‌دهند، هزینهٔ هر بایتشان نسبتاً پایین است و تا زمانی که ترافیک میان کلیدهای متعدد پخش شود، توان عبور تجمعی فوق‌العاده بالایی ارائه می‌دهند. در نتیجه، تقریباً هر چیز پایدار در معماری جدید ذخیره‌سازی Git در Azure Blob Storage قرار دارد، از جمله:

- packها و ایندکس‌هایی که با push، compaction و garbage collection نوشته می‌شوند.

- شتاب‌دهنده‌های مختلف خواندن (مثل multi-pack indexes، reachability bitmaps و برخی قالب‌های اختصاصی) که فرایند نگهداری ما از همان packها می‌سازد.

- رکوردهایی که به compaction و garbage collection اجازه می‌دهند کارشان را از سر بگیرند یا بازبینی کنند، همراه با اجاره‌نامه‌هایی (lease) که گره‌های compaction برای تصاحب کار استفاده می‌کنند.

- پاسخ‌های کش‌شده برای fetchهای پرتکرار.

- نقاط بازرسی (checkpoint) برای وضعیت مرجع مخزن، هرچند نه وضعیت مرجعِ مرجعِ مورد استفاده برای سرو درخواست‌ها.

بیشتر این داده‌ها یک بار در کلیدی متمایز نوشته می‌شوند و بعد از آن هرگز تغییر نمی‌کنند؛ همین آن‌ها را برای Blob Storage بسیار مناسب می‌کند.

مرجع‌ها برعکس‌اند. مرجع‌های یک مخزن پرترافیک تکه‌ای نسبتاً کوچک از وضعیت‌اند که بسیاری از نوشتن‌ها هم‌زمان برای به‌روزرسانی‌شان با هم رقابت می‌کنند. سرو این الگوی دسترسی از Blob Storage سخت‌تر است و نخستین نمونه‌های اولیه‌مان نشان دادند چرا. ذخیره‌سازی شیئی برای این نوع بار کاری انتخابی بدیهی است و تا سطح مشخصی از مقیاس خوب کار می‌کند: نوشتن‌های شرطی، compare-and-swap را رایگان می‌دهند و داده از قبل بادوام و تکرارشده است. اما با مجموعه‌ای از انتخاب‌های دشوار روبه‌رو شدیم که در ادامه با دو رویکردی که امتحان کردیم نشان داده می‌شود.

نخستین رویکردمان یک لاگ نوشتن-پیش-از-نوشتن (write-ahead log) برای همهٔ مرجع‌های یک مخزن بود که با یک blob ایندکس می‌شد. هر به‌روزرسانی یک نوشتن شرطی روی همان blob است. درست است و خواندن‌ها ارزان‌اند: replica مجازی می‌پرسد آیا blob تغییر کرده یا نه، و اگر نکرده باشد کارش تمام است. مشکل در نوشتن‌هاست. در هر لحظه فقط یک نوشتن شرطی روی یک blob می‌تواند در جریان باشد؛ پس حتی وقتی همهٔ pushهایی را که در طول یک نوشتن می‌رسند در نوشتن بعدی دسته می‌کنیم، سقف نوشتن مخزن یک نوشتن به ازای هر رفت‌وبرگشت به یک blob است. در عمل، این روش توان عبور نوشتن را در حدود چند صد در ثانیه برایمان به ارمغان آورد.

رویکرد دوم مرجع‌ها را میان چند blob قطعه‌ای تقسیم کرد و هر مرجع با هش به یکی از آن‌ها می‌رفت. نوشتن‌ها روی مرجع‌های قطعه‌های مختلف دیگر منتظر هم نمی‌مانند و همین سقف را بالا می‌برد. اما خواندن حالا باید همهٔ قطعه‌ها را بررسی کند تا بفهمد چیزی تغییر کرده یا نه، و سرعتش فقط به اندازهٔ کندترین قطعه است. تأخیر نوشتن را با تأخیر خواندن معاوضه کرده بودیم، در حالی که خواندن‌ها چند مرتبهٔ بزرگی بیشتر از نوشتن‌ها هستند. این را می‌توان با کنار هم گذاشتن چند نوشتن و یک خواندن نشان داد:

هیچ‌کدام از این دو گزینه همهٔ نیازمندی‌ها را برآورده نمی‌کرد، پس چیز دیگری ساختیم: یک سرویس لاگ تکرارشدهٔ اختصاصی برای مرجع‌ها، یعنی سرویس Ref-CAS. این همان گروه اجماع (کوچکی) است که در پایان مطلب قبلی گفتیم هنوز جایی در پشته باقی مانده است. نحوهٔ کارش چنین است.

هر به‌روزرسانی مرجع در Ref-CAS یک compare-and-swap است که با حد نصاب تأیید می‌شود. یک تراکنش فقط مرجع‌هایی را قفل می‌کند که به آن‌ها دست می‌زند، بررسی می‌کند هر مرجع هنوز همان مقداری را دارد که نویسنده انتظار دارد، و به‌محض ثبت شدن در اکثریت replicaهای لاگ، قابل مشاهده می‌شود. عامل‌ها بیشتر به شاخه‌های خودشان push می‌کنند، پس بیشتر به‌روزرسانی‌ها با هم رقابت نمی‌کنند و به‌صورت موازی تکرار می‌شوند. وقتی دو push همان مرجع را به‌روزرسانی می‌کنند، فقط یکی در لاگ ثبت می‌شود.

هر commit در Ref-CAS یک شمارهٔ ترتیب لاگ (LSN) می‌گیرد و نسخهٔ مخزن، LSN آخرین commit آن است. خواندن‌ها با بررسی نسخه در برابر همین نسخه شروع می‌شوند. replica مجازی نسخهٔ وضعیت مرجعی را که از قبل دارد می‌فرستد. اگر آن نسخه هنوز جاری باشد، پاسخ هیچ مرجعی را برنمی‌گرداند و مخزنی که تغییری نکرده فقط یک مقایسه هزینه دارد. اگر replica مجازی عقب باشد، مرجع‌های جاری و نسخه را می‌گیرد، همراه با اشاره‌گرهایی به دادهٔ pack و هر چیز دیگری که باید بداند، مثل زمان آخرین چرخهٔ garbage collection.

برخلاف گروه اجماع در معماری قدیمی ما، Ref-CAS هرگز دادهٔ شیئی را نگه نمی‌دارد یا اعتبارسنجی نمی‌کند. فقط اشاره‌گرهایی به آن ذخیره می‌کند. replica مجازی pack یک push را پیش از ثبت تراکنش مرجع در Blob Storage بارگذاری می‌کند. یک مرجع فقط به اشیایی اشاره می‌کند که از قبل پایدار شده‌اند.

این رویکردها به ما اجازه می‌دهند وضعیت مرجع را به‌تنهایی با نرخ ده‌ها هزار عملیات در ثانیه تراکنش کنیم و پایه‌ای فراهم کنند برای حاشیه‌نویسی‌های بیشتر روی لاگ تکرار که به خواندن‌ها کمک می‌کند برای هر درخواست تصمیم بگیرند چه چیزی را دانلود کنند.

اما پشتیبانی از هزاران نوشتن در ثانیه روی یک مخزن مسئلهٔ درجه دومی ایجاد می‌کند: حفظ کارایی خواندن و نوشتن. برای این کار به رویکرد متفاوتی در compaction نیاز داشتیم.

جدا کردن ذخیره‌سازی از محاسبات: compaction با هزاران نوشتن در ثانیه

هر push یک pack به Blob Storage اضافه می‌کند. Git می‌تواند یک مخزن را از packهای متعدد سرو کند، اما هر pack اضافه جست‌وجوها را کمی گران‌تر می‌کند، پس تعداد packها نمی‌تواند بی‌مرز رشد کند. در معماری قدیمی ما، compaction روی همان replicaهایی اجرا می‌شود که ترافیک را سرو می‌کنند و باید روی هر replica اجرا شود. در معماری جدید، کاملاً در پس‌زمینه روی گره‌های جداگانه و مستقیماً روی ذخیره‌سازی پایدار اجرا می‌شود و از سرویس Ref-CAS برای اطلاع‌دادن به replicaهای مجازی از وضعیت در حال تغییر استفاده می‌کند.

هر گرهٔ compaction با یک اجاره‌نامه (lease) مالکیت زیرمجموعه‌ای از دادهٔ مخزن را تصاحب می‌کند و همین به ما اجازه می‌دهد compaction را افقی مقیاس دهیم. یک گرهٔ compaction روی یک shard از packهای مخزن چنین کار می‌کند:

گره ابتدا روی shard در Blob Storage اجاره‌نامه می‌گیرد تا در هر لحظه فقط یک گره یک shard را compaction کند. در همین حال، replicaهای مجازی به بارگذاری packها و فهرست کردنشان در مانیفست pack ادامه می‌دهند. گره مانیفست را می‌خواند تا packهای جدید را پیدا کند و آن‌ها را در یک قطعهٔ باز (open segment) جمع می‌کند که در واقع محلی برای نگهداری موقت داده‌ای است که به‌زودی compaction می‌شود. وقتی قطعه بر اساس تعداد pack، اندازه یا سن به حد تعیین‌شده‌ای می‌رسد، آن را می‌بندد تا pack جدیدی نپذیرد، سپس packهایش را در packهای کمتر و بزرگ‌تر ادغام می‌کند. در حین compaction، قطعهٔ بعدی همان shard می‌تواند جمع‌آوری packهای ورودی خود را آغاز کند. پیش از انتشار هر چیزی، گره بررسی می‌کند که packهای جدید دقیقاً همان اشیای ورودی‌ها را داشته باشند. سپس packهای جدید را بارگذاری می‌کند و به مانیفست می‌افزاید. تراکنش دومی ورودی‌ها را از مانیفست حذف می‌کند و پاک‌سازی بعداً آن‌ها را حذف می‌کند.

برای مقیاس‌پذیری، این فرایند به‌طور مستقل برای shardهای متعدد هم‌زمان اجرا می‌شود. هش هر pack به یک shard نگاشت می‌شود، پس افزودن shard و گره، توان عبور compaction را بالا می‌برد. pack فشرده‌شده‌ای که هنوز زیر حد اندازه است، بر اساس هش خودش به یک shard برمی‌گردد و دوباره ادغام می‌شود؛ بنابراین packها در لایه‌ها رشد می‌کنند تا به حد برسند. نتیجهٔ خالص، تعداد pack تقریباً ثابت است در حالی که pushها بالا می‌روند:

compaction packها را ادغام می‌کند، اما همهٔ اشیا را نگه می‌دارد. garbage collection همان مرحله‌ای است که اشیایی را حذف می‌کند که دیگر چیزی به آن‌ها ارجاع نمی‌دهد؛ مثل اشیایی که از شاخه‌های حذف‌شده و force-pushها باقی می‌مانند. در معماری جدید ما، garbage collection بسیار شبیه compaction کار می‌کند و از کارگرهای اختصاصی برای انجام بخش پرهزینهٔ محاسباتی استفاده می‌کند. چند رفتار ویژه هم برای حذف ایمن داده دارد که ارزش بحث جداگانه‌ای دارند.

با این رویکردها توانسته‌ایم به‌طور پیوسته منحنی تأخیر ثابتی را هم‌زمان با بالا رفتن نوشتن‌ها نشان دهیم و بهینه‌سازی‌های دیگری هم در برنامه داریم تا خود فرایندهای compaction و garbage collection کارآمدتر شوند.

قدم بعدی چیست

دو اصلی که با آن‌ها شروع کردیم به هر بخش این معماری اجازه می‌دهند مستقل مقیاس بگیرد. خواندن و نوشتن را با افزودن replicaهای مجازی مقیاس می‌دهیم. Ref-CAS هر مرجع را مستقل از کل مخزن مرتب می‌کند. نگهداری را با افزودن گره‌های compaction مقیاس می‌دهیم. هدف ما این است که هر مخزن، از پروژهٔ جانبی یک توسعه‌دهنده تا پرترافیک‌ترین monorepo، روی همان معماری اجرا شود و مخزن‌های پرترافیک نیازی به رسیدگی ویژه نداشته باشند. مخزن‌ها کوچک نمی‌مانند. ممکن است یک پروژهٔ جانبی یک‌شبه مجموعه‌ای از عامل‌ها را جذب کند و نباید برای همگام شدن با آن‌ها به مهاجرت یا رسیدگی ویژه از سوی ما نیاز داشته باشد. معماری یکسان یعنی هر بهبودی که می‌دهیم هم‌زمان به همهٔ مخزن‌ها می‌رسد.

این پایه به ما اجازه می‌دهد کارهای بسیار بیشتری انجام دهیم. در مرحلهٔ بعد روی سه حوزه تمرکز می‌کنیم: مقیاس دادن معماری فراتر از آنچه امروز پیش‌بینی می‌کنیم لازم شود، کارآمدتر کردن عامل‌ها در کاری که روی GitHub انجام می‌دهند، و تکامل دادن خود Git برای توسعهٔ عامل‌محور.

بهبود معماری

برنامه‌هایی برای پیش بردن این معماری داریم. هر یک از این بهبودها به مخزن اجازه می‌دهد فعالیت بیشتری را تحمل کند و در عین حال کار پشت هر درخواست را کم می‌کند:

- فقط آنچه لازم است بخوان. یک شیء را به‌جای کل packی که آن را در خود دارد، از Blob Storage بگیر.

- packها را بر اساس نوع سازمان بده. commitها، treeها و blobها را در packهای جداگانه گروه‌بندی کن. آن‌گاه بسیاری از درخواست‌ها به دادهٔ کمتری دست می‌زنند.

- replicaهای جزئی. درخواست‌ها را بدون حضور همهٔ packها روی دیسک محلی سرو کن.

- نمای مادی‌شده (materialized views). دادهٔ مخزن را در قالب‌های آماده نگه دار، مثل آرشیوهای آماده، یک shallow clone تقریباً هم‌زمان از شاخهٔ پیش‌فرض، و زمینهٔ نشست عامل که کنار هر commit ذخیره می‌شود.

- replicaهای جهانی. replicaها را در هر منطقه‌ای و نزدیک به بارهای کاری‌ای که از آن‌ها استفاده می‌کنند قرار بده. خواندن‌ها در محدودهٔ کهنگی محدود نسبت به آخرین نوشتن می‌مانند.

- مقیاس تا صفر. مجموعه را همراه با مخزن‌هایی که واقعاً فعال‌اند بزرگ و کوچک کن.

عملیات کارآمد عامل‌ها در GitHub

مقیاس دادن زیرساخت یک روی سکهٔ پشتیبانی از عامل‌هاست. روی دیگر، ارزان‌تر کردن هر عملیات عامل است: بایت‌های کمتر برای دریافت، رفت‌وبرگشت‌های کمتر و انتظار کمتر برای تغییرات. هر یک از این موارد که به‌سرعت دنبال می‌شوند بر کار ذخیره‌سازی این مطلب بنا شده‌اند:

- کار بدون clone. بسیاری از وظایف عامل هرگز به یک working tree کامل نیاز ندارند. آن‌ها چند فایل و زمینهٔ کافی برای ایجاد یک تغییر می‌خواهند. می‌توانند هر دو را مستقیم از سرور بخوانند.

- API commit اتمیک. یک تغییر چندفایلی را در یک عملیات ثبت کن. کل تغییر commit می‌شود، یا در صورت تعارض به‌طور تمیز رد می‌شود.

- جریان‌های رویداد. عامل‌ها و سیستم‌های اطرافشان با اطلاعات لحظه‌ای بهترین کار را می‌کنند. یک جریان رویداد عمومی به آن‌ها اجازه می‌دهد در تغییرات مشترک شوند و به‌محض وقوع واکنش نشان دهند.

بهبود Git برای عامل‌ها

در خود Git هم کارهایی داریم. GitHub مدت‌هاست از مشارکت‌کنندگان پروژهٔ Git است و اکنون هم متوقف نمی‌شود. چند نمونه از کارهایی که مشتاق ادامه‌شان هستیم:

- cloneهای سبک. partial clone، shallow clone و sparse checkout هر یک به عامل اجازه می‌دهند کمتر دریافت کند. هر کدام شکاف‌هایی دارند. همیشه هم خوب با هم کار نمی‌کنند. می‌خواهیم هر قطعه را بهتر کنیم و آن‌ها را سازگار کنیم.

- حذف هزینه‌های پنهان مقیاس. Git هنوز مسیرهای کدی دارد که بسیار سریع‌تر از رشد مخزن کند می‌شوند. نسخه‌های اخیر چند مورد را رفع کرده‌اند، اما انتظار داریم موارد بیشتری پیدا کنیم.

- پیمایش سریع‌تر تاریخچه. فراداده‌هایی مثل commit-graph می‌توانند پرسش‌های merge-base و دسترس‌پذیری را بدون پیمایش تک‌تک commitها پاسخ دهند. این موضوع وقتی مهم‌تر می‌شود که یک فراخوانی API عامل به کار Git روی سرور تبدیل شود.

- پرهیز از دام‌های رایج. عامل‌ها همان اشتباه‌های توسعه‌دهنده‌ها را می‌کنند. Git می‌تواند موارد رایج بیشتری را بگیرد و پیش از ایجاد خسارت هشدار دهد.

عامل‌ها شیوهٔ ساخت نرم‌افزار را تغییر داده‌اند. GitHub و Git هم همراه با آن تغییر می‌کنند. مشتاقیم این معماری جدید را از خط شروع عبور دهیم. اکنون در یک private preview محدود در دسترس است و عرضهٔ گسترده‌تر اوایل سال آینده انجام می‌شود. بی‌صبرانه منتظریم ببینیم تیم‌ها وقتی تعداد عامل‌هایی که روی یک مخزن کار می‌کنند تنها به ایده‌هایشان محدود باشد، چه می‌سازند. Git و GitHub را همراه با مشتریان و جامعهٔ Git پیش خواهیم برد.

برچسب‌ها:

نوشتهٔ

مطالب مرتبط

پل به زیرساخت Git در مقیاس عامل‌ها

نسخه‌ای از ۹۹٫۹۹۹۹۹٪ مخزن‌های GitHub را به Azure منتقل کردیم. در ادامه می‌بینید حد نصاب‌های هر مرجع چطور بقیه را منتقل می‌کنند و ذخیره‌سازی شیئی چطور به خواندن‌ها اجازه می‌دهد مستقل مقیاس بگیرند.

همیشه سبز ماندن: چگونه دسترسی امن و بهداشت مخزن را در یک سازمان مشترک خودکار کردیم

قابلیت‌های بومی GitHub را به کار بگیرید تا دسترسی همکاران بیرونی را بازبینی کنید و مخزن‌های راکد را بایگانی کنید.

از ۲٬۵۰۰ درخواست به ۲۴: بازسازی تاریخچهٔ ستاره‌ها بدون ستاره‌دهنده‌ها

API جدید تاریخچهٔ ستاره‌های مخزن ما اکنون روندها را بدون بازگرداندن هویت‌های فردی یا نیاز به کار نامحدود پایگاه داده ارائه می‌دهد. این‌ها بده‌بستان‌های مهندسی‌ای است که انجام دادیم.

منبع: GitHub Blog

متن و تصاویر اصلی از منبع بالا. ترجمه و ویرایش در دیجیتال سرآمد.