Makale

Sunucusuz Mimari

Sunucusuz bilgi işlem, geliştiricilerin sunucuları yönetmeye gerek kalmadan uygulamalar oluşturmasına ve çalıştırmasına olanak tanır. Bulut sağlayıcısı tüm altyapıyı (tedarik, ölçeklendirme, düzeltme eki uygulama ve bakım) yönetir. Geliştiriciler işlevleri yazar, tetikleyicileri yapılandırır ve gerisini platform halleder.

3 dk okumaDil: TR TürkçeÜcretsiz0 alkış0 yorum

TeknolojiMühendislik MakaleleriArchitectureServerlessTechnologyEngineering ArticlesCloud Computing

Okuma seçenekleri

Giriş

"Sunucusuz" adı yanıltıcıdır; sunucular hâlâ işin içindedir. Ancak geliştirici bunları asla düşünmüyor. Altyapı yönetiminden saf uygulama mantığına geçiş, uygulamaların oluşturulma ve dağıtılma şeklini değiştiriyor.

Sunucusuz Nasıl Çalışır?

Yürütme Modeli

                     ┌─────────────────────┐
                     │   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    │
└──────────────────────────────────────────────────┘

Basit Sunucusuz İşlev

// 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;
};

Sunucusuz ve Geleneksel Mimari Karşılaştırması

Görünüş	Geleneksel (sunucular)	Sunucusuz
Sunucu yönetimi	Gerekli (yamalama, güncellemeler)	Yok
Ölçeklendirme	Manuel veya otomatik ölçeklendirme grupları	Otomatik, 0'dan 1000'e kadar
Faturalandırma	Saat/örnek başına (boşta kalma maliyeti)	Yürütme başına + bellek başına (boşta kalma maliyeti yok)
Soğuk çalıştırma	Yok (her zaman açık)	İlk başlatma için 100ms-1s
Maksimum yürütme	Sınırsız	Zaman Aşımı (15 dakika Lambda, 10 dakika Bulut İşlevleri)
Eyalet	Kalıcı (bellek içi durum)	Tasarım gereği vatansız
Dağıtım	Tam sunucu veya kapsayıcı	Tek işlev
Ayrıntılılık	Monolit veya hizmet	Tek işlev

Sunucusuz Olay Kaynakları

Yaygın Tetikleyiciler

Olay Kaynağı	sağlayıcı	Kullanım Örneği
HTTP (API Ağ Geçidi)	AWS, Azure, GCP	REST API'leri, web kancaları
Veritabanı Değişikliği (CDC)	DynamoDB Akışları, CosmosDB Değişiklik Akışı, Firestore	Verileri senkronize edin, iş akışlarını tetikleyin
Dosya Yükleme	S3, Blob Depolama, Bulut Depolama	Görüntü işleme, dosya doğrulama
Mesaj Sırası	SQS, Sıra Depolama, Pub/Sub	Ayrılmış eşzamansız işleme
Akış	Kinesis, Etkinlik Hub'ları, Pub/Sub	Gerçek zamanlı veri işleme
Program	CloudWatch Etkinlikleri, Zamanlayıcı, Zamanlayıcı	Cron işleri, toplu işleme
E-posta	SES, SendGrid	E-posta işleme
IoT	IoT Çekirdeği, Olay Izgarası	Cihaz telemetri işleme

Çoklu Etkinlik Fonksiyonu

# 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

Sunucusuz Uygulama Oluşturma

Örnek: Görüntü İşleme Ardışık Düzeni

                  ┌──────────┐
                  │ 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 };
};

Soğuk Başlatma ve Etki Azaltma

Soğuk Başlatmaya Ne Sebep Olur?

Bir işlev boşta kaldığında platform kaynaklarını geri alır. Bir sonraki çağrı şunları gerektirir:

Çalışma zamanı sağlama (~50ms — Node.js, Python; ~500ms — Java, C#)
Bağımlılıkları başlat (paket boyutuna bağlı olarak ~50-500ms)
İşleyici kodunu yürütün (işleyicinin dışında ~10-50ms)

Toplam soğuk başlatma: 100 ms ila 2 sn, çalışma süresine ve paket boyutuna bağlı olarak.

Çalışma Zamanına Göre Soğuk Başlatma Süreleri

Çalışma zamanı	Soğuk Başlatma (medyan)	Soğuk Başlangıç (p99)
Piton	200ms	500ms
Node.js	250ms	600ms
Git	100ms	300ms
.NET	500ms	2'ler
Java	800ms	3'ler
Pas	100ms	250ms

Azaltma Stratejileri

Strateji	Nasıl Çalışır?	Maliyet Etkisi
Tedarik Edilen Eşzamanlılık (Lambda)	N örneği her zaman sıcak tutun	Sıcak örnekler için ödeme yapın
Hızlı Başlatma (Lambda)	Çalışma zamanını önceden başlatma ve anlık görüntü alma	Minimum ekstra maliyet
Sıcak tutma uyarıları	Her 5 dakikada bir periyodik çağrılar	İhmal edilebilir
Daha kısa çalışma süresi	Java yerine Node.js/Python/Go kullanın	Ekstra maliyet yok
Bağımlılıkları en aza indirin	Daha küçük dağıtım paketleri	Ekstra maliyet yok

Sunucusuz Maliyetler

Fiyatlandırma Modeli

Çoğu sunucusuz platform aşağıdakilere göre ücretlendirilir:

İstekler — İşlev çağrılarının sayısı.
Süre — Yürütme süresi (en yakın 1 ms veya 100 ms'ye yuvarlanır).
Bellek — Çağrı başına yapılandırılmış bellek.

Maliyet Karşılaştırma Örneği

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

Maliyet Optimizasyonu

# 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"

Sunucusuz Ekosistem

Hesapla

Hizmet	sağlayıcı	Temel Özellik
AWS Lambda	AWS	En büyük ekosistem, 15 dakikalık zaman aşımı
Azure İşlevleri	Microsoft	Deep Office 365 / Teams entegrasyonu
Bulut İşlevleri	Google	Python öncelikli, eventarc entegrasyonu
Cloudflare Çalışanları	Bulut parlaması	Edge tabanlı, 1 ms'den kısa soğuk başlatma, 30 MB komut dosyası

Veritabanları

Hizmet	Tür	Sunucusuz Özellik
DinamoDB	Anahtar/değer çifti + Belge	İsteğe bağlı kapasite, otomatik ölçeklendirme
Aurora Sunucusuz	İlişkisel (MySQL/PostgreSQL)	Otomatik ölçeklendirme işlem kapasitesi
Cosmos DB	Çoklu model	Sunucusuz aktarım hızı modu
Yangın deposu	Belge	Otomatik ölçeklendirme, gerçek zamanlı senkronizasyon
Neon	Sunucusuz PostgreSQL	Dallanma, otomatik askıya alma

Depolama

Hizmet	Kullanım Örneği
S3 / Blob / Bulut Depolama	Dosya depolama, olay tetikleyicileri
ElastiCache Sunucusuz	Bellek içi önbelleğe alma
SQS / Kuyruk Depolama	Mesaj kuyruğu
EventBridge / Event Grid	Etkinlik otobüsü

Tasarım Desenleri

1. Yayılma Deseni

Birden fazla öğeyi paralel olarak işleyin:

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

2. Saga Modeli (Dağıtılmış İşlemler)

// 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. Kısma Sıra Modeli

İstekleri ara belleğe alarak trafik artışlarını ele alın:

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

4. Olay Kaynak Bulma Modeli

// 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);
};

Sunucusuz İzleme ve Gözlemlenebilirlik

Yapılandırılmış Günlük Kaydı

// 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,
    }));
  }
};

Dağıtılmış İzleme

// 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
};

Gösterge tabloları

İzlenecek temel ölçümler:

Çağrı sayısı ve hata oranı.
Süre (p50, p95, p99).
Kısıtlamalar (eşzamanlılık sınırları aşıldı).
Soğuk başlatma oranı.
İşlev başına maliyet.

Sunucusuz Ne Zaman Kullanılmamalı?

Senaryo	Sunucusuz Neden İdeal Değil?	Alternatif
Uzun süren işlemler (>15 dakika)	Yürütme zaman aşımı	Konteynerler, VM'ler
Durum bilgisi olan uygulamalar	Tasarım gereği vatansız	Durum bilgisi olan hizmetler (WebSocket API, Redis)
Sürekli yüksek trafik (>100 istek/sn sürekli)	Maliyetler sağlanan kapasiteyi aşıyor	Otomatik ölçeklenen kapsayıcılar
Düşük gecikme gereksinimleri (<10 ms)	Soğuk başlangıç yükü	Sağlanan eşzamanlılık, uç işlevler
Karmaşık orkestrasyon	Fonksiyon kompozisyonu zordur	Adım İşlevleri, iş akışları
Platforma özgü özellikler	Sınırlı çalışma zamanı yetenekleri	Tam işletim sistemi erişimi (kapsayıcılar)

Sonuç

Sunucusuz mimari aşağıdakiler için idealdir:

Olay odaklı iş yükleri — Dosya işleme, web kancaları, bildirimler.
Değişken trafik modelleri — Tahmin edilemeyen yüke sahip API'ler.
Hızlı prototip oluşturma — Kurulacak altyapı yok.
Arka planda işleme — Kuyruklar, akışlar, zamanlanmış görevler.
Mikro hizmet bileşenleri — Belirli işlevleri izole edin.

Aşağıdakiler için sunucusuz ile başlayın:

Yeni bir API uç noktası.
Bir görüntü işleme hattı.
Planlanmış bir veri toplama işi.
Bir web kancası alıcısı.

Aşağıdaki durumlarda kapsayıcılara geçiş yapın:

Trafik istikrarlı ve yüksek hacimli hale gelir.
Yürütme süresi sürekli olarak sınırları aşıyor.
Belirli işletim sistemi düzeyinde yeteneklere ihtiyacınız var.
Maliyet analizi konteynerlerin daha ucuz olduğunu gösteriyor.

Sunucusuz her şeyin yanıtı değildir; ancak doğru iş yükleri için operasyonel ek yükü ve geliştirme süresini önemli ölçüde azaltır.

Yorumlar

0 yorum

Henüz onaylı yorum yok. Yeni yanıtlar moderasyon bekleyebilir.