AWS DevTools ve CDK ile Bulut Altyapısı Yönetimi Rehberi

Bulut altyapısını yönetmek, günümüzün hızla değişen dijital dünyasında birçok geliştirici ve operasyon ekibi için karmaşık bir meydan okuma haline geldi. Manuel süreçlerin getirdiği hatalar, tutarsızlıklar ve yavaşlıklar, projelerin teslimat sürelerini ve kalitesini doğrudan etkiliyor. Peki, bu karmaşıklığı otomatize etmek, daha hızlı ve güvenilir bir şekilde bulut kaynakları oluşturmak mümkün mü? AWS Cloud Development Kit (CDK) ve DevTools’un entegre gücüyle bu sorunun cevabı evet! Bu kapsamlı rehberde, AWS CDK’nın temellerinden başlayarak, DevTools entegrasyonuyla uçtan uca CI/CD süreçlerini nasıl kuracağınızı, test edeceğinizi ve altyapınızı kod olarak nasıl yöneteceğinizi adım adım keşfedeceğiz. Geliştirme süreçlerinizi optimize etmek ve bulut altyapınızı daha verimli hale getirmek için ihtiyacınız olan her şeyi bu makalede bulacaksınız.

Modern yazılım geliştirme dünyasında, ürünleri hızla pazara sunma ve sürekli yenilik yapma baskısı her zamankinden daha yoğun. Bu dinamik ortamda, DevOps kültürü ve otomasyon araçları vazgeçilmez bir hale geldi. Geleneksel yöntemlerle, bir uygulama geliştirildiğinde, altyapının manuel olarak kurulması, yapılandırılması ve dağıtılması hem zaman alıcı hem de hataya açık bir süreçti. Bu durum, geliştirme ve operasyon ekipleri arasında sürtüşmelere yol açarak verimliliği düşürüyordu.

İşte tam da bu noktada, AWS DevTools devreye giriyor. AWS DevTools paketi, yazılım geliştirme yaşam döngüsünün her aşamasını otomatize etmek için tasarlanmış entegre hizmetler sunar: CodeCommit ile güvenli kod depolama, CodeBuild ile kod derleme ve test etme, CodeDeploy ile otomatik uygulama dağıtımı ve CodePipeline ile tüm bu adımları kapsayan uçtan uca CI/CD (Sürekli Entegrasyon/Sürekli Dağıtım) boru hatları oluşturma imkanı sunulur. Bu araçlar, geliştiricilerin sadece kod yazmaya odaklanmasını sağlarken, operasyon ekiplerinin de daha az manuel müdahale ile istikrarlı ve güvenilir sistemler yönetmesine olanak tanır.

Otomasyonun getirdiği en büyük faydalardan biri, insan kaynaklı hataları minimuma indirmesidir. Her dağıtımın aynı adımları izlemesi, tutarlılık sağlar ve “benim makinemde çalışıyordu” sendromunu ortadan kaldırır. Ayrıca, dağıtım sürelerini kısaltarak ekiplerin daha sık ve güvenli bir şekilde üretim ortamına değişiklik göndermesine olanak tanır. Bu da, ürünlerin daha hızlı olgunlaşmasını, müşteri geri bildirimlerinin daha çabuk değerlendirilmesini ve rekabet avantajı elde edilmesini sağlar. Kısacası, AWS DevTools, modern DevOps uygulamalarının temelini oluşturarak, ekiplerin daha çevik, verimli ve güvenilir çalışmasına katkıda bulunur. Bu araçların AWS CDK ile nasıl birleştiğini ilerleyen bölümlerde daha detaylı inceleyeceğiz.

AWS CDK Nedir ve Geleneksel IaC Yaklaşımlarından Farkı Nedir?

Bulut altyapısı yönetimi, yıllar içinde YAML ve JSON tabanlı şablon dosyaları (örneğin AWS CloudFormation) aracılığıyla “Altyapıyı Kod Olarak” (Infrastructure as Code – IaC) tanımlama pratikleriyle büyük bir evrim geçirdi. Ancak bu deklaratif yaklaşımlar, özellikle büyük ve karmaşık altyapılar için, tekrar eden kod blokları, sınırlı soyutlama yetenekleri ve geleneksel programlama dillerinin sunduğu test, döngü veya koşullu mantık gibi özelliklerden yoksun olması nedeniyle zorluklar yaratabiliyordu.

İşte tam bu noktada, AWS Cloud Development Kit (CDK) sahneye çıkıyor ve IaC dünyasına yepyeni bir soluk getiriyor. AWS CDK, bilinen programlama dillerini (TypeScript, Python, Java, C#, Go) kullanarak bulut altyapınızı tanımlamanıza olanak tanıyan açık kaynaklı bir yazılım geliştirme çerçevesidir. Geliştiriciler, daha önce uygulama kodu yazarken kullandıkları aynı dil, araçlar ve yazılım mühendisliği prensipleriyle bulut kaynaklarını modelleyebilirler. CDK, bu üst düzey programlama dili kodunu alıp, AWS CloudFormation şablonlarına dönüştürür. Bu sürece “synthesis” (sentez) adı verilir.

CDK’nın en büyük farkı, geleneksel IaC yaklaşımlarının sunduğu deklaratif yapıya, imperatif programlama gücünü entegre etmesidir. Bu sayede:

• Soyutlama ve Yeniden Kullanım: CDK, “Construct” adı verilen yeniden kullanılabilir bulut kaynakları modülleri sunar. Bir S3 bucket’ı, bir Lambda fonksiyonu veya karmaşık bir VPC yapısı, tek bir Construct içinde kapsüllenerek kolayca yeniden kullanılabilir. Bu, altyapı kodunuzu daha modüler ve yönetilebilir hale getirir.
• Tanıdık Programlama Dilleri: Geliştiriciler, yeni bir IaC dilini öğrenmek zorunda kalmadan, bildikleri dillerle çalışabilirler. Bu, öğrenme eğrisini önemli ölçüde azaltır ve ekiplerin benimsemesini kolaylaştırır.
• Test Edilebilirlik: Programlama dillerinin gücü sayesinde, altyapı kodunuzu birim testleri (unit tests) ve snapshot testleri ile kolayca test edebilirsiniz. Bu, dağıtım öncesi hataları yakalamanıza ve güvenilirliği artırmanıza yardımcı olur.
• Gelişmiş Mantık: Döngüler, koşullu ifadeler, fonksiyonlar ve sınıflar gibi programlama diline özgü yapıları kullanarak, dinamik ve karmaşık altyapı senaryolarını çok daha zarif bir şekilde yönetebilirsiniz.

Kısacası, CDK, sadece altyapıyı kod olarak değil, altyapıyı yazılım olarak ele alarak, modern yazılım geliştirme prensiplerini bulut altyapısı yönetimine taşır. Bu sayede, daha okunabilir, sürdürülebilir ve güvenilir bulut çözümleri oluşturmak mümkün hale gelir. Şimdi CDK’ya ilk adımlarımızı atalım.

Uygulamalı CDK: İlk Bulut Kaynaklarımızı Nasıl Oluştururuz?

AWS CDK’nın gücünü tam olarak anlamak için, somut bir örnek üzerinden ilerlemek en iyisidir. İlk olarak, bir CDK projesi nasıl başlatılır ve basit bir S3 bucket’ı nasıl oluşturulur, birlikte inceleyelim. Bu adımlar, CDK’nın temel yapı taşlarını ve işleyişini anlamanıza yardımcı olacaktır.

CDK Kurulumu ve Proje Başlatma:

Öncelikle, sisteminizde Node.js (ve npm) kurulu olması gerekmektedir. Ardından, AWS CLI’nin yapılandırıldığından ve uygun kimlik bilgileriyle AWS ortamına erişebildiğinizden emin olun. CDK Toolkit’i global olarak kurmak için aşağıdaki komutu kullanın:

npm install -g aws-cdk
  

Şimdi yeni bir CDK projesi başlatalım. Bu örnekte TypeScript kullanacağız, ancak Python veya tercih ettiğiniz başka bir dil de seçebilirsiniz:

mkdir my-first-cdk-app
cd my-first-cdk-app
cdk init app --language typescript
  

Bu komut, bir dizi dosya ve klasör içeren yeni bir CDK uygulaması oluşturacaktır. En önemli dosya, lib/my-first-cdk-app-stack.ts içinde yer alan ana yığın (stack) tanımımızdır. Ayrıca, cdk.json dosyası CDK uygulamanızın yapılandırmasını içerir.

Basit Bir S3 Bucket Oluşturma:

Şimdi lib/my-first-cdk-app-stack.ts dosyasını açalım ve içeriğini aşağıdaki gibi düzenleyelim. Bu, varsayılan bir S3 bucket oluşturacaktır.

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as s3 from 'aws-cdk-lib/aws-s3'; // S3 modülünü import ediyoruz

export class MyFirstCdkAppStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Yeni bir S3 bucket oluşturuyoruz
    new s3.Bucket(this, 'MySimpleBucket', {
      versioned: true, // S3 bucket'ın sürüm kontrolünü açıyoruz
      removalPolicy: cdk.RemovalPolicy.DESTROY, // Stack silindiğinde bucket'ın da silinmesini sağlar (dikkatli kullanılmalı!)
      autoDeleteObjects: true // Bucket silinirken içindeki objelerin de otomatik silinmesini sağlar
    });

    // İsterseniz çıktı (output) tanımlayarak bucket adını görebilirsiniz
    new cdk.CfnOutput(this, 'BucketNameOutput', {
      value: this.getLogicalId(new s3.Bucket(this, 'MySimpleBucket').node.defaultChild as s3.CfnBucket)
    });
  }
}
  

Yukarıdaki kodda, aws-cdk-lib/aws-s3 modülünü import ettik ve s3.Bucket sınıfını kullanarak basit bir S3 bucket tanımladık. removalPolicy ve autoDeleteObjects özelliklerini geliştirme ortamları için pratik hale getirdik, ancak üretim ortamlarında RETAIN kullanmak daha güvenli olabilir.

CDK Uygulamasını Dağıtma:

Değişiklikleri kaydettikten sonra, CDK'nın bu kodu CloudFormation şablonuna dönüştürmesini (synthesize) ve dağıtmasını sağlayabiliriz:

1. Sentezleme (Synthesize): Bu komut, TypeScript kodunuzu derler ve karşılık gelen CloudFormation JSON şablonunu cdk.out dizinine çıkarır.

npm run build
cdk synth
    

2. Farkları Gösterme (Diff): Dağıtım yapmadan önce mevcut AWS ortamınız ile yeni altyapı kodunuz arasındaki farkları görmek için:

cdk diff
    

3. Dağıtma (Deploy): Bu komut, sentezlenmiş CloudFormation şablonunu AWS'ye dağıtır ve kaynakları oluşturur.

cdk deploy
    

CDK sizden onay isteyecek ve onaylamanızın ardından S3 bucket'ınız AWS hesabınızda oluşturulacaktır. Bu, AWS CDK ile ilk bulut kaynağınızı başarıyla oluşturduğunuz anlamına gelir. Bu temel yapı üzerine daha karmaşık altyapılar inşa edebilirsiniz.

CDK ile CI/CD Boru Hattı Kurulumu: Otomatik Dağıtımın Sırları

Bulut altyapınızı kod olarak tanımlamak harika bir başlangıçtır, ancak bu altyapının sürekli ve güvenilir bir şekilde dağıtılabilmesi için otomatik bir CI/CD boru hattına ihtiyacınız var. AWS CDK, bu boru hatlarının kendisini de kod olarak tanımlamanıza olanak tanır, böylece uçtan uca altyapınızın ve dağıtım süreçlerinizin versiyonlanabilir, tekrarlanabilir ve test edilebilir olmasını sağlarsınız. Şimdi, bir CDK uygulamasını kullanarak temel bir CI/CD boru hattını nasıl kuracağımızı inceleyelim.

CDK ile CodePipeline Tanımlama:

Bu örnekte, kodumuzu AWS CodeCommit'te depolayacak, CodeBuild ile derleyip test edecek ve son olarak CDK stack'imizi dağıtacak bir boru hattı oluşturacağız. Öncelikle, gerekli CDK modüllerini import etmemiz gerekiyor:

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as codecommit from 'aws-cdk-lib/aws-codecommit';
import * as codepipeline from 'aws-cdk-lib/aws-codepipeline';
import * as codepipeline_actions from 'aws-cdk-lib/aws-codepipeline-actions';
import * as codebuild from 'aws-cdk-lib/aws-codebuild';

export class CdkCicdPipelineStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // 1. CodeCommit deposu oluştur
    const repo = new codecommit.Repository(this, 'MyAwesomeAppRepo', {
      repositoryName: 'my-awesome-app'
    });

    // 2. CodePipeline için Artifact (yapıt) tanımlamaları
    const sourceOutput = new codepipeline.Artifact();
    const cdkBuildOutput = new codepipeline.Artifact('CdkBuildOutput');

    // 3. CodeBuild projesi oluştur - CDK kodumuzu derleyecek ve sentezleyecek
    const cdkBuild = new codebuild.PipelineProject(this, 'CdkBuildProject', {
      buildSpec: codebuild.BuildSpec.fromObject({
        version: '0.2',
        phases: {
          install: { commands: ['npm install'] },
          build: { commands: ['npm run build', 'npx cdk synth -o dist'] }, // -o dist: CloudFormation şablonlarını dist klasörüne çıkar
        },
        artifacts: {
          'base-directory': 'dist', // dist klasöründeki çıktıları yakala
          files: ['**/*'],
        },
      }),
      environment: {
        buildImage: codebuild.LinuxBuildImage.STANDARD_5_0,
      },
    });

    // 4. CodePipeline oluştur
    new codepipeline.Pipeline(this, 'MyAwesomeAppPipeline', {
      pipelineName: 'MyAwesomeAppDeploymentPipeline',
      stages: [
        {
          stageName: 'Source',
          actions: [
            new codepipeline_actions.CodeCommitSourceAction({
              actionName: 'CodeCommit_Source',
              repository: repo,
              output: sourceOutput,
              branch: 'main', // Değişiklikleri izleyeceğimiz dal
            }),
          ],
        },
        {
          stageName: 'Build',
          actions: [
            new codepipeline_actions.CodeBuildAction({
              actionName: 'CDK_Build',
              project: cdkBuild,
              input: sourceOutput,
              outputs: [cdkBuildOutput],
            }),
          ],
        },
        {
          stageName: 'Deploy',
          actions: [
            new codepipeline_actions.CloudFormationDeployStackAction({
              actionName: 'CDK_Deploy',
              templatePath: cdkBuildOutput.atPath('MyFirstCdkAppStack.template.json'), // Sentezlenen şablon dosyası
              stackName: 'MyFirstCdkAppStack', // Dağıtılacak CloudFormation stack'inin adı
              adminPermissions: true, // Dağıtım için yönetici izinleri ver
            }),
          ],
        },
      ],
    });
  }
}
  

Yukarıdaki kod, bir AWS CodeCommit deposu oluşturur, ardından bu depodaki kod değişikliklerini izleyen bir CodePipeline tanımlar. Derleme aşamasında (CodeBuild), CDK uygulamamızın TypeScript kodunu derler ve cdk synth komutuyla CloudFormation şablonlarını dist klasörüne çıkarırız. Son olarak, dağıtım aşamasında (CloudFormationDeployStackAction), bu sentezlenmiş şablonu kullanarak AWS CloudFormation stack'ini dağıtırız.

Bu boru hattını CDK ile dağıttıktan sonra, my-awesome-app CodeCommit deposuna her main dalına kod gönderdiğinizde, boru hattı otomatik olarak tetiklenecek, CDK kodunuzu derleyecek ve yeni altyapı değişikliklerinizi AWS ortamına dağıtacaktır. Bu, DevOps prensiplerinin temelini oluşturan hızlı, güvenilir ve tekrarlanabilir dağıtımları mümkün kılar. Altyapınız artık uygulama kodunuz gibi, versiyon kontrolü altında, test edilebilir ve otomatik olarak dağıtılabilir bir varlıktır.

Gelişmiş CDK Pratikleri: Test Etme ve Güvenli Dağıtım

Bir uygulamanın güvenilirliği ve sürdürülebilirliği, yazılım mühendisliği prensiplerinin altyapı koduna da uygulanmasıyla artırılır. AWS CDK, bu prensipleri IaC dünyasına taşıyarak altyapınızı test edilebilir ve güvenli bir şekilde dağıtılabilir hale getirir. Bu bölümde, CDK uygulamalarımızı nasıl test edeceğimizi ve üretim ortamına güvenli dağıtım stratejilerini nasıl uygulayacağımızı keşfedeceğiz.

CDK Uygulamalarımızı Nasıl Test Ederiz?

CDK, programlama dillerini kullandığı için, altyapı kodunuzu da birim testleri (unit tests) ve entegrasyon testleriyle doğrulamak mümkündür. Bu, hataları erken aşamada yakalayarak dağıtım risklerini önemli ölçüde azaltır.

Birim Testleri (Unit Tests) ve Snapshot Testleri:

CDK, Jest gibi popüler test çerçevelerini kullanarak stack'lerinizin ve Construct'larınızın beklenen çıktıları üretip üretmediğini kontrol etmenizi sağlar. En yaygın test türlerinden biri "snapshot testing"dir. Snapshot testleri, CDK uygulamanızın sentezlediği CloudFormation şablonunun anlık bir görüntüsünü alır ve bu görüntüyü gelecekteki değişikliklerle karşılaştırır. Beklenmedik bir değişiklik olursa test başarısız olur.

Örnek bir test (test/my-first-cdk-app.test.ts):

import * as cdk from 'aws-cdk-lib';
import { Template } from 'aws-cdk-lib/assertions';
import * as MyFirstCdkApp from '../lib/my-first-cdk-app-stack';

test('S3 Bucket Created', () => {
  const app = new cdk.App();
  // Stack'i örnekliyoruz
  const stack = new MyFirstCdkApp.MyFirstCdkAppStack(app, 'MyTestStack');
  // Template nesnesini oluşturuyoruz
  const template = Template.fromStack(stack);

  // S3 Bucket'ının varlığını kontrol et
  template.hasResourceProperties('AWS::S3::Bucket', {
    VersioningConfiguration: {
      Status: 'Enabled',
    },
  });

  // Snapshot testi - CloudFormation çıktısının değişip değişmediğini kontrol eder
  expect(template.toJSON()).toMatchSnapshot();
});
  

Bu test, oluşturduğumuz S3 bucket'ının sürüm kontrolünün etkin olduğunu doğrular ve CloudFormation şablonunun anlık görüntüsünü alır. Testleri çalıştırmak için npm test komutunu kullanabilirsiniz.

Entegrasyon Testleri:

Daha karmaşık senaryolarda, birden fazla stack veya servisin birbiriyle entegrasyonunu doğrulamak için entegrasyon testleri yazabilirsiniz. Bu testler genellikle gerçek AWS ortamında dağıtım yaparak ve dağıtılan kaynakların beklendiği gibi çalıştığını doğrulamak için API çağrıları yaparak gerçekleştirilir.

Güvenli ve Kademeli Dağıtım Stratejileri Nelerdir?

Üretim ortamına yapılan her dağıtım risk taşır. Bu riski azaltmak için CDK ile birlikte çeşitli güvenli dağıtım stratejileri kullanılabilir:

• Kademeli Dağıtım (Phased Rollouts): Uygulama güncellemelerini tüm kullanıcılara aynı anda değil, küçük bir alt kümeye (örneğin %10) dağıtarak başlarsınız. Sorun çıkmazsa, kademeli olarak daha fazla kullanıcıya yayarsınız. AWS CodeDeploy ve AWS Lambda gibi servisler bu tür dağıtımları destekler ve CDK ile kolayca yapılandırılabilir. Örneğin, bir Lambda fonksiyonunu güncellerken Canary dağıtımını CDK ile tanımlayabilirsiniz:

  
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  import * as codedeploy from 'aws-cdk-lib/aws-codedeploy';
  
  // ... lambda fonksiyonu tanımı ...
  const myLambda = new lambda.Function(this, 'MyLambdaFunction', {
    // ...
  });
  
  const alias = new lambda.Alias(this, 'LambdaAlias', {
    aliasName: 'prod',
    version: myLambda.currentVersion,
  });
  
  new codedeploy.LambdaDeploymentGroup(this, 'LambdaDeploymentGroup', {
    alias,
    deploymentConfig: codedeploy.LambdaDeploymentConfig.LINEAR_10PERCENT_EVERY_1MINUTE, // Kademeli dağıtım stratejisi
  });
        

• Mavi/Yeşil Dağıtım (Blue/Green Deployment): Mevcut üretim ortamınızın (mavi) bir kopyasını (yeşil) oluşturursunuz. Yeni kodu yeşil ortama dağıtırsınız, testleri çalıştırırsınız ve her şey yolundaysa, kullanıcı trafiğini yavaşça veya tamamen yeşil ortama yönlendirirsiniz. Sorun çıkarsa, trafiği hızla mavi ortama geri çekebilirsiniz. CDK, CloudFormation'ın değişim setleri ve DNS güncellemeleri (Route 53) ile bu deseni destekleyecek altyapıyı tanımlamanıza yardımcı olur.
• Geri Alma (Rollback) Mekanizmaları: Her dağıtımın bir geri alma stratejisi olmalıdır. CDK ile dağıtılan CloudFormation stack'leri, sorun anında önceki başarılı duruma otomatik olarak geri dönebilir veya manuel olarak geri alınabilir. Bu, dağıtım sırasında veya sonrasında ortaya çıkan kritik sorunlara karşı bir güvenlik ağı sağlar.

Bu test ve dağıtım stratejilerini CDK ile birleştirmek, altyapı yönetim süreçlerinizi daha güvenilir, esnek ve hataya dayanıklı hale getirir. Bu, özellikle büyük ve karmaşık sistemlerde, olası kesintileri minimuma indirirken, yeni özelliklerin hızla ve güvenle yayına alınmasına olanak tanır.

Vaka Çalışması: Çok Katmanlı Bir Uygulamanın CDK ile Yönetimi

Şimdiye kadar CDK'nın temellerini ve CI/CD entegrasyonunu gördük. Gerçek dünya senaryolarında, çoğu uygulamanın basit bir S3 bucket'tan çok daha fazlasına ihtiyacı vardır. Bir örnek vaka çalışması üzerinden, çok katmanlı bir uygulamanın (ön yüz, arka yüz API'si ve veritabanı) altyapısını AWS CDK ile nasıl yöneteceğimizi inceleyelim. Bu, CDK'nın modülerliğini, yeniden kullanılabilirliğini ve karmaşık mimarileri nasıl basitleştirdiğini gösterecektir.

Uygulama Mimarisi ve CDK Yaklaşımı:

Ele alacağımız uygulama, aşağıdaki bileşenlerden oluşmaktadır:

1. Ön Yüz (Frontend): React tabanlı statik bir web uygulaması, AWS S3'te barındırılacak ve Amazon CloudFront aracılığıyla global olarak dağıtılacak.
2. Arka Yüz (Backend API): Node.js tabanlı sunucusuz (serverless) API, AWS Lambda fonksiyonları ve Amazon API Gateway kullanılarak inşa edilecek.
3. Veritabanı: Kullanıcı verilerini depolamak için Amazon DynamoDB kullanılacak.

Bu mimariyi CDK ile yönetirken, her bir ana bileşen veya mantıksal katman için ayrı bir CDK "Stack" oluşturmak iyi bir pratiktir. Bu, altyapıyı modüler hale getirir, farklı ekiplerin farklı katmanlar üzerinde bağımsız çalışmasına olanak tanır ve stack'ler arasında temiz bağımlılıklar oluşturulmasını sağlar.

CDK ile Katmanların Tanımlanması:

1. Veritabanı Stack'i (DatabaseStack):
Uygulamanın veritabanı, diğer tüm katmanların bağımlı olduğu temel bir bileşendir. Bu yüzden genellikle ayrı bir stack'te tanımlanır.

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';

export class DatabaseStack extends cdk.Stack {
  public readonly usersTable: dynamodb.Table;

  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    this.usersTable = new dynamodb.Table(this, 'UsersTable', {
      partitionKey: { name: 'userId', type: dynamodb.AttributeType.STRING },
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST, // Sunucusuz mod
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });
  }
}
  

2. Arka Yüz API Stack'i (BackendStack):
Bu stack, Lambda fonksiyonlarını ve API Gateway'i tanımlayacak. Lambda fonksiyonları, DynamoDB tablosuna erişmek için DatabaseStack'ten referans alacak.

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as apigw from 'aws-cdk-lib/aws-apigateway';
import { DatabaseStack } from './database-stack'; // DatabaseStack'i import ediyoruz

interface BackendStackProps extends cdk.StackProps {
  usersTable: dynamodb.Table; // Prop olarak DynamoDB tablosunu bekliyoruz
}

export class BackendStack extends cdk.Stack {
  public readonly apiGatewayUrl: cdk.CfnOutput;

  constructor(scope: Construct, id: string, props: BackendStackProps) {
    super(scope, id, props);

    const apiLambda = new lambda.Function(this, 'ApiHandler', {
      runtime: lambda.Runtime.NODEJS_16_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset('lambda'), // Lambda kodumuz 'lambda' klasöründe
      environment: {
        TABLE_NAME: props.usersTable.tableName,
      },
    });

    // Lambda'ya DynamoDB tablosuna okuma/yazma izni ver
    props.usersTable.grantReadWriteData(apiLambda);

    const api = new apigw.RestApi(this, 'MyApi', {
      restApiName: 'My Awesome API',
      deployOptions: {
        stageName: 'prod',
      },
    });

    api.root.addMethod('GET', new apigw.LambdaIntegration(apiLambda)); // GET /
    
    this.apiGatewayUrl = new cdk.CfnOutput(this, 'ApiGatewayUrl', { value: api.url });
  }
}
  

3. Ön Yüz Stack'i (FrontendStack):
Bu stack, statik ön yüz içeriğini barındıracak S3 bucket'ı ve CloudFront dağıtımını tanımlayacak. Arka yüz API Gateway URL'sini ön yüz uygulamasına bir ortam değişkeni olarak iletebiliriz.

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as cloudfront from 'aws-cdk-lib/aws-cloudfront';
import * as origins from 'aws-cdk-lib/aws-cloudfront-origins';

interface FrontendStackProps extends cdk.StackProps {
  apiGatewayUrl: string; // Prop olarak API Gateway URL'sini bekliyoruz
}

export class FrontendStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props: FrontendStackProps) {
    super(scope, id, props);

    const websiteBucket = new s3.Bucket(this, 'WebsiteBucket', {
      websiteIndexDocument: 'index.html',
      publicReadAccess: true, // Üretim ortamında daha kısıtlı erişim düşünülmeli
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: true,
    });

    new cdk.CfnOutput(this, 'WebsiteUrl', { value: websiteBucket.bucketWebsiteUrl });

    new cloudfront.Distribution(this, 'WebsiteDistribution', {
      defaultBehavior: {
        origin: new origins.S3Origin(websiteBucket),
      },
      // API Gateway'e proxy yapacak bir behavior eklenebilir
      // additionalBehaviors: {
      //   '/api/*': {
      //     origin: new origins.HttpOrigin(cdk.Fn.parseUrl(props.apiGatewayUrl).hostname),
      //     allowedMethods: cloudfront.AllowedMethods.ALLOW_ALL,
      //     viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.HTTPS_ONLY,
      //   },
      // },
      // ... Diğer CloudFront ayarları
    });
    // Burada Frontend build çıktısını S3 bucket'a yükleme işlemi CodePipeline ile entegre edilebilir.
  }
}
  

Ana Uygulama Dosyası (bin/my-app.ts):

Son olarak, tüm bu stack'leri ana uygulama dosyamızda bir araya getirmemiz gerekiyor:

import * as cdk from 'aws-cdk-lib';
import { DatabaseStack } from '../lib/database-stack';
import { BackendStack } from '../lib/backend-stack';
import { FrontendStack } from '../lib/frontend-stack';

const app = new cdk.App();

const databaseStack = new DatabaseStack(app, 'MyMultiTierApp-DatabaseStack');

const backendStack = new BackendStack(app, 'MyMultiTierApp-BackendStack', {
  usersTable: databaseStack.usersTable, // DatabaseStack'ten tabloyu prop olarak geçiyoruz
});

new FrontendStack(app, 'MyMultiTierApp-FrontendStack', {
  apiGatewayUrl: backendStack.apiGatewayUrl.value, // BackendStack'ten API URL'sini prop olarak geçiyoruz
});

app.synth();
  

Bu vaka çalışması, CDK'nın karmaşık uygulamaların altyapısını nasıl daha yönetilebilir, modüler ve bağlantılı hale getirdiğini gösterir. Her stack kendi içinde bağımsız bir dağıtım birimidir, ancak aralarındaki bağımlılıklar CDK'nın güçlü referans mekanizmalarıyla kolayca yönetilebilir. Bu, büyük ekiplerin ve mikroservis mimarilerinin altyapısını verimli bir şekilde yönetmek için ideal bir yaklaşımdır.

CDK Evangelizmi: Takımları ve Süreçleri Nasıl Dönüştürebiliriz?

AWS CDK'nın teknik yetenekleri tartışılmaz, ancak bir organizasyon içinde benimsenmesi ve tam potansiyeline ulaşması, sadece teknolojik bir geçişten daha fazlasını gerektirir. Bu, bir "evangelizm" sürecidir: ekipleri eğitmek, kültürel değişimi teşvik etmek ve CDK'nın sunduğu yeni düşünce yapısını benimsetmek. Peki, bu dönüşümü nasıl gerçekleştirebiliriz?

1. Başlangıçta Küçük Başlayın ve Başarıları Gösterin:

Büyük bir geçiş yapmak yerine, küçük ve yönetilebilir bir proje veya mikroservis ile CDK'yı deneyin. Hızlı bir başarı öyküsü oluşturmak, diğer ekipleri ve yöneticileri ikna etmek için en etkili yoldur. Örneğin, "manuel olarak günler süren bir kurulumu CDK ile dakikalara indirdik" gibi somut sonuçlar paylaşın.

2. Eğitim ve Bilgi Paylaşımı:

• Atölye Çalışmaları Düzenleyin: Ekipler için pratik, uygulamalı CDK atölyeleri düzenleyin. Geliştiricilerin kendi başlarına bir şeyler inşa etmelerine olanak tanıyın.
• Belgeleme Oluşturun: Şirket içi en iyi uygulamaları, kod örneklerini ve SSS'leri içeren kapsamlı bir CDK bilgi bankası oluşturun. Bu, yeni katılanların hızla adapte olmasına yardımcı olacaktır.
• Mentorluk Programları: CDK konusunda deneyimli kişileri, yeni başlayanlara mentorluk yapmaya teşvik edin. Bir araya gelip sorunları çözebilecekleri "CDK buluşmaları" düzenleyin.

3. En İyi Uygulamaları Tanımlayın ve Standartlaştırın:

CDK'nın esnekliği, farklı ekiplerin farklı yaklaşımlar benimsemesine yol açabilir. Bu tutarsızlığı önlemek için:

• Ortak Construct Kütüphaneleri: Sık kullanılan altyapı desenleri için şirkete özgü, yeniden kullanılabilir CDK Construct'ları geliştirin ve bunları merkezi bir depoda paylaşın. Bu, tutarlılığı artırır ve geliştirme hızını artırır.
• Proje Şablonları: Yeni CDK projeleri için standart şablonlar (örneğin, bir web uygulaması, bir API veya bir veritabanı için) sağlayın. Bu, başlangıç maliyetini düşürür ve en iyi uygulamaların benimsenmesini teşvik eder.
• Kod İncelemesi ve Otomasyon: CDK kodunun da uygulama kodu gibi düzenli olarak incelendiğinden emin olun. Lint araçları ve otomatik formatlama ile kod kalitesini güvence altına alın.

4. Kültürel Değişimi Kucaklayın:

CDK, geliştiricilere altyapı yönetimi konusunda daha fazla yetki verirken, operasyon ekiplerinin de geliştirme süreçlerine daha fazla entegre olmasını sağlar. Bu, geleneksel "geliştirme" ve "operasyon" silolarını yıkmaya yardımcı olur:

• Çapraz Fonksiyonel Ekipler: Hem geliştirme hem de operasyon yeteneklerine sahip ekipler oluşturarak, altyapı kodunun da uygulama kodu kadar değerli olduğunu vurgulayın.
• Sürekli Geri Bildirim: CDK kullanımıyla ilgili zorlukları ve başarıları düzenli olarak gözden geçirin. Geri bildirim mekanizmaları oluşturarak süreçleri sürekli iyileştirin.

CDK evangelizmi, sadece bir teknolojiye geçiş değil, aynı zamanda daha çevik, işbirlikçi ve verimli bir organizasyon yaratma yolculuğudur. Doğru stratejiler ve sürekli çaba ile ekiplerinizi bu güçlü aracı benimsemeye ve bulut altyapısı yönetiminde yeni bir çağa öncülük etmeye teşvik edebilirsiniz.

Sonuç ve Sıkça Sorulan Sorular

AWS DevTools ve özellikle AWS Cloud Development Kit (CDK), bulut altyapısı yönetimi ve dağıtım süreçlerinde bir devrim niteliğindedir. Bu kapsamlı rehber boyunca, CDK'nın programlama dillerinin gücünü IaC'ye nasıl taşıdığını, bir CI/CD boru hattını nasıl inşa edeceğimizi, altyapı kodumuzu nasıl test edeceğimizi ve karmaşık çok katmanlı uygulamaları nasıl yöneteceğimizi adım adım inceledik. CDK, sadece altyapı tanımını kolaylaştırmakla kalmıyor, aynı zamanda yazılım mühendisliği prensiplerini altyapı koduna uygulayarak daha güvenilir, sürdürülebilir ve ölçeklenebilir bulut çözümleri oluşturmamızı sağlıyor.

AWS DevTools ile entegrasyonu sayesinde, ekipler manuel müdahaleyi minimuma indirerek hızlı ve otomatik dağıtımlar gerçekleştirebilir. Bu, geliştiricilerin daha çok iş değerine odaklanmasına, operasyon ekiplerinin daha proaktif olmasına ve genel olarak DevOps kültürünün organizasyon içinde güçlenmesine olanak tanır. CDK'nın sunduğu soyutlama katmanı, karmaşıklığı yönetilebilir hale getirirken, Construct'lar aracılığıyla yeniden kullanım, altyapı kodunu verimli bir şekilde ölçeklendirmenize yardımcı olur. Gelecekte, CDK'nın ve benzeri araçların bulut altyapısı yönetimindeki rolünün daha da büyüyeceği ve daha fazla organizasyon tarafından benimseneceği aşikardır. Bu araçları etkin bir şekilde kullanarak, dijital dönüşüm yolculuğunuzda önemli bir avantaj elde edebilirsiniz.

Sıkça Sorulan Sorular (SSS)

• AWS CDK kullanmak için hangi programlama dillerini bilmem gerekiyor?

  AWS CDK; TypeScript, Python, Java, C#, Go ve JavaScript'i destekler. Bu dillerden birinde deneyimli olmanız, CDK'yı kolayca öğrenmenizi ve kullanmaya başlamanızı sağlar. TypeScript ve Python genellikle en popüler tercihlerdir.

• AWS CDK, CloudFormation'ın yerini mi alıyor?

  Hayır, AWS CDK aslında CloudFormation'ın üzerine inşa edilmiştir. CDK kodunuzu yazdığınızda, bu kod CloudFormation şablonlarına dönüştürülür (sentezlenir) ve bu şablonlar AWS'ye dağıtılır. Yani, CDK CloudFormation'ı daha etkili bir şekilde kullanmanızı sağlayan bir soyutlama katmanıdır.

• Mevcut CloudFormation şablonlarımı CDK'ya dönüştürebilir miyim?

  Doğrudan otomatik bir "dönüştürücü" aracı bulunmamaktadır. Ancak, mevcut CloudFormation şablonlarınızı referans alarak CDK ile eşdeğer Construct'ları sıfırdan oluşturabilirsiniz. AWS'nin CDK için "cfn-include" gibi araçları, mevcut CloudFormation kaynaklarını CDK uygulamalarınıza dahil etmenize yardımcı olabilir.

• CDK ile oluşturduğum kaynakları nasıl silerim?

  CDK ile oluşturduğunuz bir stack'i silmek için projenizin kök dizininde cdk destroy [StackAdı] komutunu kullanabilirsiniz. Bu komut, ilgili CloudFormation stack'ini ve dolayısıyla bu stack tarafından oluşturulan tüm AWS kaynaklarını (removalPolicy ayarlarınıza bağlı olarak) silecektir.

• CDK uygulamaları için en iyi test pratiği nedir?

  En iyi pratik, birim testleri (özellikle snapshot testleri) ve entegrasyon testlerini bir arada kullanmaktır. Birim testleri, CDK kodunuzun beklenen CloudFormation şablonunu ürettiğinden emin olmanızı sağlar. Entegrasyon testleri ise, dağıtılan kaynakların gerçek bir AWS ortamında doğru şekilde çalıştığını doğrular.