Terraform State Management dalam Produksi - Panduan Praktis

#Pengenalan

Terraform state adalah source of truth untuk infrastruktur Anda. Ini juga file paling dangerous yang akan Anda manage. Kehilangan, corrupt, atau biarkan multiple people edit secara bersamaan, dan Anda sedang melihat infrastructure chaos—resource dihapus secara unexpected, duplicate resource dibuat, atau lebih buruk, seluruh production environment Anda menjadi unmanageable.

Sebagian besar team mulai dengan local state file selama development. Itu bekerja baik sampai Anda hit production. Kemudian realitas hit: Anda memerlukan multiple people managing infrastructure, Anda perlu prevent concurrent modification, Anda perlu audit trail, dan Anda perlu state Anda survive laptop crash.

Panduan ini mencakup production-grade state management strategy yang prevent disaster sebelum mereka terjadi.

#Memahami Terraform State

#Apa Yang State Benar-Benar Lakukan

Terraform state adalah file JSON yang map infrastructure code Anda ke real resource dalam cloud provider Anda. Ketika Anda run terraform apply, Terraform:

1. Membaca file konfigurasi Anda
2. Membandingkan terhadap current state
3. Menghitung apa yang perlu berubah
4. Menerapkan perubahan itu
5. Update state file dengan new reality

Tanpa state, Terraform tidak memiliki cara untuk mengetahui apa yang sebelumnya dibuat. Tidak dapat track resource ID, tidak dapat detect drift, dan tidak dapat safely update atau destroy resource.

#Mengapa Local State Gagal dalam Produksi

Local state file hidup di mesin Anda. Ini membuat beberapa problem:

Collaboration breaks down. Ketika dua engineer run terraform apply dari mesin berbeda, mereka bekerja dengan state file berbeda. Perubahan orang kedua mungkin overwrite orang pertama, atau lebih buruk, keduanya mungkin coba modify resource yang sama secara bersamaan.

State hilang. Laptop Anda mati, hard drive Anda gagal, atau Anda accidentally delete file. Sekarang Anda tidak memiliki record apa yang Terraform buat, dan Anda tidak dapat safely manage resource itu lagi.

Tidak ada audit trail. Anda tidak dapat lihat siapa yang ubah apa, kapan, atau mengapa. Ini violate compliance requirement dan membuat debugging infrastructure issue hampir impossible.

Concurrent modification menyebabkan corruption. Jika dua orang run Terraform pada waktu yang sama, state file dapat menjadi corrupt atau inconsistent.

#Remote State Backend

#Bagaimana Remote Backend Bekerja

Remote backend menyimpan state file Anda pada centralized server daripada local machine Anda. Terraform membaca dan menulis state melalui API, yang berarti:

• Multiple team member dapat safely access state yang sama
• State persist independently dari any individual machine
• Anda mendapat versioning dan audit log
• Backend dapat enforce locking untuk prevent concurrent modification

#Popular Backend Option

AWS S3 dengan DynamoDB adalah most common choice untuk AWS-based infrastructure. S3 menyimpan state file, dan DynamoDB menyediakan state locking.

Terraform Cloud (managed oleh HashiCorp) menangani semua complexity untuk Anda. Ini adalah SaaS solution dengan built-in state management, locking, dan team collaboration feature.

Azure Storage Account bekerja baik jika Anda dalam Azure ecosystem.

Google Cloud Storage adalah natural choice untuk GCP deployment.

Consul berguna jika Anda sudah running Consul untuk service discovery.

Untuk panduan ini, kami akan focus pada S3 + DynamoDB karena widely used dan memberikan Anda full control.

#Setup S3 + DynamoDB Backend

#Membuat Backend Infrastructure

Anda perlu membuat S3 bucket dan DynamoDB table sebelum Terraform dapat menggunakannya. Ini adalah chicken-and-egg problem: Anda memerlukan infrastructure untuk menyimpan infrastructure code state Anda.

Solusinya adalah membuat resource ini secara manual atau dengan separate Terraform configuration yang menggunakan local state (hanya kali ini).

aws s3api create-bucket \
  --bucket my-terraform-state \
  --region us-east-1 \
  --create-bucket-configuration LocationConstraint=us-east-1

aws s3api put-bucket-versioning \
  --bucket my-terraform-state \
  --versioning-configuration Status=Enabled

aws s3api put-public-access-block \
  --bucket my-terraform-state \
  --public-access-block-configuration \
  "BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true"

aws dynamodb create-table \
  --table-name terraform-locks \
  --attribute-definitions AttributeName=LockID,AttributeType=S \
  --key-schema AttributeName=LockID,KeyType=HASH \
  --billing-mode PAY_PER_REQUEST \
  --region us-east-1

#Konfigurasi Terraform Backend

Setelah backend infrastructure ada, konfigurasi Terraform untuk menggunakannya:

terraform {
  backend "s3" {
    bucket         = "my-terraform-state"
    key            = "prod/terraform.tfstate"
    region         = "us-east-1"
    dynamodb_table = "terraform-locks"
    encrypt        = true
  }
}

Parameter key menentukan di mana state file Anda hidup dalam bucket. Menggunakan path seperti prod/terraform.tfstate memungkinkan Anda organize multiple environment dalam satu bucket.

#Migrasi dari Local State

Ketika Anda run terraform init dengan new backend configuration, Terraform bertanya apakah Anda ingin migrate existing state Anda:

terraform init

Do you want to copy existing state to the new backend?

Jawab yes, dan Terraform secara otomatis upload local state Anda ke S3 dan update configuration Anda untuk menggunakan remote backend.

#State Locking dan Concurrency

#Mengapa Locking Penting

State locking prevent dua Terraform operation dari running secara bersamaan. Tanpa itu, scenario ini terjadi:

1. Engineer A run terraform apply dan mulai modify resource
2. Engineer B run terraform apply sebelum A selesai
3. B membaca state file, yang sekarang stale (A belum selesai update)
4. B membuat change berdasarkan outdated information
5. A selesai dan update state
6. B selesai dan overwrite A state change
7. Infrastructure Anda sekarang inconsistent dengan state file Anda

Dengan locking, B operation menunggu sampai A lock dirilis.

#Bagaimana DynamoDB Locking Bekerja

Ketika Terraform acquire lock, itu membuat entry dalam DynamoDB table dengan:

• LockID: Unique identifier untuk lock ini
• Info: Metadata tentang siapa yang hold lock dan mengapa
• Digest: Hash dari state file untuk detect corruption
• Operation: Operation yang dilakukan (apply, destroy, dll)
• Who: User yang menjalankan operation
• Version: Terraform version
• Created: Ketika lock di-acquire

Jika Terraform crash atau hang, lock tetap dalam DynamoDB. Anda dapat manually release jika diperlukan:

aws dynamodb scan --table-name terraform-locks

aws dynamodb delete-item \
  --table-name terraform-locks \
  --key '{"LockID":{"S":"my-terraform-state/prod/terraform.tfstate"}}'

#State File Security

#Encryption at Rest

S3 dapat encrypt state file Anda secara otomatis. Aktifkan server-side encryption:

aws s3api put-bucket-encryption \
  --bucket my-terraform-state \
  --server-side-encryption-configuration '{
    "Rules": [{
      "ApplyServerSideEncryptionByDefault": {
        "SSEAlgorithm": "AES256"
      }
    }]
  }'

Atau gunakan KMS untuk lebih banyak control:

aws s3api put-bucket-encryption \
  --bucket my-terraform-state \
  --server-side-encryption-configuration '{
    "Rules": [{
      "ApplyServerSideEncryptionByDefault": {
        "SSEAlgorithm": "aws:kms",
        "KMSMasterKeyID": "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012"
      }
    }]
  }'

#Encryption in Transit

Selalu gunakan HTTPS saat mengakses S3. Terraform melakukan ini secara default, tetapi verify AWS CLI configuration Anda:

aws s3api get-bucket-policy --bucket my-terraform-state

Tambahkan bucket policy untuk deny unencrypted upload:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "DenyUnencryptedObjectUploads",
      "Effect": "Deny",
      "Principal": "*",
      "Action": "s3:PutObject",
      "Resource": "arn:aws:s3:::my-terraform-state/*",
      "Condition": {
        "StringNotEquals": {
          "s3:x-amz-server-side-encryption": "AES256"
        }
      }
    }
  ]
}

#Access Control

Restrict siapa yang dapat read dan modify state file Anda. Gunakan IAM policy:

resource "aws_iam_policy" "terraform_state" {
  name = "terraform-state-access"
 
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Effect = "Allow"
        Action = [
          "s3:ListBucket",
          "s3:GetBucketVersioning"
        ]
        Resource = "arn:aws:s3:::my-terraform-state"
      },
      {
        Effect = "Allow"
        Action = [
          "s3:GetObject",
          "s3:PutObject",
          "s3:DeleteObject"
        ]
        Resource = "arn:aws:s3:::my-terraform-state/*"
      },
      {
        Effect = "Allow"
        Action = [
          "dynamodb:DescribeTable",
          "dynamodb:GetItem",
          "dynamodb:PutItem",
          "dynamodb:DeleteItem"
        ]
        Resource = "arn:aws:dynamodb:us-east-1:123456789012:table/terraform-locks"
      }
    ]
  })
}

Attach policy ini hanya ke user dan role yang perlu manage infrastructure.

#State File Versioning dan Recovery

#Aktifkan S3 Versioning

S3 versioning menyimpan previous version dari state file Anda. Jika sesuatu salah, Anda dapat restore earlier version:

aws s3api put-bucket-versioning \
  --bucket my-terraform-state \
  --versioning-configuration Status=Enabled

#Melihat State History

List semua version dari state file Anda:

aws s3api list-object-versions \
  --bucket my-terraform-state \
  --prefix prod/terraform.tfstate

#Recover dari Corruption

Jika state file Anda menjadi corrupt, restore previous version:

aws s3api get-object \
  --bucket my-terraform-state \
  --key prod/terraform.tfstate \
  --version-id abc123def456 \
  terraform.tfstate.backup

Kemudian beri tahu Terraform untuk menggunakan version ini:

terraform state push terraform.tfstate.backup

#Multi-Environment State Organization

#Directory Structure

Organisir Terraform code Anda untuk keep environment terpisah:

terraform/
├── environments/
│   ├── dev/
│   │   ├── main.tf
│   │   ├── variables.tf
│   │   └── backend.tf
│   ├── staging/
│   │   ├── main.tf
│   │   ├── variables.tf
│   │   └── backend.tf
│   └── prod/
│       ├── main.tf
│       ├── variables.tf
│       └── backend.tf
└── modules/
    ├── vpc/
    ├── rds/
    └── eks/

Setiap environment memiliki own backend configuration:

terraform {
  backend "s3" {
    bucket         = "my-terraform-state"
    key            = "prod/terraform.tfstate"
    region         = "us-east-1"
    dynamodb_table = "terraform-locks"
    encrypt        = true
  }
}

terraform {
  backend "s3" {
    bucket         = "my-terraform-state"
    key            = "dev/terraform.tfstate"
    region         = "us-east-1"
    dynamodb_table = "terraform-locks"
    encrypt        = true
  }
}

#Prevent Cross-Environment Accident

Tambahkan safety check untuk prevent accidentally apply prod configuration ke dev:

terraform {
  required_version = ">= 1.0"
}
 
variable "environment" {
  type    = string
  default = "prod"
}
 
resource "null_resource" "environment_check" {
  lifecycle {
    precondition {
      condition     = var.environment == "prod"
      error_message = "This configuration is for production only."
    }
  }
}

#Kesalahan & Jebakan Umum

#Commit State File ke Git

Jangan pernah commit terraform.tfstate atau terraform.tfstate.backup ke version control. Tambahkan ke .gitignore:

terraform.tfstate
terraform.tfstate.*
.terraform/
.terraform.lock.hcl

State file contain sensitive data seperti database password, API key, dan private IP. Commit mereka expose informasi ini ke siapa pun dengan repository access.

#Manually Edit State File

Terraform state adalah file JSON, dan tempting untuk edit secara langsung. Jangan. Gunakan terraform state command sebagai gantinya:

terraform state rm aws_instance.example
terraform state mv aws_instance.old aws_instance.new
terraform state show aws_instance.example

Manual edit dapat corrupt state file, causing Terraform untuk behave unpredictably.

#Share Backend Credential

Backend credential harus dikelola melalui IAM role, bukan shared credential file. Jika Anda menggunakan AWS, gunakan:

• IAM role untuk EC2 instance
• Assume role untuk CI/CD pipeline
• AWS SSO untuk developer access

Jangan pernah hardcode AWS credential dalam Terraform configuration Anda atau share via Slack.

#Lupa Initialize Backend

Ketika Anda clone Terraform repository, run terraform init immediately. Ini download provider dan configure backend. Skip langkah ini berarti Anda bekerja dengan local state, yang mengalahkan purpose dari remote backend.

#Tidak Test State Migration

Sebelum migrate ke new backend dalam production, test dalam non-critical environment terlebih dahulu. State migration biasanya safe, tetapi lebih baik untuk sure.

#Best Practice untuk Produksi

#Gunakan Terraform Cloud atau Terraform Enterprise

Untuk team beyond certain size, managed solution seperti Terraform Cloud eliminate backend complexity. Anda mendapat:

• Built-in state management dan locking
• Team collaboration feature
• Policy as Code (Sentinel)
• Cost estimation
• VCS integration
• Audit log

Trade-off adalah cost dan less control, tetapi operational simplicity worth untuk most organization.

#Implementasikan State Backup

Bahkan dengan S3 versioning, maintain regular backup:

aws s3 cp s3://my-terraform-state/prod/terraform.tfstate \
  s3://my-terraform-backups/prod/terraform.tfstate.$(date +%Y%m%d)

Run ini daily via Lambda function atau cron job.

#Monitor State File Change

Setup CloudWatch alert untuk state file modification:

resource "aws_cloudwatch_event_rule" "state_changes" {
  name        = "terraform-state-changes"
  description = "Alert on Terraform state file modifications"
 
  event_pattern = jsonencode({
    source      = ["aws.s3"]
    detail-type = ["Object-level API calls via CloudTrail"]
    detail = {
      bucket = {
        name = ["my-terraform-state"]
      }
      object = {
        key = [{
          prefix = "prod/terraform.tfstate"
        }]
      }
      eventName = ["PutObject"]
    }
  })
}

#Gunakan State Locking Timeout

Configure lock timeout untuk prevent operation dari hanging indefinitely:

terraform {
  backend "s3" {
    bucket         = "my-terraform-state"
    key            = "prod/terraform.tfstate"
    region         = "us-east-1"
    dynamodb_table = "terraform-locks"
    encrypt        = true
    skip_credentials_validation = false
    skip_metadata_api_check     = false
  }
}

Dalam CI/CD pipeline Anda, set operation timeout:

timeout 30m terraform apply -auto-approve

#Pisahkan State oleh Blast Radius

Jangan put semua infrastructure Anda dalam satu state file. Pisahkan oleh:

• Environment (dev, staging, prod)
• Component (networking, database, application)
• Team ownership

Ini limit blast radius jika sesuatu salah. Mistake dalam dev state file tidak akan affect production.

#Kapan TIDAK Menggunakan Remote State

#Local Development

Untuk personal project atau learning, local state baik-baik saja. Anda adalah satu-satunya user, dan kehilangan state tidak catastrophic.

#Temporary Infrastructure

Jika Anda spinning up infrastructure untuk testing dan tearing down immediately, local state bekerja.

#Offline Environment

Jika Anda managing infrastructure dalam air-gapped network tanpa internet access, Anda mungkin perlu gunakan local state atau self-hosted backend.

Dalam semua case lain, especially anything touching production, gunakan remote backend.

#Kesimpulan

Terraform state management adalah foundational untuk reliable infrastructure automation. Moving dari local ke remote state dengan S3 dan DynamoDB eliminate most common failure mode: lost state, concurrent modification, dan lack of audit trail.

Takeaway kunci:

• Selalu gunakan remote backend untuk production infrastructure
• Aktifkan state locking untuk prevent concurrent modification
• Encrypt state at rest dan in transit
• Version state file Anda dan maintain backup
• Organisir multi-environment state dengan clear directory structure
• Monitor state file change dan implementasikan access control
• Gunakan managed solution seperti Terraform Cloud jika operational complexity adalah concern

Mulai dengan S3 + DynamoDB jika Anda di AWS. Ini battle-tested, cost-effective, dan memberikan Anda full control. Saat team Anda berkembang, evaluate managed solution seperti Terraform Cloud untuk additional collaboration feature.

Waktu yang Anda invest dalam proper state management sekarang prevent infrastructure disaster nanti.