بنية بدون خادم

مقدمة

تتيح الحوسبة بدون خادم للمطورين إنشاء التطبيقات وتشغيلها دون إدارة الخوادم. يتعامل موفر السحابة مع كافة البنية التحتية — التوفير والتوسيع والتصحيح والصيانة. يقوم المطورون بكتابة الوظائف، وتكوين المشغلات، ويتولى النظام الأساسي الباقي.

إن الاسم "بدون خادم" مضلل، إذ لا تزال الخوادم متضمنة. لكن المطور لا يفكر بهم أبدًا. يؤدي هذا التحول من إدارة البنية التحتية إلى منطق التطبيق الخالص إلى تغيير كيفية إنشاء التطبيقات ونشرها.

---

كيف يعمل بدون خادم

نموذج التنفيذ

                     ┌─────────────────────┐
                     │   Event Source      │
                     │ (HTTP, Queue, Timer,│
                     │  Storage, etc.)     │
                     └──────────┬──────────┘
                                │ Trigger
                                ▼
┌──────────────────────────────────────────────────┐
│              Serverless Function                 │
│  ┌────────────────────────────────────────────┐  │
│  │   1. Cold Start (if needed)               │  │
│  │      - Provision sandbox                  │  │
│  │      - Initialize runtime (Node, Python)  │  │
│  │      - Load dependencies                  │  │
│  ├────────────────────────────────────────────┤  │
│  │   2. Execute handler function              │  │
│  │   3. Return response                       │  │
│  └────────────────────────────────────────────┘  │
│              Auto-scales horizontally             │
│              from 0 to N concurrent executions    │
└──────────────────────────────────────────────────┘

وظيفة بسيطة بدون خادم

// AWS Lambda handler
exports.handler = async (event) => {
  const { name } = JSON.parse(event.body);

  const response = {
    statusCode: 200,
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      message: `Hello, ${name}!`,
      timestamp: new Date().toISOString()
    })
  };

  return response;
};

---

بدون خادم مقابل الهندسة المعمارية التقليدية

الجانب	التقليدية (الخوادم)	بدون خادم
إدارة الخادم	مطلوب (التصحيح والتحديثات)	لا شيء
** التحجيم **	مجموعات القياس اليدوية أو التلقائية	تلقائي، من 0 إلى 1000 ثانية
الفوترة	لكل ساعة/مثيل (تكلفة خاملة)	لكل تنفيذ + لكل ذاكرة (بدون تكلفة خاملة)
** بداية البرد **	غير متاح (تشغيل دائمًا)	100ms-1s للاستدعاء الأولي
** الحد الأقصى للتنفيذ **	غير محدود	المهلة (15 دقيقة من Lambda، 10 دقائق من الوظائف السحابية)
الدولة	مستمرة (حالة في الذاكرة)	عديمي الجنسية حسب التصميم
النشر	خادم كامل أو حاوية	وظيفة واحدة
التفاصيل	متراصة أو الخدمة	وظيفة واحدة

---

مصادر الأحداث بدون خادم

المشغلات المشتركة

مصدر الحدث	مزود	حالة الاستخدام
HTTP (بوابة API)	أوس، أزور، جي سي بي	واجهات برمجة تطبيقات REST، وخطافات الويب
** تغيير قاعدة البيانات (CDC) **	DynamoDB Streams، وCosmosDB Change Feed، وFirestore	مزامنة البيانات، وتشغيل سير العمل
رفع الملف	S3، تخزين Blob، التخزين السحابي	معالجة الصور والتحقق من صحة الملف
** قائمة انتظار الرسائل **	SQS، تخزين قائمة الانتظار، حانة/فرعية	معالجة غير متزامنة منفصلة
** تيار **	الحركة، مراكز الأحداث، الحانة/الفرعية	معالجة البيانات في الوقت الحقيقي
الجدول	أحداث CloudWatch، الموقت، المجدول	وظائف كرون، تجهيز الدفعات
البريد الإلكتروني	سيس، سيندغريد	معالجة البريد الإلكتروني
إنترنت الأشياء	إنترنت الأشياء الأساسية، شبكة الأحداث	معالجة القياس عن بعد للجهاز

وظيفة متعددة الأحداث

# AWS SAM template — Function triggered by multiple events
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  OrderProcessor:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: src/
      Handler: orders.handler
      Runtime: nodejs20.x
      Events:
        HttpPost:
          Type: Api
          Properties:
            Path: /orders
            Method: POST
        QueueConsumer:
          Type: SQS
          Properties:
            Queue: !GetAtt OrderQueue.Arn
            BatchSize: 10
        StreamProcessor:
          Type: DynamoDB
          Properties:
            Stream: !GetAtt OrdersTable.StreamArn
            StartingPosition: TRIM_HORIZON

---

بناء تطبيق بدون خادم

مثال: خط أنابيب معالجة الصور

                  ┌──────────┐
                  │ User     │
                  │ Uploads  │
                  └────┬─────┘
                       ▼
              ┌─────────────────┐
              │  S3 Bucket      │
              │  (upload/raw)   │
              └────────┬────────┘
                       │ trigger
                       ▼
              ┌─────────────────┐
              │  Lambda         │
              │  (process.ts)   │
              │                 │
              │   1. Read image │
              │   2. Resize     │
              │   3. Compress   │
              │   4. Extract    │
              │      metadata   │
              └────────┬────────┘
                       │
               ┌───────┴───────┐
               ▼               ▼
        ┌────────────┐  ┌──────────────┐
        │ S3 Bucket  │  │ DynamoDB    │
        │ (processed)│  │ (metadata)  │
        └────────────┘  └──────────────┘

// process.ts — Image processing Lambda
import { S3 } from '@aws-sdk/client-s3';
import { DynamoDB } from '@aws-sdk/client-dynamodb';
import sharp from 'sharp';

const s3 = new S3();
const dynamo = new DynamoDB();

const SUPPORTED_FORMATS = ['image/jpeg', 'image/png', 'image/webp'];

export const handler = async (event: S3Event) => {
  const results = await Promise.allSettled(
    event.Records.map(async (record) => {
      const bucket = record.s3.bucket.name;
      const key = decodeURIComponent(record.s3.object.key.replace(/\+/g, ' '));

      // Validate file type
      const headResult = await s3.headObject({ Bucket: bucket, Key: key });
      if (!SUPPORTED_FORMATS.includes(headResult.ContentType!)) {
        console.log(`Unsupported format: ${headResult.ContentType}`);
        return;
      }

      // Read original
      const { Body } = await s3.getObject({ Bucket: bucket, Key: key });
      const buffer = await Body!.transformToByteArray();

      // Process: resize to multiple sizes
      const sizes = [
        { suffix: 'thumbnail', width: 150, height: 150 },
        { suffix: 'medium', width: 800, height: 600 },
        { suffix: 'large', width: 1920, height: 1080 },
      ];

      for (const size of sizes) {
        const processed = await sharp(buffer)
          .resize(size.width, size.height, { fit: 'cover' })
          .webp({ quality: 80 })
          .toBuffer();

        const outputKey = key.replace('raw', `processed/${size.suffix}`);
        await s3.putObject({
          Bucket: bucket.replace('-raw', '-processed'),
          Key: outputKey,
          Body: processed,
          ContentType: 'image/webp',
        });
      }

      // Store metadata
      await dynamo.putItem({
        TableName: 'ImageMetadata',
        Item: {
          imageId: { S: key },
          originalSize: { N: buffer.byteLength.toString() },
          formats: { SS: ['thumbnail', 'medium', 'large'] },
          uploadedAt: { S: new Date().toISOString() },
        },
      });
    })
  );

  const failed = results.filter(r => r.status === 'rejected');
  if (failed.length > 0) {
    throw new Error(`${failed.length} images failed processing`);
  }

  return { processed: results.length - failed.length, failed: failed.length };
};

---

البدايات الباردة والتخفيف من حدتها

ما الذي يسبب بداية البرد؟

عندما تكون الوظيفة خاملة، تستعيد المنصة مواردها. يتطلب الاستدعاء التالي ما يلي:

1. توفير وقت التشغيل (~50 مللي ثانية — Node.js، Python؛ ~500 مللي ثانية — Java، C#)
2. تهيئة التبعيات (حوالي 50-500 مللي ثانية حسب حجم الحزمة)
3. تنفيذ رمز المعالج (~10-50 مللي ثانية خارج المعالج)

إجمالي البداية الباردة: 100 مللي ثانية إلى ثانيتين اعتمادًا على وقت التشغيل وحجم الحزمة.

أوقات البدء الباردة حسب وقت التشغيل

وقت التشغيل	بداية باردة (متوسطة)	البداية الباردة (ص 99)
بايثون	200 مللي ثانية	500 مللي ثانية
Node.js	250 مللي ثانية	600 مللي ثانية
اذهب	100 مللي ثانية	300 مللي ثانية
صافي	500 مللي ثانية	2 ثانية
جافا	800 مللي ثانية	3ث
الصدأ	100 مللي ثانية	250 مللي ثانية

استراتيجيات التخفيف

استراتيجية	كيف يعمل	تأثير التكلفة
التزامن المقدم (لامدا)	حافظ على دفء مثيلات N دائمًا	ادفع مقابل الحالات الدافئة
سناب ستارت (لامدا)	التهيئة المسبقة ووقت التشغيل اللقطة	الحد الأدنى من التكلفة الإضافية
الأصوات الدافئة	أدعية دورية كل 5 دقائق	لا يكاد يذكر
** وقت تشغيل أخف **	استخدم Node.js/Python/Go بدلاً من Java	لا توجد تكلفة إضافية
تقليل التبعيات	حزم النشر الأصغر	لا توجد تكلفة إضافية

---

تكاليف بدون خادم

نموذج التسعير

تتقاضى معظم الأنظمة الأساسية التي لا تحتوي على خادم رسومًا بناءً على:

1. الطلبات — عدد استدعاءات الوظائف.
2. المدة — وقت التنفيذ (مقربًا إلى أقرب 1 مللي ثانية أو 100 مللي ثانية).
3. الذاكرة — الذاكرة التي تم تكوينها لكل استدعاء.

مثال لمقارنة التكلفة

Scenario: API handling 1M requests/month, 200ms avg execution, 512MB memory

Traditional (t3.small, $0.0208/hr):
  $0.0208 × 730 hours = $15.18/month (always on)

Serverless (Lambda):
  Requests: 1M × $0.20/1M = $0.20
  Duration: 1M × 0.2s × 512MB/1024MB × $0.0000166667/GB-s = $1.67
  Total: $1.87/month

Savings: ~87% at low traffic

Breakeven point: At ~45M requests/month, traditional becomes cheaper

تحسين التكلفة

# Serverless cost optimization checklist
cost_optimization:
  - "Right-size memory: 128MB may be sufficient, but 1769MB costs 14x more"
  - "Use AWS Compute Optimizer for memory recommendations"
  - "Minimize function duration (optimize code, use async where possible)"
  - "Use reserved concurrency only when needed"
  - "Delete unused functions and resources"
  - "Use Lambda SnapStart for Java/.NET to reduce duration"
  - "Leverage Lambda@Edge or CloudFront Functions for edge processing"

---

النظام البيئي بدون خادم

حساب

الخدمة	مزود	الميزة الرئيسية
** أوس لامدا **	أوس	أكبر نظام بيئي، مهلة 15 دقيقة
** وظائف أزور **	مايكروسوفت	تكامل Office 365 العميق / Teams
** وظائف السحابة **	جوجل	بايثون أولا، التكامل Eventarc
** عمال Cloudflare **	كلاودفلير	مستند على الحافة، يبدأ التشغيل على البارد <1 مللي ثانية، ونصوص برمجية بحجم 30 ميجابايت

قواعد البيانات

الخدمة	اكتب	ميزة بدون خادم
** دينامو دي بي **	قيمة المفتاح + المستند	القدرة على الطلب، والتحجيم التلقائي
** أورورا بدون خادم **	العلائقية (MySQL/PostgreSQL)	قدرة الحوسبة ذات القياس التلقائي
** قاعدة بيانات الكون **	متعدد النماذج	وضع الإنتاجية بدون خادم
متجر النار	وثيقة	القياس التلقائي، والمزامنة في الوقت الحقيقي
نيون	PostgreSQL بدون خادم	المتفرعة، والتعليق التلقائي

التخزين

الخدمة	حالة الاستخدام
**S3 / Blob / التخزين السحابي **	تخزين الملفات، مشغلات الأحداث
** ElastiCache بدون خادم **	التخزين المؤقت في الذاكرة
SQS/تخزين قائمة الانتظار	قائمة انتظار الرسائل
EventBridge / شبكة الأحداث	حافلة الحدث

---

أنماط التصميم

1. نمط المروحة الخارجية

معالجة عناصر متعددة بالتوازي:

SQS Queue → Lambda → SNS Topic → Lambda (email)
                                 → Lambda (SMS)
                                 → Lambda (push)
                                 → Lambda (logging)

2. نمط الملحمة (المعاملات الموزعة)

// Order saga with compensation
async function createOrder(event) {
  const { orderId, userId, items, total } = event;

  try {
    await reserveInventory(items);
    await processPayment(userId, total);
    await createShipment(orderId);
    await sendConfirmation(userId);

    return { status: 'completed', orderId };
  } catch (error) {
    // Compensating transactions (undo)
    await cancelShipment(orderId);
    await refundPayment(userId, total);
    await releaseInventory(items);

    throw error;
  }
}

3. نمط قائمة انتظار الخانق

التعامل مع ارتفاع حركة المرور عن طريق التخزين المؤقت للطلبات:

API Gateway → SQS (buffer) → Lambda (process)
                              ↑
                     Process at your own pace

4. نمط مصادر الحدث

// Store events, derive current state
interface OrderEvent {
  type: 'CREATED' | 'ITEM_ADDED' | 'PAID' | 'SHIPPED' | 'CANCELLED';
  orderId: string;
  timestamp: string;
  data: Record<string, any>;
}

// Function: store event
exports.recordEvent = async (event: OrderEvent) => {
  await dynamo.putItem({
    TableName: 'OrderEvents',
    Item: marshal(event)
  });
  // Don't modify order state directly
};

// Function: rebuild state from events
exports.getOrderState = async (orderId: string) => {
  const events = await queryEvents(orderId);
  return events.reduce((state, event) => applyEvent(state, event), initialState);
};

---

المراقبة بدون خادم وإمكانية المراقبة

التسجيل المنظم

// Structured logging for serverless
const logger = {
  info: (message: string, context?: object) => {
    console.log(JSON.stringify({
      timestamp: new Date().toISOString(),
      level: 'INFO',
      message,
      aws_request_id: context.awsRequestId,
      function_name: context.functionName,
      ...context
    }));
  },
  error: (message: string, error?: Error) => {
    console.error(JSON.stringify({
      timestamp: new Date().toISOString(),
      level: 'ERROR',
      message,
      error_name: error?.name,
      error_message: error?.message,
      stack: error?.stack,
    }));
  }
};

التتبع الموزع

// X-Ray tracing
import { AWS } from '@aws-sdk/client-lambda';
import { captureAWS } from 'aws-xray-sdk-core';

const lambda = captureAWS(new AWS.Lambda());

exports.handler = async (event) => {
  const segment = new Segment('process_order');
  // ... function logic with automatic subsegment tracking
};

لوحات المعلومات

المقاييس الرئيسية للرصد:

• عدد الدعوات ومعدل الخطأ.
• المدة (ص50، ص95، ص99).
• الخانق (تجاوز حدود التزامن).
• معدل البداية الباردة.
• التكلفة لكل وظيفة.

---

متى لا تستخدم بدون خادم

السيناريو	لماذا لا يعد Serverless مثاليًا	بديل
عمليات طويلة الأمد (> 15 دقيقة)	مهلة التنفيذ	الحاويات، الأجهزة الافتراضية
تطبيقات الحالة	عديمي الجنسية حسب التصميم	الخدمات ذات الحالة (WebSocket API، Redis)
حركة مرور عالية ومستمرة (> 100 طلب/ثانية مستمرة)	التكاليف تتجاوز القدرة المتوفرة	حاويات القياس التلقائي
متطلبات زمن الوصول المنخفض (<10 مللي ثانية)	بداية باردة في سماء المنطقة	التزامن المقدم، وظائف الحافة
تنسيق معقد	تكوين الوظيفة صعب	وظائف الخطوة، سير العمل
ميزات خاصة بالمنصة	قدرات وقت التشغيل محدودة	الوصول الكامل إلى نظام التشغيل (الحاويات)

---

الاستنتاج

تعتبر البنية بدون خادم مثالية لما يلي:

1. أعباء العمل المستندة إلى الأحداث — معالجة الملفات وخطافات الويب والإشعارات.
2. أنماط حركة المرور المتغيرة — واجهات برمجة التطبيقات ذات التحميل غير المتوقع.
3. النماذج الأولية السريعة — لا توجد بنية تحتية للإعداد.
4. معالجة الخلفية — قوائم الانتظار، والتدفقات، والمهام المجدولة.
5. مكونات الخدمة الصغيرة — عزل وظائف محددة.

ابدأ بدون خادم من أجل:

• نقطة نهاية API جديدة.
• خط أنابيب معالجة الصور.
• مهمة تجميع البيانات المجدولة.
• جهاز استقبال webhook.

الترحيل إلى الحاويات عندما:

• تصبح حركة المرور ثابتة وعالية الحجم.
• مدة التنفيذ تتجاوز باستمرار الحدود.
• أنت بحاجة إلى إمكانات محددة على مستوى نظام التشغيل.
• يظهر تحليل التكلفة أن الحاويات أرخص.

إن الخدمة بدون خادم ليست الحل لكل شيء - ولكن بالنسبة لأحمال العمل المناسبة، فإنها تقلل بشكل كبير من تكاليف التشغيل ووقت التطوير.