Lab 19: Kubernetes(EKS) 프로비저닝

terraform {
  required_version = ">= 1.0.0"

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

    # EKS 클러스터를 만든 뒤, 같은 apply 안에서 클러스터 안의
    # 리소스(Namespace/Deployment/Service)까지 관리하기 위한 provider
    kubernetes = {
      source  = "hashicorp/kubernetes"
      version = "~> 2.30"
    }

    # IRSA용 OIDC provider 등록 시 인증서 지문(thumbprint)을 계산하는 데 사용
    tls = {
      source  = "hashicorp/tls"
      version = "~> 4.0"
    }
  }
}

provider "aws" {
  region = var.region
}

# 클러스터 접속용 임시 토큰(15분 유효) — kubeconfig 파일 없이 인증
data "aws_eks_cluster_auth" "main" {
  name = aws_eks_cluster.main.name
}

provider "kubernetes" {
  host                   = aws_eks_cluster.main.endpoint
  cluster_ca_certificate = base64decode(aws_eks_cluster.main.certificate_authority[0].data)
  token                  = data.aws_eks_cluster_auth.main.token
}

variable "project" {
  description = "프로젝트 이름"
  type        = string
  default     = "lab19"
}

variable "environment" {
  description = "배포 환경"
  type        = string
  default     = "dev"
}

variable "region" {
  description = "클러스터를 생성할 리전"
  type        = string
  default     = "ap-northeast-2"
}

variable "cluster_version" {
  description = "EKS 컨트롤 플레인 쿠버네티스 버전"
  type        = string
  default     = "1.31"
}

variable "node_instance_type" {
  description = "워커 노드 인스턴스 타입 — 실습용 최소 사양"
  type        = string
  default     = "t3.small"
}

variable "node_desired_size" {
  description = "관리형 노드 그룹의 희망 노드 수"
  type        = number
  default     = 2

  validation {
    condition     = var.node_desired_size >= 1 && var.node_desired_size <= 3
    error_message = "실습 비용을 감안해 1~3개 사이로 제한한다."
  }
}

variable "app_replicas" {
  description = "nginx Deployment의 파드 replica 수"
  type        = number
  default     = 2
}

# LoadBalancer로 바꾸면 AWS가 실제 ELB를 생성해 시간당 비용이 발생한다.
# 기본값은 ClusterIP이며, 접속 확인은 kubectl port-forward로 한다.
variable "service_type" {
  description = "nginx Service 타입 (ClusterIP | NodePort | LoadBalancer)"
  type        = string
  default     = "ClusterIP"

  validation {
    condition     = contains(["ClusterIP", "NodePort", "LoadBalancer"], var.service_type)
    error_message = "service_type은 ClusterIP, NodePort, LoadBalancer 중 하나여야 한다."
  }
}

locals {
  cluster_name = "${var.project}-eks"

  common_tags = {
    Project     = var.project
    Environment = var.environment
    ManagedBy   = "terraform"
  }

  # 클러스터 안에서 배포할 애플리케이션 식별자
  app_namespace = "demo"
  app_name      = "nginx"
}

# EKS는 서로 다른 AZ의 서브넷을 최소 2개 요구한다
data "aws_availability_zones" "available" {
  state = "available"
}

resource "aws_vpc" "main" {
  cidr_block           = "10.19.0.0/16"
  enable_dns_support   = true
  enable_dns_hostnames = true # EKS 노드 등록에 필수

  tags = merge(local.common_tags, {
    Name = "${local.cluster_name}-vpc"
  })
}

resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id

  tags = merge(local.common_tags, {
    Name = "${local.cluster_name}-igw"
  })
}

# 실습 비용 최소화를 위해 퍼블릭 서브넷만 사용한다.
# 실무에서는 워커 노드를 프라이빗 서브넷에 두고 NAT Gateway로 아웃바운드를
# 처리하는 것이 표준이지만, NAT Gateway는 시간당 요금이 붙는다.
resource "aws_subnet" "public" {
  count = 2

  vpc_id                  = aws_vpc.main.id
  cidr_block              = cidrsubnet(aws_vpc.main.cidr_block, 8, count.index)
  availability_zone       = data.aws_availability_zones.available.names[count.index]
  map_public_ip_on_launch = true # 노드가 컨트롤 플레인/ECR에 접근하려면 필요

  tags = merge(local.common_tags, {
    Name = "${local.cluster_name}-public-${count.index + 1}"

    # 쿠버네티스가 이 서브넷에 외부용 LoadBalancer를 만들 수 있다고 표시하는 태그.
    # service_type = "LoadBalancer"로 바꿀 때 이 태그가 없으면 프로비저닝이 실패한다.
    "kubernetes.io/role/elb" = "1"
  })
}

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 = merge(local.common_tags, {
    Name = "${local.cluster_name}-public-rt"
  })
}

resource "aws_route_table_association" "public" {
  count = length(aws_subnet.public)

  subnet_id      = aws_subnet.public[count.index].id
  route_table_id = aws_route_table.public.id
}

# ── 컨트롤 플레인 Role ────────────────────────────────────────────────
# EKS 서비스가 사용자 계정 안에서 ENI, 보안 그룹 등을 다루기 위해 위임받는 Role
resource "aws_iam_role" "cluster" {
  name = "${local.cluster_name}-cluster-role"

  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Effect = "Allow"
      Principal = {
        Service = "eks.amazonaws.com"
      }
      Action = ["sts:AssumeRole", "sts:TagSession"]
    }]
  })

  tags = merge(local.common_tags, {
    Name = "${local.cluster_name}-cluster-role"
  })
}

resource "aws_iam_role_policy_attachment" "cluster" {
  role       = aws_iam_role.cluster.name
  policy_arn = "arn:aws:iam::aws:policy/AmazonEKSClusterPolicy"
}

# ── 워커 노드 Role ───────────────────────────────────────────────────
# 노드는 EC2 인스턴스이므로 신뢰 주체가 ec2.amazonaws.com이다
resource "aws_iam_role" "node" {
  name = "${local.cluster_name}-node-role"

  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Effect = "Allow"
      Principal = {
        Service = "ec2.amazonaws.com"
      }
      Action = "sts:AssumeRole"
    }]
  })

  tags = merge(local.common_tags, {
    Name = "${local.cluster_name}-node-role"
  })
}

# 관리형 노드 그룹이 요구하는 3종 세트
locals {
  node_policies = {
    worker    = "arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy"          # 클러스터 조인
    cni       = "arn:aws:iam::aws:policy/AmazonEKS_CNI_Policy"               # 파드 ENI/IP 할당
    ecr_read  = "arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly" # 이미지 pull
    ssm_agent = "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore"       # SSH 키 없이 노드 접속
  }
}

resource "aws_iam_role_policy_attachment" "node" {
  for_each = local.node_policies

  role       = aws_iam_role.node.name
  policy_arn = each.value
}

# ── 컨트롤 플레인 ────────────────────────────────────────────────────
# AWS가 관리하는 API 서버/etcd. 시간당 요금이 부과되므로 실습 후 반드시 destroy.
resource "aws_eks_cluster" "main" {
  name     = local.cluster_name
  role_arn = aws_iam_role.cluster.arn
  version  = var.cluster_version

  vpc_config {
    subnet_ids              = aws_subnet.public[*].id
    endpoint_public_access  = true # 로컬 kubectl에서 접근하기 위함
    endpoint_private_access = true # 노드는 VPC 내부 경로로 통신
  }

  access_config {
    # API: aws_eks_access_entry 리소스로 접근 권한을 관리(신규 방식)
    # CONFIG_MAP: aws-auth ConfigMap 편집(레거시). 둘 다 쓰려면 API_AND_CONFIG_MAP.
    authentication_mode = "API"

    # apply를 실행한 IAM 주체에게 클러스터 관리자 권한을 자동 부여.
    # 이게 없으면 클러스터를 만들고도 kubectl/kubernetes provider가 인증에 실패한다.
    bootstrap_cluster_creator_admin_permissions = true
  }

  # Role의 권한이 먼저 붙고, 삭제는 나중에 되도록 순서 고정.
  # 그렇지 않으면 EKS가 만든 ENI/보안 그룹을 정리하지 못해 destroy가 멈춘다.
  depends_on = [aws_iam_role_policy_attachment.cluster]

  tags = merge(local.common_tags, {
    Name = local.cluster_name
  })
}

# ── 워커 노드(관리형 노드 그룹) ───────────────────────────────────────
# AMI 선택, 부트스트랩, 롤링 업데이트를 EKS가 대신 처리한다.
# lab18의 Fargate가 "노드조차 없는" 모델이라면, 여기서는 노드를 직접 소유한다.
resource "aws_eks_node_group" "main" {
  cluster_name    = aws_eks_cluster.main.name
  node_group_name = "${local.cluster_name}-ng"
  node_role_arn   = aws_iam_role.node.arn
  subnet_ids      = aws_subnet.public[*].id

  instance_types = [var.node_instance_type]
  capacity_type  = "ON_DEMAND"
  disk_size      = 20

  scaling_config {
    desired_size = var.node_desired_size
    min_size     = 1
    max_size     = 3
  }

  update_config {
    max_unavailable = 1 # 버전 업그레이드 시 한 번에 한 대씩 교체
  }

  depends_on = [aws_iam_role_policy_attachment.node]

  tags = merge(local.common_tags, {
    Name = "${local.cluster_name}-ng"
  })

  lifecycle {
    # 클러스터 오토스케일러가 desired_size를 바꿔도 Terraform이 되돌리지 않게 한다
    ignore_changes = [scaling_config[0].desired_size]
  }
}

# ── 애드온 ──────────────────────────────────────────────────────────
# CoreDNS/kube-proxy/VPC CNI는 EKS 애드온으로 버전을 코드에 고정할 수 있다.
# 애드온 파드는 노드 위에서 돌기 때문에 노드 그룹 이후에 설치한다.
resource "aws_eks_addon" "core" {
  for_each = toset(["vpc-cni", "coredns", "kube-proxy"])

  cluster_name = aws_eks_cluster.main.name
  addon_name   = each.value

  # 버전을 명시하지 않으면 클러스터 버전에 맞는 기본 버전이 설치된다
  resolve_conflicts_on_create = "OVERWRITE"
  resolve_conflicts_on_update = "OVERWRITE"

  depends_on = [aws_eks_node_group.main]

  tags = local.common_tags
}

# ── IRSA (IAM Roles for Service Accounts) ────────────────────────────
# 파드에 AWS 권한을 주는 올바른 방법. 노드 Role에 권한을 몰아주면
# 그 노드의 "모든" 파드가 같은 권한을 갖게 되므로 최소 권한 원칙(lab14)이 깨진다.
#
# 동작 원리: 클러스터가 발급한 ServiceAccount 토큰(JWT)을 IAM이 신뢰하도록
# OIDC provider로 등록해 두면, 파드가 그 토큰으로 직접 AssumeRole 할 수 있다.

# 클러스터 OIDC 발급자의 TLS 인증서를 읽어 지문(thumbprint)을 계산
data "tls_certificate" "oidc" {
  url = aws_eks_cluster.main.identity[0].oidc[0].issuer
}

resource "aws_iam_openid_connect_provider" "eks" {
  url             = aws_eks_cluster.main.identity[0].oidc[0].issuer
  client_id_list  = ["sts.amazonaws.com"]
  thumbprint_list = [data.tls_certificate.oidc.certificates[0].sha1_fingerprint]

  tags = merge(local.common_tags, {
    Name = "${local.cluster_name}-oidc"
  })
}

# 신뢰 정책: "demo 네임스페이스의 nginx ServiceAccount"만 이 Role을 쓸 수 있다.
# sub 조건을 생략하면 클러스터의 아무 파드나 Role을 가져갈 수 있으니 반드시 고정한다.
data "aws_iam_policy_document" "app_assume_role" {
  statement {
    effect  = "Allow"
    actions = ["sts:AssumeRoleWithWebIdentity"]

    principals {
      type        = "Federated"
      identifiers = [aws_iam_openid_connect_provider.eks.arn]
    }

    condition {
      test     = "StringEquals"
      variable = "${replace(aws_iam_openid_connect_provider.eks.url, "https://", "")}:sub"
      values   = ["system:serviceaccount:${local.app_namespace}:${local.app_name}"]
    }

    condition {
      test     = "StringEquals"
      variable = "${replace(aws_iam_openid_connect_provider.eks.url, "https://", "")}:aud"
      values   = ["sts.amazonaws.com"]
    }
  }
}

resource "aws_iam_role" "app" {
  name               = "${local.cluster_name}-app-irsa-role"
  assume_role_policy = data.aws_iam_policy_document.app_assume_role.json

  tags = merge(local.common_tags, {
    Name = "${local.cluster_name}-app-irsa-role"
  })
}

# 예시 권한 — 자기 계정 정보 조회만 가능한 사실상 무해한 정책.
# 실제로는 여기에 애플리케이션이 필요한 S3/SQS 권한 등을 붙인다.
data "aws_iam_policy_document" "app" {
  statement {
    effect    = "Allow"
    actions   = ["sts:GetCallerIdentity"]
    resources = ["*"]
  }
}

resource "aws_iam_role_policy" "app" {
  name   = "${local.cluster_name}-app-policy"
  role   = aws_iam_role.app.id
  policy = data.aws_iam_policy_document.app.json
}

# ── 클러스터 "안쪽" 리소스 ────────────────────────────────────────────
# 여기부터는 AWS API가 아니라 쿠버네티스 API를 호출한다.
# YAML + kubectl apply 대신 같은 state 안에서 워크로드까지 선언적으로 관리한다.

resource "kubernetes_namespace" "demo" {
  metadata {
    name = local.app_namespace

    labels = {
      "app.kubernetes.io/managed-by" = "terraform"
    }
  }

  depends_on = [aws_eks_node_group.main]
}

# irsa.tf에서 만든 IAM Role을 annotation으로 연결.
# 이 ServiceAccount를 쓰는 파드에는 AWS 자격증명이 자동 주입된다.
resource "kubernetes_service_account" "app" {
  metadata {
    name      = local.app_name
    namespace = kubernetes_namespace.demo.metadata[0].name

    annotations = {
      "eks.amazonaws.com/role-arn" = aws_iam_role.app.arn
    }
  }
}

resource "kubernetes_deployment" "app" {
  metadata {
    name      = local.app_name
    namespace = kubernetes_namespace.demo.metadata[0].name

    labels = {
      app = local.app_name
    }
  }

  spec {
    replicas = var.app_replicas

    selector {
      match_labels = {
        app = local.app_name
      }
    }

    template {
      metadata {
        labels = {
          app = local.app_name
        }
      }

      spec {
        service_account_name = kubernetes_service_account.app.metadata[0].name

        container {
          name  = local.app_name
          image = "public.ecr.aws/nginx/nginx:stable"

          port {
            container_port = 80
          }

          # 요청량을 명시해야 스케줄러가 노드를 제대로 고른다
          resources {
            requests = {
              cpu    = "100m"
              memory = "128Mi"
            }
            limits = {
              cpu    = "250m"
              memory = "256Mi"
            }
          }

          # 준비되지 않은 파드로 트래픽이 가지 않게 막는다
          readiness_probe {
            http_get {
              path = "/"
              port = 80
            }
            initial_delay_seconds = 5
            period_seconds        = 10
          }
        }
      }
    }
  }

  # 노드가 준비되기 전에는 파드가 Pending에 머문다
  depends_on = [aws_eks_node_group.main]
}

resource "kubernetes_service" "app" {
  metadata {
    name      = local.app_name
    namespace = kubernetes_namespace.demo.metadata[0].name
  }

  spec {
    type = var.service_type

    selector = {
      app = local.app_name
    }

    port {
      port        = 80
      target_port = 80
      protocol    = "TCP"
    }
  }
}

output "cluster_name" {
  description = "EKS 클러스터 이름"
  value       = aws_eks_cluster.main.name
}

output "cluster_endpoint" {
  description = "쿠버네티스 API 서버 엔드포인트"
  value       = aws_eks_cluster.main.endpoint
}

output "cluster_version" {
  description = "실행 중인 쿠버네티스 버전"
  value       = aws_eks_cluster.main.version
}

output "oidc_provider_arn" {
  description = "IRSA용 OIDC provider ARN"
  value       = aws_iam_openid_connect_provider.eks.arn
}

output "app_irsa_role_arn" {
  description = "nginx ServiceAccount에 연결된 IAM Role ARN"
  value       = aws_iam_role.app.arn
}

# 로컬에서 kubectl을 쓰려면 kubeconfig에 클러스터를 등록해야 한다
output "kubeconfig_command" {
  description = "kubeconfig 갱신 명령"
  value       = "aws eks update-kubeconfig --region ${var.region} --name ${aws_eks_cluster.main.name}"
}

terraform destroy -auto-approve