ویرگول
ورودثبت نام
مهدی مهدی پور
مهدی مهدی پور
مهدی مهدی پور
مهدی مهدی پور
خواندن ۱۱ دقیقه·۳ ماه پیش

آشنایی با معماری نرم‌ افزار با نگاهی به کتاب Head First Software Architecture

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

در یک سیستم واقعی، تصمیم هایی وجود دارند که تأثیر آن ها بسیار بیشتر از یک کلاس یا یک تابع است. برای مثال، اینکه سیستم به صورت Monolithic طراحی شود یا Distributed، اینکه اجزای سیستم چگونه از یکدیگر جدا شوند، اینکه داده ها چگونه مدیریت شوند یا اینکه سیستم تا چه اندازه قابلیت توسعه و تغییر داشته باشد، همگی تصمیم هایی هستند که می توانند سال ها روی یک پروژه تأثیر بگذارند.

این موضوع همان چیزی است که Software Architecture به آن می پردازد.

در این مطلب قصد دارم برداشت خودم را از کتاب Head First Software Architecture بیان کنم و مفاهیم مهمی را که از این کتاب یاد گرفتم، مرور کنم. هدف این مطلب ارائه ی یک خلاصه از کتاب نیست؛ بلکه می خواهم مفاهیم اصلی آن را به شکلی توضیح دهم که برای افرادی که می خواهند درک بهتری از معماری سیستم ها داشته باشد، قابل استفاده باشد.

معماری نرم افزار چیست؟

یکی از نکات مهم در معماری نرم افزار این است که Architecture را نمی توان فقط به یک Diagram یا انتخاب یک Architecture Pattern محدود کرد. معماری نرم افزار مجموعه ای از تصمیم های مهم درباره ی ساختار یک سیستم است. برای مثال فرض کنید قرار است یک فروشگاه اینترنتی طراحی کنیم. در ابتدا شاید مسئله ساده به نظر برسد: کاربر محصول را انتخاب می کند، سفارش می دهد و هزینه را پرداخت می کند.
اما وقتی سیستم بزرگ تر شود، سؤالات معماری زیادی مطرح می شوند:
آیا کل سیستم یک برنامه ی واحد باشد؟
آیا بخش های مختلف به سرویس های جداگانه تقسیم شوند؟
اطلاعات کاربران و سفارش ها چگونه مدیریت شوند؟
اگر تعداد کاربران افزایش پیدا کرد، سیستم چگونه Scale شود؟
اگر یکی از بخش ها دچار مشکل شد، آیا کل سیستم از کار بیفتد؟
تغییر یک قابلیت چقدر باید روی سایر قسمت های سیستم تأثیر بگذارد؟
امنیت و احراز هویت چگونه در بخش های مختلف سیستم اعمال شود؟

بنابراین معماری بیشتر از اینکه درباره ی چگونه کد نویسی باشد، درباره ی تصمیم های ساختاری و اثرات بلند مدت آن ها است. کتاب برای توضیح معماری نرم افزار، چند مفهوم را در کنار هم قرار می دهد:

 Architectural Characteristics

Architectural Decisions

Logical Components

 Architectural Styles

به نظرم می توان این چهار مفهوم را به صورت یک زنجیره در نظر گرفت. ابتدا باید بدانیم یک سیستم چه ویژگی هایی نیاز دارد، بعد بر اساس آن ها تصمیم های معماری را بگیریم، اجزای منطقی سیستم را مشخص کنیم و در نهایت سبک معماری مناسب را انتخاب کنیم. بنابراین انتخاب معماری نباید از اینجا شروع شود که می خواهم از Microservices استفاده کنم؛ بلکه باید از این سؤال شروع شود که این سیستم چه نیازهایی دارد و چه ویژگی هایی برای آن مهم هستند؟

در اینجا مفهوم Architectural Characteristics اهمیت پیدا می کند. این ویژگی ها مشخص می کنند سیستم از نظر فنی چه خصوصیاتی باید داشته باشد.

 ویژگی هایی مانند Performance، Scalability، Reliability، Maintainability و Security  نمونه هایی از همین Characteristics هستند. نکته ای که در این قسمت برای من جالب بود این است که نمی توان همه ی این ویژگی ها را هم زمان با بالاترین سطح ممکن در یک سیستم ایجاد کرد. اگر بخواهیم همه چیز را به بالاترین حد برسانیم، احتمالاً معماری بیش از حد پیچیده می شود و در نهایت با چیزی مواجه می شویم که اصطلاحاً Overengineering  شده است. بنابراین باید مشخص کنیم کدام ویژگی ها برای سیستم اهمیت بیشتری دارند و تصمیم های معماری را بر اساس همان اولویت ها بگیریم.

اینجاست که یکی از مهم ترین مفاهیم کتاب یعنی Trade-off خودش را نشان می دهد. در معماری نرم افزار معمولاً یک انتخاب وجود ندارد که از همه ی جنبه ها بهترین باشد. تقریباً هر تصمیمی یک مزیت را افزایش می دهد و در مقابل ممکن است هزینه یا محدودیتی در جای دیگری ایجاد کند. برای مثال، Microservices می تواند استقلال سرویس ها و امکان Scale کردن بخش های مختلف سیستم را افزایش دهد، اما در مقابل پیچیدگی ارتباط بین سرویس ها، مدیریت داده، Consistency، Monitoring و Deployment را هم بیشتر می کند. بنابراین نمی توان به سادگی گفت Microservices بهتر از Monolith است. سؤال درست این است که برای این سیستم خاص، با این نیازها و محدودیت ها، کدام انتخاب Trade-off مناسب تری ایجاد می کند؟

به همین دلیل یکی از ایده های مهم کتاب این است که در تصمیم های معماری، Why  از How مهم تر است. فرض کنیم در یک پروژه تصمیم گرفته ایم از Microservices استفاده کنیم. اینکه فقط بگوییم سیستم با Microservices طراحی شده اطلاعات چندانی درباره ی منطق این تصمیم به ما نمی دهد. اما اگر مشخص کنیم چرا این انتخاب انجام شده، چه مشکلی قرار بوده حل شود، چه گزینه هایی بررسی شده اند و چه هزینه هایی را پذیرفته ایم، تصمیم معماری ارزش بیشتری پیدا می کند. این مسئله مخصوصاً در پروژه های بلندمدت اهمیت دارد، چون ممکن است اعضای تیم در طول زمان تغییر کنند و توسعه دهندگان جدید وارد پروژه شوند. آن ها باید بتوانند دلیل پشت تصمیم های معماری را بفهمند، نه اینکه فقط با نتیجه ی آن تصمیم مواجه شوند.

یکی از راه های ثبت همین تصمیم ها Architectural Decision Record  یا ADR است. ADR را می توان یک سند نسبتا کوتاه برای ثبت تصمیم های مهم معماری در نظر گرفت. در آن می توان  Context، تصمیم نهایی، گزینه های بررسی شده و پیامد های تصمیم را ثبت کرد. برای مثال اگر تیم تصمیم گرفته باشد یک سیستم را به صورت Modular Monolith طراحی کند، بهتر است مشخص شود چرا این گزینه انتخاب شده و چرا در آن مرحله Microservices انتخاب نشده است. این اطلاعات ممکن است در زمان تصمیم گیری ساده به نظر برسند، اما چند ماه یا چند سال بعد می توانند بسیار ارزشمند باشند.

بعد از تصمیم گیری درباره ی ساختار کلی سیستم، مسئله ی تقسیم سیستم به اجزای مختلف مطرح می شود. اینجا مفاهیمی مثل  Coupling وCohesion اهمیت پیدا می کنند. Coupling به میزان وابستگی بین اجزای سیستم مربوط است. اگر دو بخش وابستگی زیادی به یکدیگر داشته باشند، تغییر در یکی از آن ها می تواند بخش دیگر را هم تحت تأثیر قرار دهد. در مقابل، Cohesion  به این موضوع مربوط می شود که مسئولیت های مرتبط تا چه اندازه در کنار هم قرار گرفته اند. در یک طراحی مناسب معمولاً به دنبال Cohesion  بالا و Coupling کنترل شده هستیم؛ یعنی هر بخش مسئولیت مشخص و مرتبطی داشته باشد و در عین حال وابستگی غیر ضروری آن به بخش های دیگر کاهش پیدا کند. این موضوع در پروژه های بزرگ اهمیت بیشتری پیدا می کند، چون با افزایش تعداد اجزای سیستم، مدیریت وابستگی ها سخت تر می شود.

بعد از این مفاهیم، کتاب وارد بحث Architecture Styles  می شود. این قسمت برای من جذاب بود، چون سبک های مختلف معماری را نه به صورت یک فهرست از Patternها، بلکه در قالب یک Landscape بررسی می کند. در این Landscape دو محور اصلی وجود دارد. محور افقی به نحوه ی تقسیم بندی سیستم مربوط می شود؛ در یک طرف Technical Partitioning  قرار دارد و در طرف دیگر Domain Partitioning.  

در Technical Partitioning سیستم بیشتر بر اساس مسئولیت های فنی تقسیم می شود، در حالی که در Domain Partitioning  تقسیم بندی بر اساس قابلیت ها یا حوزه های کسب و کار انجام می شود.

محور عمودی هم نحوه ی Deployment را نشان می دهد؛ از Monolithic Deployment  در پایین تا Distributed Deployment  در بالا. با ترکیب این دو محور، می توان جایگاه سبک هایی مانند Layered Architecture، Modular Monolith، Microkernel و Microservices را بهتر درک کرد.

در Layered Architecture  سیستم معمولاً بر اساس لایه های فنی تقسیم می شود. برای مثال ممکن است لایه های Presentation، Business و Persistence داشته باشیم. این معماری به دلیل سادگی و قابل فهم بودن، در بسیاری از سیستم ها انتخاب مناسبی است، اما در سیستم های بزرگ ممکن است یک تغییر در قابلیت های کسب و کار باعث شود مجبور شویم چند لایه ی مختلف را تغییر دهیم. در مقابل، Modular Monolith  تلاش می کند سیستم را بیشتر بر اساس Domain یا قابلیت های کسب و کار تقسیم کند، در حالی که کل سیستم همچنان به صورت یک واحد Deploy می شود. مثلاً در یک فروشگاه اینترنتی می توان Module های جداگانه ای برای User، Product، Order  و Payment داشت. این موضوع یک نکته ی مهم را نشان می دهد: برای داشتن یک ساختار ماژولار، لزوماً لازم نیست از همان ابتدا سیستم را به Microservices  تبدیل کنیم.

در طرف دیگر، با سبک هایی مواجه می شویم که بیشتر به سمت Distributed Deployment می روند. Microkernel  از یک Core System تشکیل می شود که قابلیت های مختلف می توانند به صورت Plugin  در اطراف آن قرار بگیرند. این مدل برای سیستم هایی که قابلیت توسعه یا سفارشی سازی بالایی دارند می تواند مفید باشد.

 Microservices نیز سیستم را به سرویس های مستقل تری تقسیم می کند که معمولاً هر کدام مسئول یک حوزه یا قابلیت مشخص هستند. در یک فروشگاه اینترنتی می توان سرویس هایی مانند User Service، Product Service، Order Service و Payment Service داشت. مزیت این روش می تواند استقلال بیشتر سرویس ها و امکان Scale کردن آن ها باشد، اما همان طور که در بحث Trade-off گفتیم، Distributed  شدن سیستم هزینه هایی هم دارد. ارتباطات شبکه ای، مدیریت داده، Failure  بین سرویس ها، Consistency  و پیچیدگی Deployment از جمله مسائلی هستند که باید در نظر گرفته شوند. بنابراین Microservices را نمی توان صرفاً نسخه ی بهتر Monolith دانست.

این موضوع باعث می شود به یک سؤال مهم برسیم:  چه زمانی باید Monolith انتخاب کنیم و چه زمانی Distributed Architecture؟ به نظر من یکی از پیام های مهم کتاب همین است که نباید صرفاً به دلیل محبوب بودن یک تکنولوژی یا Architecture Style آن را انتخاب کنیم. برای یک پروژه ی کوچک ممکن است یک Monolith ساده بهترین انتخاب باشد. برای پروژه ای که Domain پیچیده تری دارد، Modular Monolith می تواند ساختار مناسبی ایجاد کند و در عین حال پیچیدگی سیستم Distributed را وارد پروژه نکند. در مقابل، در بعضی سیستم های بزرگ و پیچیده، Microservices می تواند مزایای قابل توجهی داشته باشد. بنابراین انتخاب معماری باید از نیازهای واقعی سیستم شروع شود، نه از علاقه ی تیم به یک تکنولوژی خاص.

کتاب در ادامه یک مسیر برای تصمیم گیری معماری پیشنهاد می کند. ابتدا باید Architectural Characteristics  مورد نیاز سیستم را شناسایی کنیم. سپس Components  اصلی را مشخص کنیم و مسئولیت های آن ها را در نظر بگیریم. بعد از آن می توان Architecture Style مناسب را انتخاب کرد. تصمیم گرفته شده باید مستند شود و در نهایت معماری را می توان با Diagramهای مناسب نمایش داد. این فرآیند برای من جالب بود، چون نشان می دهد معماری یک تصمیم لحظه ای نیست؛ بلکه مجموعه ای از مراحل تحلیل، انتخاب، مستند سازی و ارتباط تصمیم هاست.

در نهایت، کتاب فقط درباره ی تکنولوژی ها و  Architecture Styleها صحبت نمی کند و به خود نقش Software Architect  هم توجه دارد. تصویری که کتاب از یک معمار نرم افزار ارائه می کند، صرفاً یک فرد متخصص در یک تکنولوژی خاص نیست. یک Software Architect بایدTechnical Breadth  داشته باشد و با حوزه های مختلف فنی آشنا باشد. در عین حال نباید ارتباطش را با کد نویسی از دست بدهد، چون درگیری با کد و مشکلات واقعی پیاده سازی به تصمیم های معماری کمک می کند. در کنار این موارد، Soft Skills هم اهمیت زیادی دارند. یک تصمیم معماری زمانی ارزشمند است که بتوان آن را برای اعضای تیم توضیح داد، درباره ی آن مذاکره کرد و دلیل انتخاب آن را به شکل مناسبی منتقل کرد.

اگر بخواهم تمام مطالب کتاب را در چند نکته خلاصه کنم، اولین نکته برای من این است که Architecture همیشه Contextual است. یعنی یک معماری خوب برای همه ی سیستم ها وجود ندارد و انتخاب مناسب به شرایط همان سیستم بستگی دارد. نکته ی دوم این است که در معماری نرم افزار باید Trade-offها را پذیرفت. هر انتخابی هزینه ای دارد و وظیفه ی مهندس نرم افزار این نیست که دنبال یک راه حل کاملاً بدون نقص بگردد؛ بلکه باید بتواند هزینه و فایده ی گزینه های مختلف را مقایسه کند. نکته ی سوم هم اهمیت مستندسازی و دفاع از تصمیم های معماری است. وقتی دلیل تصمیم ها ثبت شده باشد، معماری برای اعضای فعلی و آینده ی تیم قابل فهم تر خواهد بود.

در آخر شاید بتوان پیام اصلی کتاب را این طور خلاصه کرد: معماری نرم افزار درباره ی پیدا کردن یک راه حل کامل نیست؛ درباره ی گرفتن تصمیم های آگاهانه و درک پیامد های آن ها است. همین نگاه است که باعث می شود معماری به یکی از مهم ترین بخش های مهندسی نرم افزار تبدیل شود.

اين مطلب، بخشي از تمرينهاي درس معماري نرم افزار در دانشگاه شهيد بهشتي است.

نرم افزارsoftware architecture
۰
۰
مهدی مهدی پور
مهدی مهدی پور
شاید از این پست‌ها خوشتان بیاید