Neden Terraform Değişken Yönetimi Hayati Önem Taşıyor?

Birçok kuruluş, bulut altyapılarını yönetmek için manuel süreçlere veya betik yığınlarına güvenmekten vazgeçip Infrastructure as Code (IaC) paradigmalarına geçiş yapıyor. Terraform, bu geçişte en popüler ve güçlü araçlardan biri olarak öne çıkıyor. Ancak, bir altyapıyı kod ile tanımlamak yalnızca statik kaynakları oluşturmak anlamına gelmez. Gerçek dünya senaryolarında, aynı kod tabanının farklı parametrelerle yeniden kullanılabilir olması beklenir. Örneğin, geliştirme ortamınızda küçük ve uygun maliyetli sunucular kullanırken, üretim ortamınızda yüksek performanslı ve yedekli sunuculara ihtiyaç duyabilirsiniz. Veritabanı boyutu, ağ yapılandırması, güvenlik grupları ve hatta kaynak etiketleri bile ortamdan ortama değişiklik gösterebilir.

Bu değişkenliği yönetmek için her ortam için ayrı bir Terraform yapılandırma dosyası seti oluşturmak, kısa vadede pratik görünse de, uzun vadede sürdürülemez bir karmaşaya yol açar. Ortak bir değişiklik yapmanız gerektiğinde, bu değişikliği tüm kopyalara manuel olarak uygulamanız gerekir ki bu da hata riskini artırır ve zaman kaybına neden olur. İşte bu noktada Terraform değişkenleri devreye girer. Değişkenler, yapılandırma kodunuzu parametreleştirmemizi sağlar, böylece bir değerin sabit kodlanması yerine, dışarıdan beslenebilen bir yer tutucu haline gelir. Bu, kodunuzu daha esnek, tekrar kullanılabilir ve bakımı kolay hale getirir. Değişkenleri tanımladıktan sonra, bu değişkenlere değer atamanın birçok yolu vardır ve tfvars dosyaları, bu yöntemler arasında en organize ve yaygın olarak kullanılanlardan biridir. tfvars dosyaları, belirli bir ortam veya senaryo için tüm değişken değerlerini tek bir yerde toplamanıza olanak tanıyarak altyapı yönetiminizi önemli ölçüde basitleştirir. Bu sayede, aynı Terraform kodunu kullanarak sadece bir tfvars dosyasını değiştirerek farklı bulut altyapısı ortamlarını kolayca dağıtabilirsiniz. Böylece, hem çevikliği artırır hem de tutarlılığı sağlarsınız.

Terraform Değişkenleri ve tfvars Dosyaları Nelerdir?

Terraform, altyapı kaynaklarını tanımlamak için HashiCorp Configuration Language (HCL) kullanır. Bu dilin önemli özelliklerinden biri de değişkenleri tanımlama ve kullanma yeteneğidir. Terraform değişkenleri, yapılandırma dosyalarınızdaki değerleri soyutlamanıza olanak tanır. Yani, bir sunucu türünü veya bir bölge adını doğrudan kodunuza yazmak yerine, bu değerleri bir değişkene atayabilir ve kodunuzda bu değişkeni kullanabilirsiniz. Bu, kodunuzu daha genel ve tekrar kullanılabilir hale getirir.

Peki, bu değişkenlere değerleri nasıl atıyoruz? İşte burada tfvars dosyaları devreye giriyor. Bir tfvars dosyası, Terraform değişkenlerinize değer atamak için kullanılan basit bir anahtar-değer çiftleri koleksiyonudur. Bu dosyalar genellikle .tfvars uzantısına sahiptir (örneğin, terraform.tfvars, production.tfvars, development.tfvars).

tfvars Dosyalarının Rolü ve Avantajları Nelerdir?

tfvars dosyalarının temel amacı, değişken değerlerini Terraform yapılandırma kodunuzdan ayırmaktır. Bu ayrım, birçok önemli avantaj sunar:

• Tekrar Kullanılabilirlik: Aynı Terraform modülünü veya kök yapılandırmasını farklı ortamlarda (dev, test, prod) veya farklı müşteriler için kullanabilirsiniz. Sadece ilgili tfvars dosyasını değiştirmeniz yeterlidir.
• Okunabilirlik ve Bakım Kolaylığı: Değişken değerleri ayrı bir dosyada toplandığında, yapılandırma kodunuz daha temiz ve okunur hale gelir. Hangi değişkenin hangi değeri aldığını görmek çok daha kolaylaşır.
• Güvenlik: Hassas verileri (API anahtarları, veritabanı şifreleri vb.) doğrudan main.tf gibi ana yapılandırma dosyalarında saklamak yerine, bunları tfvars dosyalarına taşıyabilirsiniz. Bu dosyaları daha sonra CI/CD boru hatlarında güvenli bir şekilde yönetmek veya hassas veriler için ek güvenlik önlemleri almak daha kolaydır (ancak hassas verilerin tfvars içinde doğrudan plaintext olarak saklanması hala önerilmez, bu konuya ileri düzey bölümde değineceğiz).
• Ortamlar Arası Tutarlılık: Farklı ortamlar için yalnızca değişken değerlerinin değiştiği ve temel altyapı tanımının aynı kaldığı garantilenir. Bu, "dev ile prod arasında fark yok" felsefesini destekler.
• Otomasyon Dostu: CI/CD (Sürekli Entegrasyon/Sürekli Dağıtım) boru hatlarında, farklı tfvars dosyalarını komut satırı argümanları olarak kolayca geçirebilir ve böylece dağıtım süreçlerinizi otomatikleştirmenize olanak tanır.

tfvars dosyaları, karmaşık bulut altyapılarının yönetiminde esneklik ve kontrol sağlayarak IaC prensiplerini gerçekten hayata geçirir. İster tek bir bulut sağlayıcısında ister çoklu bulut ortamında çalışıyor olun, tfvars dosyaları, altyapınızın dinamik ve uyarlanabilir kalmasını sağlamak için vazgeçilmez bir araçtır.

Adım Adım tfvars Dosyaları Nasıl Oluşturulur ve Kullanılır?

Terraform'da tfvars dosyalarını kullanmak oldukça basittir ancak doğru adımları izlemek önemlidir. Bu bölümde, değişkenleri tanımlamaktan, tfvars dosyaları oluşturmaya ve bunları Terraform ile kullanmaya kadar tüm süreci adım adım inceleyeceğiz.

Basit Bir Değişken Tanımlama ve Kullanma

Öncelikle, Terraform'un hangi değişkenleri beklediğini belirtmemiz gerekiyor. Bunun için genellikle variables.tf adında bir dosya oluşturulur.

Adım 1: variables.tf Dosyası Oluşturma

# variables.tf
variable "instance_type" {
  description = "EC2 instance type"
  type        = string
  default     = "t2.micro" # Varsayılan bir değer atanabilir
}

variable "region" {
  description = "AWS region"
  type        = string
  default     = "us-east-1"
}

variable "ami_id" {
  description = "AMI ID for the EC2 instance"
  type        = string
}

Yukarıdaki örnekte, üç değişken tanımladık: instance_type, region ve ami_id. İlk ikisine varsayılan değerler atadık, bu da eğer bir değer sağlamazsanız Terraform'un bu varsayılanları kullanacağı anlamına gelir. ami_id değişkenine ise bir varsayılan atamadık; bu, Terraform'un bu değişken için bir değerin mutlaka sağlanmasını bekleyeceği anlamına gelir.

Adım 2: main.tf Dosyasında Değişkenleri Kullanma

Şimdi bu değişkenleri altyapı kodumuzda nasıl kullanacağımıza bakalım. Genellikle main.tf adında bir dosya içinde kaynaklarımızı tanımlarız.

# main.tf
provider "aws" {
  region = var.region # Tanımladığımız 'region' değişkenini kullanıyoruz
}

resource "aws_instance" "web_server" {
  ami           = var.ami_id        # 'ami_id' değişkeni
  instance_type = var.instance_type # 'instance_type' değişkeni
  tags = {
    Name = "MyWebServer"
  }
}

output "instance_public_ip" {
  value = aws_instance.web_server.public_ip
  description = "Public IP address of the EC2 instance."
}

Bu main.tf dosyasında, AWS EC2 örneği oluşturmak için var.instance_type, var.region ve var.ami_id değişkenlerini kullanıyoruz. Bu sayede, aynı kod yapısıyla farklı sunucu tipleri veya bölgeler belirtebiliriz.

terraform.tfvars ile Varsayılan Değerler ve Otomatik Yükleme

Terraform, belirli dosya adlarını otomatik olarak yükler. Bunlardan en önemlisi terraform.tfvars dosyasıdır. Bu dosya, tüm değişkenler için varsayılan değerleri tanımlamak veya genel bir yapılandırma sağlamak için idealdir.

Adım 3: terraform.tfvars Dosyası Oluşturma

Daha önce variables.tf dosyasında ami_id değişkenine bir varsayılan değer atamadığımızı hatırlayın. Şimdi bu değeri terraform.tfvars dosyasında sağlayalım.

# terraform.tfvars
instance_type = "t3.medium"
ami_id        = "ami-0abcdef1234567890" # Örnek bir AMI ID
region        = "eu-central-1"

Burada, terraform.tfvars dosyası, variables.tf içinde tanımlanan değişkenlere değerler atar. Terraform, terraform plan veya terraform apply gibi komutları çalıştırdığınızda bu dosyayı otomatik olarak okuyacak ve içindeki değerleri değişkenlere uygulayacaktır. Eğer variables.tf içinde bir default değeri tanımlanmışsa ve terraform.tfvars dosyasında da aynı değişken için bir değer varsa, terraform.tfvars içindeki değer öncelik kazanır.

Farklı Ortamlar için Özel tfvars Dosyaları Nasıl Kullanılır?

Bulut altyapısı yönetiminin en yaygın senaryolarından biri, aynı uygulamanın farklı dağıtım ortamlarına (geliştirme, test, üretim) ihtiyaç duymasıdır. Her ortamın kendine özgü değişken değerleri olabilir. Bu durumu yönetmek için, ortama özel tfvars dosyaları oluşturabilir ve bunları Terraform komutlarıyla belirtebiliriz.

Adım 4: Ortama Özel tfvars Dosyaları Oluşturma

Şimdi geliştirme (dev) ve üretim (prod) ortamları için iki farklı tfvars dosyası oluşturalım:

# dev.tfvars
instance_type = "t2.micro"
ami_id        = "ami-0abcdef1234567890" # Dev için farklı bir AMI ID olabilir
region        = "us-east-1"

# prod.tfvars
instance_type = "t3.large"
ami_id = "ami-0abcdef0987654321" # Prod için daha güncel veya optimize bir AMI
region = "eu-west-1"

Adım 5: Ortama Özel tfvars Dosyalarını Kullanma

Bu dosyaları kullanarak Terraform'u çalıştırmak için -var-file bayrağını kullanırız:

# Geliştirme ortamı için plan oluşturma
terraform plan -var-file="dev.tfvars"

# Üretim ortamı için plan oluşturma
terraform plan -var-file="prod.tfvars"

# Geliştirme ortamına dağıtım
terraform apply -var-file="dev.tfvars"

Bu komutlar sayesinde, aynı main.tf ve variables.tf dosyalarını kullanarak, tek bir parametre değişikliği ile farklı ortamlara özel altyapıları dağıtabiliriz. Bu, altyapı otomasyonunuzda büyük bir esneklik ve kontrol sağlar. Örneğin, bir geliştirici ekibi dev.tfvars dosyasını kullanırken, operasyon ekibi prod.tfvars dosyasını kullanarak üretim dağıtımlarını yapabilir. Bu, Infrastructure as Code'un gerçek gücünü ortaya koyar.

Gerçek Dünya Senaryosu: Birden Fazla Ortamda tfvars Kullanımı

Birçok kuruluş, yazılım geliştirme sürecinde birden fazla ortam kullanır: genellikle bir geliştirme (Dev), bir test (Test) ve bir üretim (Prod) ortamı bulunur. Bu ortamların her biri, maliyet, performans, güvenlik veya erişilebilirlik gereksinimleri nedeniyle farklı altyapı konfigürasyonlarına sahip olabilir. tfvars dosyaları, bu karmaşık senaryoyu yönetmek için mükemmel bir çözümdür. Hadi, AWS üzerinde çalışan basit bir web uygulamasının üç farklı ortamını tfvars kullanarak nasıl yöneteceğimizi gösteren bir vaka analizine göz atalım.

Vaka Analizi: AWS Üzerinde Multi-Ortam Web Uygulaması Dağıtımı

Amacımız, aynı Terraform koduyla farklı özelliklere sahip AWS EC2 örnekleri ve VPC bileşenleri oluşturmaktır.

Proje Yapısı:
Aşağıdaki gibi bir dosya yapısı hayal edelim:

• main.tf: AWS kaynaklarını tanımlayan ana dosya (VPC, Subnet, Security Group, EC2).
• variables.tf: Tüm ortamlar için ortak değişken tanımları.
• dev.tfvars: Geliştirme ortamına özel değişken değerleri.
• test.tfvars: Test ortamına özel değişken değerleri.
• prod.tfvars: Üretim ortamına özel değişken değerleri.

1. variables.tf Dosyası (Ortak Değişkenler):

# variables.tf

variable "aws_region" {
  description = "AWS Region for resource deployment."
  type        = string
}

variable "vpc_cidr_block" {
  description = "CIDR block for the VPC."
  type        = string
}

variable "instance_type" {
  description = "EC2 instance type for the web server."
  type        = string
}

variable "ami_id" {
  description = "AMI ID for the EC2 instance."
  type        = string
}

variable "instance_count" {
  description = "Number of EC2 instances to deploy."
  type        = number
  default     = 1
}

variable "environment" {
  description = "Deployment environment (e.g., dev, test, prod)."
  type        = string
}

variable "project_name" {
  description = "Name of the project."
  type        = string
  default     = "WebApp"
}

2. main.tf Dosyası (Altyapı Tanımı):

# main.tf

provider "aws" {
  region = var.aws_region
}

resource "aws_vpc" "main" {
  cidr_block = var.vpc_cidr_block
  tags = {
    Name        = "${var.project_name}-${var.environment}-VPC"
    Environment = var.environment
  }
}

resource "aws_subnet" "main" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = cidrsubnet(var.vpc_cidr_block, 8, 0) # Basit bir subnet örneği
  availability_zone = "${var.aws_region}a"
  tags = {
    Name        = "${var.project_name}-${var.environment}-Subnet"
    Environment = var.environment
  }
}

resource "aws_security_group" "web" {
  vpc_id      = aws_vpc.main.id
  name        = "${var.project_name}-${var.environment}-WebSG"
  description = "Allow HTTP and SSH access"

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Environment = var.environment
  }
}

resource "aws_instance" "web_server" {
  count         = var.instance_count # instance_count değişkeni ile dinamik instance sayısı
  ami           = var.ami_id
  instance_type = var.instance_type
  subnet_id     = aws_subnet.main.id
  vpc_security_group_ids = [aws_security_group.web.id]

  tags = {
    Name        = "${var.project_name}-${var.environment}-WebServer-${count.index}"
    Environment = var.environment
  }
}

output "vpc_id" {
  value       = aws_vpc.main.id
  description = "The ID of the VPC."
}

output "web_server_ips" {
  value       = aws_instance.web_server.*.public_ip
  description = "Public IPs of the web servers."
}

3. Ortama Özel tfvars Dosyaları:

# dev.tfvars
aws_region     = "us-east-1"
vpc_cidr_block = "10.0.0.0/16"
instance_type  = "t2.micro"
ami_id         = "ami-0abcdef1234567890" # Geliştirme için uygun bir AMI
instance_count = 1
environment    = "dev"

# test.tfvars
aws_region = "us-east-2"
vpc_cidr_block = "10.10.0.0/16"
instance_type = "t3.small"
ami_id = "ami-0abcdef0987654321" # Test için farklı bir AMI
instance_count = 2
environment = "test"

# prod.tfvars
aws_region = "eu-west-1"
vpc_cidr_block = "10.20.0.0/16"
instance_type = "m5.large"
ami_id = "ami-0abcdef5432109876" # Üretim için stabilize ve güvenli bir AMI
instance_count = 3
environment = "prod"
project_name = "WebApp-Production" # Üretim için farklı bir proje adı

4. Dağıtım Komutları:

# Geliştirme ortamını dağıtma
terraform init
terraform plan -var-file="dev.tfvars"
terraform apply -var-file="dev.tfvars"

# Test ortamını dağıtma
terraform init
terraform plan -var-file="test.tfvars"
terraform apply -var-file="test.tfvars"

# Üretim ortamını dağıtma
terraform init
terraform plan -var-file="prod.tfvars"
terraform apply -var-file="prod.tfvars"

Bu vaka analizi, tfvars dosyalarının aynı Terraform koduyla nasıl farklı, ancak tutarlı, altyapıları kolayca yönetmenize olanak tanıdığını açıkça göstermektedir. Geliştiriciler kendi dev ortamlarını hızlıca oluşturabilirken, test ekibi test ortamını, operasyon ekibi ise üretim ortamını yönetebilir. Bu yaklaşım, dağıtım süreçlerinizi hızlandırır, hataları azaltır ve altyapı yönetiminizi daha esnek hale getirir.

İleri Düzey tfvars Uygulamaları ve En İyi Pratikler

Terraform ve tfvars dosyaları, temel altyapı dağıtımlarının ötesine geçerek daha karmaşık ve güvenli senaryoları destekler. Deneyimli kullanıcılar için, değişken yönetimini bir sonraki seviyeye taşıyacak bazı ileri düzey uygulamalar ve en iyi pratikler bulunmaktadır.

Hassas Veri Yönetimi: tfvars Dosyalarında Saklama Riskleri ve Alternatifler

tfvars dosyaları, değişken değerlerini depolamak için harika olsa da, hassas verileri (API anahtarları, veritabanı şifreleri, SSH anahtarları vb.) doğrudan bu dosyalarda plaintext olarak saklamak şiddetle tavsiye edilmez. Bu, güvenlik açıkları yaratır ve potansiyel veri sızıntılarına yol açabilir, özellikle bu dosyalar versiyon kontrol sistemlerine (Git) yüklenirse.

Peki, hassas verileri güvenli bir şekilde nasıl yönetiriz?

• Ortam Değişkenleri: Küçük ve hassas olmayan veriler için, Terraform'a ortam değişkenleri aracılığıyla değer geçirebilirsiniz. Örneğin, TF_VAR_my_secret_key="my-value" şeklinde tanımlanan bir ortam değişkeni, Terraform tarafından otomatik olarak okunur. Ancak bu da terminal geçmişinde görülebileceği için çok hassas veriler için yeterince güvenli değildir.
• Gizlilik Yönetim Sistemleri (Secrets Managers): Bu, en iyi ve en önerilen yöntemdir. Bulut sağlayıcılarının kendi gizlilik yönetim hizmetleri (örneğin, AWS Secrets Manager, Azure Key Vault, Google Secret Manager) veya üçüncü taraf çözümler (HashiCorp Vault) kullanılabilir. Terraform, bu sistemlerden çalışma zamanında hassas verileri güvenli bir şekilde çekebilir. Örneğin:

  
  # main.tf - AWS Secrets Manager'dan bir şifre çekme örneği
  data "aws_secretsmanager_secret_version" "db_password" {
    secret_id = "my-database-password"
  }
  
  resource "aws_db_instance" "main" {
    # ... diğer ayarlar ...
    password = data.aws_secretsmanager_secret_version.db_password.secret_string
  }
          

• Tfsec veya Checkov gibi Güvenlik Tarayıcıları: Kodunuzu dağıtmadan önce hassas verilerin tfvars dosyalarında veya doğrudan HCL içinde olup olmadığını kontrol etmek için bu araçları CI/CD boru hattınıza entegre edebilirsiniz.

Dizin Yapısı ve Modülerlik ile tfvars Organizasyonu

Büyük ve karmaşık altyapılarda, tfvars dosyalarını mantıklı bir şekilde organize etmek kritik önem taşır. Modüler bir yaklaşım benimseyerek, altyapınızı daha yönetilebilir hale getirebilirsiniz.

• Ortam Tabanlı Dizin Yapısı: Her ortam için ayrı bir dizin oluşturmak popüler bir yöntemdir.

  
  .
  ├── modules/
  │   ├── vpc/
  │   └── ec2-instance/
  ├── environments/
  │   ├── dev/
  │   │   ├── main.tf
  │   │   ├── variables.tf
  │   │   └── terraform.tfvars # Bu dizin için varsayılan tfvars
  │   ├── prod/
  │   │   ├── main.tf
  │   │   ├── variables.tf
  │   │   └── terraform.tfvars
  │   └── common.tfvars # Tüm ortamlar için ortak değişkenler
          

  
  Bu yapıda, her environments// dizini bağımsız bir Terraform çalışma alanıdır ve kendi terraform.tfvars dosyasını içerir. Ortak değişkenler common.tfvars içinde tutulup her ortam için -var-file=../common.tfvars ile dahil edilebilir.

• Modül Kullanımı ile Değişken Aktarımı: Terraform modülleri, altyapı kodunuzu tekrar kullanılabilir bloklara ayırmanın en iyi yoludur. Modüllere değişkenleri ana yapılandırmanızdan geçirebilirsiniz.

  
  # main.tf (ana yapılandırma)
  module "web_app_prod" {
    source        = "./modules/web-app"
    instance_type = var.prod_instance_type
    ami_id        = var.prod_ami_id
    environment   = "prod"
  }
  
  # variables.tf (ana yapılandırma için)
  variable "prod_instance_type" { type = string }
  variable "prod_ami_id" { type = string }
  
  # prod.tfvars (ana yapılandırma için)
  prod_instance_type = "m5.xlarge"
  prod_ami_id        = "ami-0abcdef5432109876"
          

  
  Bu yaklaşım, değişkenleri katmanlı bir şekilde yönetmenize olanak tanır.

tfvars ile Dinamik Değişkenlerin Beslenmesi

Bazen değişken değerleri statik bir dosyadan değil, dinamik olarak çalışma zamanında elde edilmelidir.

• Komut Satırı Argümanları: En basit yöntemdir. Tekil değişkenleri komut satırından -var="key=value" şeklinde geçirebilirsiniz.

  
  terraform plan -var="instance_type=t3.small" -var="region=eu-west-1"
          

  
  Bu, hızlı testler veya tek seferlik değişiklikler için kullanışlıdır ancak çok sayıda değişken için pratik değildir.

• Çıktıları Değişken Olarak Kullanma: Terraform, başka bir Terraform konfigürasyonunun çıktısını (output) kendi girdisi olarak kullanabilir. Bu, iç içe geçmiş veya bağımlı altyapı dağıtımları için idealdir.
• terraform.tfvars.json Kullanımı: tfvars dosyaları HCL formatında yazılabileceği gibi JSON formatında da yazılabilir (terraform.tfvars.json). Bu, özellikle başka bir sistemden (örneğin bir CI/CD aracı veya bir envanter sistemi) dinamik olarak oluşturulan verileri Terraform'a beslemek gerektiğinde kullanışlıdır.

  
  // terraform.tfvars.json
  {
    "instance_type": "t2.medium",
    "ami_id": "ami-0abcdef1234567890",
    "instance_count": 2
  }
          

  
  Bu dosya da terraform.tfvars gibi otomatik olarak yüklenir.

Bu ileri düzey teknikler ve en iyi pratikler, Terraform dağıtımlarınızın ölçeklenebilirliğini, güvenliğini ve yönetilebilirliğini artırmanıza yardımcı olur. Karmaşık altyapı senaryolarında, bu yöntemleri doğru bir şekilde uygulamak, uzun vadede büyük faydalar sağlayacaktır.

Terraform'da Değişken Yönetimi ile İlgili Sıkça Sorulan Sorular

Terraform'da değişken yönetimi, esneklik ve otomasyon sağlarken, bazı kavramlar başlangıçta kafa karıştırıcı olabilir. İşte bu konuyla ilgili sıkça sorulan bazı sorular ve cevapları:

terraform.tfvars ve -var-file arasındaki temel fark nedir?

Cevap: Temel fark, Terraform'un bu dosyaları ne zaman ve nasıl işlediğidir. terraform.tfvars (veya terraform.tfvars.json) adlı dosyalar, bir Terraform çalışma dizininde bulunduklarında, herhangi bir özel komut bayrağına gerek kalmadan Terraform tarafından otomatik olarak yüklenir. Bu dosyalar genellikle projenin varsayılan veya genel ayarlarını tutmak için kullanılır. Öte yandan, -var-file="dosya_adı.tfvars" bayrağı ile belirtilen dosyalar, Terraform'un belirli bir komut çalıştırılırken manuel olarak yüklemesini istediğiniz dosyalardır. Bu, genellikle farklı ortamlar (geliştirme, test, üretim) veya belirli senaryolar için özel değişken değerleri sağlamak amacıyla kullanılır. -var-file ile belirtilen bir değer, otomatik yüklenen terraform.tfvars içindeki aynı değişkenin değerini geçersiz kılar.

Hassas verileri (şifreler, API anahtarları) tfvars dosyasında saklamak güvenli midir?

Cevap: Hayır, kesinlikle güvenli değildir ve şiddetle tavsiye edilmez. tfvars dosyaları genellikle plaintext (düz metin) formatındadır ve versiyon kontrol sistemlerine (Git gibi) yüklendiğinde veya uygun olmayan izinlerle depolandığında kolayca erişilebilir hale gelebilir. Hassas veriler için HashiCorp Vault, AWS Secrets Manager, Azure Key Vault veya Google Secret Manager gibi özel gizlilik yönetim çözümleri kullanılmalıdır. Terraform, bu servislerle entegre olarak çalışma zamanında hassas verileri güvenli bir şekilde çekebilir. Ortam değişkenleri bile terminal geçmişinde görünebileceği için çok hassas veriler için risk taşıyabilir.

Bir tfvars dosyasında başka bir tfvars dosyasını referans gösterebilir miyim?

Cevap: Doğrudan bir tfvars dosyası içinde başka bir tfvars dosyasını "include" veya "import" etme gibi bir mekanizma Terraform'da bulunmamaktadır. Ancak, birden fazla tfvars dosyasını aynı anda kullanarak benzer bir etki yaratabilirsiniz. Örneğin:

terraform plan -var-file="common.tfvars" -var-file="environment.tfvars"
    

Bu durumda, eğer aynı değişken her iki dosyada da tanımlıysa, komut satırında en son belirtilen dosya öncelik kazanır. Bu sayede, ortak değişkenleri ayrı bir dosyada tutup, ortama özel değişkenlerle bunları geçersiz kılabilirsiniz.

terraform plan komutu değişkenleri hangi sırayla yükler ve öncelik sıralaması nasıldır?

Cevap: Terraform, değişken değerlerini birden fazla kaynaktan toplayabilir ve belirli bir öncelik sırasına göre uygular. Öncelik, en düşükten en yükseğe doğru genellikle şöyledir:

1. variables.tf dosyasındaki default değerleri.
2. terraform.tfvars veya terraform.tfvars.json dosyalarından gelen değerler.
3. *.auto.tfvars veya *.auto.tfvars.json adlı otomatik yüklenen dosyalar.
4. Ortam değişkenleri (TF_VAR_ önekli olanlar).
5. -var-file bayrağı ile belirtilen dosyalar (birden fazla ise son belirtilen önceliklidir).
6. -var bayrağı ile komut satırından doğrudan verilen değerler.

Yüksek öncelikli bir kaynakta belirtilen değişken değeri, düşük öncelikli bir kaynakta belirtilen aynı değişkenin değerini geçersiz kılar. Bu öncelik sırası, altyapınızın beklenen şekilde yapılandırıldığından emin olmak için kritik öneme sahiptir.