Go vs Python AWS Lambda'da: Pratik Bir Terraform Karşılaştırması (Function URL'leri ile)

Go vs Python AWS Lambda’da: Pratik Bir Terraform Karşılaştırması (Function URL’leri ile)

Sunucusuz mimariler, geliştiricilere altyapı yönetimi yükünü hafifleterek daha hızlı ve ölçeklenebilir uygulamalar oluşturma imkanı sunar. AWS Lambda, bu alandaki en popüler hizmetlerden biridir. Bu makalede, AWS Lambda üzerinde Go ve Python dillerinin performans, geliştirme hızı ve maliyet açısından karşılaştırmasını, Terraform ile altyapı yönetimi ve Function URL’lerinin pratik kullanımı üzerinden ele alacağız.

Neden Go ve Python AWS Lambda için Popüler Seçenekler?

AWS Lambda için dil seçimi, projenin gereksinimlerine, ekibin deneyimine ve performans beklentilerine göre değişiklik gösterebilir. Go ve Python, farklı avantajlarıyla Lambda geliştiricileri arasında öne çıkan iki popüler dildir.

Go’nun Avantajları (Performans, Derlenmiş Yapı)

Go (Golang), Google tarafından geliştirilen, derlenmiş, statik tipli bir programlama dilidir. Lambda ortamında Go’yu tercih etmenin başlıca nedenleri şunlardır:

Yüksek Performans: Go, derlenmiş bir dil olduğu için çalışma zamanı performansı genellikle yorumlanmış dillere göre daha yüksektir. Bu, özellikle CPU yoğun veya düşük gecikme süresi gerektiren iş yükleri için kritik bir avantajdır.
Düşük Bellek Tüketimi: Go uygulamaları genellikle daha az bellek kullanır. Bu durum, Lambda’nın bellek tabanlı faturalandırma modeli göz önüne alındığında maliyet avantajı sağlayabilir.
Hızlı Soğuk Başlangıç (Cold Start): Go ikilileri genellikle küçüktür ve hızlı bir şekilde başlatılabilir. Bu, sunucusuz mimarilerde sıkça karşılaşılan soğuk başlangıç sorununu minimize etmeye yardımcı olur.
Tek İkili Dosya: Go uygulamaları, tüm bağımlılıkları içeren tek bir statik ikili dosya halinde derlenebilir. Bu, dağıtımı basitleştirir ve bağımlılık yönetimi karmaşasını azaltır.

Python’ın Avantajları (Geliştirme Hızı, Ekosistem)

Python, yüksek seviyeli, yorumlanmış bir programlama dilidir ve geniş bir kullanım alanına sahiptir. Lambda’da Python’ı tercih etmenin nedenleri ise şunlardır:

Hızlı Geliştirme: Python’ın basit ve okunabilir sözdizimi, geliştirme sürecini hızlandırır. Prototipleme ve hızlı iterasyonlar için idealdir.
Geniş Ekosistem ve Kütüphaneler: Python, veri bilimi, makine öğrenimi, web geliştirme ve otomasyon gibi birçok alanda zengin bir kütüphane ve çerçeve ekosistemine sahiptir. Bu, birçok işlevselliği kolayca entegre etme imkanı sunar.
Büyük Geliştirici Topluluğu: Geniş bir topluluğa sahip olması, sorun giderme ve kaynak bulma konusunda büyük kolaylık sağlar.
Kolay Öğrenilebilirlik: Yeni başlayanlar için nispeten kolay öğrenilebilir bir dil olması, ekiplerin hızla adapte olmasını sağlar.

Ortak Avantajlar (Sunucusuz Modelin Faydaları)

Her iki dil de AWS Lambda’nın sunduğu sunucusuz modelin genel avantajlarından faydalanır:

Otomatik Ölçeklendirme: Talep arttıkça fonksiyonlar otomatik olarak ölçeklenir.
Yönetilen Altyapı: Sunucu provizyonu, yamalama ve bakım gibi operasyonel yükler AWS tarafından yönetilir.
Kullandıkça Öde Modeli: Sadece fonksiyonunuz çalıştığında ödeme yaparsınız, bu da maliyet etkinliği sağlar.

AWS Lambda Function URL’leri Nedir ve Neden Önemli?

AWS Lambda Function URL’leri, Lambda fonksiyonlarınıza doğrudan HTTP(S) uç noktaları atamanıza olanak tanıyan, tam olarak yönetilen bir özelliktir. Bu özellik, Lambda fonksiyonlarınıza erişimi basitleştirir.

Function URL’lerinin Temelleri

Bir Function URL oluşturduğunuzda, Lambda fonksiyonunuz için benzersiz ve kalıcı bir HTTP(S) uç noktası elde edersiniz. Bu uç nokta, herhangi bir ek hizmete (örneğin API Gateway) ihtiyaç duymadan fonksiyonunuzu doğrudan çağırabilir. Her Function URL, bir yetkilendirme modu (NONE veya AWS_IAM) ve bir CORS yapılandırması ile birlikte gelir.

API Gateway’e Göre Avantajları

Geleneksel olarak, Lambda fonksiyonlarını HTTP üzerinden tetiklemek için API Gateway kullanılırdı. Function URL’leri, belirli senaryolarda API Gateway’e göre avantajlar sunar:

Basitlik: Tek bir Lambda fonksiyonu için basit bir HTTP uç noktası gerektiğinde, Function URL’leri API Gateway’in karmaşıklığını ortadan kaldırır. Daha az yapılandırma, daha az hareketli parça demektir.
Düşük Gecikme Süresi: Function URL’leri, API Gateway’e kıyasla daha düşük gecikme süresi sunabilir, çünkü istekler doğrudan Lambda’ya yönlendirilir ve ek bir hizmet katmanı atlanır.
Maliyet Etkinliği: API Gateway’in kendi faturalandırma modeli vardır. Basit HTTP tetikleyicileri için Function URL’leri genellikle daha uygun maliyetli olabilir.

Kullanım Senaryoları ve Kısıtlamalar

Function URL’leri, özellikle aşağıdaki senaryolar için idealdir:

Webhooks: Üçüncü taraf hizmetlerden gelen webhooks’ları işlemek.
Basit HTTP API’leri: Tek bir işlevi yerine getiren basit API uç noktaları oluşturmak.
Form Gönderimleri: Doğrudan Lambda’ya gönderilen HTML form verilerini işlemek.
Mobil ve Web Uygulamaları: Doğrudan bir Lambda fonksiyonunu çağıran basit arka uç işlevleri.

Ancak, Function URL’lerinin bazı kısıtlamaları da vardır:

Gelişmiş API Yönetimi Yok: API Gateway’in sunduğu kullanım planları, API anahtarları, istek/yanıt dönüşümleri, doğrulama veya önbellekleme gibi gelişmiş özellikler Function URL’lerinde bulunmaz.
Yalnızca Tek Fonksiyon: Her Function URL yalnızca bir Lambda fonksiyonuna işaret eder. Birden fazla fonksiyonu veya farklı rotaları yönetmek için API Gateway daha uygundur.
Yetkilendirme Seçenekleri Sınırlı: Sadece IAM veya anonim erişim seçenekleri mevcuttur.

Terraform ile AWS Lambda Kaynaklarını Yönetmek

Altyapıyı Kod Olarak (Infrastructure as Code – IaC) yönetmek, modern bulut geliştirme pratiklerinin temelidir. Terraform, bu alanda lider araçlardan biridir ve AWS Lambda kaynaklarını yönetmek için güçlü ve esnek bir yol sunar.

Terraform’un Gücü ve Avantajları

Terraform, HashiCorp tarafından geliştirilen açık kaynaklı bir IaC aracıdır. Declarative (bildirimsel) bir yaklaşımla çalışır ve altyapınızın istenen durumunu tanımlamanıza olanak tanır. Avantajları:

Çoklu Bulut Desteği: AWS’nin yanı sıra Azure, Google Cloud, Oracle Cloud gibi birçok bulut sağlayıcısını ve diğer SaaS hizmetlerini destekler.
Versiyon Kontrolü: Altyapı kodunu versiyon kontrol sistemlerinde (Git gibi) yöneterek değişiklikleri izlemeyi ve geri almayı kolaylaştırır.
Tekrarlanabilirlik: Aynı altyapıyı birden fazla ortamda (geliştirme, test, üretim) tutarlı bir şekilde oluşturmayı ve dağıtmayı sağlar.
Modülerlik: Altyapı bileşenlerini yeniden kullanılabilir modüller halinde düzenlemeye olanak tanır.

Temel Lambda Kaynak Yapılandırması (IAM, S3)

Bir AWS Lambda fonksiyonunu Terraform ile dağıtmak için genellikle aşağıdaki temel kaynaklara ihtiyaç duyulur:

IAM Rolü ve Politikası: Lambda fonksiyonunun AWS hizmetlerine (örneğin CloudWatch günlükleri yazma, S3’ten okuma) erişim izinlerini tanımlayan bir IAM rolü ve ilişkili politikalar.
S3 Kovası: Fonksiyon kodunun (ZIP dosyası) depolanacağı bir S3 kovası. Terraform, kodu S3’e yükler ve Lambda fonksiyonunu bu S3 nesnesinden dağıtır.
Lambda Fonksiyonu Kaynağı: aws_lambda_function kaynağı, fonksiyonun çalışma zamanı (runtime), bellek (memory), zaman aşımı (timeout) ve handler gibi özelliklerini tanımlar.

Function URL Entegrasyonu

Function URL’lerini Terraform ile entegre etmek oldukça basittir. aws_lambda_function_url kaynağını kullanarak, mevcut bir Lambda fonksiyonuna bir URL atayabilir ve yetkilendirme ile CORS ayarlarını yapılandırabilirsiniz. Ayrıca, bu URL’ye erişim izni vermek için aws_lambda_permission kaynağını da kullanmanız gerekebilir.

Go ile AWS Lambda Fonksiyonu Geliştirme ve Terraform Entegrasyonu

Go ile Lambda fonksiyonu geliştirmek, performans odaklı uygulamalar için mükemmel bir seçenektir. İşte basit bir Go Lambda fonksiyonu ve Terraform ile nasıl dağıtılacağı.

Go Fonksiyonu Yazımı (Basit HTTP Handler)

Bir Go Lambda fonksiyonu genellikle main paketinde bir main fonksiyonu ve github.com/aws/aws-lambda-go/lambda kütüphanesini kullanarak bir handler fonksiyonu içerir. Function URL’leri, standart HTTP isteklerini doğrudan Lambda’ya ilettiği için, Go’nun net/http paketi ile uyumlu bir handler yazmak en doğal yoldur.

// main.go
package main

import (
	"fmt"
	"net/http"
	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
)

func handler(request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	fmt.Printf("Processing request data for request %s.\n", request.RequestContext.RequestID)

	return events.APIGatewayProxyResponse{
		StatusCode: 200,
		Headers: map[string]string{"Content-Type": "text/plain"},
		Body:       fmt.Sprintf("Merhaba Go Lambda! İstek ID: %s", request.RequestContext.RequestID),
	}, nil
}

func main() {
	lambda.Start(handler)
}

Derleme ve Dağıtım Süreci (ZIP Paketi)

Go kodu, Lambda'ya dağıtılmadan önce derlenmelidir. AWS Lambda, Linux ortamında çalıştığı için çapraz derleme (cross-compilation) yapmanız gerekir. Ardından, derlenmiş ikili dosyayı bir ZIP arşivi içine koymanız yeterlidir.

GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -o main main.go
zip deployment_package.zip main

Bu deployment_package.zip dosyası S3'e yüklenerek Lambda tarafından kullanılacaktır.

Terraform ile Go Lambda Yapılandırması (Code Hashing, Runtime)

Terraform, Go Lambda fonksiyonunu dağıtmak için aws_lambda_function kaynağını kullanır. Kodun her değiştiğinde Lambda'nın güncellenmesini sağlamak için, ZIP dosyasının SHA256 hash değerini source_code_hash parametresine atamak önemlidir. Bu, Terraform'un kod değişikliğini algılamasını sağlar.

# S3 Kovası
resource "aws_s3_bucket" "lambda_bucket" {
  bucket = "go-python-lambda-code-${random_id.id.hex}"
}

# S3 Nesnesi (Go kodu)
resource "aws_s3_object" "go_lambda_code" {
  bucket = aws_s3_bucket.lambda_bucket.id
  key    = "go-lambda-function.zip"
  source = "deployment_package.zip" # Yerel ZIP dosyanız
  etag   = filemd5("deployment_package.zip") # Değişiklikleri algılamak için

  depends_on = [null_resource.go_build] # Go derleme adımı tamamlandıktan sonra
}

# IAM Rolü
resource "aws_iam_role" "go_lambda_exec_role" {
  name = "go_lambda_exec_role"
  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Action = "sts:AssumeRole"
      Effect = "Allow"
      Principal = {
        Service = "lambda.amazonaws.com"
      }
    }]
  })
}

resource "aws_iam_role_policy_attachment" "go_lambda_policy" {
  role       = aws_iam_role.go_lambda_exec_role.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
}

# Go Lambda Fonksiyonu
resource "aws_lambda_function" "go_example" {
  function_name    = "GoExampleFunction"
  s3_bucket        = aws_s3_bucket.lambda_bucket.id
  s3_key           = aws_s3_object.go_lambda_code.key
  handler          = "main" # Derlenmiş ikili dosyanın adı
  runtime          = "go1.x"
  role             = aws_iam_role.go_lambda_exec_role.arn
  memory_size      = 128
  timeout          = 30
  source_code_hash = data.archive_file.go_lambda_zip.output_base64sha256 # ZIP dosyasının hash'i
}

# Go Lambda Function URL
resource "aws_lambda_function_url" "go_example_url" {
  function_name      = aws_lambda_function.go_example.function_name
  authorization_type = "NONE" # Public erişim
  cors {
    allow_credentials = false
    allow_origins     = ["*"]
    allow_methods     = ["*"]
    allow_headers     = ["*"]
    expose_headers    = ["*"]
  }
}

# Function URL'e anonim erişim izni
resource "aws_lambda_permission" "go_example_url_permission" {
  statement_id   = "AllowPublicAccess"
  action         = "lambda:InvokeFunctionUrl"
  function_name  = aws_lambda_function.go_example.function_name
  principal      = "*"
  function_url_auth_type = "NONE"
}

# Go derleme adımını tetiklemek için null_resource
resource "null_resource" "go_build" {
  triggers = {
    always_run = timestamp() # Her Terraform plan/apply'de çalıştır
  }
  provisioner "local-exec" {
    command = "GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -o main go-lambda/main.go && zip -j go-lambda/deployment_package.zip go-lambda/main"
    working_dir = path.module
  }
}

# ZIP dosyasının hash'ini almak için data kaynağı
data "archive_file" "go_lambda_zip" {
  type        = "zip"
  source_file = "go-lambda/main"
  output_path = "go-lambda/deployment_package.zip"
}

Python ile AWS Lambda Fonksiyonu Geliştirme ve Terraform Entegrasyonu

Python, hızlı geliştirme ve zengin ekosistemi ile Lambda için popüler bir seçimdir. İşte basit bir Python Lambda fonksiyonu ve Terraform ile nasıl dağıtılacağı.

Python Fonksiyonu Yazımı (Basit HTTP Handler)

Python Lambda fonksiyonları genellikle lambda_handler adında bir fonksiyon içerir. Function URL'leri, API Gateway Proxy entegrasyonu gibi bir olay yapısı bekler, bu yüzden Python handler'ınız bu formatı işlemelidir.

# main.py
import json

def lambda_handler(event, context):
    print(f"Received event: {json.dumps(event)}")

    # Function URL'leri için API Gateway Proxy entegrasyonu benzeri bir yanıt döndürülür.
    return {
        "statusCode": 200,
        "headers": {
            "Content-Type": "text/plain"
        },
        "body": f"Merhaba Python Lambda! İstek ID: {context.aws_request_id}"
    }

Bağımlılık Yönetimi ve Dağıtım (venv, pip)

Python projelerinde harici kütüphaneler kullanılıyorsa, bu bağımlılıkların Lambda dağıtım paketine dahil edilmesi gerekir. Genellikle bir venv (sanal ortam) oluşturulur, bağımlılıklar pip ile yüklenir ve ardından tüm bu dosyalar ZIPlenir.

# Sanal ortam oluştur ve aktifleştir
python3 -m venv venv
source venv/bin/activate

# Bağımlılıkları yükle (eğer varsa, requirements.txt dosyasından)
# pip install -r requirements.txt

# Fonksiyon kodunu ve bağımlılıkları ZIPle
# Eğer bağımlılıklar varsa, venv/lib/pythonX.Y/site-packages içindeki her şeyi ZIP'e ekleyin.
zip -r deployment_package.zip main.py
# Örnek: zip -r deployment_package.zip main.py venv/lib/python3.9/site-packages

Terraform ile Python Lambda Yapılandırması (Runtime, Layers)

Python Lambda fonksiyonu için Terraform yapılandırması, Go'ya benzer ancak çalışma zamanı ve handler adlandırmasında farklılıklar gösterir. Bağımlılıklar için Lambda Katmanları (Layers) kullanmak, dağıtım paketini küçültmenin ve bağımlılıkları birden fazla fonksiyonda paylaşmanın iyi bir yoludur.

# S3 Kovası (öncekiyle aynı olabilir veya yeni oluşturulabilir)
# resource "aws_s3_bucket" "lambda_bucket" { ... }

# S3 Nesnesi (Python kodu)
resource "aws_s3_object" "python_lambda_code" {
  bucket = aws_s3_bucket.lambda_bucket.id
  key    = "python-lambda-function.zip"
  source = "python-lambda/deployment_package.zip" # Yerel ZIP dosyanız
  etag   = filemd5("python-lambda/deployment_package.zip")

  depends_on = [null_resource.python_build]
}

# IAM Rolü (öncekiyle aynı olabilir veya yeni oluşturulabilir)
# resource "aws_iam_role" "python_lambda_exec_role" { ... }
# resource "aws_iam_role_policy_attachment" "python_lambda_policy" { ... }

# Python Lambda Fonksiyonu
resource "aws_lambda_function" "python_example" {
  function_name    = "PythonExampleFunction"
  s3_bucket        = aws_s3_bucket.lambda_bucket.id
  s3_key           = aws_s3_object.python_lambda_code.key
  handler          = "main.lambda_handler" # Dosyaadı.fonksiyonadı
  runtime          = "python3.9" # Veya kullandığınız Python sürümü
  role             = aws_iam_role.go_lambda_exec_role.arn # Aynı rolü kullanabiliriz
  memory_size      = 128
  timeout          = 30
  source_code_hash = data.archive_file.python_lambda_zip.output_base64sha256
}

# Python Lambda Function URL
resource "aws_lambda_function_url" "python_example_url" {
  function_name      = aws_lambda_function.python_example.function_name
  authorization_type = "NONE"
  cors {
    allow_credentials = false
    allow_origins     = ["*"]
    allow_methods     = ["*"]
    allow_headers     = ["*"]
    expose_headers    = ["*"]
  }
}

# Function URL'e anonim erişim izni
resource "aws_lambda_permission" "python_example_url_permission" {
  statement_id   = "AllowPublicAccessPython"
  action         = "lambda:InvokeFunctionUrl"
  function_name  = aws_lambda_function.python_example.function_name
  principal      = "*"
  function_url_auth_type = "NONE"
}

# Python ZIP paketini oluşturmak için null_resource
resource "null_resource" "python_build" {
  triggers = {
    always_run = timestamp()
  }
  provisioner "local-exec" {
    command = "cd python-lambda && zip -r deployment_package.zip main.py && cd .."
    working_dir = path.module
  }
}

# ZIP dosyasının hash'ini almak için data kaynağı
data "archive_file" "python_lambda_zip" {
  type        = "zip"
  source_file = "python-lambda/main.py"
  output_path = "python-lambda/deployment_package.zip"
}

Performans, Maliyet ve Geliştirici Deneyimi Karşılaştırması

Go ve Python arasındaki seçim, sadece teknik özelliklere değil, aynı zamanda projenin genel gereksinimlerine ve ekibin dinamiklerine de bağlıdır.

Soğuk Başlangıç (Cold Start) ve Çalışma Zamanı Performansı

Go: Genellikle daha hızlı soğuk başlangıç sürelerine sahiptir. Derlenmiş, küçük ikili dosyaları sayesinde Lambda ortamında daha hızlı başlatılır. Çalışma zamanı performansı da CPU yoğun işlerde Python'a göre daha üstündür.
Python: Yorumlanmış bir dil olduğu için Go'ya göre daha uzun soğuk başlangıç süreleri yaşayabilir. Bağımlılıkların fazla olduğu durumlarda bu süre daha da artabilir. Çalışma zamanı performansı çoğu I/O yoğun iş için yeterli olsa da, CPU yoğun işlerde Go kadar verimli değildir.

Maliyet Etkileri (Bellek, Süre)

AWS Lambda, kullanılan bellek ve çalışma süresine göre faturalandırılır. Bu bağlamda:

Go: Genellikle daha az bellek tüketir ve daha hızlı çalıştığı için daha kısa süreler kullanır. Bu, özellikle yüksek hacimli veya performans kritik uygulamalarda daha düşük maliyetlere yol açabilir.
Python: Go'ya göre biraz daha fazla bellek tüketebilir ve daha uzun çalışma süreleri gerektirebilir. Ancak, çoğu senaryoda bu farklar ihmal edilebilir düzeyde kalabilir. Geliştirme hızı sayesinde pazara çıkış süresi (time-to-market) avantajı, potansiyel mikro maliyet farklarını dengeleyebilir.

Geliştirici Verimliliği ve Ekosistem

Go: Daha katı bir dil yapısına sahiptir ve öğrenme eğrisi Python'a göre biraz daha dik olabilir. Ancak, ekip Go'ya hakimse, güçlü tip sistemi ve eşzamanlılık özellikleri sayesinde büyük ölçekli ve performanslı sistemler geliştirmek için çok verimli olabilir. Ekosistemi büyümeye devam etse de, Python kadar geniş değildir.
Python: Hızlı prototipleme ve geliştirme için mükemmeldir. Geniş ve olgun ekosistemi, birçok farklı alanda hazır kütüphaneler sunar. Bu, geliştiricilerin tekerleği yeniden icat etmek yerine iş mantığına odaklanmasını sağlar. Büyük bir geliştirici topluluğu, öğrenmeyi ve sorun gidermeyi kolaylaştırır.

Aşağıdaki tablo, Go ve Python'ın temel karşılaştırmasını özetlemektedir:

Özellik	Go (Golang)	Python
Performans	Yüksek (Derlenmiş)	Orta (Yorumlanmış)
Soğuk Başlangıç	Çok Hızlı	Orta - Yavaş (Bağımlılığa bağlı)
Bellek Tüketimi	Düşük	Orta
Geliştirme Hızı	Orta - Yüksek	Çok Yüksek
Ekosistem	Gelişmekte	Çok Geniş ve Olgun
Öğrenme Eğrisi	Orta	Düşük
Kullanım Alanı	Performans kritik API'ler, mikroservisler	Hızlı API'ler, veri işleme, ML, otomasyon

Uygulamalı Bir Karşılaştırma: Terraform Shootout

Yukarıdaki kod örnekleri ve açıklamalar, Go ve Python Lambda fonksiyonlarını Function URL'leri ile Terraform kullanarak nasıl dağıtacağınızı göstermektedir. Bu "shootout" (karşılaştırma), iki dilin aynı altyapı yönetimi aracıyla nasıl entegre olduğunu pratik bir şekilde ortaya koyar.

Ortak Terraform Modülleri ve Yapılandırma

Her iki dil için de IAM rolleri, S3 kovaları gibi temel altyapı bileşenleri ortak olabilir veya ayrı ayrı tanımlanabilir. Modüler bir Terraform yapısı, bu ortak bileşenleri tek bir yerde tanımlayıp farklı Lambda fonksiyonları için yeniden kullanmaya olanak tanır. Örneğin, temel bir Lambda yürütme rolü her iki fonksiyon için de kullanılabilir.

# Ortak IAM Rolü
resource "aws_iam_role" "lambda_exec_role" {
  name = "common_lambda_exec_role"
  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Action = "sts:AssumeRole"
      Effect = "Allow"
      Principal = {
        Service = "lambda.amazonaws.com"
      }
    }]
  })
}

resource "aws_iam_role_policy_attachment" "lambda_policy" {
  role       = aws_iam_role.lambda_exec_role.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
}

# Ortak S3 Kovası
resource "aws_s3_bucket" "lambda_code_bucket" {
  bucket = "common-go-python-lambda-code-${random_id.id.hex}"
  force_destroy = true # Dikkat: Üretimde kullanılmamalıdır
}

Bu ortak kaynaklar tanımlandıktan sonra, Go ve Python fonksiyonları kendi özel yapılandırmalarıyla bu ortak kaynakları kullanabilir.

Go ve Python Fonksiyonlarının Dağıtımı

Terraform'u kullanarak her iki fonksiyonu da aynı anda dağıtabilirsiniz. Her bir fonksiyon için ayrı aws_lambda_function ve aws_lambda_function_url kaynakları tanımlayarak, AWS üzerinde iki ayrı Lambda fonksiyonu ve onlara özel Function URL'leri oluşturulur.

Dağı

Go vs Python AWS Lambda’da: Pratik Bir Terraform Karşılaştırması (Function URL’leri ile)