🍎 macOS 설치

맥 유저라면 Homebrew 쓰면 개꿀이야 ㅋㅋㅋ

brew tap hashicorp/tap
brew install hashicorp/tap/terraform

설치 끝! 진짜 간단하지? 😎

🪟 Windows 설치

윈도우 유저는 Chocolatey 쓰거나 직접 다운로드 받으면 돼.

choco install terraform

또는 HashiCorp 공식 사이트에서 바이너리 다운받아서 PATH에 추가해주면 끝!

🐧 Linux 설치

리눅스는 패키지 매니저 쓰면 돼. Ubuntu 기준으로 알려줄게!

wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install terraform

1️⃣ main.tf 파일 생성

Terraform의 메인 설정 파일이야. 여기에 프로바이더 설정과 리소스를 정의해.

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
  required_version = ">= 1.0"
}

provider "aws" {
  region = "ap-northeast-2"  # 서울 리전!
}

resource "aws_instance" "my_first_server" {
  ami           = "ami-0c9c942bd7bf113a2"  # Amazon Linux 2023
  instance_type = "t2.micro"  # 프리티어 가능!

  tags = {
    Name = "MyFirstTerraformServer"
    Environment = "Learning"
  }
}

이게 끝이야! 진짜 간단하지? ㅋㅋㅋ 이 코드만으로 EC2 인스턴스가 만들어져!

Step 1: terraform init 🎬

초기화 명령어야! 프로바이더 플러그인을 다운로드하고 작업 디렉토리를 준비해줘.

terraform init

실행하면 이런 메시지가 나와:

Initializing the backend...
Initializing provider plugins...
- Finding hashicorp/aws versions matching "~> 5.0"...
- Installing hashicorp/aws v5.31.0...
- Installed hashicorp/aws v5.31.0

Terraform has been successfully initialized!

.terraform 디렉토리가 생성되고 필요한 플러그인들이 다운로드돼. 이건 프로젝트당 한 번만 하면 돼! ✅

Step 2: terraform plan 📋

실행 계획을 미리 보는 명령어야! 실제로 뭐가 만들어질지 확인할 수 있어서 완전 꿀이야 ㅋㅋㅋ

terraform plan

그럼 이런 식으로 출력돼:

Terraform will perform the following actions:

  # aws_instance.my_first_server will be created
  + resource "aws_instance" "my_first_server" {
      + ami                          = "ami-0c9c942bd7bf113a2"
      + instance_type                = "t2.micro"
      + tags                         = {
          + "Environment" = "Learning"
          + "Name"        = "MyFirstTerraformServer"
        }
      # ... (생략)
    }

Plan: 1 to add, 0 to change, 0 to destroy.

Plan: 1 to add, 0 to change, 0 to destroy 이 부분이 핵심이야!
1개를 추가하고, 0개를 변경하고, 0개를 삭제한다는 뜻이지. 실수로 뭔가 지워질 일이 없는지 확인할 수 있어서 안전해! 🛡️

Step 3: terraform apply 🎉

드디어 실제로 인프라를 만드는 명령어야! 긴장되지? ㅋㅋㅋ

terraform apply

실행하면 plan 결과를 다시 보여주고 확인을 요청해:

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: 

여기서 yes를 입력하면 진짜로 AWS에 리소스가 생성돼! 😱

몇 초 기다리면...

aws_instance.my_first_server: Creating...
aws_instance.my_first_server: Still creating... [10s elapsed]
aws_instance.my_first_server: Still creating... [20s elapsed]
aws_instance.my_first_server: Creation complete after 25s [id=i-0123456789abcdef0]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

완성! 🎊 AWS 콘솔 가서 확인해봐. EC2 인스턴스가 진짜로 만들어져 있을 거야!

📁 프로젝트 구조 잡기

일단 파일을 여러 개로 나누는 게 좋아. 관리하기 편하거든!

web-server-infra/
├── main.tf          # 메인 리소스 정의
├── variables.tf     # 변수 정의
├── outputs.tf       # 출력값 정의
├── terraform.tfvars # 변수 값 설정
└── .gitignore       # Git 무시 파일

1️⃣ variables.tf - 변수 정의하기

하드코딩 대신 변수를 사용하면 재사용성이 엄청 좋아져!

variable "aws_region" {
  description = "AWS 리전"
  type        = string
  default     = "ap-northeast-2"
}

variable "project_name" {
  description = "프로젝트 이름"
  type        = string
  default     = "my-web-server"
}

variable "environment" {
  description = "환경 (dev, staging, prod)"
  type        = string
  default     = "dev"
}

variable "instance_type" {
  description = "EC2 인스턴스 타입"
  type        = string
  default     = "t2.micro"
}

variable "allowed_cidr_blocks" {
  description = "접근 허용할 IP 대역"
  type        = list(string)
  default     = ["0.0.0.0/0"]  # 실무에서는 특정 IP만 허용해야 해!
}

2️⃣ main.tf - 메인 인프라 코드

이제 진짜 인프라를 정의해보자! 좀 길지만 하나씩 보면 어렵지 않아 😊

# Provider 설정
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
  required_version = ">= 1.0"
}

provider "aws" {
  region = var.aws_region
}

# VPC 생성
resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name        = "${var.project_name}-vpc"
    Environment = var.environment
  }
}

# 인터넷 게이트웨이
resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id

  tags = {
    Name        = "${var.project_name}-igw"
    Environment = var.environment
  }
}

# 퍼블릭 서브넷
resource "aws_subnet" "public" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.1.0/24"
  availability_zone       = "${var.aws_region}a"
  map_public_ip_on_launch = true

  tags = {
    Name        = "${var.project_name}-public-subnet"
    Environment = var.environment
  }
}

# 라우팅 테이블
resource "aws_route_table" "public" {
  vpc_id = aws_vpc.main.id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.main.id
  }

  tags = {
    Name        = "${var.project_name}-public-rt"
    Environment = var.environment
  }
}

# 라우팅 테이블 연결
resource "aws_route_table_association" "public" {
  subnet_id      = aws_subnet.public.id
  route_table_id = aws_route_table.public.id
}

# 보안 그룹
resource "aws_security_group" "web" {
  name        = "${var.project_name}-web-sg"
  description = "Security group for web server"
  vpc_id      = aws_vpc.main.id

  # HTTP 인바운드
  ingress {
    description = "HTTP from anywhere"
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = var.allowed_cidr_blocks
  }

  # HTTPS 인바운드
  ingress {
    description = "HTTPS from anywhere"
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = var.allowed_cidr_blocks
  }

  # SSH 인바운드
  ingress {
    description = "SSH from anywhere"
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = var.allowed_cidr_blocks
  }

  # 모든 아웃바운드 허용
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Name        = "${var.project_name}-web-sg"
    Environment = var.environment
  }
}

# 최신 Amazon Linux 2023 AMI 찾기
data "aws_ami" "amazon_linux_2023" {
  most_recent = true
  owners      = ["amazon"]

  filter {
    name   = "name"
    values = ["al2023-ami-*-x86_64"]
  }

  filter {
    name   = "virtualization-type"
    values = ["hvm"]
  }
}

# EC2 인스턴스 (웹 서버)
resource "aws_instance" "web" {
  ami                    = data.aws_ami.amazon_linux_2023.id
  instance_type          = var.instance_type
  subnet_id              = aws_subnet.public.id
  vpc_security_group_ids = [aws_security_group.web.id]

  user_data = <<-EOF
              #!/bin/bash
              yum update -y
              yum install -y httpd
              systemctl start httpd
              systemctl enable httpd
              echo "<h1>Hello from Terraform! 🚀</h1>" > /var/www/html/index.html
              echo "<p>Server deployed at: $(date)</p>" >> /var/www/html/index.html
              EOF

  tags = {
    Name        = "${var.project_name}-web-server"
    Environment = var.environment
  }
}

와... 길다 ㅋㅋㅋ 근데 이게 전부야! 이 코드로 VPC부터 웹 서버까지 완전한 인프라가 만들어져! 😎

3️⃣ outputs.tf - 출력값 정의

인프라 만들고 나서 필요한 정보를 출력하게 해줘. 엄청 유용해!

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

output "public_subnet_id" {
  description = "Public Subnet ID"
  value       = aws_subnet.public.id
}

output "web_server_public_ip" {
  description = "Web Server Public IP"
  value       = aws_instance.web.public_ip
}

output "web_server_url" {
  description = "Web Server URL"
  value       = "http://${aws_instance.web.public_ip}"
}

output "security_group_id" {
  description = "Security Group ID"
  value       = aws_security_group.web.id
}

4️⃣ terraform.tfvars - 변수 값 설정

환경별로 다른 값을 설정할 수 있어!

aws_region     = "ap-northeast-2"
project_name   = "my-awesome-web"
environment    = "dev"
instance_type  = "t2.micro"

# 보안을 위해 특정 IP만 허용하는 게 좋아!
# allowed_cidr_blocks = ["123.456.789.0/24"]

🌐 Remote State 사용하기 (S3 + DynamoDB)

실무에서는 무조건 Remote State를 써야 해! AWS S3에 State를 저장하고, DynamoDB로 Lock을 관리하는 게 베스트야 👍

Step 1: S3 버킷과 DynamoDB 테이블 만들기

먼저 State를 저장할 S3 버킷과 Lock용 DynamoDB 테이블을 만들어야 해. 이건 수동으로 하거나 별도의 Terraform 코드로 만들어줘.

# backend-setup.tf (별도로 먼저 실행)
resource "aws_s3_bucket" "terraform_state" {
  bucket = "my-terraform-state-bucket-unique-name-12345"

  tags = {
    Name = "Terraform State Bucket"
  }
}

resource "aws_s3_bucket_versioning" "terraform_state" {
  bucket = aws_s3_bucket.terraform_state.id

  versioning_configuration {
    status = "Enabled"
  }
}

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

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

resource "aws_dynamodb_table" "terraform_locks" {
  name         = "terraform-state-locks"
  billing_mode = "PAY_PER_REQUEST"
  hash_key     = "LockID"

  attribute {
    name = "LockID"
    type = "S"
  }

  tags = {
    Name = "Terraform State Lock Table"
  }
}

Step 2: Backend 설정하기

이제 메인 프로젝트에서 이 S3 버킷을 backend로 사용하도록 설정해줘.

terraform {
  backend "s3" {
    bucket         = "my-terraform-state-bucket-unique-name-12345"
    key            = "web-server/terraform.tfstate"
    region         = "ap-northeast-2"
    dynamodb_table = "terraform-state-locks"
    encrypt        = true
  }

  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

Step 3: State 마이그레이션

기존에 로컬 State를 쓰고 있었다면 마이그레이션해줘야 해.

terraform init -migrate-state

그럼 Terraform이 자동으로 로컬 State를 S3로 옮겨줘! 완전 편하지? ㅋㅋㅋ

1️⃣ 모듈 만들기 (modules/web-server/)

modules/web-server/variables.tf

variable "vpc_id" {
  description = "VPC ID"
  type        = string
}

variable "subnet_id" {
  description = "Subnet ID"
  type        = string
}

variable "instance_type" {
  description = "EC2 instance type"
  type        = string
  default     = "t2.micro"
}

variable "server_name" {
  description = "Server name tag"
  type        = string
}

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

modules/web-server/main.tf

data "aws_ami" "amazon_linux_2023" {
  most_recent = true
  owners      = ["amazon"]

  filter {
    name   = "name"
    values = ["al2023-ami-*-x86_64"]
  }
}

resource "aws_security_group" "web" {
  name        = "${var.server_name}-sg"
  description = "Security group for ${var.server_name}"
  vpc_id      = var.vpc_id

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

  ingress {
    from_port   = 443
    to_port     = 443
    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 = {
    Name        = "${var.server_name}-sg"
    Environment = var.environment
  }
}

resource "aws_instance" "web" {
  ami                    = data.aws_ami.amazon_linux_2023.id
  instance_type          = var.instance_type
  subnet_id              = var.subnet_id
  vpc_security_group_ids = [aws_security_group.web.id]

  user_data = <<-EOF
              #!/bin/bash
              yum update -y
              yum install -y httpd
              systemctl start httpd
              systemctl enable httpd
              echo "<h1>${var.server_name}</h1>" > /var/www/html/index.html
              EOF

  tags = {
    Name        = var.server_name
    Environment = var.environment
  }
}

modules/web-server/outputs.tf

output "instance_id" {
  description = "EC2 Instance ID"
  value       = aws_instance.web.id
}

output "public_ip" {
  description = "Public IP address"
  value       = aws_instance.web.public_ip
}

output "security_group_id" {
  description = "Security Group ID"
  value       = aws_security_group.web.id
}

2️⃣ 모듈 사용하기 (root/main.tf)

이제 만든 모듈을 사용해보자! 엄청 간단해져 ㅋㅋㅋ

module "web_server_dev" {
  source = "./modules/web-server"

  vpc_id        = aws_vpc.main.id
  subnet_id     = aws_subnet.public.id
  instance_type = "t2.micro"
  server_name   = "dev-web-server"
  environment   = "dev"
}

module "web_server_staging" {
  source = "./modules/web-server"

  vpc_id        = aws_vpc.main.id
  subnet_id     = aws_subnet.public.id
  instance_type = "t2.small"
  server_name   = "staging-web-server"
  environment   = "staging"
}

# 모듈 출력값 사용하기
output "dev_server_ip" {
  value = module.web_server_dev.public_ip
}

output "staging_server_ip" {
  value = module.web_server_staging.public_ip
}

같은 모듈을 여러 번 호출해서 dev, staging 서버를 동시에 만들 수 있어! 완전 편하지? 😎

📋 GitHub Actions 워크플로우

.github/workflows/terraform.yml 파일을 만들어줘.

name: 'Terraform'

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

env:
  AWS_REGION: ap-northeast-2

jobs:
  terraform:
    name: 'Terraform'
    runs-on: ubuntu-latest
    
    # OIDC를 사용한 AWS 인증 (더 안전!)
    permissions:
      id-token: write
      contents: read
      pull-requests: write

    steps:
    - name: Checkout
      uses: actions/checkout@v4

    - name: Configure AWS credentials
      uses: aws-actions/configure-aws-credentials@v4
      with:
        role-to-assume: arn:aws:iam::123456789012:role/GitHubActionsRole
        aws-region: ${{ env.AWS_REGION }}

    - name: Setup Terraform
      uses: hashicorp/setup-terraform@v3
      with:
        terraform_version: 1.6.0

    - name: Terraform Format
      id: fmt
      run: terraform fmt -check
      continue-on-error: true

    - name: Terraform Init
      id: init
      run: terraform init

    - name: Terraform Validate
      id: validate
      run: terraform validate -no-color

    - name: Terraform Plan
      id: plan
      if: github.event_name == 'pull_request'
      run: terraform plan -no-color -input=false
      continue-on-error: true

    - name: Update Pull Request
      uses: actions/github-script@v7
      if: github.event_name == 'pull_request'
      env:
        PLAN: "${{ steps.plan.outputs.stdout }}"
      with:
        github-token: ${{ secrets.GITHUB_TOKEN }}
        script: |
          const output = `#### Terraform Format and Style 🖌\`${{ steps.fmt.outcome }}\`
          #### Terraform Initialization ⚙️\`${{ steps.init.outcome }}\`
          #### Terraform Validation 🤖\`${{ steps.validate.outcome }}\`
          #### Terraform Plan 📖\`${{ steps.plan.outcome }}\`

          <details><summary>Show Plan</summary>

          \`\`\`terraform
          ${process.env.PLAN}
          \`\`\`

          </details>

          *Pushed by: @${{ github.actor }}, Action: \`${{ github.event_name }}\`*`;

          github.rest.issues.createComment({
            issue_number: context.issue.number,
            owner: context.repo.owner,
            repo: context.repo.repo,
            body: output
          })

    - name: Terraform Plan Status
      if: steps.plan.outcome == 'failure'
      run: exit 1

    - name: Terraform Apply
      if: github.ref == 'refs/heads/main' && github.event_name == 'push'
      run: terraform apply -auto-approve -input=false