ویرگول
ورودثبت نام
Kian
Kianفعال در مهندسی نرم‌افزار با اندکی تجربه از صنعت (عمدتا گوگل) و آکادمی (عمدتا اتلاف عمر). علاقمندم آموخته‌هامون رو رد و بدل کنیم.
Kian
Kian
خواندن ۱۱ دقیقه·۶ سال پیش

طراحی برای پایداری و کارایی در سرویس‌های آنلاین - بخش نخست

مساله‌ی پایداری سرورها در برابر سرریز بار (overload) و مساله‌ی کارایی و نیاز به منابع سخت‌افزاری کمتر، دو مساله‌ی برادرند با راه حل‌هایی با کاربرد دوگانه. در یک مجموعه نوشتار که نوشتارِ پیشِ رو بخش نخست آن است، به نکاتی از این راه حل‌ها می‌پردازیم. بدیهی‌ست که هر سیستمی یکتاست و نکات گفته شده تنها برای ایده گرفتن‌اند، و تعمدا در سطح مفاهیم‌اند و نه تکنولوژی.

۱. دنبال چه هستیم

فرض کنید سرویسی داریم برساخته از یک یا چند job (مثال)، هر یک مستقر روی تعدادی نمونه (instance). در این نوشتار منظور از «سرور»، همین نمونه‌هاست، نه سرور فیزیکی. در سرویسمان مشخصا در پی این هستیم:

  • چه تک‌سرور و چه مجموع سرویس، اگر برای مثلا ۱۰۰ درخواست بر ثانیه (QPS) با زمان پاسخ‌گویی ۸۰ms تامین (provision) شده، اگر زیر بار ۲۵۰qps قرار گرفت باید همچنان به ۱۰۰qps (یا دست کم ۹۰qps) پاسخ ۸۰ms دهد و ۱۵۰تا را پاسخ ندهد، نه این که تلاش کند به همه یا بیشتر ۲۵۰ تا پاسخ بدهد که نتیجه‌اش---تازه اگر زیر حجم بار crash نکند و زنده بماند---تاخیر فراوان و timeout شدن بیشتر درخواست‌ها و خوابیدن سرویس است. (در سخن از QPS، گوناگونی درخواست‌ها در ارزش و سختی را برای سادگی نادیده می‌گیریم.)
  • سرورها باید معماری نرم‌افزاری کارا داشته باشند و بتوانند با حداکثر راندمان کار کنند. ما معمولا از معیار «درخواست به ازای هر ثانیه CPU» برای سنجش این توان استفاده می‌کنیم، یا به عبارتی QPS per core: یعنی QPS در صورت کسر و مصرف هسته‌های CPU به شکل ثانیه بر ثانیه---مثلا با ۶ هسته که پیوسته ۸۰٪ در مصرف‌اند، ۴/۸ ثانیه بر ثانیه (s/s) هسته مصرف می‌شود---در مخرج کسر. نسخه‌ی معکوس این کسر هم شدنی‌ست: core per QPS. نسخه‌های دیگر هم. هدف از معرفی این معیار نمونه به جای مثلا خود QPS، مشخصا جدا کردن دو مقوله‌ی «کارایی بیشتر در یک سطح ثابت مصرف/بهره‌گیری از CPU» و «بالا بردن بهره‌گیری» است (بهره‌گیری=utilization).
  • سرورها باید بتوانند با بهره‌گیری بالا (حتی بالای ۹۰٪) یا اصطلاحا «داغ» کار کنند در عین پایداری و بدون خدشه به زمان پاسخ‌گویی یا نرخ خطا. مقصود از کارایی در این مجموعه نوشتار، کارایی در منابع پردازشی‌ست، نه حافظه و شبکه و غیره که معمولا ساده‌ترند.

در این نوشتار ارجاع‌های فراوانی به این سرویس سرهمیِ فروشگاه اینترنتی خواهیم داشت که برای فهم بهتر از مثال‌ها، دست کم مرور دیاگرام آن توصیه می‌شود. برای ملموس شدن هدف‌هایی که در بالا گفته شد، همین سرویس را در نظر بگیرید که چینش سخت‌افزاری آن ۱۵ نمونه از job «میان‌دار» و ۱۰ تا «انبارگرد» و … است: در معماری نرم‌افزار و ارتباطات jobها چه کنیم تا: (۱) در برابر سرریز بار مقاوم باشیم؛ (۲) به مثلا ۲۰٪ نمونه‌های کمتر (۱۲ به جای ۱۵ و ۸ به جای ۱۰) نیاز داشته باشیم؟

۱.۱. اصلا بهینه‌سازی بکنیم؟

پیش از هر بهینه‌سازی در یک سیستم مستقر و جاافتاده، نخستین پرسش پیش از جَوگیری، تخمین هزینه و فایده است: در یک سو نفر-ساعت و در یک سو درصد صرفه‌جویی ضرب‌در هزینه‌ی سخت‌افزار. در شرکت ما یک فرمول مشخص و اصلا یک فرم تعاملی وِب برای این مقایسه وجود دارد که مثلا وارد می‌کنیم X هزار CPU Core یا Y ترابایت RAM و پاسخ می‌گیریم که ارزش Z نفر-سال کار را دارد؛ روشن است که این تنها یک تخمین حدودی‌ست (مثلا در سخن از نفر-سال، کدام «نفر» با چه حقوقی؟) و با نام برازنده‌ی «قانون سرانگشتی» معروف است. گردآوری یک سیستم تخمین سرانگشتی مشابه به نظام‌مند شدن تلاش‌ها میان تیم‌ها کمک می‌کند و بسیار توصیه می‌شود.

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

همچنین پیش از خیز برای بهینه‌سازی ساختاری، نخست، میوه‌های دمِ دست‌تر را می‌چینیم: با profile کردن برنامه‌های سرورها در محیط عملیاتی (مثلا بجویید pprof)، که جزییاتش فراتر از این نوشتار است و منابع آنلاین برایش فراوان.

۲.۱. راه‌حل معمول و ناکارا ولی شاید کافی

یک رویه‌ی معمول در کنترل بار که احتمالا زیاد دیده‌اید یا استفاده کرده‌اید، تنظیم «طول صف ورودی» و «تعداد threadها» و سپس سپردن سلامت و بهره‌گیری سرورها به این دو سوییچِ نادقیق است. مثلا اگر نیاز شد بهره‌گیری برنامه را بالا ببریم، طول صف ورودی یا تعداد threadها را افزایش می‌دهیم تا کار بیشتری برداشته شود. یا اگر زمان پاسخ گند خورد یا دچار سرریز بار (overload) شدیم، سراغ کاهش طول صف ورودی یا تعداد threadها می‌رویم. در فصل بعدی، این سیستم گوجه خیاری را بهتر می‌کنیم.

همچنین یک رویه‌ی معمول، انتشار وضعیت میان jobها (مثلا گلوگاه شدن یکی و اثرش بر کل سیستم) به صورت صورت منفعلانه و غیرمستقیم است، یعنی اطلاعات شلوغی/خلوتی jobها مستقیما منتشر و بر اساسش تصمیم‌گیری نمی‌‌شود، بلکه روی این حساب می‌کنیم که خود سیستم هم‌گرا شود: اگر job الف شلوغ شد و درخواست‌ها را از صف ورودی‌اش برنداشت پس job‌ ب که بالادست الف است پشت الف معطل می‌شود و درخواست‌هایش را برنمی‌دارد و صف ورودی ب ‌پر می‌شود و … و به همین شکل بار مجموع سیستم (مثلا یک stack یا درخت از jobها) با ظرفیت گلوگاه تنظیم می‌شود، یعنی به سمت آن «هم‌گرا» می‌شود - البته در تئوری. یک پیش‌شرط بزرگ برای این تئوری این است که مقیاس زمانی هم‌گرا شدنِ سیستم در پیِ تغییرات شلوغی/خلوتی یک job، کوچک‌تر از مقیاس زمانی خود تغییرات باشد، ولی در عمل همیشه چنین نیست. به این مثال برخواهیم گشت.

۲. نوسان کمتر، زندگی بهتر

یک تک‌سرور را تصور کنید زیر بار مثلا ۱۰۰qps، و نمودار بهره‌گیری CPU این سرور را در نظر بگیرید: احتمالا به طور پیوسته و با فرکانس بسیار بالا (در مقیاس صدُم ثانیه) بین مثلا ۶۰٪ و ۱۰۰٪ در نوسان است، با بهره‌گیری میانگین ۸۰٪. اگر این بهره‌گیری را کمی بالاتر ببریم، قله‌های این نوسان از ۱۰۰٪ رد می‌شود و مشکلات پایداری و تاخیر آغاز می‌شود.

در این فصل یکی (و تنها یکی) از کارهایی را خواهیم دید که توان «۱۰۰qps در ۸۰٪ بهره‌گیری» را به مثلا «۱۱۰qps در ۸۰٪» افزایش می‌دهد و همچنین دامنه‌ی نوسان گفته شده را از ۱۰۰-۶۰ به مثلا ۹۰-۷۰ کاهش می‌دهد و در نتیجه امکان افزایش میانگین بهره‌گیری از ۸۰٪ به ۹۰٪ را فراهم می‌کند (بدون تجاوز قله‌ها از ۱۰۰٪) و این یعنی ممکن شدن ۱۲۰qps و افزایش ۲۰٪ی ظرفیت سیستم. (همه‌ی این عددها شکمی‌ست.)

از بین طراحی کد با فراخوانی‌های ناهم‌گام (asynchronous IO) با threadهای کم (مثلا تنها ۲ thread به ازای هر هسته‌ی CPU) و طراحی با فراخوانی‌های هم‌گام با threadهای فراوان، برتری‌های مدل نخست به ویژه زمانی که پایِ کارایی و پایداری در میان است بزرگ و روشن است - و اگر برای شما نیز از پیش چنین است می‌توانید از ادامه‌ی این نوشتار رد شوید. ولی شخصا سوگیری نادرست در این زمینه را زیاد دیده‌ام و بنابراین در این فصل به بازبینی پایه‌ایِ این دو با مثال می‌پردازیم. علاوه بر صِرف پیروی از مدل ناهم‌گام، کارهای دیگری هم معمولا بر روی آن برای کارایی بیشتر قابل انجام است مانند گره زدن درخواست‌ها به threadها (پیش و پس از بازگشت از IO) و threadها به هسته‌های پردازشی (بجویید affinity) و داده‌ساختارهای cpu local/per cpu (+) و غیره که فراتر از این نوشتار‌ند.

۱.۲. از طراحی چه کُدی صحبت می‌کنیم؟

ماهیت ۹۸/۲٪ (!) برنامه‌های دنیا که اجزای یک سرویس آنلاین را می‌سازند این شکلی‌ست: درخواست را بردار، مقداری کار پردازشی انجام بده (مثلا جابه‌جا کردن fieldهای کلاس‌ها و protoها از این دست به آن دست)، سپس یک کار IO (مثلا فراخوانی یک backend یا مخزن داده یا غیره)، باز مقداری کار پردازشی (مثلا این بار مقداری محاسبه‌ی)، باز فلان فراخوانی دیگر و … و تمام. مثلا فرض کنید «میان‌دار» در این سیستم نمونه، درخواست را از «جلودار» تحویل می‌گیرد، درخواست دیگری برای فرستادن به «مقررات‌چی» و «فضول ملت» آماده می‌کند و آن‌ها را فرامی‌خواند، سپس داده‌ها را تنگ هم می‌زند و «عقب‌دار » را فرا می‌خواند، روی نتیجه مقداری محاسبه انجام می‌دهد، و پاسخ را پس می‌فرستد به «جلودار».

چنین برنامه‌ای چه شکلی طراحی می‌شود؟ طبیعتا با تشت (pool)هایی از threadها: چه با یک تشت برای سر تا ته رسیدگی به یک درخواست و چه با یک تشت جداگانه برای هر فاز یا هر مولفه از برنامه؛ چه با threadهای وصل به لایه‌ی سیستم عامل (مثل threadهای ++C و Java) و چه thread-نماهای لایه‌ی apllication (مثل fiberهای کتابخانه‌ی boost) و چه میان این دو (مثل goroutineهای Go).

۲.۲. مدل هم‌گام

یک رویه‌ی معمول این است که threadها فراخوانی‌های هم‌گام / مسدود کننده (synchronous / blocking IO) می‌کنند. یعنی مثلا در مثال بالا یک تشت thread داریم برای مولفه‌ی اِعمال مقررات، که بخشی از وظیفه‌اش فراخوانی «مقررات‌چی» است: هر یک از threadهای این تشت، درخواست را می‌فرستد و می‌خوابد تا آمدن پاسخ.

یعنی threadها بخوابند؟ بله، ظاهرا اشکالی ندارد، چون می‌توان تعداد thread را تا صدها یا حتی هزارها زیاد کرد تا اگر بیشترشان هم مسدود/خواب بودند باز به اندازه‌ی کافی thread‌ بیدار و مشغول بهره‌گیری از CPU داشته باشیم. اگر هم بیشترشان بیدار بودند، سیستم آن‌ها را به خوبی مدیریت می‌کند و تنها به اندازه‌ی CPU موجود کار انجام خواهد شد و مشکلی نیست.

اشکال این مدل کجاست؟ موازی‌بازی، سواری مفتی نیست که یک خروار thread‌ بسازیم و سیستم برای ما مدیریت بهینه کند، هر چه قدر هم که نرم‌افزار را عالی و بدون گلوگاهِ هم‌روندی (concurrency) طراحی کنیم. کاوش چرایی این مساله فراتر از این نوشتار است و هم به سیستم عامل و سخت‌افزار برمی‌گردد و هم تئوری صف‌ها. باز هم برای تجسم درست، لازم است یک معیار تعریف کنیم تا به ما شهود کمّی بدهد:

  • میانگین تعداد threadهای آماده‌ی اجرا (یعنی مسدود پشت IO نه بلکه تشنه‌ی CPU) تقسیم بر تعداد هسته‌ی CPU - یا num runnable threads per CPU core.
  • میانگین زمانی که هر thread از لحظه‌ی آماده‌ی اجرا شدن تا لحظه‌ی دریافت CPU صرف می‌کند - یا runnable thread run delay.
  • یا همین‌ها در لایه‌ی application: میانگین طول صف یا میانگین زمان انتظار در executorها یا threadpoolها یا schedulerها یا هر نامی که برای آن موجودیت/کلاس‌هایی می‌گذارید که تکه‌های کار را می‌ریزید سرش و آن‌ها را زمان‌بندی و اجرا می‌کند.

شهود گرفتیم؟ حالا تعداد thread زیاد و فراخوانی‌های هم‌گام یعنی چه؟

  • یعنی دامنه‌ی نوسان‌های زیاد در هر یک از این شاخص‌ها، که خوب نیست، نه برای کارایی و نه پایداری.
  • یعنی حال و روز سرور ما بسته است به دماغ بالا کشیدن بقیه و به بالا و پایین شدن تاخیر فراخوانی‌ها: اگر یک backend کُند شود، ما هم بدتر، هم سیستم را کُند می‌کنیم و هم منابع پردازشی سرور را هدر می‌دهیم چون thread کافی برای بهره‌گیری کامل نداریم؛ اگر backendها سریع شوند باز ما سیستم را کند می‌کنیم به ویژه در «دُم تاخیر» (tail latency) چون ازدحام thread داریم.
  • یعنی همیشه پی نخود سیاه «تعداد thread بهینه» هستیم که وجود ندارد و تابع حساسی از شرایط پرنوسان محیط است.

۳.۲. مدل ناهم‌گام

در طراحی نرم‌افزارِ کارا/efficient، اگر فراخوانی‌های متعدد یا با تاخیر بالا یا با تاخیر پرنوسان داریم، فراخوانی‌های ناهم‌گام (asynchronous) احتمالا به شکل مشهودی کاراتر خواهند بود. ولی آیا لزوما با ناهم‌گامی جلو برویم؟

سودمندی مدل ناهم‌گام: مدل ناهمگام یعنی فراخوانی را انجام بده و خداحافظ؛ صبر نکن. یا یک callback بده که وقتی پاسخ آمد اجرایش کنیم برای انجام بقیه‌ی کار پس از دریافت پاسخ، یا یک بیلبیلک (مثل یک شیء future یا task که روی آن wait یا await می‌کنیم) بگیر که هر وقت خواستی روی آن منتظر پاسخ شوی.

  • در یک طراحی درست با مدل callback، آن callback هم نباید خودِ «بقیه‌ی کار» باشد بلکه باید تنها «گذاشتن» آن کار در تشت threadها باشد و سریع تمام شود. همه‌ی کارهای اصلی برنامه و مصرف منابع پردازشی باید به دست threadهای تشت اصلی ما و با مدیریت و کنترل ما باشد، ولی threadهایی که callback را صدا می‌کنند از این تشت نیستند (و نباید باشند) و باید زود از صحنه بیرون روند.
  • در مدل future، انتظار روی future که هر وقت پاسخ آماده بود به بقیه‌ی کار بپردازیم، نباید توسط threadهای تشت اصلی ما باشد، تا بتوانیم threadهای محدود داشته باشیم، و همچنین باید مانند بالا تنها «بقیه‌ی کار» را در صف تشت‌های اصلی بگذارد و از صحنه خارج شود.

اضافه‌کاری بالا برای چیست؟ برای این که بعد از ارسال فراخوانی، کار thread به پایان برسد---تصور کنید می‌رسیم با پایان تابعی در کُد که thread صدا کرده بود---و thread برود سراغ برداشتن کار/درخواست بعدی از تشت. چرا؟

  • تا threadهای تشت اصلی هرگز پشت فراخوانی مسدود نشوند (هرچند هم که مدیریت threadهای سیستم یا زبان مورد علاقه‌ی شما «خفن» باشد) بلکه همیشه همه‌ی threadها تشنه‌ی CPU باشند - دقیقا می‌خواهیم همین‌طور باشد.
  • تا نیاز به تعداد threadهای بسیار کمتری نسبت به مدل پیش داشته باشیم: در حالت ایده‌آل، برای سروری که روی ۱۲ هسته‌ی CPU مستقر شده تنها ۱۲ thread، ولی در عمل بیشتر مثلا ۲۴ یا ۳۶، نه بیشتر. این هم یک پارامتر نیازمند تنظیم است، ولی «عدد بهینه» واقعا برایش وجود دارد و مثل مدل قبلی نخود سیاه نیست. تابعی از تاخیر و نوسان‌های تاخیر فراخوانی‌ها هم نیست.
  • یعنی معیارهایی که در بالا معرفی شد (مانند طول/زمان انتظار صف‌ها) ایستاتر و کم‌نوسان‌ترند. یعنی رفتار سرور بهینه‌تر و هم باثبات‌تر خواهد بود.

سختی مدل ناهم‌گام: سرراست در نیامدن کُد (مستقل از زبان و سکو) برای نوشتن و نگهداری. کدی که یک فراخوانی هم‌گام را انجام دهد و در خط بعدی به بقیه‌ی کار بپردازد (هرچند با یک خواب بزرگ این وسط)، ساده‌تر و قابل دنبال کردن‌تر از کد شکسته و دو تکه شده بین پیش و پسِ فراخوانی است - مثلا یک تابع جداگانه‌ی ()HandleResponse پیچیده شده در یک callback یا future و رساندن داده‌های لازم به آن. شاید در روز نخست خیلی ساده و تمیز باشد ولی به مرور که کُدها بزرگ شدند، callbackها/futureها بین چند تابع دست به دست می‌شوند تا به نقطه‌ی استفاده (فراخوانی ناهم‌گام) برسند، به مرور هر کدام هم چیزی به تَنگ callback می‌زنند تا پیش/پس از آن اجرا شود، زنجیره‌ها تشکیل می‌شوند و خلاصه نگهداری و اشکال‌زدایی در این فضا را سخت‌تر می‌کنند.

نتیجه: نابهینگی در کارایی و بهره‌گیری سرور (هزینه‌ی سخت‌افزار) یا نوسان در زمان پاسخ سرور چه قدر برای سرویسمان مهم است؟ تفاوت کارایی و زمان پاسخ بین دو مدل هم‌گام و ناهم‌گام چه قدر خواهد بود؟ (کاملا بسته به ماهیت کار و زبان برنامه‌نویسی و لایه‌ی threading است؛ ارزش یک پیاده‌سازی شبیه‌سازانه و تحلیل پیش از تعهد به یکی از دو مدل را دارد.) تفاوت پیچیدگی کد ما در مدل هم‌گام و ناهم‌گام چه قدر خواهد بود؟ اصلا از چه threadهایی استفاده خواهیم کرد؟ این‌ها پرسش‌هایی‌ست که طراحی ما را کارگردانی می‌کند. در سرویس‌هایی که بنده شخصا درگیرشان بودم، هر جا کارایی یا منابع پردازشی یا پایداری زمان پاسخ مهم بوده، ناهم‌گام کار کردیم، و در سرویس‌های ساده‌تر و زیر بار سبک یا گه‌گاهی، هم‌گام.

مطالب این فصل در راستای: (۱) کاهش دامنه‌ی نوسان‌های بهره‌گیریِ لحظه‌ایِ سرور، و (۲) بالا بردن معیار QPS per core که در مقدمه اشاره شد بود؛ هر دو تنها در سطح تک سرور. هنوز تا یک سیستم توزیع شده‌ی پایدار و کارا خیلی مانده و در بخش‌های بعدیِ این مجموعه به آن‌ها خواهیم پرداخت.


۱۷
۱۱
Kian
Kian
فعال در مهندسی نرم‌افزار با اندکی تجربه از صنعت (عمدتا گوگل) و آکادمی (عمدتا اتلاف عمر). علاقمندم آموخته‌هامون رو رد و بدل کنیم.
شاید از این پست‌ها خوشتان بیاید