
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.
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.
"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.
┌─────────────────────┐
│ 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;
};
| 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 |
| 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 |
# 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 };
};
Bir işlev boşta kaldığında platform kaynaklarını geri alır. Bir sonraki çağrı şunları gerektirir:
Toplam soğuk başlatma: 100 ms ila 2 sn, çalışma süresine ve paket boyutuna bağlı olarak.
| Ç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 |
| 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 |
Çoğu sunucusuz platform aşağıdakilere göre ücretlendirilir:
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"
| 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 | Python öncelikli, eventarc entegrasyonu | |
| Cloudflare Çalışanları | Bulut parlaması | Edge tabanlı, 1 ms'den kısa soğuk başlatma, 30 MB komut dosyası |
| 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 |
| 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ü |
Birden fazla öğeyi paralel olarak işleyin:
SQS Queue → Lambda → SNS Topic → Lambda (email)
→ Lambda (SMS)
→ Lambda (push)
→ Lambda (logging)
// 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;
}
}
İstekleri ara belleğe alarak trafik artışlarını ele alın:
API Gateway → SQS (buffer) → Lambda (process)
↑
Process at your own pace
// 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
};
İzlenecek temel ölçümler:
| 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) |
Sunucusuz mimari aşağıdakiler için idealdir:
Aşağıdakiler için sunucusuz ile başlayın:
Aşağıdaki durumlarda kapsayıcılara geçiş yapın:
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.
Henüz onaylı yorum yok. Yeni yanıtlar moderasyon bekleyebilir.