Terraform Docker: Kapsamlı Bir Rehber

Geliştirme ve üretim ortamlarında Docker konteynerlerini saatlerce elle yönettim. Uyuşmayan yapılandırmalar, kayan durumlar ve yerel kurulumumun üretimle eşleşip eşleşmediğine dair belirsizlik her dağıtımı problemli hâle getiriyordu. Terraform'un Docker sağlayıcısını keşfettiğimde her şey değişti.

Bu eğitimde, yeniden üretilebilir, sürüm kontrollü bir altyapı oluşturmak için Terraform'u Docker ile nasıl entegre edeceğinizi adım adım göstereceğim. Konteynerleri sağlama, ağlar ve birimleri (volumes) yönetme, kaynak kısıtları uygulama ve ekip genelinde durumu koruma konularını öğreneceksiniz.

İster derleme sunucularını yönetin ister mikro hizmetleri orkestre edin, terminalinizi alın ve Docker altyapısını ele alma biçiminizi birlikte dönüştürelim.

Docker'da yeniyseniz, Introduction to Docker kursumuzla başlamanızı öneririm.

Terraform Docker Entegrasyonu Nedir?

Terraform, bildirimsel bir iş akışıyla kaynak yaşam döngülerini yöneten bir altyapı-kod-olarak aracıdır. Tek tek Docker komutları çalıştırmak yerine, istenen altyapı durumunu yapılandırma dosyalarında tanımlarsınız. Terraform ardından plan-uygula-yık (plan-apply-destroy) yaşam döngüsünü yürütür: gerekli değişiklikleri hesaplar, bir önizleme gösterir ve yalnızca onaydan sonra uygular.

Terraform Docker sağlayıcısı, HashiCorp Configuration Language (HCL) kodu ile Docker API arasında bir çeviri katmanı görevi görür. Yapılandırmada resource “docker_container" yazdığınızda, sağlayıcı bu bildirimi ilgili Docker API çağrılarına dönüştürür. Bu soyutlama, Docker kaynaklarının bulut altyapısı için kullanılan aynı iş akışıyla yönetilebilmesi anlamına gelir.

İşte Terraform'un Docker Compose'dan ayrıştığı nokta.

Compose, YAML dosyalarıyla proje tabanlı bir yaklaşımla konteynerleri yönetir, ancak gerçekte neyin var olduğunu izleyen bir durum dosyası tutmaz. 

Buna karşılık Terraform, oluşturduğu her kaydı terraform.tfstate içinde kaydeder; böylece yapılandırmam ile gerçeklik arasındaki sapmayı tespit edebilir. Biri bir konteyneri elle değiştirirse Terraform bunu fark eder ve tanımlı duruma geri döndürebilir.

Bu yaklaşım şu senaryolarda parlıyor:

• Tekrarlanabilir derleme sunucuları için, tutarlılığı garanti ederek tek bir komutla tüm ortamı yok edip yeniden oluşturabilirsiniz. 
• Test ortamlarında, her test çalıştırması için izole altyapı ayağa kaldırabilirsiniz. 
• Değiştirilemez dağıtımlarda, konteynerleri yerinde değiştirmek yerine tamamen yenisiyle değiştirirsiniz; bu da dağıtım risklerini azaltır.

Ön Koşullar ve Kurulum

Terraform yapılandırmalarına dalmadan önce, gerekli araçların kurulu ve doğru yapılandırıldığını doğrulayalım.

Sistem gereksinimlerini karşılama

Önce, makinenizde Docker Engine'in çalıştığını doğrulayın. 

• Linux: docker ps ile kontrol edin

• macOS veya Windows: Docker Desktop'ın kurulu ve çalışır durumda olduğundan emin olun

Terraform sağlayıcısının Docker daemon'a erişmesi gerekir; bu yüzden Linux'ta /var/run/docker.sock Unix soketine veya Windows'ta adlandırılmış kanala erişim izniniz olduğundan emin olun.

Sonra, Terraform CLI'ı HashiCorp'un resmi sitesinden yükleyin. Terraform kurulumu işletim sistemine göre değişir:

• Linux: Uygun paketi indirin veya dağıtımınızın paket yöneticisini kullanın. 

• macOS: Homebrew kullanın. Önce brew tap hashicorp/tap ile HashiCorp tap'ini ekleyin, ardından brew install hashicorp/tap/terraform komutuyla Terraform'u kurun. 

• Windows: İkili dosyayı hashicorp.com'dan indirip PATH'inize ekleyin ya da Chocolatey kullanın: choco install terraform. 

Kurulumdan sonra terraform version komutunu çalıştırarak doğrulayın. 

Docker ve Terraform'u doğruladıktan sonra sıradaki adım, sürdürülebilirlik için proje dosyalarını düzenlemektir.

Proje yapısını yapılandırma

Terraform projeleri, açık ve düzenli bir yaklaşımdan fayda sağlar. Genellikle Terraform projem için özel bir dizin oluşturur ve sürüm kontrolünü başlatırım:

mkdir terraform-docker-project
cd terraform-docker-project
git initAltyapı:

Altyapı-kod-olarak için sürüm kontrolü kritiktir. Docker altyapısındaki her değişiklik izlenebilir, gözden geçirilebilir ve geri alınabilir olmalıdır. Genelde Terraform'un çalışma dizinini ve durum dosyalarını .gitignore dosyasına ekleyerek sürüm kontrolü dışında tutarım:

.terraform/
*.tfstate
*.tfstate.backup
.terraform.lock.hclAltyapı:

Son olarak, altyapımı tanımlayacağım boş bir main.tf dosyası oluştururum. Bu dosya sağlayıcı yapılandırmasını ve kaynak tanımlarını barındıracaktır.

Terraform Docker Sağlayıcısı ve Çekirdek Kaynaklar

Proje yapısını kurduğumuza göre, Docker sağlayıcısını yapılandırıp kaynakları tanımlamaya başlayalım.

Docker sağlayıcısını başlatma

Önce, main.tf'ye sağlayıcı yapılandırmasını ekleyerek:

terraform {
  required_providers {
    docker = {
      source  = "kreuzwerker/docker"
      version = "~> 3.0"
    }
  }
}

provider "docker" {
  host = "unix:///var/run/docker.sock"
}Altyapı:

required_providers bloğu, Terraform'un sağlayıcı eklentisini nereden indirmesi gerektiğini belirtir. Sürüm kısıtlamaları (~> 3.0) küçük sürüm güncellemelerine izin verirken kırıcı değişiklikleri engeller. Uzak Docker ana makineleri için host parametresini tcp://192.168.1.100:2376 gibi bir değere değiştirebilirsiniz.

Şimdi proje kök dizininde terraform init çalıştırın. Bu, Docker sağlayıcı eklentisini indirir ve .terraform/providers/ içine kaydeder. Komut, yüklenen tam sürümü çıktılar ve Terraform ekip genelinde tutarlı sağlayıcı sürümleri için bir kilit dosyası oluşturur.

Konteyner imajlarını yönetme

Sağlayıcıyı başlattıktan sonra sıradaki adım, konteyner imajlarını tanımlamaktır. Konteyner oluşturmadan önce, kullanacakları imajları yönetmeniz gerekir; bu nedenle bir imaj kaynağı tanımlayın:

resource "docker_image" "nginx" {
  name         = "nginx:1.29"
  keep_locally = true
}Altyapı:

Bu kaynağı sağlayıcı bloğunun hemen ardına ekleyin. keep_locally parametresi önemlidir; terraform destroy çalıştırdığımda Terraform'un imajı kaldırmasını engeller. Aynı imajı paylaşan birden fazla konteyner olduğunda veya dağıtımlar arasında önbelleğe alınmış imajları korumak istediğimde kullanışlıdır.

Üretim dağıtımları için, değişmezliği sağlamak üzere imajları SHA256 özetiyle sabitleyin:

resource "docker_image" "nginx" {
 name = "nginx@sha256:b60f25eb5acdd79172de1a289891d9cfe4fc3669daddeeb68619240cbe839d9f"
}Altyapı:

Özet, konteyner kayıt defterinden alınabilir. nginx gibi Docker Hub imajları için resmi Docker web sitesindeki Etiketler (Tags) bölümünde bulabilirsiniz. Özet kullanmak, biri aynı etikete yeni bir imaj itmiş olsa bile her seferinde tam olarak aynı ikili imajın dağıtılmasını garanti eder.

Docker konteynerlerini sağlama

İmajlar tanımlandıktan sonra, onları referans alan konteynerleri oluşturma aşamasına geçelim:

resource "docker_container" "web" {
  name  = "nginx-web"
  image = docker_image.nginx.image_id

  ports {
    internal = 80
    external = 8080
  }

  env = [
    "NGINX_HOST=example.com",
    "NGINX_PORT=80"
  ]
}Altyapı:

İmaj, docker_image.nginx.image_id kullanılarak referanslanır. Bu, örtük bir bağımlılık oluşturur; Terraform, imaj mevcut olmadan konteyneri yaratmaya çalışmaz. ports bloğu, konteynerin 80 numaralı dahili portunu ana makinedeki 8080 portuna eşler; bu, docker run -p 8080:80 ile eşdeğerdir.

Ortam değişkenleri, env listesine string olarak yazılır. Parametrelerden herhangi biri değiştiğinde Terraform konteyneri yeniden oluşturur; böylece çalışan altyapı her zaman yapılandırmayla eşleşir.

Bu noktada terraform plan ile Terraform'un neler oluşturacağını görün, ardından altyapıyı sağlamak için terraform apply çalıştırın. Terraform imajı ve konteyneri oluşturacaktır. Bunu Docker Desktop'ta kaynağı kontrol ederek veya terminalde docker ps çalıştırarak doğrulayabilirsiniz.

Terraform'da Ağ, Depolama ve Kaynak Sınırları

Artık temel bir konteyner çalışıyor ve çekirdek iş akışını anladınız; şimdi altyapıyı üretime hazır özelliklerle genişletelim. Sıradaki bölümler, gerçek dünya dağıtımları için gerekli olan ağ, kalıcı depolama ve kaynak kısıtlarını ekleyerek bu temelin üzerine inşa edilecek

Ağ yönetimi

Konteynerler arasında iletişimi etkinleştirirken izolasyonu korumak için özel ağlar oluşturmak esastır. Konteyner bağlantılarını kontrol etmek için izole ağları şu şekilde oluşturabilirsiniz. Aşağıdaki kaynağı main.tf dosyasına ekleyin:

resource "docker_network" "app_network" {
  name   = "application_net"
  driver = "bridge"
}Altyapı:

Şimdi bu ağı kullanan ikinci bir konteyner ekleyin. Bunu web konteynerinden sonra ekleyin:

resource "docker_container" "api" {
  name  = "api-server"
  image = docker_image.nginx.image_id

  networks_advanced {
    name = docker_network.app_network.name
  }
}Altyapı:

Bu, özel bir köprü ağı (bridge) oluşturur ve api konteynerini ona bağlar. Aynı ağdaki konteynerler, konteyner adlarını ana bilgisayar adı olarak kullanarak iletişim kurabilir; bu, mikro hizmet mimarileri için idealdir. 

Ağ izolasyonunu docker network inspect application_net çalıştırarak ve yalnızca amaçlanan konteynerlerin bağlı olduğunu doğrulayarak test edin. Bu komutu, terraform plan ve terraform apply ile kaynakları oluşturduktan sonra çalıştırdığınızdan emin olun.

Konteynerler arası iletişim için ağ yapılandırmasını tamamladığımıza göre, sıradaki kritik konu veri kalıcılığıdır.

Kalıcı birimleri yapılandırma

Konteyner yeniden başlatmalarından sonra da korunması gereken veriler için birim (volume) kaynakları ekleyin. Bunları konteyner tanımlarından önce ekleyin:

resource "docker_volume" "db_data" {
  name = "postgres_data"
}Altyapı:

Şimdi bu birimi kullanan bir veritabanı konteyneri ekleyin:

resource "docker_container" "database" {
  name  = "postgres"
  image = "postgres:15"

 env = [
    "POSTGRES_PASSWORD=mysecretpassword"
  ]

  volumes {
    volume_name    = docker_volume.db_data.name
    container_path = "/var/lib/postgresql/data"
  }
}Altyapı:

Bunun gibi yönetilen birimler, Docker tarafından oluşturulur ve Docker'ın veri dizininde saklanır. Ana makineden yapılandırma dosyalarını paylaşmak için bind mount kullanarak volume_name yerine host_path belirtin.

volumes {
  host_path      = "/opt/app/config"
  container_path = "/etc/app/config"
  read_only      = true
}Altyapı:

Verilerin konteyner yeniden başlatmalarında da korunmasını sağladıktan sonra, tek bir konteynerin sistem kaynaklarını tekeline almasını engellemek de aynı derecede önemlidir.

Kaynak kısıtları belirleme

Depolamanın ötesinde, her konteynerin ne kadar CPU ve belleği tüketebileceğini kontrol etmek sistem kararlılığı için kritiktir. Aşırı kaynak kullanımını engellemek için kaynak limitleri uygulayın.

Docker bazı kaynak limitlerini yerinde güncellemeye izin verse de, Terraform'un bildirimsel modeli, durumun yapılandırmanızla eşleşmesini sağlamak için çoğunlukla konteynerin değiştirilmesini gerektirir. Bu değiştirme sırasında kesinti olmaması için create_before_destroy yaşam döngüsü kuralını kullanırız. 

Önemli: Değiştirme sürecinde ad çakışmalarını önlemek için sabit name argümanını kaldırmalıyız. Bir seçenek olarak name_prefix argümanını kullanabilirsiniz.

resource "docker_container" "api" {
  name_prefix       = "api-server-"
  image      = docker_image.nginx.image_id
  memory     = 512
  cpu_shares = 1024

  networks_advanced {
    name = docker_network.app_network.name
  }

 lifecycle {
    create_before_destroy = true
  }
}Altyapı:

memory parametresi RAM'i megabayt cinsinden sınırlar. cpu_shares ise farklı çalışır. Bu, CPU çekişmesi olduğunda kullanılan göreli bir ağırlıktır. 1024 paya sahip bir konteyner, 512 paya sahip olandan iki kat fazla CPU süresi alır, ancak yalnızca ana makine yük altındayken. 

Sert CPU limitleri için cpu_set kullanarak konteynerleri belirli CPU çekirdeklerine de sabitleyebilirsiniz:

cpu_set = "0,1"
}Altyapı:

Bu kısıtları docker inspect background-worker --format='{{.HostConfig.Memory}} {{.HostConfig.CpuShares}} komutunu çalıştırıp Memory ve NanoCpus değerlerinin yapılandırmayla eşleştiğini kontrol ederek doğrulayın. 

Burada da yukarıda belirtildiği gibi, kaynakları oluşturmak için önce terraform plan ve terraform apply çalıştırmanız gerekir.

Bu noktada main.tf dosyası; sağlayıcı yapılandırması, bir imaj, bir ağ, bir birim ve çeşitli yapılandırmalara sahip üç konteyner içeriyor. 

Terraform'da Değişkenler, Modüller ve Gizli Bilgiler

Altyapı büyüdükçe, sabitlenmiş değerler esnekliğini yitirir. Bu bölüm, yapılandırmayı değişkenler, modüller ve uygun gizli bilgi yönetimi kullanarak nasıl yeniden kullanılabilir hâle getireceğinizi gösterir.

Girdi değişkenlerini kullanma

Yapılandırmaları esnek kılmanın ilk adımı, ana kodu değiştirmeden kolayca değiştirilebilecek sabit değerleri değişkenlere çıkarmaktır. Aynı dizinde variables.tf adlı yeni bir dosya oluşturarak yapılabilir:

variable "web_port" {
  description = "External port for web container"
  type        = number
  default     = 8080

  validation {
    condition     = var.web_port > 1024 && var.web_port < 65535
    error_message = "Port must be between 1024 and 65535."
  }
}Altyapı:

Şimdi main.tf içindeki web konteynerini bu değişkeni kullanacak şekilde güncelleyin:

resource "docker_container" "web" {
  name  = "nginx-web"
  image = docker_image.nginx.image_id

  ports {
    internal = 80
    external = var.web_port
  }

  env = [
    "NGINX_HOST=example.com",
    "NGINX_PORT=80"
  ]
}Altyapı:

Doğrulama bloğu, ayrıcalıklı portların kullanılmasını engeller. Varsayılan değeri geçersiz kılmak için bir terraform.tfvars dosyası oluşturun:

web_port = 9000Altyapı:

terraform apply çalıştırırken Terraform bu dosyadan değerleri otomatik olarak okur. Alternatif olarak, komut satırından değer geçebilirsiniz: terraform apply -var="web_port=9000".

Yeniden kullanılabilir modüller oluşturma

Değişkenler sabit değerler sorununu çözer; peki tüm kaynaklarıyla birlikte aynı deseni birden çok kez dağıtmanız gerekirse?

İşte modüllerin parladığı yer burası. Bir modülü, tüm bu parçaları tek bir pakette toplayan ve bu karmaşık kurulumu tek bir birim olarak "basmanıza" olanak tanıyan bir plan olarak düşünün.

Önce bir modül dizin yapısı oluşturun:

mkdir -p modules/web-appAltyapı:

Şimdi modules/web-app/variables.tf dosyasını oluşturup aşağıdakileri ekleyin:

variable "environment" {
  description = "Environment name"
  type        = string
}

variable "port" {
  description = "External port"
  type        = number
}Altyapı:

Ardından modules/web-app/main.tf adlı bir ana dosya oluşturup şu kaynağı ekleyin:

resource "docker_container" "app" {
  name  = "app-${var.environment}"
  image = var.image_id

  ports {
    internal = 80
    external = var.port
  }
}Altyapı:

Son olarak, modules/web-app/outputs.tf adlı bir çıktılar dosyası oluşturun; bu, esas olarak terraform apply çalıştırıldıktan sonra terminalde istenen değeri göstermek için kullanılır:

output "container_ip" {
  value       = docker_container.app.network_data[0].ip_address
  description = "IP address of the application container"
}Altyapı:

Modül tanımlarını ekledikten sonra modülleri yüklemek için terraform init, ardından aynı şablondan iki konteyner oluşturmak için terraform apply çalıştırın. Tüm kaynakları Docker Desktop'ta görebilmelisiniz.

Modüllerle yeniden kullanılabilir altyapı kalıpları oluşturulduktan sonra, yapılandırma yönetiminin bir başka kritik yönü daha var: parola ve API anahtarları gibi hassas bilgileri güvenle ele almak.

Hassas verileri yönetme

Veritabanı parolaları gibi hassas değerler asla sabitlenmemelidir. Bunun yerine variables.tf dosyasını kullanıp sensitive = true ayarını yapabilirsiniz:

variable "db_password" {
  description = "Database root password"
  type        = string
  sensitive   = true
}Altyapı:

Şimdi main.tf içindeki veritabanı konteynerini veritabanı parolasına referans verecek şekilde güncelleyin:

resource "docker_container" "database" {
  name  = "postgres"
  image = "postgres:15"

  env = [
    "POSTGRES_PASSWORD=${var.db_password}"
  ]

  volumes {
    volume_name    = docker_volume.db_data.name
    container_path = "/var/lib/postgresql/data"
  }
}Altyapı:

Parolayı terraform.tfvars içine koyup sabitlemek yerine, bir ortam değişkeni olarak ayarlayın:

export TF_VAR_db_password="your-secure-password"
terraform applyAltyapı:

sensitive = true bayrağı, Terraform'un değeri konsol çıktısında göstermesini engeller. 

Ancak bu değerler terraform.tfstate içinde düz metin olarak saklanır; bu dosyayı güvene almak için şifrelemeli uzak arka uçlar (remote backends) kullanarak koruma sağlayabiliriz. Nasıl yapılacağına bakalım.

Terraform Durum Yönetimi ve CI/CD Entegrasyonu

Bu bölüm, üretim dağıtımları için gerekli olan durum mekaniğini ve otomasyon iş akışlarını kapsar. Ancak otomasyonu uygulamadan önce, Terraform'un altyapınızı durum dosyası aracılığıyla nasıl izlediğini anlamak önemlidir. 

Durum mekaniğini anlama

Durum, Terraform'un altyapıyı yönetebilme yetisinin temelidir. terraform.tfstate dosyası, yapılandırmayı gerçek Docker konteyner kimlikleri ve kaynak öznitelikleriyle eşler. terraform apply çalıştırıldığında Terraform bu durumu yapılandırmayla karşılaştırır ve gereken en az değişikliği hesaplar.

Mevcut durumu terraform show ile inceleyin; bu komut yönetilen her kaynağı gösterir. Ekipler için yerel durum dosyaları sorunlara, çakışmalara ve olası veri kayıplarına yol açar. Çözüm uzak arka uçlardır.

Bulut altyapısı olmadan Docker odaklı iş akışları için Terraform Cloud'un ücretsiz katmanı idealdir. main.tf içindeki terraform bölümüne bir arka uç bloğu ekleyin:

terraform {
  required_providers {
    docker = {
      source  = "kreuzwerker/docker"
      version = "~> 3.0"
    }
  }
  
  backend "remote" {
    organization = "your-org-name"
    
    workspaces {
      name = "docker-infrastructure"
    }
  }
}Altyapı:

Şu adreste ücretsiz bir hesap oluşturun: the Terraform website. Ardından terraform login ile verilen anahtarla kimlik doğrulayın ve terraform init ile durumu taşıyın. Bu, uzak bir çalışma alanında durum kilitleme ve bulut altyapısına gerek olmadan ekip iş birliği sağlar. 

Bununla birlikte, AWS veya GCP gibi Bulut sağlayıcılarında da uzak bir arka uç oluşturmak mümkündür.

İş akışlarını otomatikleştirme

Durum yönetimi yapılandırılıp uzaktan saklandıktan sonra altyapı, ekip iş birliği için hazırdır. Son parça, tutarlı ve gözden geçirilebilir değişiklikler sağlamak üzere CI/CD ardışık düzenleriyle dağıtım sürecini otomatikleştirmektir.

Önce .github/workflows/terraform.yml oluşturun:

name: Terraform Docker Deploy

on:
  pull_request:
    branches: [main]
  push:
    branches: [main]

jobs:
  terraform:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      
      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v3
        
      - name: Terraform Init
        run: terraform init
        
      - name: Terraform Plan
        if: github.event_name == 'pull_request'
        run: terraform plan
        
      - name: Terraform Apply
        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
        run: terraform apply -auto-approveAltyapı:

Bu iş akışı, her çekme isteğinde terraform plan çalıştırarak, değerlendiricilere hangi altyapı değişikliklerinin gerçekleşeceğini gösterir. Değişiklikler main'e birleştirildiğinde terraform apply otomatik olarak çalışır; böylece her altyapı değişikliği, kod değişiklikleriyle aynı inceleme sürecinden geçer.

Terraform Docker Sorunlarını Giderme

Dikkatli yapılandırmaya rağmen sorunlar ortaya çıkabilir. Yaygın problemleri ve ne zaman alternatifleri düşünmeniz gerektiğini anlamak, daha iyi mimari kararlar almanıza yardımcı olur. 

“Permission denied”

Linux'taki en yaygın hata, Docker soketine bağlanırken alınan "permission denied" hatasıdır. Bu, kullanıcının /var/run/docker.sock'a erişim izni olmadığında gerçekleşir. Kullanıcıyı docker grubuna ekleyerek düzeltin:

sudo usermod -aG docker $USERAltyapı:

Ardından oturumu kapatıp tekrar açın.

WSL2 bağlantı sorunları

Windows ve WSL2'de, soket yolu farklı olduğundan bağlantı sorunları oluşur. Docker Desktop'ta "Expose daemon on tcp://localhost:2375 without TLS" ayarının etkin olduğundan emin olun, ardından main.tf içindeki sağlayıcıyı güncelleyin:

provider "docker" {
  host = "tcp://localhost:2375"
}Altyapı:

Özel kayıt defteri kimlik doğrulama hataları

Özel Docker kayıt defterleri için, sağlayıcı bloğuna kimlik doğrulaması ekleyin; kimlik bilgilerini değişken olarak tanımlayın ve sabitlemeden kaynaklanan sorunları önlemek için ortam değişkenleri aracılığıyla ayarlayın.

hclprovider "docker" {
  host = "unix:///var/run/docker.sock"
  
  registry_auth {
    address  = "registry.mycompany.com"
    username = var.registry_username
    password = var.registry_password
  }
}Altyapı:

Terraform'a Alternatifler

Sorun gidermenin ötesinde, belirli kullanım durumunuz için Terraform'dan daha uygun olabilecek araçları ne zaman tercih etmeniz gerektiğini anlamak da aynı derecede değerlidir.

Terraform vs Kubernetes

Kubernetes çok daha gelişmiş orkestrasyon özellikleri sunar: 

• Kendini iyileştirme
• Gelişmiş zamanlama
• Servis keşfi
• Yerleşik yük dengeleme

Yüksek kullanılabilirlik gerektiren karmaşık çok düğümlü dağıtımlar için Kubernetes daha iyi bir seçimdir. Terraform, Kubernetes altyapısını sağlayabilirken, Helm veya Kubernetes manifestleri uygulama dağıtımını yönetir.

Terraform vs Ansible

Ansible, konteynerlerin içindeki yapılandırma yönetiminde üstündür. Terraform altyapıyı sağlarken, Ansible yazılım yapılandırması ve paket kurulumunu yönetir. Bu iki araç sıklıkla birlikte çalışır: Terraform Docker konteynerlerini oluşturur, ardından Ansible içlerinde çalışan uygulamaları yapılandırır.

Terraform vs Docker Compose

Basit yerel geliştirme ortamları için Docker Compose en pragmatik seçenektir. Terraform, ortamlar arasında tekrarlanabilir dağıtımlarda ve diğer altyapı bileşenleriyle entegrasyon gerektiğinde öne çıkar.

Hangisini seçeceğinize yardımcı olmak için en önemli farkları bu tabloda özetledim:

Docker'ın yerine geçecek bir araç arıyorsanız, en iyi Docker alternatifleri rehberimize göz atın.

Sonuç

Docker'ı Terraform'un yaşam döngüsü yönetimine almak, konteyner dağıtımlarını manuel süreçlerden tekrarlanabilir, sürüm kontrollü altyapıya dönüştürür. Bu eğitimde, sağlayıcı ve tek bir konteynerle başlayıp ardından ağ, depolama, değişkenler, modüller ve otomasyon ekleyerek adım adım eksiksiz bir altyapının nasıl kurulacağını gösterdim.

Temel ayrım, Terraform'un bildirimsel yapılandırmaya dayalı olarak kaynakları sağlama, oluşturma, güncelleme ve yok etme işlemlerini yönetmesidir. Otomatik ölçekleme ve kendini iyileştirmeyle tam orkestrasyon için Kubernetes veya Docker Swarm gibi araçlar gerekir. Terraform bu orkestratörleri sağlayabilir, ancak onların yerine geçmez.

Bir sonraki adım olarak, Docker sağlayıcısı için gelişmiş kaynak seçeneklerini (Swarm için Docker servisleri, gizli yönetimi ve eklenti yapılandırmaları gibi) bulmak üzere resmi Terraform Registry dokümantasyonunu keşfedin.

Konteynerlerle pratik yapmak isterseniz, etkileşimli Docker ve Kubernetes ile Konteynerleştirme ve Sanallaştırma beceri rotamıza kaydolmanızı öneririm.