Multi-Account AWS Mimarisi: Ölçeklenebilir Event-Driven Sistemler

// Cross-account event routing için CDK koduimport { Rule, EventBus } from 'aws-cdk-lib/aws-events';import { LambdaFunction } from 'aws-cdk-lib/aws-events-targets';
const orderPlacedRule = new Rule(this, 'OrderPlacedRule', {  eventBus: EventBus.fromEventBusArn(    this,    'CentralEventBus',    'arn:aws:events:us-east-1:121212121212:event-bus/central-bus'  ),  eventPattern: {    source: ['quickgrocer.customer-web'],    detailType: ['Order Placed'],    detail: {      orderStatus: ['PENDING'],      paymentMethod: ['CREDIT_CARD', 'DEBIT_CARD', 'APPLE_PAY']    }  },  targets: [    new LambdaFunction(orderProcessingLambda, {      retryAttempts: 2,      deadLetterQueue: orderProcessingDLQ,      maxEventAge: Duration.hours(2)    })  ]});
// Cross-account event publishing için izinlerconst centralBusArn = 'arn:aws:events:us-east-1:121212121212:event-bus/central-bus';const publishPolicy = new PolicyStatement({  effect: Effect.ALLOW,  actions: ['events:PutEvents'],  resources: [centralBusArn],  conditions: {    StringEquals: {      'events:detail-type': [        'Order Placed',        'Order Updated',        'Order Cancelled'      ]    }  }});

// Subscription Service - authoritative event yayınlarexport class SubscriptionService {  async upgradeSubscription(userId: string, planId: string) {    const subscription = await this.subscriptionRepo.create({      userId, planId, status: 'ACTIVE',      startDate: new Date(), features: this.getFeaturesByPlan(planId)    });    await this.eventPublisher.publish({      source: '"quickgrocer".subscription-service',      detailType: 'Subscription Activated',      detail: { userId, subscriptionId: subscription.id, plan: { id: planId, features: ['priority_delivery'] } }    });    return subscription;  }}
// Order Processor - local subscription cache ileexport class OrderProcessor {  private subscriptionCache = new Map<string, SubscriptionInfo>();  @EventHandler('Subscription Activated')  async onSubscriptionActivated(event: SubscriptionEvent) {    this.subscriptionCache.set(event.detail.userId, { plan: event.detail.plan, features: event.detail.plan.features });  }  async processOrder(order: Order) {    const subscription = this.subscriptionCache.get(order.userId);    if (subscription?.features.includes('priority_delivery')) order.priority = 'HIGH';  }}

// Choreography - her servis kendi parçasını bilirexport class PaymentEventHandlers {  @EventHandler('Subscription Upgrade Requested')  async handleUpgradeRequest(event: UpgradeEvent) {    const result = await this.processPayment(event.detail);    await this.publishEvent('Payment Processed', { userId: event.detail.userId, amount: result.amount });  }}export class SubscriptionEventHandlers {  @EventHandler('Payment Processed')  async activateSubscription(event: PaymentEvent) {    const subscription = await this.create(event.detail.userId);    await this.publishEvent('Subscription Activated', { userId: event.detail.userId, subscriptionId: subscription.id });  }}

// Maliyet tahsis etiketlerimizfunction applyCostTags(resource: any, teamName: string, serviceName: string): Record<string, string> {    return {        'Team': teamName,        'Service': serviceName,        'Environment': process.env.ENVIRONMENT || 'dev',        'CostCenter': TEAM_COST_CENTERS[teamName],        'Owner': TEAM_LEADS[teamName],        'CreatedDate': new Date().toISOString(),        'ManagedBy': 'CDK'    };}
// Aylık maliyet dağılımı kristal berraklıkta oldu:// Customer Web:         $12,450 (%25)// Mobile Apps:          $8,230  (%17)// Order Processing:     $15,670 (%32)// Delivery Orchestration: $7,890 (%16)// Identity Service:     $4,760  (%10)

// Payment service hesap güvenlik baseline'ıconst paymentServiceBaseline = new SecurityHub(this, 'PCICompliance', {  standards: [    SecurityHubStandard.PCI_DSS_V321,    SecurityHubStandard.AWS_FOUNDATIONAL_SECURITY  ],  enabledRegions: ['us-east-1', 'us-west-2'],  // Sadece payment service hesabı için  accountId: '999999999999'});

// "Schema registry kullanmalıydık" handler'ıexport const handleOrderPlaced = async (event: any) => {  // Hangi versiyonla uğraştığımızı kontrol et  const version = event.metadata?.schemaVersion ||                  (event.customerIdV2 ? 7 :                   event.totalAmount ? 5 :                   event.items?.[0]?.modifiers ? 4 : 1);
  switch(version) {    case 1:    case 2:    case 3:      return handleLegacyOrder(event);    case 4:      return handleV4Order(migrateV4ToV7(event));    case 5:    case 6:      return handleV5Order(migrateV5ToV7(event));    case 7:      return handleCurrentOrder(event);    default:      // Logla ve dua et      console.error('Bilinmeyen order versiyonu:', event);      throw new Error('Bilinmeyen schema versiyonu');  }};

// Distributed tracing akıl sağlığımızı kurtardıimport { trace, context, SpanStatusCode } from '@opentelemetry/api';
const tracer = trace.getTracer('quickgrocer-order-service', '1.0.0');
export const processOrder = async (event: any) => {  // EventBridge event'inden trace context'i çıkar  const traceParent = event.detail?.traceContext?.traceparent;  const traceState = event.detail?.traceContext?.tracestate;
  // Upstream service'ten trace'i devam ettir  const extractedContext = propagation.extract(context.active(), {    traceparent: traceParent,    tracestate: traceState  });
  return context.with(extractedContext, () => {    const span = tracer.startSpan('process-order', {      attributes: {        'order.id': event.detail.orderId,        'order.account': process.env.AWS_ACCOUNT_ID,        'order.region': process.env.AWS_REGION,        'order.service': 'order-processing'      }    });
    try {      // Siparişi işle      const result = await actuallyProcessOrder(event);      span.setStatus({ code: SpanStatusCode.OK });      return result;    } catch (error) {      span.recordException(error);      span.setStatus({        code: SpanStatusCode.ERROR,        message: error.message      });      throw error;    } finally {      span.end();    }  });};

// Önce: Her servis her istekte secret'ları çekiyorconst getSecret = async (secretName: string) => {  const client = new SecretsManagerClient({});  const response = await client.send(    new GetSecretValueCommand({ SecretId: secretName })  );  return response.SecretString;};
// Sonra: TTL ile cachingclass SecretCache {  private cache = new Map<string, {value: string, expiry: number}>();  private ttl = 3600000; // 1 saat
  async getSecret(secretName: string): Promise<string> {    const cached = this.cache.get(secretName);    if (cached && cached.expiry > Date.now()) {      return cached.value;    }
    const client = new SecretsManagerClient({});    const response = await client.send(      new GetSecretValueCommand({ SecretId: secretName })    );
    this.cache.set(secretName, {      value: response.SecretString!,      expiry: Date.now() + this.ttl    });
    return response.SecretString!;  }}
// Secrets Manager maliyetlerini %94 azalttı

// Event bus sağlığı için otomatik monitoringconst eventBusMonitor = new Lambda(this, 'EventBusMonitor', {  runtime: Runtime.NODEJS_18_X,  handler: 'monitor.handler',  environment: {    EXPECTED_EVENTS_PER_MINUTE: '1000',    ALERT_THRESHOLD: '100',    SLACK_WEBHOOK: process.env.SLACK_WEBHOOK  }});
// Her dakika çalıştırnew Rule(this, 'MonitorSchedule', {  schedule: Schedule.rate(Duration.minutes(1)),  targets: [new LambdaFunction(eventBusMonitor)]});
// Gerçek monitoring mantığıexport const handler = async () => {  const cloudWatch = new CloudWatchClient({});
  // Son dakikada yayınlanan event'leri kontrol et  const metrics = await cloudWatch.send(new GetMetricStatisticsCommand({    Namespace: 'AWS/Events',    MetricName: 'SuccessfulRuleMatches',    StartTime: new Date(Date.now() - 120000),  // 2 dakika önce    EndTime: new Date(),    Period: 60,    Statistics: ['Sum']  }));
  const eventCount = metrics.Datapoints?.[0]?.Sum || 0;
  if (eventCount < parseInt(process.env.ALERT_THRESHOLD!)) {    // YÜKSEK SESLE BAĞIR    await sendSlackAlert({      text: `🚨 EVENT BUS KRİTİK: Son dakikada sadece ${eventCount} event!`,      color: 'danger'    });
    // Otomatik iyileşme denemesi    await enableAllRules();  }};

// Baştan yapmalıydıkimport { SchemaRegistry } from '@aws-sdk/client-schemas';
const registry = new SchemaRegistry({});
// Schema'yı versiyonlama ile tanımlaconst orderSchema = {  openapi: '3.0.0',  info: {    version: '1.0.0',    title: 'OrderPlaced'  },  paths: {},  components: {    schemas: {      OrderPlaced: {        type: 'object',        required: ['orderId', 'customerId', 'items', 'totalAmount'],        properties: {          orderId: { type: 'string', pattern: '^ord-[0-9a-f]{8} },          customerId: { type: 'string', pattern: '^cust-[0-9a-f]{8} },          items: {            type: 'array',            items: {              $ref: '#/components/schemas/OrderItem'            }          },          totalAmount: {            $ref: '#/components/schemas/Money'          }        }      }    }  }};
// Yayınlamadan önce doğrulaconst validateAndPublish = async (event: any) => {  const validation = await registry.validateSchema(event, 'OrderPlaced', '1.0.0');  if (!validation.valid) {    throw new Error(`Schema doğrulama başarısız: ${validation.errors}`);  }  return await eventBridge.putEvents({ Entries: [event] });};

// Observability-first yaklaşımclass InstrumentedEventPublisher {  private metrics: MetricsClient;  private tracer: Tracer;
  async publish(event: Event): Promise<void> {    const span = this.tracer.startSpan('event.publish');    const timer = this.metrics.startTimer('event.publish.duration');
    try {      // Event'e trace context ekle      event.traceContext = {        traceparent: span.spanContext().traceId,        tracestate: span.spanContext().traceState      };
      await this.eventBridge.putEvents({        Entries: [{          ...event,          Detail: JSON.stringify({            ...JSON.parse(event.Detail),            _metadata: {              timestamp: Date.now(),              account: process.env.AWS_ACCOUNT_ID,              service: process.env.SERVICE_NAME,              version: process.env.SERVICE_VERSION,              traceId: span.spanContext().traceId            }          })        }]      });
      this.metrics.increment('event.published', {        type: event.DetailType,        source: event.Source      });
    } catch (error) {      this.metrics.increment('event.publish.error', {        type: event.DetailType,        error: error.name      });      span.recordException(error);      throw error;    } finally {      timer.end();      span.end();    }  }}

// Hemen inşa etmeliydikimport { Organizations } from '@aws-sdk/client-organizations';import { ControlTower } from '@aws-sdk/client-controltower';
class AccountVendingMachine {  async createTeamAccount(team: TeamConfig): Promise<AWSAccount> {    // 1. Control Tower üzerinden hesap oluştur    const account = await this.controlTower.createAccount({      accountName: `quickgrocer-${team.name}-${team.environment}`,      accountEmail: `aws+${team.name}+${team.environment}@quickgrocer.com`,      organizationalUnit: this.getOUForTeam(team),
      // Baseline konfigürasyon      baselineConfig: {        enableCloudTrail: true,        enableConfig: true,        enableSecurityHub: true,        enableGuardDuty: true,        budgetLimit: team.monthlyBudget      }    });
    // 2. Takıma özel SCP'leri uygula    await this.applyServiceControlPolicies(account.id, team.permissions);
    // 3. Cross-account rolleri kur    await this.setupCrossAccountRoles(account.id, {      identityServiceRole: 'arn:aws:iam::000000000000:role/identity-validator',      eventBusRole: 'arn:aws:iam::121212121212:role/event-publisher'    });
    // 4. Baseline altyapıyı deploy et    await this.deployBaseline(account.id, {      vpcCidr: this.allocateVpcCidr(team),      eventBusArn: 'arn:aws:events:us-east-1:121212121212:event-bus/central-bus',      logGroupRetention: 30    });
    return account;  }}

// İlk günden multi-region ayları kurtarırdıconst multiRegionStack = new Stack(app, 'MultiRegionInfra', {  env: {    account: process.env.CDK_DEFAULT_ACCOUNT,    region: process.env.CDK_DEFAULT_REGION  }});
// Birden fazla bölgeye deploy et['us-east-1', 'eu-west-1', 'ap-southeast-1'].forEach(region => {  new RegionalStack(app, `Regional-${region}`, {    env: { region },    eventBusArn: `arn:aws:events:${region}:121212121212:event-bus/central-bus`,    // Regional event routing    eventRouting: {      primary: region,      failover: getFailoverRegion(region)    }  });});