OpenTofu vs Terraform 2026 완벽 비교: IaC 도구 선택과 마이그레이션 전략

# 이러한 내부 사용은 BSL 하에서도 허용됨
# - 자사 인프라 관리
# - 내부 Platform Engineering 도구 개발
# - 컨설팅 목적의 고객 인프라 구성

# 아래와 같은 경우는 BSL 위반 가능성
# - Terraform을 래핑한 SaaS 제품 출시
# - Terraform CLI를 포함한 Managed IaC 서비스 제공
# - Terraform을 기반으로 한 경쟁 IaC 플랫폼 개발

# main.tf - OpenTofu State 암호화 구성
terraform {
  encryption {
    # 방법 1: PBKDF2 기반 패스프레이즈 암호화
    method "aes_gcm" "passphrase" {
      keys = key_provider.pbkdf2.mykey
    }

    key_provider "pbkdf2" "mykey" {
      passphrase = var.state_encryption_passphrase
    }

    state {
      method   = method.aes_gcm.passphrase
      enforced = true
    }

    plan {
      method   = method.aes_gcm.passphrase
      enforced = true
    }
  }
}

# AWS KMS 기반 State 암호화
terraform {
  encryption {
    key_provider "aws_kms" "production" {
      kms_key_id = "arn:aws:kms:ap-northeast-2:123456789012:key/mrk-abc123"
      region     = "ap-northeast-2"
      key_spec   = "AES_256"
    }

    method "aes_gcm" "kms_encrypt" {
      keys = key_provider.aws_kms.production
    }

    state {
      method   = method.aes_gcm.kms_encrypt
      enforced = true
    }

    plan {
      method   = method.aes_gcm.kms_encrypt
      enforced = true
    }
  }

  backend "s3" {
    bucket         = "my-tofu-state"
    key            = "prod/terraform.tfstate"
    region         = "ap-northeast-2"
    encrypt        = true
    use_lockfile   = true  # DynamoDB 없이 S3 네이티브 잠금
  }
}

# Terraform - S3 백엔드 서버 측 암호화 (State 자체 암호화 아님)
terraform {
  backend "s3" {
    bucket         = "my-terraform-state"
    key            = "prod/terraform.tfstate"
    region         = "ap-northeast-2"
    encrypt        = true  # SSE-S3 또는 SSE-KMS
    kms_key_id     = "arn:aws:kms:ap-northeast-2:123456789012:key/mrk-abc123"
    dynamodb_table = "terraform-locks"  # DynamoDB 잠금 테이블 필요
  }
}

# 주의: S3 encrypt=true는 "저장 시 암호화"일 뿐
# State 파일을 S3에서 다운로드하면 평문으로 노출됨
# terraform state pull 명령도 평문 출력

# OpenTofu - Provider for_each로 멀티 리전 리소스 생성
variable "regions" {
  type    = set(string)
  default = ["ap-northeast-2", "us-east-1", "eu-west-1"]
}

provider "aws" "by_region" {
  for_each = var.regions
  region   = each.value
}

resource "aws_s3_bucket" "regional_logs" {
  for_each = var.regions
  provider = aws.by_region[each.value]
  bucket   = "app-logs-${each.value}"

  tags = {
    Region  = each.value
    Purpose = "regional-logs"
  }
}

# Terraform - 수동 provider alias (확장성 제한)
provider "aws" {
  alias  = "ap_northeast_2"
  region = "ap-northeast-2"
}

provider "aws" {
  alias  = "us_east_1"
  region = "us-east-1"
}

provider "aws" {
  alias  = "eu_west_1"
  region = "eu-west-1"
}

# 리전이 추가될 때마다 provider + resource 블록을 수동 추가해야 함
resource "aws_s3_bucket" "logs_apne2" {
  provider = aws.ap_northeast_2
  bucket   = "app-logs-ap-northeast-2"
}

resource "aws_s3_bucket" "logs_use1" {
  provider = aws.us_east_1
  bucket   = "app-logs-us-east-1"
}

# tests/vpc.tftest.hcl - OpenTofu 테스트
variables {
  vpc_cidr     = "10.0.0.0/16"
  environment  = "test"
  project_name = "myapp"
}

run "create_vpc" {
  command = apply

  assert {
    condition     = aws_vpc.main.cidr_block == "10.0.0.0/16"
    error_message = "VPC CIDR이 예상과 다릅니다"
  }

  assert {
    condition     = aws_vpc.main.enable_dns_hostnames == true
    error_message = "DNS 호스트네임이 활성화되어야 합니다"
  }

  assert {
    condition     = length(aws_subnet.private) == 3
    error_message = "프라이빗 서브넷이 3개여야 합니다"
  }
}

run "verify_security_group" {
  command = plan

  assert {
    condition     = aws_security_group.web.ingress[0].from_port == 443
    error_message = "HTTPS 인그레스가 설정되어야 합니다"
  }
}

# tests/vpc.tftest.hcl - Terraform 테스트 (구조 유사)
variables {
  vpc_cidr    = "10.0.0.0/16"
  environment = "test"
}

run "create_vpc" {
  command = apply

  assert {
    condition     = aws_vpc.main.cidr_block == "10.0.0.0/16"
    error_message = "VPC CIDR mismatch"
  }
}

# 참고: 기본 구조는 동일하나, OpenTofu는 더 많은
# 테스트 러너 옵션과 mock provider 기능을 제공

# 1. 현재 Terraform 버전 확인
terraform version
# Terraform v1.10.x

# 2. 사용 중인 프로바이더 목록 확인
terraform providers

# 3. State 파일 버전 확인
terraform state pull | python3 -c "
import sys, json
state = json.load(sys.stdin)
print(f'State Version: {state.get(\"version\", \"unknown\")}')
print(f'TF Version: {state.get(\"terraform_version\", \"unknown\")}')
print(f'Resources: {len(state.get(\"resources\", []))}')
"

# Step 1: OpenTofu 설치
# macOS
brew install opentofu

# Linux (공식 설치 스크립트)
curl -fsSL https://get.opentofu.org/install-opentofu.sh | sh -s -- --install-method rpm

# 버전 확인
tofu version
# OpenTofu v1.10.x

# Step 2: 기존 프로젝트 디렉토리에서 초기화
cd /path/to/terraform/project

# .terraform 디렉토리 정리 (선택사항 - 클린 시작)
rm -rf .terraform .terraform.lock.hcl

# OpenTofu로 초기화
tofu init

# Step 3: Plan으로 변경 사항 없음 확인
tofu plan
# 정상적인 경우: "No changes. Your infrastructure matches the configuration."

# Step 4: State 파일 무결성 확인
tofu state list
tofu state show aws_vpc.main

# .github/workflows/tofu-deploy.yml
name: OpenTofu Deploy
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

permissions:
  id-token: write
  contents: read
  pull-requests: write

jobs:
  plan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup OpenTofu
        uses: opentofu/setup-opentofu@v1
        with:
          tofu_version: '1.10.0'

      - name: Configure AWS Credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: arn:aws:iam::123456789012:role/github-actions-tofu
          aws-region: ap-northeast-2

      - name: OpenTofu Init
        run: tofu init -no-color

      - name: OpenTofu Plan
        id: plan
        run: tofu plan -no-color -out=tfplan
        continue-on-error: true

      - name: Comment PR with Plan
        if: github.event_name == 'pull_request'
        uses: actions/github-script@v7
        with:
          script: |
            const plan = `${{ steps.plan.outputs.stdout }}`;
            const truncated = plan.length > 60000
              ? plan.substring(0, 60000) + '\n... (truncated)'
              : plan;
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## OpenTofu Plan\n\`\`\`\n${truncated}\n\`\`\``
            });

  apply:
    needs: plan
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/checkout@v4

      - name: Setup OpenTofu
        uses: opentofu/setup-opentofu@v1
        with:
          tofu_version: '1.10.0'

      - name: Configure AWS Credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: arn:aws:iam::123456789012:role/github-actions-tofu
          aws-region: ap-northeast-2

      - name: OpenTofu Init & Apply
        run: |
          tofu init -no-color
          tofu apply -no-color -auto-approve

# .gitlab-ci.yml
stages:
  - validate
  - plan
  - apply

variables:
  TOFU_VERSION: '1.10.0'
  TF_ROOT: 'infrastructure/production'

.tofu_base:
  image: ghcr.io/opentofu/opentofu:${TOFU_VERSION}
  before_script:
    - cd ${TF_ROOT}
    - tofu init -no-color

validate:
  extends: .tofu_base
  stage: validate
  script:
    - tofu validate -no-color
    - tofu fmt -check -recursive

plan:
  extends: .tofu_base
  stage: plan
  script:
    - tofu plan -no-color -out=plan.cache
  artifacts:
    paths:
      - ${TF_ROOT}/plan.cache
    expire_in: 1 week
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'

apply:
  extends: .tofu_base
  stage: apply
  script:
    - tofu apply -no-color -auto-approve plan.cache
  dependencies:
    - plan
  rules:
    - if: '$CI_COMMIT_BRANCH == "main"'
  when: manual

# atlantis.yaml
version: 3
automerge: false
delete_source_branch_on_merge: true

projects:
  - name: production-infra
    dir: infrastructure/production
    workspace: default
    terraform_version: v1.10.0 # Atlantis에서 OpenTofu 사용 시
    workflow: opentofu
    autoplan:
      when_modified:
        - '*.tf'
        - '*.tfvars'
        - 'modules/**/*.tf'
      enabled: true

workflows:
  opentofu:
    plan:
      steps:
        - env:
            name: ATLANTIS_TERRAFORM_EXECUTABLE
            value: tofu
        - init
        - plan
    apply:
      steps:
        - env:
            name: ATLANTIS_TERRAFORM_EXECUTABLE
            value: tofu
        - apply

# imports.tf - 기존 리소스를 코드로 가져오기
import {
  to = aws_vpc.existing_production
  id = "vpc-0abc123def456"
}

import {
  to = aws_subnet.existing_private["ap-northeast-2a"]
  id = "subnet-0abc123"
}

import {
  to = aws_security_group.existing_web
  id = "sg-0abc123"
}

# 코드 자동 생성 (OpenTofu/Terraform 모두 지원)
# tofu plan -generate-config-out=generated.tf
# 또는
# terraform plan -generate-config-out=generated.tf

# Import 실행 및 검증
tofu plan -generate-config-out=generated_imports.tf

# 생성된 코드 리뷰
cat generated_imports.tf

# 필요한 수정 후 적용
tofu apply

// Pulumi 예시 - TypeScript로 인프라 정의
import * as aws from '@pulumi/aws'

const vpc = new aws.ec2.Vpc('production-vpc', {
  cidrBlock: '10.0.0.0/16',
  enableDnsHostnames: true,
  tags: {
    Name: 'production-vpc',
    ManagedBy: 'pulumi',
  },
})

// 기존 TypeScript 지식을 그대로 활용 가능
const subnets = ['a', 'b', 'c'].map(
  (az, i) =>
    new aws.ec2.Subnet(`private-${az}`, {
      vpcId: vpc.id,
      cidrBlock: `10.0.${i + 1}.0/24`,
      availabilityZone: `ap-northeast-2${az}`,
    })
)

#!/bin/bash
# migration-readiness-check.sh
# OpenTofu 마이그레이션 준비도 체크 스크립트

echo "=== OpenTofu Migration Readiness Check ==="

# 1. Terraform 버전 호환성
TF_VERSION=$(terraform version -json | python3 -c "import sys,json; print(json.load(sys.stdin)['terraform_version'])")
echo "[1] Current Terraform Version: ${TF_VERSION}"

MAJOR=$(echo "${TF_VERSION}" | cut -d. -f1)
MINOR=$(echo "${TF_VERSION}" | cut -d. -f2)
if [ "${MAJOR}" -ge 1 ] && [ "${MINOR}" -ge 6 ]; then
  echo "    -> Compatible with OpenTofu migration"
else
  echo "    -> WARNING: Upgrade Terraform first before migration"
fi

# 2. 사용 중인 프로바이더 확인
echo ""
echo "[2] Provider Check:"
terraform providers | grep -E "provider\[" | sort -u

# 3. State 백엔드 확인
echo ""
echo "[3] Backend Configuration:"
grep -r "backend " *.tf 2>/dev/null || echo "    Local backend (default)"

# 4. 외부 모듈 소스 확인
echo ""
echo "[4] Module Sources:"
grep -r "source " modules/ *.tf 2>/dev/null | grep -v ".terraform" | head -20

# 5. Provisioner 사용 여부 (마이그레이션 위험 요소)
echo ""
echo "[5] Provisioner Usage (migration risk):"
grep -rn "provisioner " *.tf modules/ 2>/dev/null || echo "    No provisioners found (good)"

echo ""
echo "=== Check Complete ==="

# 증상: tofu plan 시 "Error refreshing state" 발생

# 1. State 백업 확인
ls -la terraform.tfstate.backup

# 2. 백업에서 복원
cp terraform.tfstate.backup terraform.tfstate

# 3. State 무결성 확인
tofu state list

# 4. 원격 State 손상 시 - 로컬로 풀링 후 수동 복구
tofu state pull > state_backup.json

# JSON 파일을 편집하여 손상된 리소스 제거
python3 -c "
import json
with open('state_backup.json', 'r') as f:
    state = json.load(f)

# 손상된 리소스 필터링
state['resources'] = [
    r for r in state['resources']
    if r.get('type') != 'corrupted_resource_type'
]

with open('state_fixed.json', 'w') as f:
    json.dump(state, f, indent=2)
"

# 수정된 State 푸시
tofu state push state_fixed.json

# 문제: OpenTofu 마이그레이션 후 특정 프로바이더가 동작하지 않는 경우

terraform {
  required_providers {
    aws = {
      # OpenTofu 레지스트리 명시
      source  = "hashicorp/aws"
      # 버전 범위를 넓게 지정하여 호환성 확보
      version = ">= 5.0, < 6.0"
    }

    # 커뮤니티 프로바이더의 경우 소스가 다를 수 있음
    datadog = {
      source  = "DataDog/datadog"
      version = "~> 3.0"
    }
  }
}

# 프로바이더 미러링 설정 (에어갭 환경)
# .tofurc 또는 .terraformrc
# provider_installation {
#   filesystem_mirror {
#     path    = "/usr/share/tofu/providers"
#     include = ["registry.opentofu.org/*/*"]
#   }
# }

# 증상: Terraform과 OpenTofu를 동시에 실행하여 State Lock 충돌

# 1. Lock 강제 해제 (주의: 다른 사용자가 작업 중이 아닌지 확인)
tofu force-unlock LOCK_ID

# 2. DynamoDB Lock 테이블 직접 확인 (Terraform 백엔드 사용 시)
aws dynamodb scan \
  --table-name terraform-locks \
  --filter-expression "attribute_exists(LockID)" \
  --output json

# 3. S3 네이티브 Lock으로 전환 (OpenTofu 전용)
# backend "s3" 설정에서 dynamodb_table 제거 후
# use_lockfile = true 추가

# 권장 디렉토리 구조 (OpenTofu/Terraform 공통)
infrastructure/
  environments/
    production/
      main.tf
      variables.tf
      outputs.tf
      terraform.tfvars
      backend.tf
    staging/
      main.tf
      variables.tf
      outputs.tf
      terraform.tfvars
      backend.tf
  modules/
    vpc/
      main.tf
      variables.tf
      outputs.tf
      tests/
        vpc.tftest.hcl
    ecs-service/
      main.tf
      variables.tf
      outputs.tf
      tests/
        ecs.tftest.hcl
  global/
    iam/
      main.tf
    dns/
      main.tf

# .github/workflows/drift-detection.yml
name: Infrastructure Drift Detection
on:
  schedule:
    - cron: '0 9 * * 1-5' # 평일 오전 9시

jobs:
  detect-drift:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        environment: [production, staging]
    steps:
      - uses: actions/checkout@v4
      - uses: opentofu/setup-opentofu@v1

      - name: Detect Drift
        id: drift
        run: |
          cd infrastructure/environments/${{ matrix.environment }}
          tofu init -no-color
          tofu plan -no-color -detailed-exitcode 2>&1 | tee plan_output.txt
          echo "exitcode=$?" >> "$GITHUB_OUTPUT"
        continue-on-error: true

      - name: Notify on Drift
        if: steps.drift.outputs.exitcode == '2'
        uses: slackapi/slack-github-action@v1
        with:
          payload: |
            {
              "text": "Infrastructure drift detected in ${{ matrix.environment }}!",
              "blocks": [
                {
                  "type": "section",
                  "text": {
                    "type": "mrkdwn",
                    "text": "*Drift detected* in `${{ matrix.environment }}`\nRun: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
                  }
                }
              ]
            }
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_DRIFT_WEBHOOK }}