AWS CDK ve CLI kullanarak üretim seviyesinde, güvenilir ve ölçeklenebilir çok katmanlı web altyapısı nasıl inşa edilir? Bu makale, sıfırdan ileri düzeye detaylı bir rehber sunuyor ve bulut altyapınızı otomatize etmenizi sağlıyor.
Günümüz dijital dünyasında, bir web uygulamasının başarısı sadece sunduğu özelliklerle değil, aynı zamanda temelini oluşturan altyapının sağlamlığıyla da ölçülür. Henüz yeni başlayan bir proje için basit bir sunucu yeterli olabilirken, kullanıcı trafiği arttığında, iş yükü çeşitlendiğinde veya uygulamanın kritiklik düzeyi yükseldiğinde, “basit” altyapılar hızla darboğaz haline gelebilir. Peki, uygulamanızın milyonlarca kullanıcıya hizmet vermesini, kesintisiz çalışmasını ve veri güvenliğini sağlamasını nasıl garantilersiniz?
İşte tam bu noktada, “üretim seviyesi” çok katmanlı bir web altyapısı kurmanın önemi ortaya çıkar. Bu, sadece bir veya iki sunucuyu çalıştırmakla ilgili değildir; aynı zamanda ölçeklenebilirlik, yüksek erişilebilirlik, güvenlik, maliyet etkinliği ve yönetilebilirlik gibi kritik faktörleri baştan sona düşünerek tasarlanmış bir sistemdir. Bir e-ticaret sitesi düşünün: Black Friday indirimlerinde anlık trafik patlamalarını kaldırabilmeli, müşteri verilerini en üst düzeyde koruyabilmeli ve herhangi bir sunucu arızasında bile çalışmaya devam edebilmelidir. Bu beklentiler, tek bir sunucunun kapasitesini aşar ve daha sofistike bir mimari gerektirir.
AWS (Amazon Web Services) gibi bulut platformları, bu karmaşık gereksinimleri karşılamak için geniş bir hizmet yelpazesi sunar. Ancak bu hizmetleri manuel olarak yönetmek veya her değişiklikte baştan yapılandırmak hem zaman alıcı hem de hataya açıktır. Burada devreye altyapının kod olarak yönetilmesi (Infrastructure as Code – IaC) kavramı girer. AWS CDK (Cloud Development Kit) ve AWS CLI (Command Line Interface), IaC felsefesini benimseyerek, bulut altyapınızı programatik olarak tanımlamanıza ve otomatikleştirmenize olanak tanır. Bu araçlar sayesinde, altyapınızın versiyon kontrolünü yapabilir, tekrarlanabilir dağıtımlar gerçekleştirebilir ve geliştirme, test ve üretim ortamları arasında tutarlılığı sağlayabilirsiniz. Bu makale boyunca, bu güçlü araçları kullanarak, uygulamanızın gelecekteki büyüme ve zorluklara hazır, güvenilir bir temel üzerine nasıl oturtulacağını adım adım inceleyeceğiz. İşte bu heyecan verici yolculuğa şimdi çıkalım!
Temel Kavramlar: AWS CDK, AWS CLI ve Çok Katmanlı Mimariyi Anlamak
Bulut altyapısı oluşturma serüvenimize başlamadan önce, temel taşları iyi anlamamız gerekiyor. AWS CDK, AWS CLI ve çok katmanlı mimari, üretim seviyesi bir yapı inşa etmek için vazgeçilmez kavramlardır. Gelin bu temel bileşenleri birlikte inceleyelim.
AWS CDK Nedir ve Neden Kullanmalıyız?
Geleneksel olarak, bulut altyapısı kaynakları (sunucular, veritabanları, ağ yapılandırmaları) genellikle AWS yönetim konsolu üzerinden manuel olarak veya karmaşık YAML/JSON şablonları (AWS CloudFormation gibi) aracılığıyla tanımlanırdı. Ancak bu yaklaşımlar, büyük ve dinamik projelerde hızlıca yönetilemez hale gelebilir. İşte AWS CDK’nın parladığı nokta tam da burası.
AWS CDK, bulut kaynaklarınızı tanıdık programlama dilleri (TypeScript, Python, Java, C#, Go) kullanarak tanımlamanıza olanak tanıyan açık kaynaklı bir yazılım geliştirme çerçevesidir. Bu sayede, if-else koşulları, döngüler ve fonksiyonlar gibi bilindik programlama paradigmalarını kullanarak altyapınızı daha esnek, okunabilir ve yönetilebilir hale getirebilirsiniz. CDK, yazdığınız kodu AWS CloudFormation şablonlarına dönüştürür ve ardından bu şablonları AWS’e dağıtır. Böylece, CloudFormation’ın güvenilir ve idempotent dağıtım yeteneklerinden faydalanırken, kodun esnekliğini de korursunuz.
CDK’nın en büyük avantajlarından biri “Construct” adı verilen yeniden kullanılabilir soyutlama katmanlarıdır. Örneğin, sadece tek bir ec2.Vpc construct’u ile bir VPC, alt ağlar, rota tabloları, internet ağ geçidi ve NAT ağ geçidi gibi karmaşık bir ağ yapısını saniyeler içinde oluşturabilirsiniz. Bu, geliştirme hızınızı artırır, best practices’i (en iyi uygulamalar) otomatik olarak uygulamanıza yardımcı olur ve manuel hataları azaltır.
CDK kurulumu oldukça basittir. Node.js yüklü bir sistemde aşağıdaki komutlarla global olarak kurabilirsiniz:
npm install -g aws-cdk
Yeni bir CDK projesi başlatmak için ise, tercih ettiğiniz dil ile (örneğin Python için) şu komutu kullanırsınız:
mkdir my-cdk-app && cd my-cdk-app
cdk init app --language python
Altyapınızı yazdıktan sonra, cdk synth komutu CloudFormation şablonunu oluşturur, cdk deploy ise bu şablonu AWS'e dağıtır.
AWS CLI: Bulut Kaynaklarınızı Komut Satırından Yönetmek
AWS CLI (Command Line Interface), AWS hizmetlerini komut satırından yönetmenizi sağlayan güçlü bir araçtır. Otomasyon scriptleri yazmak, rutin görevleri gerçekleştirmek veya hızlıca kaynak bilgilerini sorgulamak için idealdir. Konsolun görsel arayüzüne ihtiyaç duymadan, AWS ile tam bir etkileşim kurmanızı sağlar.
CLI'ı kullanmaya başlamadan önce kimlik bilgilerinizi yapılandırmanız gerekir:
aws configure
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-east-1
Default output format [None]: json
Bu yapılandırma sayesinde CLI, sizin adınıza AWS kaynaklarına güvenli bir şekilde erişebilir. CLI ile yapabileceğiniz bazı örnek işlemler şunlardır:
# EC2 örneklerini listele
aws ec2 describe-instances
# S3 bucket'larını listele
aws s3 ls
# Bir S3 bucket'ına dosya yükle
aws s3 cp my-local-file.txt s3://my-unique-bucket/remote-file.txt
CLI, CDK'nın dağıtımı ve yönetimi için de temel bir bileşendir. CDK, arka planda CLI'ı kullanarak AWS API çağrılarını yapar. Bu iki araç, bulut altyapınızı daha verimli ve otomatik hale getirmeniz için birbirini tamamlayan bir ikili oluşturur.
Çok Katmanlı (N-Tier) Mimari Nedir ve Bileşenleri Nelerdir?
Çok katmanlı mimari, bir uygulamanın farklı işlevsel sorumluluklarını (sunum, iş mantığı, veri depolama) ayrı, mantıksal olarak izole edilmiş katmanlara ayırma prensibine dayanır. Bu yaklaşım, her katmanın bağımsız olarak ölçeklenmesini, geliştirilmesini ve güvenliğinin sağlanmasını kolaylaştırır. Tipik bir çok katmanlı web altyapısı şu bileşenleri içerir:
- Sunum Katmanı (Web/Frontend): Kullanıcıların doğrudan etkileşimde bulunduğu arayüzdür. Statik dosyalar (HTML, CSS, JavaScript) genellikle S3'te barındırılır ve CloudFront CDN üzerinden sunularak düşük gecikme sağlanır. Dinamik içerikler için Application Load Balancer (ALB) ve arkasındaki web sunucuları (EC2 veya Fargate) kullanılır.
- Uygulama Katmanı (Backend/Logic): İş mantığının yürütüldüğü yerdir. Kullanıcı isteklerini işler, veritabanı ile iletişim kurar ve sunum katmanına yanıtları döndürür. Genellikle EC2 instances veya Fargate üzerinde çalışan konteynerize uygulamalardan oluşur. Otomatik ölçeklendirme grupları ile talep artışlarına yanıt verebilir.
- Veri Katmanı (Database): Uygulamanın verilerini depoladığı ve yönettiği katmandır. İlişkisel veritabanları (RDS - MySQL, PostgreSQL vb.) veya NoSQL veritabanları (DynamoDB) bu katmanda yer alır. Yüksek erişilebilirlik ve veri güvenliği burada kritik öneme sahiptir.
- Ağ Katmanı (Network): Tüm bu katmanların birbiriyle ve dış dünya ile güvenli bir şekilde iletişim kurmasını sağlar. Amazon VPC (Virtual Private Cloud), alt ağlar (subnet'ler), rota tabloları, Internet Gateway ve NAT Gateway gibi bileşenleri içerir. Güvenlik Grupları (Security Groups) ve Ağ Erişim Kontrol Listeleri (NACL'ler) bu katmanda trafik filtrelemesi yaparak güvenliği artırır.
- Güvenlik Katmanı: IAM (Identity and Access Management) ile yetkilendirme, AWS WAF (Web Application Firewall) ile web uygulaması koruması, Secrets Manager ile hassas verilerin yönetimi gibi mekanizmaları kapsar.
Vaka Analizi: E-ticaret sitemiz için bu katmanları hayal edelim. Müşterilerimiz CloudFront üzerinden hızlıca ürün sayfalarına erişirken (Sunum Katmanı), ürün arama, sepete ekleme gibi işlemler Fargate üzerinde çalışan mikroservislerimiz tarafından (Uygulama Katmanı) işlenir. Ürün bilgileri, müşteri siparişleri ve hesap bilgileri ise RDS PostgreSQL veritabanında (Veri Katmanı) saklanır. Tüm bu iletişim, güvenli bir VPC içinde (Ağ Katmanı) gerçekleşir. Bu katmanlı yapı, her bir bileşenin kendi sorumluluğunu yerine getirmesini ve böylece sistemin bir bütün olarak daha sağlam ve yönetilebilir olmasını sağlar.
Adım Adım İnşa: Temel Ağ Altyapısını (VPC) CDK ile Oluşturmak
Bir web altyapısının temeli, güvenli ve iyi yapılandırılmış bir ağ ortamıdır. AWS'te bu, Amazon Virtual Private Cloud (VPC) ile sağlanır. VPC, AWS bulutu içinde size özel, mantıksal olarak izole edilmiş bir sanal ağ oluşturmanıza olanak tanır. İçine koyduğunuz sanal sunucular (EC2 instances), veritabanları (RDS instances) ve diğer AWS kaynakları bu özel ağda çalışır ve siz, ağ yapılandırması üzerinde tam kontrole sahip olursunuz.
Güvenli ve İzole Bir Ağ Ortamı Nasıl Tasarlanır?
Üretim seviyesi bir VPC tasarlarken, güvenlik ve erişilebilirlik en üst önceliklerdir. Tipik bir senaryoda, VPC'nizi birden fazla kullanılabilirlik bölgesine (Availability Zone - AZ) yayarak yüksek erişilebilirlik sağlarsınız. Her AZ içinde ise, kaynakların erişim ihtiyaçlarına göre public ve private subnet'ler oluşturursunuz.
- Public Subnet'ler: İnternet'ten doğrudan erişilebilir olması gereken kaynaklar (örneğin, Application Load Balancer veya genel IP adresi atanan web sunucuları) burada yer alır. Bir Internet Gateway (IGW) aracılığıyla dış dünya ile iletişim kurarlar.
- Private Subnet'ler: İnternet'ten doğrudan erişimin istenmediği, daha hassas kaynaklar (örneğin, uygulama sunucuları, veritabanları) burada bulunur. Bu subnet'lerdeki kaynaklar, dış dünyaya erişmek istediklerinde genellikle bir NAT Gateway üzerinden trafiklerini yönlendirirler. Bu sayede, dışarıdan erişilemezler ancak güncellemeleri veya dış API'ları çağırabilirler.
Her bir subnet'in kendi rota tabloları (Route Tables) bulunur ve bu tablolar, trafiğin nasıl yönlendirileceğini belirler. Örneğin, public subnet'in rota tablosu trafiği IGW'ye yönlendirirken, private subnet'in rota tablosu trafiği NAT Gateway'e yönlendirir.
Şimdi, bu karmaşık yapıyı CDK ile nasıl oluşturacağımıza bakalım. Python dilini kullanarak, basit ama üretim seviyesine uygun bir VPC oluşturan bir CDK kodu örneği:
import aws_cdk as cdk
from aws_cdk import aws_ec2 as ec2
from constructs import Construct
class MyVpcStack(cdk.Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Üretim seviyesi bir VPC oluşturma
self.vpc = ec2.Vpc(self, "ProdVPC",
ip_addresses=ec2.IpAddresses.cidr("10.0.0.0/16"), # Kendi IP aralığınızı belirleyin
max_azs=3, # Yüksek erişilebilirlik için 3 farklı Kullanılabilirlik Bölgesi kullan
nat_gateways=1, # Her AZ'de NAT Gateway yerine tek bir AZ'de 1 NAT Gateway
subnet_configuration=[
ec2.SubnetConfiguration(
name="Public",
subnet_type=ec2.SubnetType.PUBLIC,
cidr_mask=24 # Örnek: 10.0.0.0/24, 10.0.1.0/24 vb.
),
ec2.SubnetConfiguration(
name="Private",
subnet_type=ec2.SubnetType.PRIVATE_WITH_EGRESS, # NAT Gateway üzerinden çıkış yapabilen private subnet
cidr_mask=24
),
ec2.SubnetConfiguration(
name="Isolated", # Veritabanları için tamamen izole subnet
subnet_type=ec2.SubnetType.PRIVATE_ISOLATED,
cidr_mask=24
)
]
)
cdk.CfnOutput(self, "VPCId",
value=self.vpc.vpc_id,
description="The ID of the VPC")
cdk.CfnOutput(self, "PublicSubnets",
value=str([s.subnet_id for s in self.vpc.public_subnets]),
description="Public Subnet IDs")
cdk.CfnOutput(self, "PrivateSubnets",
value=str([s.subnet_id for s in self.vpc.private_subnets]),
description="Private Subnet IDs")
Yukarıdaki kod bloğu, AWS üzerinde ProdVPC adında bir VPC oluşturur. Bu VPC:
10.0.0.0/16CIDR bloğunu kullanır.- Üç farklı Kullanılabilirlik Bölgesine yayılır (
max_azs=3), bu da yüksek erişilebilirliği artırır. - Tüm private subnet'lerin internete çıkış yapabilmesi için bir tane NAT Gateway kurar (
nat_gateways=1). Daha yüksek erişilebilirlik için her AZ'ye birer NAT Gateway de kurabilirsiniz, ancak bu maliyeti artırır. - Her AZ'de birer adet Public, Private (NAT Gateway üzerinden çıkabilen) ve Isolated (tamamen izole, veritabanları için ideal) subnet oluşturur.
Bu yapılandırma, uygulamanızın farklı bileşenlerini uygun güvenlik ve erişim seviyeleriyle konumlandırmak için sağlam bir temel sağlar. Örneğin, web sunucularınızın ALB tarafından erişilebilen public subnet'lerde, uygulama sunucularınızın NAT Gateway üzerinden çıkış yapabilen private subnet'lerde ve veritabanlarınızın ise tamamen izole edilmiş private subnet'lerde yer almasını sağlayabilirsiniz. Mobil uyumlu uygulamalar veya IoT cihazları gibi farklı client türleri için, bu katmanlı ağ yapısı, trafiğin en verimli ve güvenli yollarla yönlendirilmesini mümkün kılar. Örneğin, mobil uygulamanızdaki bir API çağrısı, ALB ve uygulama katmanına ulaşmadan önce CloudFront üzerinden önbelleğe alınabilir, bu da gecikmeyi önemli ölçüde azaltır.
Bu temel ağ altyapısı kurulduktan sonra, sıra uygulama ve veri katmanlarımızı bu güvenli ortama yerleştirmeye gelecek.
Uygulama ve Veri Katmanlarını Oluşturmak: EC2, Fargate ve RDS ile Ölçeklenebilirlik
Güvenli bir ağ ortamı oluşturduktan sonra, web uygulamanızın kalbi olan uygulama ve veri katmanlarını inşa etmeye geçebiliriz. Bu katmanlar, uygulamanızın iş mantığını yürütür ve tüm verileri depolar. AWS, bu görevler için EC2, ECS Fargate ve RDS gibi güçlü ve ölçeklenebilir hizmetler sunar.
Web Sunucularını ve Uygulama Konteynerlerini Nasıl Konumlandırırız?
Uygulama katmanınız için iki ana seçenek öne çıkar: Amazon EC2 (Elastic Compute Cloud) veya Amazon ECS (Elastic Container Service) Fargate ile konteynerize uygulamalar. Seçiminiz, projenizin gereksinimlerine ve operasyonel tercihinize bağlıdır.
- Amazon EC2: Sanal sunucular üzerinde tam kontrol isteyenler için idealdir. Sunucu işletim sistemini, çalışma zamanlarını ve bağımlılıkları kendiniz yönetirsiniz. Otomatik Ölçeklendirme Grupları (Auto Scaling Groups - ASG) ile EC2 instance'larınızı talebe göre otomatik olarak artırıp azaltabilirsiniz.
- Amazon ECS Fargate: Eğer konteynerize uygulamalar kullanıyorsanız (Docker gibi), Fargate "serverless containers" deneyimi sunar. EC2'deki gibi sunucuları yönetmek zorunda kalmazsınız; AWS, temel altyapıyı sizin için yönetir. Bu, operasyonel yükü önemli ölçüde azaltır ve geliştiricilerin sadece uygulamalarına odaklanmasını sağlar. Üretim seviyesi modern uygulamalar için genellikle Fargate tercih edilir.
Hangi seçeneği tercih ederseniz edin, trafiği bu sunuculara yönlendirmek ve yatay ölçeklemeyi sağlamak için bir Application Load Balancer (ALB) kullanmak şarttır. ALB, gelen trafiği arka uçtaki sağlıklı hedefler (EC2 instance'ları veya Fargate görevleri) arasında dağıtır ve uygulama katmanınızın yüksek erişilebilirliğini sağlar.
Aşağıda, CDK ile bir Fargate servisi ve ALB oluşturan bir kod örneği bulunmaktadır. Bu yapılandırma, sunucusuz konteyner teknolojisinin avantajlarından yararlanarak yüksek ölçeklenebilirlik ve düşük operasyonel yük sunar:
import aws_cdk as cdk
from aws_cdk import aws_ec2 as ec2
from aws_cdk import aws_ecs as ecs
from aws_cdk import aws_ecs_patterns as ecs_patterns
from constructs import Construct
class MyWebAppStack(cdk.Stack):
def __init__(self, scope: Construct, construct_id: str, vpc: ec2.Vpc, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# ECS Cluster oluştur
cluster = ecs.Cluster(self, "MyCluster", vpc=vpc)
# Uygulama kodumuzun bulunduğu Docker imajını tanımlayalım.
# Gerçek senaryoda, bu imaj AWS ECR'de (Elastic Container Registry) saklanır.
# Örnek olması için basit bir nginx imajı kullanıyoruz.
# Kendi uygulamanız için 'my-app:latest' gibi bir imaj belirtebilirsiniz.
image_name = "nginx:latest" # Veya ecs.ContainerImage.from_registry("ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com/my-app:latest")
# Fargate servisi ile bir ALB ve konteynerize uygulama dağıt
ecs_patterns.ApplicationLoadBalancedFargateService(self, "MyFargateService",
cluster=cluster,
cpu=256, # Minimum CPU birimi
memory_limit_mib=512, # Minimum bellek birimi
desired_count=2, # Başlangıçta 2 adet görev çalıştır
public_load_balancer=True, # Public Load Balancer kullan
task_image_options=ecs_patterns.ApplicationLoadBalancedTaskImageOptions(
image=ecs.ContainerImage.from_registry(image_name),
container_port=80, # Uygulamanızın dinlediği port
log_driver=ecs.LogDriver.aws_logs( # CloudWatch Logs ile loglama
stream_prefix="my-fargate-app-logs"
)
)
)
cdk.CfnOutput(self, "LoadBalancerDNS",
value=f"http://{ecs_patterns.ApplicationLoadBalancedFargateService.from_service_attributes(self, 'LB', service_name='MyFargateService', cluster=cluster).load_balancer.load_balancer_dns_name}",
description="The DNS name of the Load Balancer")
Bu kod parçacığı, daha önce oluşturduğumuz VPC içinde bir ECS kümesi tanımlar. Ardından, bir Application Load Balancer (ALB) ile entegre edilmiş bir Fargate servisi oluşturur. Bu servis, Nginx imajını kullanarak (siz kendi uygulama imajınızla değiştirebilirsiniz) iki adet konteyner görevi çalıştırır ve bunları ALB'nin arkasına yerleştirir. desired_count parametresi ile başlangıç görev sayısını belirleyebilir, sonrasında otomatik ölçeklendirme kuralları ekleyerek trafiğe göre dinamik ölçeklenmesini sağlayabilirsiniz.
Güvenilir ve Yüksek Performanslı Veritabanı Nasıl Sağlanır?
Veri katmanı, web uygulamanızın en kritik bileşenlerinden biridir. Amazon RDS (Relational Database Service), yönetilen bir veritabanı hizmeti sunarak operasyonel yükü sizin üzerinizden alır. Yedeklemeler, yamalar, donanım temini ve replikasyon gibi görevleri AWS sizin için yönetir. RDS, MySQL, PostgreSQL, Oracle, SQL Server ve MariaDB gibi popüler veritabanı motorlarını destekler.
Üretim ortamında veritabanınızın yüksek erişilebilirliğini sağlamak için Multi-AZ (Çoklu Kullanılabilirlik Bölgesi) dağıtımını mutlaka kullanmalısınız. Bu sayede, birincil veritabanı örneğiniz farklı bir AZ'deki eşzamanlı bir bekleme replikasına otomatik olarak çoğaltılır. Birincil örnekte bir arıza olması durumunda, RDS otomatik olarak bekleme replikasına geçiş yapar ve kesinti süresini minimize eder.
Aşağıda, CDK ile Multi-AZ PostgreSQL RDS veritabanı örneği oluşturan bir kod bloğu yer almaktadır:
import aws_cdk as cdk
from aws_cdk import aws_ec2 as ec2
from aws_cdk import aws_rds as rds
from constructs import Construct
class MyDatabaseStack(cdk.Stack):
def __init__(self, scope: Construct, construct_id: str, vpc: ec2.Vpc, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Veritabanı güvenlik grubu tanımla: Sadece uygulama sunucularından erişime izin ver
db_security_group = ec2.SecurityGroup(self, "DBSecurityGroup",
vpc=vpc,
description="Allow access to RDS from Fargate tasks",
allow_all_outbound=True # Dışarıya çıkışa izin ver
)
# Uygulama katmanının güvenlik grubundan veritabanına erişime izin ver
# Gerçek uygulamada, Fargate servisinizin güvenlik grubunu buraya eklemelisiniz.
# Örnek olması için kendi IP'nizden veya bir Security Group ID'sinden erişime izin verebiliriz.
# db_security_group.add_ingress_rule(
# peer=ec2.Peer.ipv4("YOUR_APP_SUBNET_CIDR_HERE"), # Uygulama subnet CIDR'ınız
# connection=ec2.Port.tcp(5432), # PostgreSQL varsayılan portu
# description="Allow PostgreSQL access from application layer"
# )
# Fargate servisinin çalışacağı private subnet'ler
# Bu subnet'ler daha önce VPC tanımında 'PRIVATE_WITH_EGRESS' olarak oluşturulmuştu.
private_subnets_selection = vpc.select_subnets(
subnet_type=ec2.SubnetType.PRIVATE_WITH_EGRESS
)
# Veritabanı subnet grubunu oluştur (izole subnetleri kullanmak idealdir)
# Isolated subnet'leri kullanmak veritabanı güvenliği için daha uygundur.
isolated_subnets_selection = vpc.select_subnets(
subnet_type=ec2.SubnetType.PRIVATE_ISOLATED
)
# PostgreSQL RDS veritabanı örneği oluşturma
database = rds.DatabaseInstance(self, "MyPostgresDB",
engine=rds.DatabaseEngine.postgres(version=rds.PostgresEngineVersion.VER_14),
instance_type=ec2.t3.Micro.to_string(), # Üretim için daha büyük bir instance tipi seçin
vpc=vpc,
multi_az=True, # Yüksek erişilebilirlik için Multi-AZ dağıtımı
allocated_storage=20, # GB cinsinden depolama alanı
database_name="mydb",
credentials=rds.Credentials.from_generated_secret("dbadmin"), # Yönetilen bir parola oluşturur
vpc_subnets=isolated_subnets_selection, # Veritabanını izole subnet'lere yerleştir
security_groups=[db_security_group],
removal_policy=cdk.RemovalPolicy.RETAIN, # Stack silindiğinde veritabanını koru (üretim için önemli)
parameter_group=rds.ParameterGroup.from_parameter_group_name(
self, "PostgresParamGroup", "default.postgres14"
)
)
# Veritabanı bağlantı bilgilerini çıktı olarak göster (DİKKAT: Üretimde hassas bilgileri çıktı göstermeyin!)
cdk.CfnOutput(self, "DBEndpoint",
value=database.db_instance_endpoint_address,
description="RDS Database Endpoint Address")
Bu CDK kodu, mydb adında bir PostgreSQL veritabanı oluşturur. multi_az=True ile yüksek erişilebilirlik sağlanırken, vpc_subnets=isolated_subnets_selection ile veritabanının en güvenli olan izole subnet'lerde çalışması garanti altına alınır. removal_policy=cdk.RemovalPolicy.RETAIN ise, eğer bir hata olur ve bu CDK stack'ini silmek zorunda kalırsanız, veritabanının silinmeyip korunmasını sağlar; bu, üretim ortamları için hayati bir güvenlik önlemidir. Veritabanına erişim, tanımladığımız DBSecurityGroup ile kontrol edilir, böylece yalnızca yetkili uygulama sunucularının veritabanına bağlanmasına izin verilir.
Vaka Analizi: E-ticaret sitemiz için bu katmanlar, ürün envanterini, müşteri siparişlerini ve kullanıcı profil bilgilerini depolayan PostgreSQL veritabanımızı (RDS) ve sipariş işleme, envanter yönetimi, kullanıcı kimlik doğrulaması gibi iş mantığını yürüten Fargate servislerimizi barındıracaktır. ALB, gelen tüm API isteklerini Fargate görevlerine yönlendirerek uygulamanın talebe göre otomatik ölçeklenmesini sağlar. Bu sayede, Black Friday gibi yüksek trafikli dönemlerde bile sistem kesintisiz ve performanslı bir şekilde çalışmaya devam edecektir.
Ön Uç ve İçerik Dağıtımı: S3, CloudFront ve Route 53 ile Performans ve Güvenlik
Uygulamanızın arka ucu ve veritabanı sağlam bir şekilde kurulduktan sonra, kullanıcıların doğrudan etkileşim kuracağı ön uç (frontend) kısmını ve statik içerik dağıtımını ele almanın zamanı geldi. Bu aşamada, performans, güvenlik ve küresel erişilebilirlik kritik öneme sahiptir. AWS S3, CloudFront ve Route 53, bu hedeflere ulaşmak için mükemmel bir üçlü oluşturur.
Statik Web İçeriklerini Global Olarak Nasıl Dağıtırız?
Modern web uygulamalarının çoğu, HTML, CSS, JavaScript dosyaları, resimler ve videolar gibi statik varlıkları içerir. Bu tür içerikleri doğrudan uygulama sunucularından sunmak, sunucu kaynaklarını gereksiz yere meşgul eder ve performansı düşürebilir. Bunun yerine, AWS'in özel olarak tasarlanmış hizmetlerini kullanmak çok daha verimlidir.
- Amazon S3 (Simple Storage Service): Yüksek ölçeklenebilir, güvenilir, hızlı ve maliyet-etkin bir nesne depolama hizmetidir. Statik web sitelerini barındırmak için idealdir. S3'e yüklediğiniz dosyalar, milyonlarca kullanıcıya eş zamanlı olarak sunulabilir.
- Amazon CloudFront: AWS'in küresel İçerik Dağıtım Ağı (CDN) hizmetidir. Statik ve dinamik web içeriklerinizi dünya çapındaki "edge location" adı verilen coğrafi noktalarda önbelleğe alarak, son kullanıcılara en yakın noktadan dağıtımını sağlar. Bu sayede, gecikme süresi (latency) önemli ölçüde azalır ve kullanıcı deneyimi iyileşir. CloudFront ayrıca DDoS koruması ve SSL/TLS şifrelemesi gibi güvenlik avantajları da sunar.
- Amazon Route 53: AWS'in yüksek erişilebilir ve ölçeklenebilir Bulut DNS (Domain Name System) web servisidir. Uygulamanıza özel bir alan adı (örneğin,
www.ornek.com) atamanızı ve bu alan adını CloudFront dağıtımınıza veya Application Load Balancer'ınıza yönlendirmenizi sağlar.
Aşağıda, CDK ile bir S3 kovası, CloudFront dağıtımı ve Route 53 kaydı oluşturan bir kod örneği bulunmaktadır. Bu yapı, statik ön uç dosyalarınızı küresel olarak yüksek performansla sunmanızı sağlar:
import aws_cdk as cdk
from aws_cdk import aws_s3 as s3
from aws_cdk import aws_s3_deployment as s3_deployment
from aws_cdk import aws_cloudfront as cloudfront
from aws_cdk import aws_cloudfront_origins as origins
from aws_cdk import aws_route53 as route53
from aws_cdk import aws_route53_targets as targets
from aws_cdk import aws_certificatemanager as acm
from constructs import Construct
class FrontendStack(cdk.Stack):
def __init__(self, scope: Construct, construct_id: str, domain_name: str, zone: route53.IHostedZone, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# 1. S3 Kovası (Bucket) oluştur - Statik web sitesi barındırma için
website_bucket = s3.Bucket(self, "WebsiteBucket",
removal_policy=cdk.RemovalPolicy.DESTROY, # Geliştirme için Destroy, üretim için RETAIN
auto_delete_objects=True, # Stack silindiğinde objeleri sil
public_read_access=False, # CloudFront ile erişileceği için doğrudan public erişime gerek yok
block_public_access=s3.BlockPublicAccess.BLOCK_ALL # Güvenlik için tüm public erişimi engelle
)
# 2. SSL Sertifikası oluştur veya var olanı kullan
# Domaininizin Certificate Manager'da doğrulanması gerekmektedir.
certificate = acm.DnsValidatedCertificate(self, "WebsiteCertificate",
domain_name=domain_name,
hosted_zone=zone,
region="us-east-1" # CloudFront için sertifika us-east-1 bölgesinde olmalıdır
)
# 3. CloudFront dağıtımı oluştur
distribution = cloudfront.Distribution(self, "WebsiteDistribution",
default_behavior=cloudfront.BehaviorOptions(
origin=origins.S3Origin(website_bucket),
viewer_protocol_policy=cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
cache_policy=cloudfront.CachePolicy.CACHING_OPTIMIZED # Optimum önbellekleme
),
default_root_object="index.html", # Varsayılan giriş sayfası
domain_names=[domain_name], # Özel alan adınızı ekleyin
certificate=certificate
)
# 4. S3 Kovasına örnek bir index.html dağıtımı
s3_deployment.BucketDeployment(self, "DeployWebsite",
sources=[s3_deployment.Source.asset("./frontend-app")], # frontend-app klasörünüzdeki dosyaları dağıtın
destination_bucket=website_bucket,
distribution=distribution,
distribution_paths=["/*"] # Önbelleği temizle
)
# 5. Route 53 DNS kaydı oluştur - Alan adını CloudFront'a yönlendir
route53.ARecord(self, "AliasRecord",
zone=zone,
target=route53.RecordTarget.from_alias(targets.CloudFrontTarget(distribution)),
record_name=domain_name
)
cdk.CfnOutput(self, "CloudFrontUrl",
value=f"https://{distribution.domain_name}",
description="CloudFront Distribution URL")
cdk.CfnOutput(self, "WebsiteBucketName",
value=website_bucket.bucket_name,
description="S3 Bucket Name")
Bu kod bloğu, WebsiteBucket adında bir S3 kovası oluşturur ve statik dosyalarınızı buraya yüklemeniz için bir s3_deployment.BucketDeployment kaynağı kullanır. Daha sonra, WebsiteDistribution adında bir CloudFront dağıtımı oluşturulur. Bu dağıtım, S3 kovanızı bir kaynak olarak kullanır, HTTPS üzerinden erişimi zorlar ve özel alan adınızı (domain_name) sertifika ile ilişkilendirir. Son olarak, Route 53'teki bir A kaydı, özel alan adınızı CloudFront dağıtımınıza yönlendirir. Bu sayede, kullanıcılar www.ornek.com adresine girdiklerinde, en yakın CloudFront edge location'ından hızlı ve güvenli bir şekilde statik içeriğinize ulaşabilirler. Burada bahsedilen frontend-app klasöründe ise, örneğin React, Angular veya Vue.js ile geliştirilmiş web uygulamanızın build edilmiş çıktıları yer almalıdır. Ayrıca, CloudFront dağıtımına özel alan adı atamak için us-east-1 bölgesinde bir SSL sertifikasına ihtiyacınız olduğunu unutmayın; CDK bunu otomatik olarak yönetecek şekilde tasarlanmıştır.
Güvenlik ve İzleme: Üretim Ortamınızı Nasıl Korursunuz ve Gözlersiniz?
Bir web altyapısı kurmak önemli olsa da, onu güvende tutmak ve sorunsuz çalıştığından emin olmak da bir o kadar kritiktir. Üretim ortamları sürekli tehdit altındadır ve performansı yakından izlemek, olası sorunları proaktif olarak ele almanın anahtarıdır. AWS, güvenlik ve izleme için geniş bir hizmet yelpazesi sunar; biz de CDK aracılığıyla bu hizmetleri altyapımıza entegre edeceğiz.
Entegre Güvenlik Mekanizmaları Nasıl Uygulanır?
Bulut güvenliği, paylaşılan sorumluluk modeline dayanır: AWS, bulutun güvenliğinden sorumluyken, siz buluttaki güvenliğinizden sorumlusunuz. Bu nedenle, altyapınızın her katmanında güvenlik önlemlerini uygulamak çok önemlidir.
- IAM Rolleri ve Politikaları: AWS kaynaklarına kimlerin ne tür erişimi olduğunu belirlemek için IAM (Identity and Access Management) kullanılır. "En az yetki prensibi"ni (Least Privilege Principle) benimseyin: Her kullanıcıya veya servise, yalnızca görevini yerine getirmesi için kesinlikle gerekli olan minimum yetkileri verin. Örneğin, Fargate servisinizin sadece RDS veritabanına erişmesine izin veren bir IAM rolü atayın.
- Security Groups ve NACL'ler: Ağ katmanında trafik filtrelemesi için kullanılırlar.
- Security Groups (Güvenlik Grupları): Kaynak düzeyinde (EC2 instance, RDS instance) çalışan sanal güvenlik duvarlarıdır. Gelen (ingress) ve giden (egress) trafiği kontrol eder. Durum bilgisine sahiptirler (stateful), yani giden trafiğe izin verdiğinizde, dönen trafiğe de otomatik olarak izin verilir.
- NACL'ler (Network Access Control Lists): Alt ağ düzeyinde çalışan durum bilgisi olmayan (stateless) güvenlik duvarlarıdır. Hem gelen hem de giden her kuralı ayrı ayrı tanımlamanız gerekir. Daha genel bir güvenlik katmanı sağlar.
- AWS WAF (Web Application Firewall): Web uygulamalarınızı SQL injection, cross-site scripting (XSS) gibi yaygın web açıklıklarından ve botlardan korur. ALB veya CloudFront ile entegre edilebilir.
- Secrets Manager / Parameter Store: Veritabanı kimlik bilgileri, API anahtarları gibi hassas bilgileri güvenli bir şekilde depolamak ve yönetmek için kullanılır. Uygulamalarınız bu sırları doğrudan kodlarında tutmak yerine, bu hizmetlerden dinamik olarak almalıdır.
Aşağıda, bir Fargate servisi için gerekli bir IAM rolünü ve bir Security Group kuralını CDK ile tanımlayan bir örnek bulunmaktadır:
import aws_cdk as cdk
from aws_cdk import aws_iam as iam
from aws_cdk import aws_ec2 as ec2
from constructs import Construct
class SecurityStack(cdk.Stack):
def __init__(self, scope: Construct, construct_id: str, vpc: ec2.Vpc, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Fargate Task için IAM Rolü oluştur
# Bu rol, Fargate görevinin gerekli AWS hizmetlerine (örn. CloudWatch Logs, ECR, S3) erişmesini sağlar.
fargate_task_role = iam.Role(self, "FargateTaskRole",
assumed_by=iam.ServicePrincipal("ecs-tasks.amazonaws.com"),
description="IAM role for Fargate tasks"
)
fargate_task_role.add_managed_policy(
iam.ManagedPolicy.from_aws_managed_policy_name("service-role/AmazonECSTaskExecutionRolePolicy")
)
# Eğer Fargate göreviniz RDS'e erişecekse, buraya ilgili izinleri de eklemelisiniz.
# fargate_task_role.add_to_policy(iam.PolicyStatement(
# actions=["rds-db:connect"],
# resources=["arn:aws:rds-db:REGION:ACCOUNT_ID:dbuser:DB_INSTANCE_RESOURCE_ID/DB_USER_NAME"],
# ))
# Bir Security Group tanımla - sadece belirli portlara izin ver
web_app_security_group = ec2.SecurityGroup(self, "WebAppSecurityGroup",
vpc=vpc,
description="Allow web traffic to Fargate tasks",
allow_all_outbound=True # Uygulama internete çıkış yapabilir
)
# HTTP (80) ve HTTPS (443) trafiğine izin ver (ALB'den gelen trafik için)
web_app_security_group.add_ingress_rule(
peer=ec2.Peer.ipv4("0.0.0.0/0"), # Normalde ALB'nin SG'sinden gelen trafiğe izin verilir.
connection=ec2.Port.tcp(80),
description="Allow HTTP access from anywhere (ALB)"
)
web_app_security_group.add_ingress_rule(
peer=ec2.Peer.ipv4("0.0.0.0/0"),
connection=ec2.Port.tcp(443),
description="Allow HTTPS access from anywhere (ALB)"
)
cdk.CfnOutput(self, "FargateTaskRoleArn",
value=fargate_task_role.role_arn,
description="ARN of the Fargate Task Role")
cdk.CfnOutput(self, "WebAppSecurityGroupId",
value=web_app_security_group.security_group_id,
description="ID of the Web App Security Group")
Bu kod parçacığı, Fargate görevlerinizin AWS hizmetlerine güvenli bir şekilde erişmesini sağlayan bir IAM rolü ve web uygulamanıza gelen HTTP/HTTPS trafiğine izin veren bir Güvenlik Grubu oluşturur. Özellikle, Güvenlik Grubu'nda peer=ec2.Peer.ipv4("0.0.0.0/0") yerine ALB'nin Security Group ID'sini kullanmak, daha sıkı bir güvenlik sağlar.
Altyapınızın Sağlığını Sürekli Nasıl Takip Edebilirsiniz?
İzleme, üretim ortamının sağlığını, performansını ve güvenliğini anlamak için hayati öneme sahiptir. AWS, bu amaçla çeşitli araçlar sunar:
- Amazon CloudWatch: AWS kaynaklarınızı ve uygulamalarınızı izlemek için temel bir hizmettir. Metrikleri toplar, logları depolar ve alarmlar oluşturarak belirli eşik değerleri aşıldığında sizi bilgilendirir. CPU kullanımı, bellek tüketimi, ağ trafiği, veritabanı bağlantıları gibi birçok metrik otomatik olarak toplanır.
- CloudWatch Logs: Uygulamalarınızdan ve AWS hizmetlerinizden (EC2, Fargate, Lambda vb.) gelen logları merkezi bir konumda toplar, depolar ve analiz etmenizi sağlar.
- CloudTrail: AWS hesabınızdaki tüm API aktivitesini kaydeder. Kimin, ne zaman, hangi AWS kaynağında ne işlem yaptığını takip etmenizi sağlar. Güvenlik denetimi ve sorun giderme için paha biçilmezdir.
CDK ile CloudWatch alarmları oluşturarak altyapınızdaki kritik durumları otomatik olarak izleyebilirsiniz. Örneğin, bir Fargate servisinin CPU kullanımının belirli bir eşiği aşması durumunda sizi bilgilendiren bir alarm kurmak:
import aws_cdk as cdk
from aws_cdk import aws_cloudwatch as cloudwatch
from aws_cdk import aws_sns as sns # Alarm bildirimleri için SNS
from constructs import Construct
class MonitoringStack(cdk.Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# SNS Konusu oluştur - Alarmlar buraya bildirim gönderir
alarm_topic = sns.Topic(self, "AlarmTopic",
display_name="Critical System Alarms"
)
# Örnek bir CloudWatch Alarmı: Fargate servisi CPU kullanımı %80'i aşarsa bildirim gönder
# Bu alarmı gerçek Fargate servisinizin CPU metriğine bağlamanız gerekecektir.
# Örnek olması açısından genel bir CPU metrik tanımı kullanıyoruz.
cpu_utilization_metric = cloudwatch.Metric(
namespace="AWS/ECS", # ECS için metrik namespace
metric_name="CPUUtilization",
dimensions_map={
"ClusterName": "MyCluster", # Kendi ECS kümenizin adını girin
"ServiceName": "MyFargateService" # Kendi Fargate servisinizin adını girin
},
period=cdk.Duration.minutes(1),
statistic="Average"
)
cpu_alarm = cloudwatch.Alarm(self, "FargateCpuHighAlarm",
metric=cpu_utilization_metric,
evaluation_periods=5, # 5 dakika boyunca eşiğin üzerinde kalırsa
threshold=80, # %80 CPU kullanımı
comparison_operator=cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
alarm_description="Fargate service CPU utilization is too high!",
actions_enabled=True
)
cpu_alarm.add_alarm_action(cloudwatch.SnsAction(alarm_topic))
cpu_alarm.add_ok_action(cloudwatch.SnsAction(alarm_topic))
cdk.CfnOutput(self, "AlarmTopicArn",
value=alarm_topic.topic_arn,
description="ARN of the SNS topic for alarms")
Bu kod, Fargate servisinizin CPU kullanımını izleyen ve %80'in üzerine çıktığında bir SNS konusuna bildirim gönderen bir CloudWatch Alarmı oluşturur. Bu SNS konusuna e-posta adresleri veya diğer bildirim uç noktaları abone olarak kritik uyarıları alabilir. Bu tür alarmlar, sorunları hızla tespit etmenizi ve proaktif müdahalelerde bulunmanızı sağlayarak üretim ortamınızın istikrarını ve performansını garantiler.
Operasyonel Mükemmellik: CDK ve CLI ile Otomasyon ve Bakım
Üretim seviyesi bir altyapı sadece kurulmakla kalmaz, aynı zamanda sürekli olarak yönetilmeli, bakımı yapılmalı ve geliştirilmelidir. Operasyonel mükemmellik, tekrarlayan görevleri otomatize etmek, hızlı ve güvenilir dağıtımlar sağlamak ve kaynakları verimli kullanmak anlamına gelir. AWS CDK ve AWS CLI, bu hedeflere ulaşmanız için vazgeçilmez araçlardır.
Geliştirme Yaşam Döngüsünü Nasıl Hızlandırırsınız?
Modern yazılım geliştirme, sürekli entegrasyon ve sürekli teslimat (CI/CD) prensiplerine dayanır. Altyapının kod olarak yönetilmesi (IaC) sayesinde, CI/CD süreçlerinizi altyapınıza da genişletebilirsiniz.
- CI/CD Entegrasyonu: CDK kodunuzu Git repolarında saklayarak, değişiklikleri otomatik olarak test edebilir ve AWS CodePipeline, CodeBuild, GitHub Actions veya GitLab CI gibi araçlar aracılığıyla üretim ortamına dağıtabilirsiniz. Bu, manuel hataları ortadan kaldırır ve dağıtım hızını artırır. Bir geliştirici bir pull request açtığında, CDK kodunun sentetik testi (
cdk synth) ve hatta belirli entegrasyon testleri otomatik olarak çalıştırılabilir. - Geriye Dönüş (Rollback) Stratejileri: CDK (ve temelindeki CloudFormation), dağıtımları bir "stack" olarak yönettiği için, bir dağıtım başarısız olduğunda veya bir sorun tespit edildiğinde, önceki kararlı duruma kolayca geri dönebilirsiniz. Bu, üretimde yapılan hataların etkisini minimize etmenin kritik bir yoludur.
- Ortam Farklılıkları: Geliştirme, test ve üretim ortamları arasında genellikle farklı kaynak konfigürasyonları (örn. test ortamı için daha küçük EC2 instance'ları, üretim için Multi-AZ RDS) bulunur. CDK, bu farklılıkları aynı kod tabanı içinde yönetmenizi sağlar. Örneğin, bir environment değişkeni okuyarak farklı Construct'lar veya Construct özellikleri uygulayabilirsiniz.
# Örnek: Farklı ortamlar için koşullu kaynak oluşturma
import os
environment = os.getenv("ENV", "dev") # Ortam değişkeninden 'dev' veya 'prod' oku
if environment == "prod":
# Üretim ortamı için Multi-AZ ve daha büyük instance tipi
rds.DatabaseInstance(self, "MyDatabase",
instance_type=ec2.InstanceType.of(ec2.InstanceClass.R5, ec2.InstanceSize.LARGE),
multi_az=True,
# ...
)
else:
# Geliştirme ortamı için tek AZ ve daha küçük instance tipi
rds.DatabaseInstance(self, "MyDatabase",
instance_type=ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MICRO),
multi_az=False,
# ...
)
CLI ise rutin görevlerin otomasyonunda parlar. Örneğin, her sabah belirli bir S3 bucket'ındaki log dosyalarını indiren veya belirli bir EC2 instance'ını başlatan/durduran Bash scriptleri yazmak için CLI'ı kullanabilirsiniz. Bu tür otomasyonlar, operasyonel yükü azaltır ve insan hatası riskini düşürür.
# Örnek CLI komutu: Bir EC2 instance'ı başlatma
aws ec2 start-instances --instance-ids i-0abcdef1234567890
# Örnek CLI komutu: Bir S3 bucket'ından belirli bir önekteki tüm dosyaları senkronize etme
aws s3 sync s3://my-prod-logs/2023/ ~/local-logs/2023/
Kaynak Yönetimi ve Maliyet Optimizasyonu İçin İpuçları
Bulut ortamlarında maliyet yönetimi, özellikle üretim seviyesi altyapılarda, sürekli dikkat gerektiren bir konudur. CDK ve CLI, maliyetleri optimize etmenize yardımcı olacak araçlar sunar:
- Gereksiz Kaynakları Temizleme: CDK stack'lerini silmek, stack içindeki tüm kaynakları otomatik olarak temizler. Geliştirme ve test ortamlarında kullanılmayan kaynakların atıl kalmasını önlemek için düzenli temizlik yapmak önemlidir.
- Etiketleme (Tagging) Stratejileri: Tüm AWS kaynaklarınıza (VPC, EC2, RDS, S3 vb.) tutarlı etiketler (örneğin,
Project: ECommerce,Environment: Production,Owner: DevOpsTeam) eklemek, maliyetleri departmanlara, projelere veya ortamlara göre izlemenize ve raporlamanıza olanak tanır. CDK, Construct'larınıza kolayca etiket eklemenizi sağlar. - Rezerveli Instance'lar (Reserved Instances) ve Tasarruf Planları (Savings Plans): Tahmin edilebilir, uzun vadeli kaynak kullanımları için bu seçenekleri değerlendirin. Önemli maliyet tasarrufu sağlarlar. CLI ile mevcut kullanımlarınızı analiz edebilirsiniz.
- AWS Cost Explorer: Harcamalarınızı görselleştirmek ve analiz etmek için Cost Explorer'ı kullanın. CLI ile Cost Explorer'dan veri çekerek kendi raporlama mekanizmalarınızı oluşturabilirsiniz.
# CDK ile tüm kaynaklara otomatik etiket ekleme
import aws_cdk as cdk
from constructs import Construct
class MyTaggedStack(cdk.Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
cdk.Tags.of(self).add("Project", "ECommerce")
cdk.Tags.of(self).add("Environment", "Production")
cdk.Tags.of(self).add("Owner", "DevOpsTeam")
# Diğer kaynak tanımlamaları buraya gelecek...
Bu şekilde, CDK ile oluşturduğunuz tüm kaynaklara merkezi olarak etiketler uygulayabilir ve maliyet analizlerinizi basitleştirebilirsiniz. Unutmayın, maliyet optimizasyonu sürekli bir süreçtir ve düzenli olarak gözden geçirilmesi gerekir.
Sonuç: Geleceğe Hazır Bir Altyapı İnşa Etmenin Gücü
Bu makale boyunca, AWS CDK ve AWS CLI'ın gücünü kullanarak, sıfırdan üretim seviyesi, çok katmanlı bir web altyapısını nasıl inşa edeceğimizi adım adım inceledik. Modern web uygulamalarının değişen ve büyüyen ihtiyaçlarına yanıt verebilen, güvenli, ölçeklenebilir ve yüksek erişilebilir bir mimariyi programatik olarak tanımlamanın önemini vurguladık.
Başlangıçta, bir VPC ile uygulamanız için izole ve güvenli bir ağ temeli attık. Ardından, Fargate ve Application Load Balancer kullanarak ölçeklenebilir uygulama katmanımızı ve Multi-AZ RDS ile güvenilir veri katmanımızı kurduk. Statik ön uç içeriğimizi S3, CloudFront ve Route 53 ile küresel olarak hızlı ve güvenli bir şekilde dağıttık. Son olarak, IAM, Security Groups, CloudWatch ve CloudTrail gibi hizmetlerle altyapımızın güvenlik ve izleme ihtiyaçlarını karşıladık ve CI/CD entegrasyonu, ortam farklılıklarının yönetimi ve maliyet optimizasyonu gibi operasyonel mükemmellik konularına değindik.
AWS CDK ve CLI, altyapı yönetiminde devrim niteliğinde araçlardır. Altyapınızı kod olarak tanımlayarak, manuel hataları azaltır, dağıtım süreçlerini hızlandırır, versiyon kontrolü sağlar ve farklı ortamlar arasında tutarlılığı garantilersiniz. Bu sadece mühendislik verimliliğini artırmakla kalmaz, aynı zamanda iş süreçlerinizin hızlanmasına ve maliyetlerin düşmesine de katkıda bulunur. Geleceğin bulut altyapısını inşa etmek, otomasyon, güvenlik ve ölçeklenebilirlik prensiplerine dayanır. Bu makaledeki bilgileri ve örnekleri rehber alarak, siz de bu güçlü araçlarla kendi üretim seviyesi altyapılarınızı güvenle oluşturabilir ve yönetebilirsiniz.
Sıkça Sorulan Sorular
-
AWS CDK öğrenme eğrisi ne kadar?
CDK, programlama dillerini (Python, TypeScript vb.) bilen geliştiriciler için nispeten düşük bir öğrenme eğrisine sahiptir. AWS hizmetleri ve temel bulut mimarisi prensipleri hakkında bilgi sahibi olmak süreci hızlandırır. Temel konseptleri ve construct'ları öğrendikten sonra, hızla karmaşık altyapılar oluşturmaya başlayabilirsiniz.
-
Mevcut bir altyapıyı CDK'ya taşıyabilir miyim?
Evet, mevcut AWS kaynaklarınızı CDK'ya taşıyabilirsiniz. Bu sürece "import" veya "adopt" denir. CDK, CloudFormation'ın import yeteneklerini kullanarak mevcut kaynakları bir CDK stack'ine dahil etmenizi sağlar. Bu, manuel olarak oluşturulmuş veya başka bir IaC aracıyla oluşturulmuş altyapıları CDK yönetimine almanıza olanak tanır.
-
CDK ve Terraform arasındaki temel farklar nelerdir?
Her ikisi de popüler IaC araçları olsa da, temel farkları vardır:
- CDK: Programlama dillerini (TypeScript, Python vb.) kullanarak bulut kaynaklarını tanımlar. AWS'e özgüdür ve CloudFormation'a derlenir. Yüksek düzeyli soyutlamalar (Construct'lar) sunar.
- Terraform: HashiCorp Configuration Language (HCL) veya JSON kullanır. Çapraz bulut platformlarını destekler (AWS, Azure, GCP vb.). Daha düşük seviyeli kaynak tanımlaması sunar ve daha az soyutlama sağlar.
Seçiminiz, projenizin dil tercihine, bulut platformu bağımlılığına ve soyutlama ihtiyacına göre değişir.
-
Üretim ortamı için en önemli güvenlik önlemleri nelerdir?
En önemli güvenlik önlemleri arasında "En az yetki prensibi" (IAM), ağ segmentasyonu (VPC, Security Groups, NACL'ler), veri şifrelemesi (aktarım halinde ve bekleyen veriler için), düzenli güvenlik denetimleri ve yamalama, WAF gibi uygulamaya özel korumalar ve hassas verilerin (API anahtarları, veritabanı şifreleri) Secrets Manager gibi güvenli hizmetlerde saklanması yer alır.
-
Maliyetleri optimize etmek için hangi adımları atmalıyım?
Maliyet optimizasyonu için şunları yapmalısınız: Kullanılmayan veya gereksiz kaynakları temizleyin, tüm kaynaklarınızı tutarlı bir şekilde etiketleyin, AWS Cost Explorer'ı kullanarak harcamalarınızı analiz edin, üretim yükleriniz için Rezerveli Instance'lar veya Tasarruf Planları gibi uzun vadeli taahhütleri değerlendirin, Auto Scaling ile kaynaklarınızı talebe göre otomatik ölçeklendirin ve EC2 yerine Fargate/Lambda gibi sunucusuz hizmetleri tercih ederek operasyonel maliyetleri azaltın.