Özel Bir Terraform Modülü Nasıl Oluşturulur?

Giriş

Modern bulut altyapısı yönetimi, karmaşıklığı azaltmak, tekrarlanabilirliği sağlamak ve süreçleri otomatikleştirmek üzerine kuruludur. Bu hedeflere ulaşmak için “altyapıyı kod olarak” (Infrastructure as Code – IaC) yaklaşımı benimsenmiştir. IaC araçları arasında Terraform, bulut sağlayıcısından bağımsız yapısı ve geniş ekosistemi sayesinde öne çıkmaktadır. Terraform, altyapıyı bildirimsel bir sözdizimi kullanarak tanımlamanıza, sağlamanıza ve yönetmenize olanak tanır.

Terraform’un temel taşlarından biri de modüllerdir. Modüller, bir veya daha fazla kaynak için yapılandırmaları kapsülleyen ve yeniden kullanılabilir birimler halinde paketleyen self-contained Terraform yapılandırmalarıdır. Bu makale, kendi özel Terraform modüllerinizi nasıl oluşturacağınızı, bunların faydalarını, temel bileşenlerini ve en iyi uygulamalarını detaylı bir şekilde ele alacaktır. Kendi modüllerinizi oluşturmak, organizasyonunuzun özel ihtiyaçlarına uygun, standartlaştırılmış ve bakımı kolay altyapı bileşenleri geliştirmenizi sağlar.

Terraform Modülleri Neden Önemlidir?

Modüller, Terraform’un gücünü ve esnekliğini artıran kritik bir özelliktir. İşte modüllerin sağladığı başlıca faydalar:

Yeniden Kullanılabilirlik (Reusability): Aynı altyapı bileşenlerini (örneğin, bir VPC, bir veritabanı, bir depolama kovası) farklı projelerde veya ortamlarda tekrar tekrar kullanmanızı sağlar. Bu, kod tekrarını azaltır ve geliştirme hızını artırır.
Standartlaştırma (Standardization): Modüller, organizasyonunuzun en iyi uygulamalarını, güvenlik politikalarını ve adlandırma kurallarını kod içinde zorunlu kılarak altyapı bileşenlerinizde tutarlılık sağlar.
Kapsülleme (Encapsulation): Karmaşık altyapı yapılandırmalarını soyutlayarak, modül kullanıcılarının iç detaylarla uğraşmasına gerek kalmadan yüksek seviyeli bir arayüz sunar. Bu, modülün kullanımını basitleştirir.
İşbirliği (Collaboration): Ekip üyeleri, farklı modüller üzerinde bağımsız olarak çalışabilir ve bu modülleri bir araya getirerek daha büyük altyapı yığınları oluşturabilirler.
Karmaşıklık Yönetimi (Complexity Management): Büyük ve karmaşık altyapıları daha küçük, yönetilebilir parçalara ayırarak genel karmaşıklığı azaltır.

Hazır modüller (Terraform Registry’deki gibi) harika olsa da, bazen organizasyonunuzun özel ihtiyaçlarına veya dahili standartlarına tam olarak uymayabilirler. Bu durumlarda, özel modüller geliştirmek, size tam kontrol ve esneklik sağlar.

Modül Temelleri

Her Terraform yapılandırması, en azından bir “root modül” olarak adlandırılan bir modüle sahiptir. Bu, terraform apply komutunu çalıştırdığınız dizindir. Bir modül, aşağıdaki temel dosyaları ve dizinleri içerir:

Modül Yapısı

Tipik bir modül dizini aşağıdaki gibi görünür:


my-module/
├── main.tf
├── variables.tf
├── outputs.tf
├── versions.tf
├── locals.tf (isteğe bağlı)
├── README.md
└── examples/ (isteğe bağlı)
    └── basic-usage/
        └── main.tf

main.tf: Modülün ana kaynaklarını ve veri kaynaklarını tanımlayan dosyadır. Burası, modülün sağladığı asıl altyapı bileşenlerinin bulunduğu yerdir.
variables.tf: Modülün dışarıdan alacağı giriş değişkenlerini tanımlar. Bu değişkenler, modülün davranışını ve oluşturduğu kaynakların özelliklerini özelleştirmek için kullanılır.
outputs.tf: Modülün dışarıya açtığı çıkış değerlerini tanımlar. Bu değerler, modülü çağıran diğer yapılandırmalar veya modüller tarafından kullanılabilir.
versions.tf: Modülün gerektirdiği Terraform sürümünü ve sağlayıcı (provider) sürümlerini belirtir. Bu, uyumluluk sorunlarını önlemek için önemlidir.
locals.tf: (İsteğe bağlı) Yerel değerleri tanımlar. Yerel değerler, modül içinde tekrarlayan ifadeleri veya karmaşık hesaplamaları basitleştirmek için kullanılır. DRY (Don’t Repeat Yourself) prensibini uygulamaya yardımcı olur.
README.md: Modülün amacını, kullanımını, giriş değişkenlerini, çıkış değerlerini ve örneklerini açıklayan bir belgedir. İyi bir README.md modülün anlaşılabilirliğini ve kullanılabilirliğini büyük ölçüde artırır.
examples/: (İsteğe bağlı) Modülün nasıl kullanılacağına dair örnek yapılandırmaları içerir. Bu, modül kullanıcıları için hızlı başlangıç kılavuzu görevi görür.

Giriş Değişkenleri (`variables.tf`)

Giriş değişkenleri, modülünüzün esnekliğini sağlar. Bir değişken tanımlarken, aşağıdaki özellikleri kullanabilirsiniz:

description: Değişkenin amacını açıklayan bir metin.
type: Değişkenin veri tipini belirtir (string, number, bool, list, map, object).
default: Değişken için varsayılan bir değer. Bu, değişkenin isteğe bağlı olmasını sağlar.
validation: (Terraform 0.13+ ile geldi) Değişkenin değerini doğrulamak için özel kurallar tanımlar.
sensitive: (Terraform 0.14+ ile geldi) Bu değişkenin değerinin Terraform çıktılarında (plan, apply) gizlenmesini sağlar. Şifreler veya API anahtarları gibi hassas bilgiler için kullanılır.

Örnek bir değişken tanımı:


variable "bucket_name" {
  description = "S3 kovasının benzersiz adı."
  type        = string
  default     = null # Varsayılan olarak boş bırakılır, kullanıcı tarafından sağlanması beklenir.

  validation {
    condition     = length(var.bucket_name) > 0 && can(regex("^[a-z0-9.-]+$", var.bucket_name))
    error_message = "Kova adı boş olamaz ve sadece küçük harf, rakam, nokta ve tire içermelidir."
  }
}

variable "tags" {
  description = "Kovaya uygulanacak etiketler."
  type        = map(string)
  default     = {}
}

Çıkış Değerleri (`outputs.tf`)

Çıkış değerleri, modülün oluşturduğu veya hesapladığı bilgileri dış dünyaya açar. Bu bilgiler, diğer modüller veya root yapılandırması tarafından kullanılabilir.

value: Çıkarılacak değer. Bu genellikle bir kaynağın niteliği veya bir yerel değerdir.
description: Çıkış değerinin amacını açıklayan bir metin.
sensitive: (Terraform 0.14+ ile geldi) Bu çıkış değerinin Terraform çıktılarında gizlenmesini sağlar.

Örnek bir çıkış tanımı:


output "bucket_arn" {
  description = "Oluşturulan S3 kovasının ARN'si."
  value       = aws_s3_bucket.this.arn
}

output "bucket_id" {
  description = "Oluşturulan S3 kovasının ID'si."
  value       = aws_s3_bucket.this.id
}

Yerel Değerler (`locals.tf`)

Yerel değerler, modül içindeki karmaşık ifadeleri veya tekrarlayan değerleri basitleştirmek için kullanılır. Bunlar, değişkenler gibi dışarıdan beslenmez, yalnızca modül içinde tanımlanır ve kullanılır.

Örnek bir yerel değer tanımı:


locals {
  full_bucket_name = var.environment == "prod" ? var.bucket_name : "${var.environment}-${var.bucket_name}"
  common_tags = merge(var.tags, {
    Environment = var.environment
    ManagedBy   = "Terraform"
  })
}

Bu full_bucket_name ve common_tags değerleri, main.tf içindeki kaynaklarda local.full_bucket_name ve local.common_tags olarak kullanılabilir.

Örnek Bir Modül Oluşturma: AWS S3 Kovası

Şimdi, standartlaştırılmış bir AWS S3 kovası oluşturan basit bir modül geliştirelim. Bu modül, kova adı, etiketler, erişim ayarları ve şifreleme gibi temel özellikleri yapılandırmamıza olanak tanıyacak.

Senaryo

Amacımız, aşağıdaki özelliklere sahip bir S3 kovası oluşturmak için bir modül geliştirmektir:

Benzersiz bir kova adı alabilmeli.
Ortam ve diğer özel etiketleri desteklemeli.
Varsayılan olarak genel erişimi engellemeli.
Sürümleme (versioning) isteğe bağlı olarak etkinleştirilebilmeli.
Varsayılan sunucu tarafı şifrelemesi (SSE-S3) olmalı.

Adım 1: Modül Dizini Oluşturma

Modül için bir dizin oluşturun:


mkdir s3-bucket
cd s3-bucket

Adım 2: `versions.tf` İçeriği

Gerekli Terraform ve AWS sağlayıcı sürümlerini belirtin:


s3-bucket/versions.tf
terraform {
  required_version = ">= 1.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

Adım 3: `variables.tf` İçeriği

Modülün alacağı giriş değişkenlerini tanımlayın:


s3-bucket/variables.tf

variable "bucket_name" {
  description = "S3 kovasının benzersiz adı. Boş bırakılırsa otomatik oluşturulur."
  type        = string
  default     = null # Eğer null ise, Terraform otomatik bir isim oluşturur.
}

variable "environment" {
  description = "Modülün dağıtıldığı ortam (örneğin, dev, staging, prod)."
  type        = string
  default     = "dev"
}

variable "tags" {
  description = "Kovaya uygulanacak ek etiketler."
  type        = map(string)
  default     = {}
}

variable "block_public_acls" {
  description = "S3 kovası için genel ACL'leri engelle."
  type        = bool
  default     = true
}

variable "ignore_public_acls" {
  description = "S3 kovası için genel ACL'leri yoksay."
  type        = bool
  default     = true
}

variable "restrict_public_buckets" {
  description = "S3 kovası için genel kova politikalarını kısıtla."
  type        = bool
  default     = true
}

variable "block_public_policy" {
  description = "S3 kovası için genel kova politikalarını engelle."
  type        = bool
  default     = true
}

variable "versioning_enabled" {
  description = "S3 kova sürümlemeyi etkinleştir."
  type        = bool
  default     = true
}

variable "acl" {
  description = "S3 kovasının erişim kontrol listesi (ACL)."
  type        = string
  default     = "private"
  validation {
    condition     = contains(["private", "public-read", "public-read-write", "aws-exec-read", "authenticated-read", "bucket-owner-read", "bucket-owner-full-control", "log-delivery-write"], var.acl)
    error_message = "Geçersiz ACL değeri. Desteklenen değerler: private, public-read, public-read-write, aws-exec-read, authenticated-read, bucket-owner-read, bucket-owner-full-control, log-delivery-write."
  }
}

Adım 4: `locals.tf` İçeriği (İsteğe Bağlı ama Faydalı)

Ortak etiketleri ve kova adını yönetmek için yerel değerler kullanın:


s3-bucket/locals.tf

locals {
  # Eğer bucket_name sağlanmadıysa, otomatik bir isim oluşturulur.
  # Eğer sağlandıysa, ortam öneki eklenir (prod hariç).
  final_bucket_name = var.bucket_name != null ? (
    var.environment == "prod" ? var.bucket_name : "${var.environment}-${var.bucket_name}"
  ) : null # Eğer null ise, aws_s3_bucket kaynağı otomatik bir isim oluşturur.

  # Ortak etiketleri birleştir
  common_tags = merge(var.tags, {
    Environment = var.environment
    ManagedBy   = "Terraform"
    Module      = "s3-bucket"
  })
}

Adım 5: `main.tf` İçeriği

S3 kovasını ve ilgili ayarları tanımlayın:


s3-bucket/main.tf

resource "aws_s3_bucket" "this" {
  # Eğer locals.final_bucket_name null ise, bucket özelliği kullanılmaz ve AWS otomatik bir isim atar.
  # Aksi takdirde, locals.final_bucket_name kullanılır.
  bucket = local.final_bucket_name

  acl    = var.acl
  tags   = local.common_tags
}

resource "aws_s3_bucket_public_access_block" "this" {
  bucket = aws_s3_bucket.this.id

  block_public_acls       = var.block_public_acls
  ignore_public_acls      = var.ignore_public_acls
  restrict_public_buckets = var.restrict_public_buckets
  block_public_policy     = var.block_public_policy
}

resource "aws_s3_bucket_versioning" "this" {
  bucket = aws_s3_bucket.this.id
  versioning_configuration {
    status = var.versioning_enabled ? "Enabled" : "Suspended"
  }
}

resource "aws_s3_bucket_server_side_encryption_configuration" "this" {
  bucket = aws_s3_bucket.this.id

  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm = "AES256"
    }
  }
}

Adım 6: `outputs.tf` İçeriği

Modülün dışarıya açacağı değerleri tanımlayın:


s3-bucket/outputs.tf

output "bucket_id" {
  description = "Oluşturulan S3 kovasının ID'si (adı)."
  value       = aws_s3_bucket.this.id
}

output "bucket_arn" {
  description = "Oluşturulan S3 kovasının ARN'si."
  value       = aws_s3_bucket.this.arn
}

output "bucket_domain_name" {
  description = "Oluşturulan S3 kovasının domain adı."
  value       = aws_s3_bucket.this.bucket_domain_name
}

Adım 7: `README.md` Oluşturma

Modülün kullanımını açıklayan bir README.md dosyası ekleyin:

s3-bucket Terraform Modülü Bu modül, standartlaştırılmış bir AWS S3 kovası oluşturur. Varsayılan olarak genel erişimi engeller, sunucu tarafı şifrelemeyi (SSE-S3) etkinleştirir ve sürümlemeyi destekler. Kullanım module "my_s3_bucket" { source = "./s3-bucket" # Yerel bir dizin veya Git deposu olabilir. bucket_name = "my-unique-application-bucket" environment = "prod" versioning_enabled = true tags = { Application = "MyApp" Owner = "DevOpsTeam" } } output "s3_bucket_id" { value = module.my_s3_bucket.bucket_id } Girişler | İsim | Açıklama | Tip | Varsayılan | Gerekli | |---------------------------|------------------------------------------------|-------------|------------|---------| | acl | S3 kovasının erişim kontrol listesi (ACL). | string | "private"| no | | block_public_acls | S3 kovası için genel ACL'leri engelle. | bool | true | no | | block_public_policy | S3 kovası için genel kova politikalarını engelle.| bool | true | no | | bucket_name | S3 kovasının benzersiz adı. Boş bırakılırsa otomatik oluşturulur. | string | null | no | | environment | Modülün dağıtıldığı ortam. | string | "dev" | no | | ignore_public_acls | S3 kovası için genel ACL'leri yoksay. | bool | true | no | | restrict_public_buckets | S3 kovası için genel kova politikalarını kısıtla.| bool | true | no | | tags | Kovaya uygulanacak ek etiketler. | map(string)| {} | no | | versioning_enabled | S3 kova sürümlemeyi etkinleştir. | bool | true | no | Çıkışlar

| İsim | Açıklama | |--------------------|------------------------------------------| | bucket_arn | Oluşturulan S3 kovasının ARN'si. | | bucket_id | Oluşturulan S3 kovasının ID'si (adı). | | bucket_domain_name | Oluşturulan S3 kovasının domain adı. |

Adım 8: `examples/` Dizini Oluşturma

Modülün nasıl kullanılacağına dair örnek bir yapılandırma oluşturun.
Ana dizine geri dönüp bir examples dizini oluşturun:


cd ..
mkdir examples
mkdir examples/basic-s3-usage

Şimdi examples/basic-s3-usage/main.tf dosyasını oluşturun:


examples/basic-s3-usage/main.tf

provider "aws" {
  region = "us-east-1" # Modülü test etmek için bir bölge belirtin
}

module "my_app_s3_bucket" {
  source = "../../s3-bucket" # Modülün göreceli yolu

  bucket_name        = "my-awesome-app-data"
  environment        = "staging"
  versioning_enabled = true
  tags = {
    Project = "AwesomeApp"
    Owner   = "PlatformTeam"
  }
}

output "staging_bucket_id" {
  description = "Staging ortamı için S3 kovasının ID'si."
  value       = module.my_app_s3_bucket.bucket_id
}

output "staging_bucket_arn" {
  description = "Staging ortamı için S3 kovasının ARN'si."
  value       = module.my_app_s3_bucket.bucket_arn
}

Modülü Kullanma ve Test Etme

Modülünüzü oluşturduktan sonra, onu çağıran bir yapılandırma ile test etmeniz gerekir. examples/basic-s3-usage dizinindeki örneği kullanarak test edelim.

Modülü Çağırma

Modüller, module bloğu kullanılarak çağrılır. source bağımsız değişkeni, modülün nerede bulunduğunu belirtir. Bu, yerel bir dosya sistemi yolu, bir Git deposu URL’si veya Terraform Registry’deki bir modül olabilir.


module "module_adı" {
  source = "./modül_dizini" # Yerel modül
  # source = "git::https://example.com/repo.git?ref=v1.0.0" # Git deposu
  # source = "hashicorp/s3-bucket/aws" # Terraform Registry

  giriş_değişkeni_1 = "değer_1"
  giriş_değişkeni_2 = "değer_2"
}

Terraform Komutları

Örnek dizinine gidin ve aşağıdaki Terraform komutlarını çalıştırın:


cd examples/basic-s3-usage

terraform init

Bu komut, modülü indirir ve gerekli sağlayıcıları kurar.


terraform plan

Bu komut, Terraform’un uygulayacağı değişiklikleri gösterir. Modülünüzün beklenen kaynakları oluşturup oluşturmadığını ve değişkenlerin doğru şekilde işlendiğini kontrol edin.


terraform apply

Bu komut, planlanan değişiklikleri uygular ve S3 kovasını AWS hesabınızda oluşturur.


terraform destroy

Testleriniz bittiğinde kaynakları temizlemek için bu komutu kullanın.

Test Stratejileri

Manuel Test: Geliştirmenin ilk aşamalarında terraform plan ve terraform apply ile manuel olarak kontrol etmek faydalıdır.
Otomatik Testler: Daha olgun modüller için otomatik test araçları kullanmak önemlidir.
- Terratest: Go dilinde yazılmış bir kütüphanedir ve gerçek altyapı üzerinde entegrasyon testleri yapmanızı sağlar.
- Kitchen-Terraform: Test Kitchen çerçevesini kullanarak Terraform modüllerini test etmenizi sağlar.
- InSpec/Serverspec: Sağlanan altyapının beklenen durumu karşılayıp karşılamadığını doğrulayan denetim araçlarıdır.
Statik Analiz: Kod kalitesini ve güvenlik açıklarını kontrol etmek için araçlar:
- Terraform Validate: Terraform yapılandırmasının sözdizimsel olarak geçerli olup olmadığını kontrol eder.
- TFLint: Terraform kodunuzda hataları, tutarsızlıkları ve en iyi uygulama ihlallerini bulan bir linter.
- Checkov: Bulut yapılandırmalarındaki güvenlik ve uyumluluk sorunlarını bulan bir statik analiz aracı.

İyi Uygulama Örnekleri ve İpuçları

Modülerlik ve Tek Sorumluluk Prensibi (SRP)

Her modülün tek bir şeyi iyi yapmasını sağlayın. Örneğin, bir S3 kovası modülü yalnızca S3 kovasıyla ilgili kaynakları ve yapılandırmaları içermelidir, bir EC2 örneği veya bir veritabanı ile ilgili kaynakları değil. Bu, modüllerinizi daha anlaşılır, bakımı kolay ve yeniden kullanılabilir hale getirir.

Versiyonlama

Modüllerinizi anlamsal versiyonlama (Semantic Versioning – SemVer) kurallarına göre versiyonlayın (örneğin, v1.0.0, v1.1.0, v2.0.0). Bu, modül kullanıcılarının bağımlılıkları yönetmelerine ve kırıcı değişikliklerden kaçınmalarına yardımcı olur. Bir modülün versions.tf dosyasında required_version ve required_providers bloklarını kullanarak bağımlılıkları açıkça belirtin.

Kapsamlı Dokümantasyon (`README.md`)

Modülünüzün README.md dosyası, modülün amacı, nasıl kullanılacağı, tüm giriş değişkenleri (açıklamaları, tipleri, varsayılan değerleri) ve çıkış değerleri hakkında net ve eksiksiz bilgi içermelidir. İyi dokümantasyon, modülünüzün benimsenmesini ve doğru kullanılmasını sağlar.

Giriş Değişkenleri Tasarımı

Minimum Gerekli Değişkenler: Yalnızca modülün esnekliği için kesinlikle gerekli olan değişkenleri tanımlayın. Çok fazla değişken, modülü karmaşık hale getirebilir.
Mantıklı Varsayılan Değerler: Mümkün olduğunca varsayılan değerler sağlayın. Bu, modülün kullanımını basitleştirir ve kullanıcıların yalnızca özel gereksinimleri olduğunda değişkenleri geçirmesini sağlar.
validation Blokları: Giriş değişkenlerinin beklenen formatta veya aralıkta olduğunu doğrulamak için validation bloklarını kullanın. Bu, hataları erken aşamada yakalamanıza yardımcı olur.
Karmaşık Tipler (list, map, object): Benzer yapıdaki birden çok kaynağı veya karmaşık yapılandırmaları yönetmek için list, map veya object tiplerini kullanmaktan çekinmeyin.

Çıkış Değerleri

Yalnızca modülün dışına açılması gereken değerleri çıkış olarak tanımlayın. Modülün iç detaylarını gereksiz yere dışarıya sızdırmayın. Hassas bilgileri (örneğin, veritabanı şifreleri) sensitive = true ile işaretleyin.

Yerel Değerler

Tekrarlayan ifadeleri, karmaşık hesaplamaları veya türetilmiş değerleri basitleştirmek için locals bloklarını kullanın. Bu, kodunuzu daha okunabilir ve bakımı kolay hale getirir.

Sağlayıcı Blokları

Modül içinde sağlayıcı (provider) blokları tanımlamaktan kaçının (örneğin, provider "aws" { ... }). Sağlayıcı yapılandırması genellikle root modülde yapılmalı ve modül, root modülün sağlayıcı yapılandırmasını devralmalıdır. Bu, modülün farklı AWS hesaplarında veya bölgelerinde kolayca kullanılmasını sağlar.

Terraform Registry

Eğer modülünüzü geniş bir kitleyle paylaşmayı planlıyorsanız, Terraform Registry’yi kullanmayı düşünün. Registry, modülünüzü dağıtmak, keşfedilebilirliğini artırmak ve versiyonlamayı yönetmek için bir platform sağlar.

Kullanım Örnekleri (`examples/`)

Modülünüzün nasıl kullanılacağını gösteren basit ve anlaşılır örnekler içeren bir examples/ dizini ekleyin. Bu, kullanıcıların modülü hızlı bir şekilde anlamalarına ve entegre etmelerine yardımcı olur.

Gelişmiş Konulara Kısa Bir Bakış

Koşullu Kaynaklar (`count` ve `for_each`)

Bazen bir modülün belirli bir kaynağı oluşturup oluşturmayacağına karar vermesi gerekebilir. Bunu count veya for_each meta-argümanları ile yapabilirsiniz:

count: Bir kaynak örneğinin oluşturulup oluşturulmayacağını veya kaç tane oluşturulacağını kontrol eder. count = var.enable_resource ? 1 : 0 gibi ifadelerle koşullu olarak kaynak oluşturabilirsiniz.
for_each: Bir map veya set’teki her öğe için bir kaynak örneği oluşturur. Bu, daha dinamik ve esnek kaynak oluşturma senaryoları için idealdir.

Dinamik Bloklar

Dinamik bloklar, bir kaynak içindeki tekrarlayan blokları (örneğin, bir güvenlik grubundaki ingress kuralları) programatik olarak oluşturmanıza olanak tanır. Bu, modülünüzün daha esnek ve yapılandırılabilir olmasını sağlar.

Modül Kaynakları

Modüller, farklı kaynaklardan yüklenebilir:

Yerel Dosya Sistemi: Aynı depoda veya yerel bir yolda bulunan modüller (source = "./modules/my-module").
Uzak Git Depoları: GitHub, GitLab, Bitbucket gibi Git depolarında barındırılan modüller (source = "git::https://github.com/org/repo.git?ref=v1.0.0").
Terraform Registry: HashiCorp’un resmi modül kayıt defteri (source = "hashicorp/vpc/aws").
HTTP/S3/GCS: Tarball olarak depolanan modüller.

Meta-Arguments (`depends_on`, `lifecycle`)

Gelişmiş senaryolarda depends_on ile kaynaklar arasındaki örtük bağımlılıkların yeterli olmadığı durumlarda açık bağımlılıklar tanımlayabilir veya lifecycle blokları ile kaynakların yaşam döngüsü davranışlarını (örneğin, prevent_destroy, ignore_changes) özelleştirebilirsiniz.

Sonuç

Terraform modülleri, altyapıyı kod olarak yönetmenin temel bir parçasıdır. Kendi özel modüllerinizi oluşturmak, organizasyonunuzun altyapı dağıtım süreçlerini standartlaştırmanın, otomatikleştirmeyi artırmanın ve karmaşıklığı yönetmenin güçlü bir yoludur. Bu makalede ele alınan adımları ve en iyi uygulamaları takip ederek, yeniden kullanılabilir, bakımı kolay ve sağlam Terraform modülleri geliştirebilirsiniz.

Modül geliştirme, sürekli bir öğrenme ve iyileştirme sürecidir. Topluluktan ilham alın, açık kaynak modülleri inceleyin ve kendi modüllerinizi geliştirirken esnekliği, güvenliği ve performansını her zaman göz önünde bulundurun. İyi tasarlanmış modüller, DevOps ekiplerinin verimliliğini artırırken, altyapı tutarlılığını ve güvenliğini sağlamaya yardımcı olur. Özel modüllerinizle, altyapı yönetiminde bir sonraki seviyeye geçmeye hazırsınız.

Özel Bir Terraform Modülü Nasıl Oluşturulur?