[Terraform] 기본 사용법#5 (for, for_each, dynamic 반복문, 조건식, 함수)

💡cloudNet@ 팀의 가시다 님이 진행하는 Terraform 101 Study 4기 3주차 내용으로,
[테라폼으로 시작하는 IaC] 도서를 참조하였습니다. 감사합니다..

 

1. 반복문

1.1 for_each 반복문

for_each는 반복(for)을 할 때 타임 값에 대해 하나하나 each object로 접근한다는 의미이다.

즉, 리소스 또는 모듈에서 for_each에 입력된 데이터 형태가 map 또는 set이면, 선언된 key 값 개수만큼 리소스를 생성하게 된다.

for_each : 반복문으로, 선언된 key 값 개수만큼 리소스를 생성함

 

다음과 같이 tf파일을 생성하여 apply를 실핼해보겠다.

# main.tf
resource "local_file" "abc" {
  **for_each** = {
    **a = "content a"
    b = "content b"**
  }
  **content**  = **each.value**
  filename = "${path.module}/**${each.key}**.txt"
}

사진-1

 

for_each가 설정된 블록에서는 each 속성을 사용해 구성을 수정할 수 있다.

• each.key : 이 인스턴스에서 해당하는 map 타입의 key 값
• each.value : 이 인스턴스에서 해당하는 map 타입의 value 값

생성되는 리소스의 경우 <리소스 타입>.<이름>[], 모듈의 경우 module.<모듈 이름>[]로 해당 리소스의 값을 참조한다. 이 참조 방식을 통해 리소스 간 종속성을 정의하기도 하고 다른 리소스에서 사용하거나 출력을 위한 결과 값으로 사용한다.

 

다음으로 local_file.abc는 변수의 map 형태의 값을 참조하고, local_file.def의 경우 local_file.abc 또한 결과가 map으로 반환되므로 다시 for_each 구문을 사용할 수 있다.

# main.tf
**variable** "names" {
  **default = {
    a = "content a"
    b = "content b"
    c = "content c"
  }**
}

resource "local_file" "**abc**" {
  **for_each = var.names
  content  = each.value**
  filename = "${path.module}/abc-${each.key}.txt"
}

resource "local_file" "**def**" {
  **for_each = local_file.abc
  content  = each.value.content**
  filename = "${path.module}/def-${each.key}.txt"

사진-2

 

key 값은 count의 index와 달리 고유하기 때문에 중간에 값을 삭제한 후 다시 적용해도 삭제한 값에 대해서만 리소스를 삭제한다.

증간 값을 삭제한 변수를 적용하여 확인해보겠다.(count와 유사하게..)

# main.tf
variable "names" {
  default = {
    a = "content a"
    c = "content c"
  }
}

resource "local_file" "abc" {
  for_each = var.names
  content  = each.value
  filename = "${path.module}/abc-${each.key}.txt"
}

resource "local_file" "def" {
  for_each = local_file.abc
  content  = each.value.content
  filename = "${path.module}/def-${each.key}.txt"
}

사진-3

배열로 인덱스를 지정하는 count와 달리 for_each의 경우 고유한 key에 해당되는 리소스로 지정할 수 있어 중간 값을 삭제하고 다시 적용해도 삭제 대상에 대해서만 삭제되는 것을 확인할 수 있다.

 

1.2 for_each 데이터 유형

for_each 데이터 유형에 대해 확인해보겠다.

# main.tf
resource "aws_iam_user" "the-accounts" {
  for_each = ["Todd", "James", "Alice", "Dottie"]
  name     = each.key
}

사진-4

데이터 형식이 잘못된다고 나타난다.

 

다음과 같이 수정한 후 실행한다.

# main.tf
resource "aws_iam_user" "the-accounts" {
  for_each = toset(["Todd", "James", "Alice", "Dottie"])
  name     = each.key
}

 

 

다음과 같이 정상적으로 실행된 것을 확인할 수 있다.

Terraform will perform the following actions:

  # aws_iam_user.the-accounts["Alice"] will be created
  + resource "aws_iam_user" "the-accounts" {
      + arn           = (known after apply)
      + force_destroy = false
      + id            = (known after apply)
      + name          = "Alice"
      + path          = "/"
      + tags_all      = (known after apply)
      + unique_id     = (known after apply)
    }

  # aws_iam_user.the-accounts["Dottie"] will be created
  + resource "aws_iam_user" "the-accounts" {
      + arn           = (known after apply)
      + force_destroy = false
      + id            = (known after apply)
      + name          = "Dottie"
      + path          = "/"
      + tags_all      = (known after apply)
      + unique_id     = (known after apply)
    }

  # aws_iam_user.the-accounts["James"] will be created
  + resource "aws_iam_user" "the-accounts" {
      + arn           = (known after apply)
      + force_destroy = false
      + id            = (known after apply)
      + name          = "James"
      + path          = "/"
      + tags_all      = (known after apply)
      + unique_id     = (known after apply)
    }

  # aws_iam_user.the-accounts["Todd"] will be created
  + resource "aws_iam_user" "the-accounts" {
      + arn           = (known after apply)
      + force_destroy = false
      + id            = (known after apply)
      + name          = "Todd"
      + path          = "/"
      + tags_all      = (known after apply)
      + unique_id     = (known after apply)
    }

 

번외. 데이터 유형 확인 실습

기본 유형	집합 유형
string : 글자 유형 number : 숫자 유형 bool : true 또는 false any : 명시적으로 모든 유형이 허용됨을 표시	list [<유형>]: 인덱스 기반 집합 map (<유형>): 값 = 속성 기반 집합이며 키값 기준 정렬 set (<유형>): 값 기반 집합이며 정렬 키값 기준 정렬 object ({<인수 이름>=<유형>, …}) tuple ([<유형>, …])

 

list와 set은 선언하는 형태가 비슷하지만 참조 방식이 인덱스와 키로 각각 차이가 있고, map와 set의 경우 선언된 값이 정렬되는 특징을 가진다.

 

상세 내역은 다음과 같다.

상세 내역 확인

variable "string_a" {
  default     = "myString"
}

variable "string_b" {
  type        = string
  default     = "myString"
}

# variable "string_c" {
#   type        = string
#   default     = myString
# }

variable "number_a" {
  default = 123
}

variable "number_b" {
  type    = number
  default = 123
}

variable "number_c" {
  default = "123"
}

variable "boolean" {
  default = true
}

# (Array) list , set , tuple - value , [ ] 사용
variable "list_set_tuple_a" {
  default = ["aaa", "bbb", "ccc"]
}

variable "list_set_tuple_b" {
  type    = list(string)
  default = ["bbb", "ccc", "aaa"]
}

variable "list_set_tuple_c" {
  type    = set(string)
  default = ["bbb", "ccc", "aaa"]
}

variable "list_set_tuple_d" {
  default = ["aaa", 1, false]
}

variable "list_set_tuple_e" {
  type    = tuple([string, number, bool])
  default = ["aaa", 1, false]
}

# (Object) map , object - key : value , { } 사용
variable "map_object_a" {
  default = {"a" : "aaa", "b" : "bbb" , "c" : "ccc"}
}

variable "map_object_b" {
  type    = map(string)
  default = {"b" : "bbb" , "c" : "ccc", "a" : "aaa"}
}

variable "map_object_c" {
  default = {"name" : "gasida", "age" : 27 }
}

variable "map_object_d" {
  type = object({ name = string, age = number })
  default = {"name" : "gasida", "age" : 27 }
}

실행결과

#
terraform plan

#
terraform console
-----------------
# 기본
type(12)
type("12")

type(a)
type("a")

type(true)
type("true")

# string
var.string_a
var.string_b

type(var.string_a)
type(var.string_b)

# number
var.number_a
var.number_b
var.number_c
type(var.number_a)
type(var.number_b)
type(var.number_c)

# boolean
var.boolean
type(var.boolean)

# list , set , tuple - 'value'
var.list_set_tuple_a
var.list_set_tuple_b
var.list_set_tuple_c
var.list_set_tuple_d
var.list_set_tuple_e
type(var.list_set_tuple_a)
type(var.list_set_tuple_b)
type(var.list_set_tuple_c)
type(var.list_set_tuple_d)
type(var.list_set_tuple_e)

var.list_set_tuple_a[0]
type(var.list_set_tuple_a[0])

var.list_set_tuple_b[0]
type(var.list_set_tuple_b[0])

var.list_set_tuple_d[0]
var.list_set_tuple_d[1]
var.list_set_tuple_d[2]
type(var.list_set_tuple_d[0])
type(var.list_set_tuple_d[1])
type(var.list_set_tuple_d[2])

var.list_set_tuple_e[0]
type(var.list_set_tuple_e[0])

# map , object - 'key : value'
var.map_object_a
var.map_object_b
var.map_object_c
var.map_object_d
type(var.map_object_a)
type(var.map_object_b)
type(var.map_object_c)
type(var.map_object_d)

var.map_object_a["a"]
type(var.map_object_a["a"])

var.map_object_b["a"]
type(var.map_object_b["a"])

var.map_object_c["name"]
type(var.map_object_c["name"])

var.map_object_d["age"]
type(var.map_object_d["age"])

# tuple > list > set
type(["a","b"])
type(tolist(["a","b"]))
type(toset(["a","b"]))

# object > map
type({a="a", b="b"})
type({a="a", b=1})
type(tomap({a="a", b="b"}))
type(tomap({a="a", b=1}))

exit
-----------------

 

1.3 for_each, count 반복문 비교

count는 index로 몇번에 어떤 내용이 있는지 확인할 수 없다. 즉, 중간 리소스 삭제나 추가 시 문제가 발생할 수 있다.

resource "local_file" "abc" {
  count    = 3
  content  = "This is filename abc${count.index}.txt"
  filename = "${path.module}/abc${count.index}.txt"
}

사진-5

사진-6

 

배열(Array) 와 리스트(List) 의 차이점은 무엇일까?
큰 차이점은 배열은 연속되고 리스트는 비 연속적이란 것이다.
배열은 같은 특성을 가지는 원소들을 순서대로 구성한 선형 자료 구조이고, 리스트는 배열의 인덱스를 버리고 빈틈없이 데이터를 적재하나(메모리 낭비가 덜함) 연속적으로 저장하지 않는 연결 리스트 구조이다.

 

 

for_each 표현식을 사용하면 lists, sets, maps를 사용하여 전체 리소스의 여러 복사본 또는 리소스 내 인라인 블록의 여러 복사본, 모듈의 복사본을 생성할 수 있다.

 

다음은 for_each를 사용해 리소스의 여러 복사본을 만드는 구문이다.

resource "<PROVIDER>_<TYPE>" "<NAME>" {
  for_each = <COLLECTION>

  [CONFIG ...]
}

(COLLECTION은 루프를 처리할 sets 또는 maps)

리소스에 for_each를 사용할 때에는 리스트는 지원하지 않는다. 그리고 CONFIG는 해당 리소스와 관련된 하나 이상의 인수로 구성되는데 CONFIG 내에서 each.key 또는 each.value를 사용하여 COLLECTION에서 현재 항목의 키와 값에 접근할 수 있다.

 

 

예로 다음은 for_each를 사용하여 3개의 IAM 사용자를 생성하는 방법이다.

provider "aws" {
  region = "ap-northeast-2"
}

resource "aws_iam_user" "myiam" {
  **for_each = toset(var.user_names)**
  **name     = each.value**
}

variable "user_names" {
  description = "Create IAM users with these names"
  type        = list(string)
  default     = ["gasida", "akbun", "ssoon"]
}

output "all_users" {
  value = aws_iam_user.myiam
}

var.user_names 리스트를 set으로 변환하기 위해 toset를 사용한다.(for_each는 리소스에 사용될 때는 set과 map만 지원)

for_each가 이 집합을 반복하면 each.value에서 각 사용자 이름을 사용할 수 있다.

 

일반적으로는 each.key는 키/값 쌍 맵에서만 사용 가능하지만, 사용자 이름은 each.key 에서도 사용할 수 있다.

 

 

for_each를 사용한 후에는 하나의 리소스 또는 count를 사용한 것과 같은 리소스 배열이 되는 것이 아닌 리소스 맵(list into a set)이 된다.

terraform init -upgrade
**terraform plan && terraform apply -auto-approve**

# 확인
**terraform state list**
**terraform output**
aws iam list-users | jq

****# 배포 결과 content만 필터링 확인
cat terraform.tfstate | grep -e key -e name -e "content:"

all_users 출력 변수가 for_each의 키 즉, 사용자 이름을 가지며 값이 해당 리소스의 전체 출력인 맵을 포함한다.

 

무엇보다 for_each를 사용하어 리소스를 맵으로 처리하면 컬렉션 중간의 항목도 안전하게 제거할 수 있어 count로 리소스를 배열 처리하는 것 보다 해당 부분에서 이점이 크다.

정리 : for_each는 주변 모든 리소스를 옮기지 않고 정확히 목표한 리소스만 삭제한다. 따라서 리소스의 구별되는 여러 복사본을 만들 때는 count 대신 for_each를 사용하는 것이 바람직하다.

 

1.4 for Expressions (for 반복문)

	count	for_each	for expression
사용목적	반복 조회	반복 조회	반복 변환

 

 

for문은 복합 형식 값의 형태를 변환하는 데 사용된다. 예를 들어 list 값의 포맷을 변경하거나 특정 접두사를 추가할 수도 있고, output에 원하는 형태로 반복적인 결과를 표현할 수 있다.

• list 타입의 경우 값 또는 인덱스와 값을 반환
• map 타입의 경우 키 또는 키와 값에 대해 반환
• set 타입의 경우 키 값에 대해 반환

 

테스트를 위해 기본 구성을 진행해보겠다. list의 내용을 담는 리소스를 생성한다. var.name의 내용이 결과 파일에 content로 기록된다.

# main.tf
variable "names" {
  default = ["a", "b", "c"]
}

resource "local_file" "abc" {
  content  = **jsonencode**(var.names) # 결과 : ["a", "b", "c"]
  filename = "${path.module}/abc.txt"
}

output "file_content" {
  value = local_file.abc.content
}

사진-7

 

 

 

추가! var.name 값을 일괄적으로 대문자로 변환!

파일 내용을 다음과 같이 수정한다. content의 값 정의에 for 구문을 사용하여 내부 값을 일괄적으로 변경할 수 있다.

variable "names" {
  default = ["a", "b", "c"]
}

resource "local_file" "abc" {
  content  = **jsonencode([for s in var.names : upper(s)])** # 결과 : ["A", "B", "C"]
  filename = "${path.module}/abc.txt"
}

output "file_content" {
  value = local_file.abc.content
}

jsonencode Function - 링크

• jsonencode encodes a given value to a string using JSON syntax.

사진-8

 

다시 for 구문으로 넘어가자면, for 구문은 사용하는 규칙이 존재하는데 이는 다음과 같다.

1. list 유형의 경우 반환 받는 값이 하나로 되어 있으면 값을, 두 개의 경우 앞의 인수가 인덱스를 반환하고 뒤의 인수가 값을 반환
   • 관용적으로는 인덱스는 i, 값은 v로 표현
2. map 유형의 경우 반환 받는 값이 하나로 되어 있으면 키를, 두 개의 경우 앞의 인수가 키를 반환하고 뒤의 인수가 값을 반환
   • 관용적으로는 키는 k, 값은 v로 표현
3. 결과 값은 for 문을 묶는 기호가 [ ] 인 경우 tuple로 반환되고 { } 인 경우 object 형태로 반환
4. object 형태의 경우 키와 값에 대한 쌍은 ⇒ 기호로 구분
5. { } 형식을 사용해 object 형태로 결과를 반환하는 경우 키 값은 고유해야 하므로 값 뒤에 그룹화 모드 심볼(…)를 붙여서 키의 중복을 방지
   • SQL의 group by 문 혹은 Java의 MultiValueMap과 같은 개념
6. IF 구문을 추가해 조건 부여 가능

 

list 유형에 대한 for 구문 처리의 몇 가지 예를 확인하기 위해 다음과 같이 파일을 작성하고 output을 확인한다.

# main.tf
variable "names" {
  type    = list(string)
  default = ["a", "b"]
}

output "A_upper_value" {
  value = [for v in var.names : upper(v)]
}

output "B_index_and_value" {
  value = [for i, v in var.names : "${i} is ${v}"]
}

output "C_make_object" {
  value = { for v in var.names : v => upper(v) }
}

output "D_with_filter" {
  value = [for v in var.names : upper(v) if v != "a"]
}

사진-9

 

다음은 map 유형에 대한 for 구문 처리 예시를 확인해보겠다.

# main.tf
variable "members" {
  **type = map(object**({
    role = string
  }))
  **default** = {
    ab = { role = "member", group = "dev" }
    cd = { role = "admin", group = "dev" }
    ef = { role = "member", group = "ops" }
  }
}

output "A_to_tupple" {
  value = [for k, v in var.members : "${k} is ${v.role}"]
}

output "B_get_only_role" {
  value = {
    for name, user in var.members : name => user.role
    if user.role == "admin"
  }
}

output "C_group" {
  value = {
    for name, user in var.members : user.role => name...
  }
}

사진-10

 

for expression으로 s3 이름 일괄 수정 (스터디 악분님 제공)

변경 전

변경 후

 

Terraform Registry

Terraform Registry

다음 S3 생성 예제를 참고하여 미리 S3를 구성하였다. 이후 다음과 같이 내용을 수정하여 s3 이름 변경을 진행하였다.

# main.tf
variable "cloud-stady" {
    type        = set(string)
    default     = ["dev","ops"]
    description = "devChanWoo"
}

variable "postfix" {
    type        = string
    default     = "test"
    description = "postfix"
}

provider "aws" {
    region = "ap-northeast-2"
}

resource "aws_s3_bucket" "woo-test" {
  for_each = toset([for cloud-stady in var.cloud-stady : format("%s-%s", cloud-stady, var.postfix)])
  bucket = "devwoo-tf-test-${each.key}"

  tags = {
    Name        = "My bucket"
    Environment = "Dev"
  }
}

 

 

 

1.5 dynamic

테라폼 구성을 작성하다 보면 count나 for_each 구문을 사용하여 리소스 전체를 여러 개 생성하는 것 외에도 리소스 내에서 선언되는 구성 블록을 다중으로 작성해야 하는 경우가 있다.

 

예를 들면, AWS의 Security Group 리소스 구성에 ingress, egress 요소가 리소스 선언 내부에서 블록 형태로 여러 번 정의되는 경우이다.

# AWS_Security_group_ex.tf
**resource** "aws_security_group" "example" {
  name        = "example-security-group"
  description = "Example security group"
  vpc_id.     = aws_vpc.main.id

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

  **ingress** {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    ipv6_cidr_blocks = ["::/0"]
  }
}

리소스 내의 블록 속성(Attributes as Blocks)은 리소스 자체의 반복 선언이 아닌 내부 속성 요소 중 블록으로 표현되는 부분에 대해서만 반복 구문을 사용해야 하므로, 이때 dynamic 블록을 사용해 동적인 블록을 생성할 수 있다.

 

dynamic 블록을 작성하려면, 기존 블록의 속성 이름을 dynamic 블록의 이름으로 선언하고 기존 블록 속성에 정의되는 내용을 content 블록에 작성한다. 반복 선언에 사용되는 반복문 구문은 for_each를 사용한다. 기존 for_each 적용 시 each 속성에 key, value가 적용되었다면 dynamic에서는 dynamic에 지정한 이름에 대해 속성이 부여된다.

 

dynamic 블록 활용 예시

일반적인 블록 속성 반복 적용 시	dynamic 블록 적용 시
resource "provider_resource" "name" {    name = "some_resource"    some_setting {      key = a_value    }        some_setting {      key = b_value    }    some_setting {      key = c_value    }     some_setting {      key = d_value    } }	resource "provider_resource" "name" {    name = "some_resource"    dynamic "some_setting" {      for_each = {       a_key = a_value       b_key = b_value       c_key = c_value       d_key = d_value       }     content {       key = some_setting.value      }    }  }

 

 

한번 archive 프로바이더의 archive_file에 source 블록 선언을 반복하는 경우 terraform apply를 수행해 확인해보겠다. (새로운 프로바이더가 추가되는 경우 terraform init 명령이 필요함)

# main.tf
data "**archive**_file" "dotfiles" {
  type        = "zip"
  output_path = "${path.module}/**dotfiles.zip**"

  source {
    content  = "hello a"
    filename = "${path.module}/a.txt"
  }

  source {
    content  = "hello b"
    filename = "${path.module}/b.txt"
  }

  source {
    content  = "hello c"
    filename = "${path.module}/c.txt"
  }
}

사진-11

 

리소스 내 반복 선언 구성을 dynamic 블록으로 재구성해성해서 확인해보겠다.

# main.tf
variable "names" {
  default = {
    a = "hello a"
    b = "hello b"
    c = "hello c"
  }
}

data "archive_file" "dotfiles" {
  type        = "zip"
  output_path = "${path.module}/dotfiles.zip"

  **dynamic "source" {
    for_each = var.names
    content {
      content  = source.value
      filename = "${path.module}/${source.key}.txt"
    }
  }**
}

사진-12

실행해보니 동일한 결과가 기대되어 변경 사항이 없는 것을 확인할 수 있다!

 

 

2. 조건식

테라폼에서 조건식은 3항 연산자 형태를 갖는다. 조건은 true 또는 false로 확인되는 모든 표현식을 사용할 수 있다.

일반적으로 비교, 논리 연산자를 사용해 조건을 확인한다. 조건식은 ? 기호를 기준으로 왼쪽은 조건이며 오른쪽은 : 기호를 기준으로 왼쪽이 조건에 대해 true가 반환되는 경우이고 오른쪽이 false가 반환되는 경우다.

 

다음 예시를 보면 var.a가 빈 문자열이 아니라면 var.a를 나타내지만 비어 있을 때는 “default=a”를 반환한다.

# <조건 정의> ? <옳은 경우> : <틀린 경우>
var.a != "" ? var.a : "default-a"

 

 

조건식의 각 조건은 비교 대상의 형태가 다르면 테라폼 실행 시 조건 비교를 위해 형태를 추론하여 자동으로 변환하는데, 이때 명시적인 형태로 작성하는 것을 권장한다.(협업하는 작업자 사이에 의미 전달이 명확하지 않으면 혼란을 겪을 수 있음)

# 조건식 형태 권장 사항 
var.example ? 12 : "hello"            # 비권장
var.example ? "12" : "hello"          # 권장
var.example ? tostring(12) : "hello"  # 권장

 

 

조건식은 단순히 특정 속성에 대한 정의, 로컬 변수에 대한 재정의, 출력 값에 대한 조건 정의 뿐만 아니라 리소스 생성 여부에 응용할 수 있다. count에 조건식을 결합한 경우 다음과 같이 특정 조건에 따라 리소스 생성 여부를 선택할 수 있다.

# main.tf
variable "enable_file" {
  default = true
}

resource "**local**_file" "foo" {
  **count    = var.enable_file ? 1 : 0**
  content  = "foo!"
  filename = "${path.module}/foo.bar"
}

output "content" {
  **value = var.enable_file ? local_file.foo[0].content : ""**
}

 

변수 우선순위를 환경 변수로 변경 및 실행 결과

사진-13

사진-14

 

환경 변수 삭제 후 실행 결과

사진-15

 

3. 함수

테라폼은 프로그래밍 언어적인 특성을 가지고 있다. 그래서 값의 유형을 변경하거나 조합할 수 있는 내장 함수를 사용할 수 있다.

단, 내장된 함수 외에 사용자가 구현하는 별도의 사용자 정의 함수를 지원하지 않는다. 함수 종류에는 숫자, 문자열, 컬렉션, 인코딩, 파일 시스템, 날짜/시간, 해시/암호화, IP 네트워크, 유형 변환이 있다.

 

테라폼 코드에서 함수를 적용하면 변수, 리소스 속성, 데이터 소스 속성, 출력 값 표현 시 작업을 동적이고 효과적을 수행할 수 있다.

 

간단한 내장 함수를 사용해보겠다.

# main.tf
resource "local_file" "foo" {
  content  = **upper**("foo! bar!")
  filename = "${path.module}/foo.bar"
}

사진-16

 

추천실습

count + 함수 cidrhost 로 EC2의 ENI 에 10개의 ip를 장착

추가 예정