Serverless Framework'ten AWS CDK'ya Geçiş: Bölüm 6 - Production İpuçları

// lib/stacks/production-blue-green-stack.tsimport { Stack, StackProps, Tags, CfnOutput, Duration } from 'aws-cdk-lib';import { Construct } from 'constructs';import { RestApi, Deployment, Stage, MethodLoggingLevel, LambdaIntegration } from 'aws-cdk-lib/aws-apigateway';import { Alarm, Metric, ComparisonOperator, TreatMissingData } from 'aws-cdk-lib/aws-cloudwatch';import { LambdaAction } from 'aws-cdk-lib/aws-cloudwatch-actions';import { PolicyStatement } from 'aws-cdk-lib/aws-iam';import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
export interface BlueGreenStackProps extends StackProps {  stage: string;  environment: 'blue' | 'green';  monitoringConfig: {    errorThreshold: number;    latencyThreshold: number;    rollbackFunction: NodejsFunction;  };}
export class ProductionBlueGreenStack extends Stack {  public readonly api: RestApi;  public readonly healthCheckEndpoint: string;  public readonly switchOverFunction: NodejsFunction;
  constructor(scope: Construct, id: string, props: BlueGreenStackProps) {    super(scope, id, props);
    // Tam CDK infrastructure oluştur    this.api = new RestApi(this, 'Api', {      restApiName: `my-service-${props.stage}-${props.environment}`,      description: `Production API - ${props.environment.toUpperCase()} environment`,      deployOptions: {        stageName: props.environment,        // Migration sırasında güvenlik için agresif throttling        throttlingRateLimit: props.environment === 'green' ? 500 : 1000,        throttlingBurstLimit: props.environment === 'green' ? 1000 : 2000,        // Migration sırasında gelişmiş monitoring        metricsEnabled: true,        loggingLevel: MethodLoggingLevel.INFO,        dataTraceEnabled: true,        tracingEnabled: true,      },    });
    // Tüm Lambda fonksiyonlarını deploy et    const functions = this.createLambdaFunctions(props);
    // API route'ları kur    this.setupApiRoutes(functions);
    // Monitoring için health check endpoint oluştur    const healthCheckFn = new NodejsFunction(this, 'HealthCheckFunction', {      entry: 'src/health/health-check.ts',      handler: 'handler',      environment: {        ENVIRONMENT: props.environment,        API_VERSION: process.env.API_VERSION || 'v1',        DEPLOYMENT_TIME: new Date().toISOString(),      },    });
    const healthResource = this.api.root.addResource('health');    healthResource.addMethod('GET', new LambdaIntegration(healthCheckFn));
    this.healthCheckEndpoint = `${this.api.url}health`;
    // Production monitoring alarm'ları oluştur    this.createProductionAlarms(props);
    // Traffic switching fonksiyonu    this.switchOverFunction = this.createSwitchOverFunction(props);
    // Tanımlama için tüm kaynakları tagla    Tags.of(this).add('Environment', props.environment);    Tags.of(this).add('MigrationPhase', 'cdk-migration');    Tags.of(this).add('DeploymentTime', new Date().toISOString());    Tags.of(this).add('Version', process.env.COMMIT_SHA || 'latest');
    // Kritik bilgileri export et    new CfnOutput(this, 'ApiEndpoint', {      value: this.api.url,      exportName: `${this.stackName}-api-endpoint`,      description: `API endpoint for ${props.environment} environment`,    });
    new CfnOutput(this, 'HealthCheckUrl', {      value: this.healthCheckEndpoint,      exportName: `${this.stackName}-health-check`,      description: 'Health check endpoint for monitoring',    });  }
  private createProductionAlarms(props: BlueGreenStackProps) {    // Error rate alarm - rollback tetikler    const errorAlarm = new Alarm(this, 'HighErrorRateAlarm', {      metric: this.api.metricServerError({        period: Duration.minutes(2),        statistic: 'Sum',      }),      threshold: props.monitoringConfig.errorThreshold,      evaluationPeriods: 2,      comparisonOperator: ComparisonOperator.GREATER_THAN_THRESHOLD,      alarmDescription: `High error rate detected in ${props.environment} environment`,      treatMissingData: TreatMissingData.NOT_BREACHING,    });
    // Latency alarm - araştırma tetikler    const latencyAlarm = new Alarm(this, 'HighLatencyAlarm', {      metric: this.api.metricLatency({        period: Duration.minutes(5),        statistic: 'Average',      }),      threshold: props.monitoringConfig.latencyThreshold,      evaluationPeriods: 3,      alarmDescription: `High latency detected in ${props.environment} environment`,    });
    // Alarm'ları otomatik rollback'e bağla    errorAlarm.addAlarmAction(      new LambdaAction(props.monitoringConfig.rollbackFunction)    );
    // External monitoring için alarm ARN'lerini export et    new CfnOutput(this, 'ErrorAlarmArn', {      value: errorAlarm.alarmArn,      exportName: `${this.stackName}-error-alarm`,    });  }
  private createSwitchOverFunction(props: BlueGreenStackProps) {    return new NodejsFunction(this, 'TrafficSwitchFunction', {      entry: 'src/deployment/traffic-switch.ts',      handler: 'handler',      timeout: Duration.minutes(5),      environment: {        CURRENT_ENVIRONMENT: props.environment,        TARGET_ENVIRONMENT: props.environment === 'blue' ? 'green' : 'blue',        HOSTED_ZONE_ID: process.env.HOSTED_ZONE_ID!,        DOMAIN_NAME: process.env.API_DOMAIN!,        SLACK_WEBHOOK_URL: process.env.SLACK_WEBHOOK_URL!,      },      initialPolicy: [        new PolicyStatement({          actions: ['route53:ChangeResourceRecordSets', 'route53:GetChange'],          resources: ['*'],        }),      ],    });  }}
// src/health/health-check.ts - Kapsamlı health validationimport { APIGatewayProxyHandler } from 'aws-lambda';import { DynamoDBClient, DescribeTableCommand } from '@aws-sdk/client-dynamodb';
const dynamoDB = new DynamoDBClient({});
export const handler: APIGatewayProxyHandler = async () => {  const startTime = Date.now();  const checks = [];
  try {    // Database connectivity check    const tableCheck = await dynamoDB.send(new DescribeTableCommand({      TableName: process.env.USERS_TABLE!,    }));    checks.push({      name: 'database',      status: tableCheck.Table?.TableStatus === 'ACTIVE' ? 'healthy' : 'unhealthy',      responseTime: Date.now() - startTime,    });
    // Memory usage check    const memoryUsed = process.memoryUsage();    checks.push({      name: 'memory',      status: memoryUsed.heapUsed < 100 * 1024 * 1024 ? 'healthy' : 'warning', // 100MB threshold      details: {        heapUsed: Math.round(memoryUsed.heapUsed / 1024 / 1024) + 'MB',        heapTotal: Math.round(memoryUsed.heapTotal / 1024 / 1024) + 'MB',      },    });
    const overallStatus = checks.every(check => check.status === 'healthy') ? 'healthy' : 'degraded';
    return {      statusCode: overallStatus === 'healthy' ? 200 : 503,      headers: {        'Content-Type': 'application/json',        'Cache-Control': 'no-cache',      },      body: JSON.stringify({        status: overallStatus,        environment: process.env.ENVIRONMENT,        version: process.env.API_VERSION,        deploymentTime: process.env.DEPLOYMENT_TIME,        timestamp: new Date().toISOString(),        responseTime: Date.now() - startTime,        checks,      }),    };  } catch (error) {    return {      statusCode: 503,      headers: { 'Content-Type': 'application/json' },      body: JSON.stringify({        status: 'unhealthy',        error: error.message,        timestamp: new Date().toISOString(),      }),    };  }};

// test/infrastructure/api-stack.test.tsimport { Template, Match } from 'aws-cdk-lib/assertions';import { App } from 'aws-cdk-lib';import { ApiStack } from '../../lib/stacks/api-stack';
describe('ApiStack', () => {  let template: Template;
  beforeAll(() => {    const app = new App();    const stack = new ApiStack(app, 'TestStack', {      config: testConfig,    });    template = Template.fromStack(stack);  });
  test('Lambda functions have correct runtime', () => {    template.allResourcesProperties('AWS::Lambda::Function', {      Runtime: 'nodejs20.x',    });  });
  test('API Gateway has throttling enabled', () => {    template.hasResourceProperties('AWS::ApiGateway::Stage', {      ThrottlingRateLimit: Match.anyValue(),      ThrottlingBurstLimit: Match.anyValue(),    });  });
  test('DynamoDB tables have point-in-time recovery', () => {    template.allResourcesProperties('AWS::DynamoDB::Table', {      PointInTimeRecoverySpecification: {        PointInTimeRecoveryEnabled: true,      },    });  });});

// test/integration/api.test.tsimport { CloudFormationClient } from '@aws-sdk/client-cloudformation';import { ApiGatewayClient } from '@aws-sdk/client-api-gateway';import axios from 'axios';
describe('API Integration Tests', () => {  let apiEndpoint: string;  let authToken: string;
  beforeAll(async () => {    // Deploy edilmiş API endpoint'ini al    const cf = new CloudFormationClient({});    const exports = await cf.send(new ListExportsCommand({}));    apiEndpoint = exports.Exports?.find(      e => e.Name === 'ApiStack-endpoint'    )?.Value!;
    // Auth token al    authToken = await getTestAuthToken();  });
  test('Health check endpoint', async () => {    const response = await axios.get(`${apiEndpoint}/health`);    expect(response.status).toBe(200);    expect(response.data).toEqual({ status: 'healthy' });  });
  test('Create and retrieve user', async () => {    // User oluştur    const createResponse = await axios.post(      `${apiEndpoint}/users`,      { name: 'Test User', email: '[email protected]' },      { headers: { Authorization: `Bearer ${authToken}` } }    );    expect(createResponse.status).toBe(201);
    // User'ı getir    const userId = createResponse.data.userId;    const getResponse = await axios.get(      `${apiEndpoint}/users/${userId}`,      { headers: { Authorization: `Bearer ${authToken}` } }    );    expect(getResponse.data.name).toBe('Test User');  });});

// test/load/k6-script.jsimport http from 'k6/http';import { check, sleep } from 'k6';import { Rate } from 'k6/metrics';
const errorRate = new Rate('errors');
export const options = {  stages: [    { duration: '2m', target: 100 },  // Ramp up    { duration: '5m', target: 100 },  // Sustain    { duration: '2m', target: 200 },  // Spike    { duration: '5m', target: 200 },  // Sustain spike    { duration: '2m', target: 0 },    // Ramp down  ],  thresholds: {    http_req_duration: ['p(95)<500'], // Request'lerin 95%'i 500ms altında    errors: ['rate<0.01'],            // Error oranı 1% altında  },};
export default function() {  const response = http.get(`${__ENV.API_URL}/users`);
  const success = check(response, {    'status is 200': (r) => r.status === 200,    'response time < 500ms': (r) => r.timings.duration < 500,  });
  errorRate.add(!success);  sleep(1);}

// lib/constructs/deployment/safe-deployment.tsexport class SafeDeployment extends Construct {  constructor(scope: Construct, id: string, props: {    api: RestApi;    alarmThreshold: number;    rollbackFunction: IFunction;  }) {    super(scope, id);
    // CloudWatch alarm oluştur    const alarm = new Alarm(this, 'DeploymentAlarm', {      metric: props.api.metricServerError(),      threshold: props.alarmThreshold,      evaluationPeriods: 2,      treatMissingData: TreatMissingData.NOT_BREACHING,    });
    // Bildirimler için SNS topic    const topic = new Topic(this, 'RollbackTopic');    alarm.addAlarmAction(new SnsAction(topic));
    // Otomatik rollback için Lambda    topic.addSubscription(      new LambdaSubscription(props.rollbackFunction)    );
    // Manuel rollback komutu    new CfnOutput(this, 'RollbackCommand', {      value: `aws lambda invoke --function-name ${props.rollbackFunction.functionName} --payload '{"action":"rollback"}' response.json`,    });  }}
// src/deployment/rollback-handler.tsexport const handler = async (event: SNSEvent) => {  console.log('Initiating rollback:', JSON.stringify(event, null, 2));
  const codedeploy = new CodeDeployClient({});
  // Mevcut deployment'ı durdur  await codedeploy.send(new StopDeploymentCommand({    deploymentId: process.env.CURRENT_DEPLOYMENT_ID,    autoRollbackEnabled: true,  }));
  // Traffic'i önceki versiyona döndür  await switchTraffic('blue'); // Green başarısız olduğunu varsayarak
  // Ekibi bilgilendir  await notifySlack({    channel: '#alerts',    message: 'Automatic rollback initiated due to high error rate',  });};

// lib/constructs/performance/optimized-function.tsexport class OptimizedFunction extends ServerlessFunction {  constructor(scope: Construct, id: string, props: ServerlessFunctionProps & {    enableProvisioning?: boolean;    enableSnapStart?: boolean;  }) {    super(scope, id, {      ...props,      memorySize: props.memorySize || 1024,      architecture: Architecture.ARM_64, // Daha iyi price/performance      environment: {        ...props.environment,        NODE_OPTIONS: '--enable-source-maps --max-old-space-size=896',        AWS_NODEJS_CONNECTION_REUSE_ENABLED: '1',      },    });
    // Kritik fonksiyonlar için provisioned concurrency    if (props.enableProvisioning && props.config.stage === 'prod') {      const version = this.currentVersion;
      new CfnAlias(this, 'ProvisionedAlias', {        functionName: this.functionName,        functionVersion: version.version,        name: 'provisioned',        provisionedConcurrencyConfig: {          provisionedConcurrentExecutions: 5,        },      });    }
    // Java fonksiyonları için SnapStart    if (props.enableSnapStart) {      const cfnFunction = this.node.defaultChild as CfnFunction;      cfnFunction.snapStart = {        applyOn: 'PublishedVersions',      };    }  }}

// lib/constructs/performance/cached-api.tsexport class CachedApi extends RestApi {  constructor(scope: Construct, id: string, props: RestApiProps & {    cacheConfig?: {      ttlMinutes: number;      encrypted: boolean;      clusterSize: string;    };  }) {    super(scope, id, {      ...props,      deployOptions: {        ...props.deployOptions,        cachingEnabled: true,        cacheClusterEnabled: true,        cacheClusterSize: props.cacheConfig?.clusterSize || '0.5',        cacheDataEncrypted: props.cacheConfig?.encrypted ?? true,        cacheTtl: Duration.minutes(props.cacheConfig?.ttlMinutes || 5),        methodOptions: {          '/*/*': {            cachingEnabled: true,            cacheKeyParameters: [              'method.request.path.proxy',              'method.request.querystring.page',            ],          },        },      },    });  }}

// lib/stacks/monitoring-stack.tsexport class MonitoringStack extends Stack {  constructor(scope: Construct, id: string, props: {    apiStack: ApiStack;    stage: string;  }) {    super(scope, id);
    // Dashboard oluştur    const dashboard = new Dashboard(this, 'ServiceDashboard', {      dashboardName: `my-service-${props.stage}`,    });
    // API metrikleri    dashboard.addWidgets(      new GraphWidget({        title: 'API Requests',        left: [props.apiStack.api.metricCount()],        right: [props.apiStack.api.metricLatency()],      }),      new GraphWidget({        title: 'API Errors',        left: [          props.apiStack.api.metric4XXError(),          props.apiStack.api.metric5XXError(),        ],      })    );
    // Lambda metrikleri    const lambdaWidgets = props.apiStack.functions.map(fn =>      new GraphWidget({        title: `${fn.functionName} Performance`,        left: [fn.metricInvocations()],        right: [fn.metricDuration()],      })    );    dashboard.addWidgets(...lambdaWidgets);
    // Alarmlar    this.createAlarms(props.apiStack);  }
  private createAlarms(apiStack: ApiStack) {    // API Gateway alarmları    new Alarm(this, 'HighErrorRate', {      metric: apiStack.api.metric5XXError({        period: Duration.minutes(5),        statistic: 'Sum',      }),      threshold: 10,      evaluationPeriods: 2,    });
    // Lambda alarmları    apiStack.functions.forEach(fn => {      new Alarm(this, `${fn.node.id}Throttles`, {        metric: fn.metricThrottles(),        threshold: 5,        evaluationPeriods: 2,      });
      new Alarm(this, `${fn.node.id}Errors`, {        metric: fn.metricErrors(),        threshold: 10,        evaluationPeriods: 2,      });    });  }}

// lib/constructs/observability/tracing.tsexport class TracedFunction extends OptimizedFunction {  constructor(scope: Construct, id: string, props: ServerlessFunctionProps) {    super(scope, id, {      ...props,      tracing: Tracing.ACTIVE,      environment: {        ...props.environment,        _X_AMZN_TRACE_ID: process.env._X_AMZN_TRACE_ID || '',        AWS_XRAY_CONTEXT_MISSING: 'LOG_ERROR',        AWS_XRAY_LOG_LEVEL: 'error',      },    });
    // X-Ray izinleri ekle    this.addToRolePolicy(new PolicyStatement({      actions: [        'xray:PutTraceSegments',        'xray:PutTelemetryRecords',      ],      resources: ['*'],    }));  }}
// src/libs/tracing.tsimport { Tracer } from '@aws-lambda-powertools/tracer';
const tracer = new Tracer({  serviceName: process.env.SERVICE_NAME || 'my-service',});
export function traceMethod(  target: any,  propertyKey: string,  descriptor: PropertyDescriptor) {  const originalMethod = descriptor.value;
  descriptor.value = async function(...args: any[]) {    const segment = tracer.getSegment();    const subsegment = segment?.addNewSubsegment(propertyKey);
    try {      const result = await originalMethod.apply(this, args);      subsegment?.close();      return result;    } catch (error) {      subsegment?.addError(error as Error);      subsegment?.close();      throw error;    }  };
  return descriptor;}

// Hardcoded isimlerden kaçın// Kötüconst table = new Table(this, 'Table', {  tableName: 'users-table', // Varsa çakışır});
// İyiconst table = new Table(this, 'Table', {  tableName: `${props.serviceName}-${props.stage}-users`,});

// Stateful ve stateless kaynakları ayırconst app = new App();
// Stateful kaynaklar ayrı stack'teconst dataStack = new DataStack(app, 'DataStack', {  terminationProtection: true,});
// Stateless kaynaklar serbestçe güncellenebilirconst apiStack = new ApiStack(app, 'ApiStack', {  tables: dataStack.tables,});

// Serverless variable'larını CDK'ya maplaconst legacyMappings: Record<string, string> = {  '${self:service}': props.serviceName,  '${opt:stage}': props.stage,  '${opt:region}': Stack.of(this).region,  '${cf:OtherStack.Output}': Fn.importValue('OtherStack-Output'),};