[태그:] terraform

# readme.md 작성
vi readme.md

# git push
git add -A
git commit -m 'Initial checkin'
git push
오브젝트 나열하는 중: 3, 완료.
오브젝트 개수 세는 중: 100% (3/3), 완료.
오브젝트 쓰는 중: 100% (3/3), 229 bytes | 229.00 KiB/s, 완료.
Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
remote: Validating objects: 100%
To codecommit::ap-northeast-2://terraformiac
 * [new branch]      master -> master

#buildspec.yml
version: 0.2

phases:
  install:
    commands:
      - echo "Installing Terraform"
      - sudo yum install -y yum-utils
      - sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/AmazonLinux/hashicorp.repo
      - sudo yum -y install terraform
      - terraform init
  pre_build:
    commands:
      - echo "Running terraform fmt"
      - terraform fmt
  build:
    commands:
      - echo "Running terraform plan"
      - terraform plan

# main.tf
provider "aws" {
  region = "ap-northeast-2"
}

resource "aws_instance" "example" {
  ami           = "ami-084e92d3e117f7692"
  instance_type = "t2.micro"

  tags = {
    Name = "ybs-iac-ec2"
  }

}

#git push 진행
git add -A
git commit -m 'Initial checkin'
git push

오브젝트 나열하는 중: 5, 완료.
오브젝트 개수 세는 중: 100% (5/5), 완료.
Delta compression using up to 10 threads
오브젝트 압축하는 중: 100% (4/4), 완료.
오브젝트 쓰는 중: 100% (4/4), 691 bytes | 691.00 KiB/s, 완료.
Total 4 (delta 0), reused 0 (delta 0), pack-reused 0
remote: Validating objects: 100%
To codecommit::ap-northeast-2://terraformiac
   f8bf77b..0c7981d  master -> master

#appspec.yml
version: 0.0
os: linux
files:
  - source: /
    destination: /home/ec2-user/terraform/
hooks:
  ApplicationStart:
    - location: scripts/run_build.sh
      timeout: 300
      runas: root

#ipts/run_build.sh
#!/bin/bash
terraform -chdir=/home/ec2-user/terraform/ init
terraform -chdir=/home/ec2-user/terraform/ apply -auto-approve

# workspace 확인
terraform workspace list
* default

# 간단 EC2 배포 main.tf
resource "aws_instance" "mysrv1" {
  ami           = "ami-0ea4d4b8dc1e46212"
  instance_type = "t2.micro"
  tags = {
    Name = "t101-week4"
  }
}

# Terraform 배포 후 state 확인
terraform init && terraform apply -auto-approve
terraform state list
aws_instance.mysrv1

# Public/Private IP 확인
cat terraform.tfstate | jq -r '.resources[0].instances[0].attributes.public_ip'
3.39.231.x
cat terraform.tfstate | jq -r '.resources[0].instances[0].attributes.private_ip'
172.31.39.105
cat terraform.tfstate | jq -r '.resources[0].instances[0].private' | base64 -d | jq
{
  "e2bfb730-ecaa-11e6-8f88-34363bc7c4c0": {
    "create": 600000000000,
    "delete": 1200000000000,
    "update": 600000000000
  },
  "schema_version": "1"
}

# 새 워크스페이스 생성
terraform workspace new mywork1
terraform workspace list
  default
* mywork1
terraform workspace show
mywork1

tree terraform.tfstate.d
terraform.tfstate.d
└── mywork1
2 directories, 0 files

# plan 할 경우 기존 워크스페이스라면 create가 표시되지 않아야 하나 새로운 워크스페이스(mywork1)이 선택되어 있어서 create로 표시
terraform plan

# apply을 하면 plan 내용처럼 배포가 진행 된다.
terraform apply -auto-approve

# 워크스페이스 확인
terraform workspace list
  default
* mywork1

# State 확인하면 기존 배포한 것과 새로 배포한 것의 Public IP가 차이가 난다.
cat terraform.tfstate | jq -r '.resources[0].instances[0].attributes.public_ip'
3.39.231.x
cat terraform.tfstate.d/mywork1/terraform.tfstate | jq -r '.resources[0].instances[0].attributes.public_ip'
15.164.x.x

# 실습 리소스 삭제
terraform workspace select default
terraform destroy -auto-approve
terraform workspace select mywork1
terraform destroy -auto-approve

module "vpc" {
  source  = "aws/vpc/aws"
  version = "2.0.0"
  ...
}

#my_vpc_module/main.tf
resource "aws_vpc" "ybs-vpc" {
  cidr_block = var.cidr_block
  tags = {
    Name = var.vpc_name
  }
}

output "vpc_id" {
  value = aws_vpc.ybs-vpc.id
}

variable "cidr_block" {
  description = "CIDR block for the VPC"
  type        = string
}

variable "vpc_name" {
  description = "Name tag for the VPC"
  type        = string
}

module "my_vpc" {
  source    = "./my_vpc_module"
  cidr_block = "10.0.0.0/16"
  vpc_name   = "ybs-test-vpc"
}

output "created_vpc_id" {
  value = module.my_vpc.vpc_id
}

#terraform init 및 Plan/Apply 실행
terraform init && terraform apply -auto-approve

#terraform state 확인
terraform state list                          
module.my_vpc.aws_vpc.ybs-vpc

#vpc/main.tf
resource "aws_vpc" "ybs-vpc" {
  cidr_block = var.cidr_block
  tags = {
    Name = var.vpc_name
  }
}

resource "aws_subnet" "ybs-subnet" {
  vpc_id     = aws_vpc.ybs-vpc.id
  cidr_block = var.subnet_cidr_block
  availability_zone = var.availability_zone
  tags = {
    Name = "${var.vpc_name}-subnet"
  }
}

output "vpc_id" {
  value = aws_vpc.ybs-vpc.id
}

output "subnet_id" {
  value = aws_subnet.ybs-subnet.id
}

variable "cidr_block" {
  description = "CIDR block for the VPC"
 
}

variable "vpc_name" {
  description = "VPC Name"
  type = string
 
}
variable "subnet_cidr_block" {
  description = "CIDR block for the Subnet"
 
}

variable "availability_zone" {
  description = "The availability zone where the subnet will be created"
  type = string
}

#ec2/main.tf
resource "aws_instance" "ybs-ec2" {
  ami           = var.ami_id
  instance_type = var.instance_type
  subnet_id     = var.subnet_id
  tags = {
    Name = var.instance_name
  }
}

output "instance_id" {
  value = aws_instance.ybs-ec2.id
}

variable "ami_id" {
  description = "AMI ID for the EC2 instance"
  type        = string
}

variable "instance_type" {
  description = "Instance type for the EC2 instance"
  type        = string
}

variable "subnet_id" {
  description = "Subnet ID where the EC2 instance will be launched"
  type        = string
}

variable "instance_name" {
  description = "Name tag for the EC2 instance"
  type        = string
}

#main.tf
module "my_vpc" {
  source    = "./vpc"
  cidr_block = "10.0.0.0/16"
  vpc_name   = "MyVPC"
}

module "my_ec2" {
  source         = "./ec2"
  ami_id         = "ami-0123456789abcdef0" # 예시 AMI ID
  instance_type  = "t2.micro"
  subnet_id      = module.my_vpc.vpc_id # VPC 모듈에서 생성된 VPC의 ID를 사용
  instance_name  = "MyInstance"
}

output "created_vpc_id" {
  value = module.my_vpc.vpc_id
}

output "created_instance_id" {
  value = module.my_ec2.instance_id
}

#terraform init 및 Plan/Apply 실행
terraform init && terraform apply -auto-approve

#terraform state 확인
terraform state list 
module.my_ec2.aws_instance.ybs-ec2
module.my_vpc.aws_subnet.ybs-subnet
module.my_vpc.aws_vpc.ybs-vpc      

locals {
  instance_size = var.is_production ? "t2.large" : "t2.micro"
}

variable "create_instance" {
  type        = bool
}

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

resource "aws_instance" "ybs-ec2-bool" {
  count = var.create_instance ? 1 : 0

  ami           = "ami-084e92d3e117f7692"
  instance_type = "t2.micro"

  tags = {
    Name = "ybs-ec2-bool"
  }
}

variable "create_instance" {
  type        = bool
}

variable "app_env" {
  type = string

  validation {
    condition     = contains(["prd", "dev", "stg"], var.app_env)
    error_message = "prd, dev, stg 중 하나만 입력하세요."

  }
}


locals {
  common_tags = {
    "Name" = "ybs-ec2-fn"
  }
  env_tags = {
    "Environment" = var.app_env
  }


  final_tags = merge(local.common_tags, local.env_tags)
}

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

resource "aws_instance" "ybs-ec2-fn" {
  count = var.create_instance ? 1 : 0

  ami           = "ami-084e92d3e117f7692"
  instance_type = "t2.micro"

  tags = local.final_tags
}

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

resource "aws_key_pair" "pem_key" {
  key_name   = "testpem"
  public_key = file("~/.ssh/id_rsa.pub")
}

resource "aws_security_group" "allow_ssh" {
  name        = "inssh"

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

resource "aws_instance" "example" {
  ami           = "ami-084e92d3e117f7692"
  instance_type = "t2.micro"

  key_name          = aws_key_pair.pem_key.key_name
  security_groups   = [aws_security_group.allow_ssh.name]
  associate_public_ip_address = true

#로컬 파일에 있는 sh 파일을 원격 업로드
  provisioner "file" {
    source      = "./test.sh"
    destination = "/tmp/test.sh"
  }

#업로드한 sh 파일을 실행(chmod로 실행 권한 부여 진행)
    provisioner "remote-exec" {
    inline = [
      "chmod +x /tmp/test.sh",
      "/tmp/test.sh"
    ]
  }

  connection {
    type        = "ssh"
    host        = self.public_ip
    user        = "ec2-user"
    private_key = file("~/.ssh/id_rsa")
  }

  tags = {
    Name = "ybs-remote-test"
  }
}

resource "aws_instance" "example" {
  ami           = "ami-xxxxxxxxxx"
  instance_type = "t2.micro"
}

resource "null_resource" "example" {
  triggers = {
    instance_id = aws_instance.example.id
  }

  provisioner "local-exec" {
    command = "echo ${aws_instance.example.id} >> instances.txt"
  }
}

variable "create_instance" {
  type        = bool
}

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

resource "aws_instance" "ybs-ec2-bool" {
  count = var.create_instance ? 1 : 0

  ami           = "ami-084e92d3e117f7692"
  instance_type = "t2.micro"

  tags = {
    Name = "ybs-ec2-bool"
  }
}

variable "create_instance" {
  type        = bool
}

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

#moved 블록으로 이름 전환
  moved {
    from = aws_instance.ybs-ec2-bool
    to   = aws_instance.ybs-ec2-bool-new
  }

#리소스 이름도 같이 변경
resource "aws_instance" "ybs-ec2-bool-new" {
  count = var.create_instance ? 1 : 0

  ami           = "ami-084e92d3e117f7692"
  instance_type = "t2.micro"

  tags = {
    Name = "ybs-ec2-bool"
  }
}

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

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

# 서울 리전에 S3 버킷 생성
resource "aws_s3_bucket" "bucket_seoul" {
  provider = aws.seoul
  bucket   = "ybs-t102-prv-seoul"

  tags = {
    Name        = "ybs-t102-prv-seoul"
  }
}

# 버지니아북부 리전에 S3 버킷 생성
resource "aws_s3_bucket" "bucket_virginia" {
  provider = aws.virginia
  bucket   = "ybs-t102-prv-virginia"

  tags = {
    Name        = "ybs-t102-prv-virginia"
  }
}

data "aws_instance" "example" {
  instance_id = "i-12345678"
}

output "instance_public_ip" {
  value = data.aws_instance.example.public_ip
}

#초기화 및 plan 진행
terraform init
terraform plan

data "aws_availability_zones" "available" {
  state = "available"
}

resource "aws_vpc" "ybs-c1-vpc" {
  cidr_block = "10.0.0.0/16"

  tags = {
    Name = "ybs-c1-vpc"
  }
}

resource "aws_subnet" "ybs-c1-vpc-subnet" {
  count = length(data.aws_availability_zones.available.names)

  cidr_block = "10.0.${count.index + 1}.0/24"
  availability_zone = data.aws_availability_zones.available.names[count.index]
  vpc_id = aws_vpc.ybs-c1-vpc.id

  tags = {
    Name = "ybs-c1-vpc-subnet-${count.index}"
  }
}

# 테라폼 초기화/plan/실행
terraform init && terraform plan && terraform apply -auto-approve

variable "region" {
  description = "The AWS region to deploy into"
  default     = "ap-northeast-2"
  type        = string
}

provider "aws" {
  region = var.region
}

variable "region" {
  description = "The AWS region to deploy into"
  default     = "ap-northeast-2"
  type        = string
}

variable "az1" {
  description = "The availability zone a"
  default     = "ap-northeast-2a"
  type        = string
}

variable "az3" {
  description = "The availability zone c"
  default     = "ap-northeast-2c"
  type        = string
}

provider "aws" {
  region  = var.region
}

resource "aws_vpc" "ybs-vpc" {
  cidr_block       = "10.10.0.0/16"

  enable_dns_support   = true
  enable_dns_hostnames = true

  tags = {
    Name = "ybs-vpc"
  }
}

resource "aws_subnet" "ybs-subnet1" {
  vpc_id     = aws_vpc.ybs-vpc.id
  cidr_block = "10.10.1.0/24"

  availability_zone = var.az1

  tags = {
    Name = "ybs-subnet1"
  }
}

resource "aws_subnet" "ybs-subnet2" {
  vpc_id     = aws_vpc.ybs-vpc.id
  cidr_block = "10.10.2.0/24"

  availability_zone = var.az3

  tags = {
    Name = "ybs-subnet2"
  }
}

resource "aws_internet_gateway" "ybs-igw" {
  vpc_id = aws_vpc.ybs-vpc.id

  tags = {
    Name = "ybs-igw"
  }
}

resource "aws_route_table" "ybs-rt1" {
  vpc_id = aws_vpc.ybs-vpc.id

  tags = {
    Name = "ybs-rt1"
  }
}

resource "aws_route_table_association" "ybs-rt1-asso1" {
  subnet_id      = aws_subnet.ybs-subnet1.id
  route_table_id = aws_route_table.ybs-rt1.id
}

resource "aws_route_table_association" "ybs-rt1-asso2" {
  subnet_id      = aws_subnet.ybs-subnet2.id
  route_table_id = aws_route_table.ybs-rt1.id
}

resource "aws_route" "ybs-rt1-drt" {
  route_table_id         = aws_route_table.ybs-rt1.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_internet_gateway.ybs-igw.id
}

output "aws_vpc_id" {
  value = aws_vpc.ybs-vpc.id
}

# 테라폼 초기화/plan/실행
terraform init && terraform plan && terraform apply -auto-approve

# state list 확인
terraform state list
aws_internet_gateway.ybs-igw
aws_route.ybs-rt1-drt
aws_route_table.ybs-rt1
aws_route_table_association.ybs-rt1-asso1
aws_route_table_association.ybs-rt1-asso2
aws_subnet.ybs-subnet1
aws_subnet.ybs-subnet2
aws_vpc.ybs-vpc

variable "http" {
  description = "The HTTP port"
  default     = 80
  type        = number
}

variable "anycidr" {
  description = "The any cidr block"
  default     = ["0.0.0.0/0"]
  type        = list
}

resource "aws_security_group" "ybs-sg1" {
  vpc_id      = aws_vpc.ybs-vpc.id
  name        = "YBS SG 1"
  description = "YBS Study SG 1"
}

resource "aws_security_group_rule" "ybs-in-http-rule" {
  type              = "ingress"
  from_port         = var.http
  to_port           = var.http
  protocol          = "tcp"
  cidr_blocks       = var.anycidr
  security_group_id = aws_security_group.ybs-sg1.id
}

resource "aws_security_group_rule" "ybs-out-any-rule" {
  type              = "egress"
  from_port         = 0
  to_port           = 0
  protocol          = "-1"
  cidr_blocks       = var.anycidr
  security_group_id = aws_security_group.ybs-sg1.id
}

# 테라폼 초기화/plan/실행
terraform init && terraform plan && terraform apply -auto-approve

# state list 확인
terraform state list
aws_internet_gateway.ybs-igw
aws_route.ybs-rt1-drt
aws_route_table.ybs-rt1
aws_route_table_association.ybs-rt1-asso1
aws_route_table_association.ybs-rt1-asso2
aws_security_group.ybs-sg1
aws_security_group_rule.ybs-in-http-rule
aws_security_group_rule.ybs-out-any-rule
aws_subnet.ybs-subnet1
aws_subnet.ybs-subnet2
aws_vpc.ybs-vpc

data "aws_ami" "ybs-aml2id" {
  most_recent = true
  filter {
    name   = "owner-alias"
    values = ["amazon"]
  }

  filter {
    name   = "name"
    values = ["amzn2-ami-hvm-*-x86_64-ebs"]
  }

  owners = ["amazon"]
}

locals {
  ec2name = {
    Name = "ybs-ec2"
  }
}


resource "aws_instance" "ybs-ec2" {

  depends_on = [
    aws_internet_gateway.ybs-igw
  ]

  ami                         = data.aws_ami.ybs-aml2id.id
  associate_public_ip_address = true
  instance_type               = "t2.micro"
  vpc_security_group_ids      = ["${aws_security_group.ybs-sg1.id}"]
  subnet_id                   = aws_subnet.ybs-subnet1.id

  user_data = <<-EOF
              #!/bin/bash
              wget https://busybox.net/downloads/binaries/1.31.0-defconfig-multiarch-musl/busybox-x86_64
              mv busybox-x86_64 busybox
              chmod +x busybox
              RZAZ=$(curl http://169.254.169.254/latest/meta-data/placement/availability-zone-id)
              IID=$(curl 169.254.169.254/latest/meta-data/instance-id)
              LIP=$(curl 169.254.169.254/latest/meta-data/local-ipv4)
              echo "<h1>RegionAz($RZAZ) : Instance ID($IID) : Private IP($LIP) : Web Server</h1>" > index.html
              nohup ./busybox httpd -f -p 80 &
              EOF

  user_data_replace_on_change = true

  tags = local.ec2name
}

output "ybs-ec2-publicip" {
  value       = aws_instance.ybs-ec2.public_ip
  description = "The public IP of the Instance"
}

# 테라폼 초기화/plan/실행
terraform init && terraform plan && terraform apply -auto-approve

# state list 확인
terraform state list
data.aws_ami.ybs-aml2id
aws_instance.ybs-ec2
aws_internet_gateway.ybs-igw
aws_route.ybs-rt1-drt
aws_route_table.ybs-rt1
aws_route_table_association.ybs-rt1-asso1
aws_route_table_association.ybs-rt1-asso2
aws_security_group.ybs-sg1
aws_security_group_rule.ybs-in-http-rule
aws_security_group_rule.ybs-out-any-rule
aws_subnet.ybs-subnet1
aws_subnet.ybs-subnet2
aws_vpc.ybs-vpc

# 데이터소스 값 확인
terraform console
> data.aws_ami.ybs-aml2id
{
  "architecture" = "x86_64"
  "arn" = "arn:aws:ec2:ap-northeast-2::image/ami-05749a4578e04e5ac"
  "block_device_mappings" = toset([
...
}

# 출력된 EC2 퍼블릭IP로 cul 접속 확인
terraform output -raw ybs-ec2-publicip
MYIP=$(terraform output -raw ybs-ec2-publicip)
while true; do curl --connect-timeout 1  http://$MYIP/ ; echo "------------------------------"; date; sleep 1; done
2023년 9월  8일 금요일 17시 48분 27초 KST
<h1>RegionAz(apne2-az1) : Instance ID(i-06633af887ed4a47a) : Private IP(10.10.1.84) : Web Server</h1>
------------------------------
2023년 9월  8일 금요일 17시 48분 28초 KST
<h1>RegionAz(apne2-az1) : Instance ID(i-06633af887ed4a47a) : Private IP(10.10.1.84) : Web Server</h1>
------------------------------

locals {
  calculated_value = var.some_input * 10
  name_prefix      = "dev-"
  full_name        = "${local.name_prefix}${var.resource_name}"
}

resource "aws_instance" "example" {
  tags = {
    Name = local.full_name
  }
}

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

locals {
  name = "mytest"
  team = {
    group = "dev"
  }
}

resource "aws_iam_user" "myiamuser1" {
  name = "${local.name}1"
  tags = local.team
}

resource "aws_iam_user" "myiamuser2" {
  name = "${local.name}2"
  tags = local.team
}

#
terraform init && terraform apply -auto-approve
terraform state list
aws_iam_user.myiamuser1
aws_iam_user.myiamuser2
terraform state show aws_iam_user.myiamuser1
resource "aws_iam_user" "myiamuser1" {
    arn           = "arn:aws:iam::xxxxxxxxxx:user/mytest1"
    force_destroy = false
    id            = "mytest1"
    name          = "mytest1"
....
}

resource "aws_instance" "example" {
  count = 3

  ami           = "ami-xxxxxxxxxxxxxx"
  instance_type = "t2.micro"

  tags = {
    Name = "example-instance-${count.index}"
  }
}

locals {
  user_map = {
    alice = "admin"
    bob   = "developer"
  }
}

resource "aws_iam_user" "example" {
  for_each = local.user_map

  name = each.key
  tags = {
    Role = each.value
  }
}

locals {
  numbers    = [1, 2, 3, 4]
  square_map = { for num in local.numbers : tostring(num) => num * num }
}

output "square_map" {
  value = local.square_map
}

resource "aws_security_group" "example" {
  name        = "example"
  description = "Example security group"

  dynamic "ingress" {
    for_each = [
      {
        from_port   = 22
        to_port     = 22
        protocol    = "tcp"
        cidr_blocks = ["0.0.0.0/0"]
      },
      {
        from_port   = 80
        to_port     = 80
        protocol    = "tcp"
        cidr_blocks = ["0.0.0.0/0"]
      }
    ]
    content {
      from_port   = ingress.value.from_port
      to_port     = ingress.value.to_port
      protocol    = ingress.value.protocol
      cidr_blocks = ingress.value.cidr_blocks
    }
  }
}

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

resource "aws_iam_user" "myiam" {
  count = 3
  name  = "myuser.${count.index}"
}

# 테라폼 초기화/plan/실행
terraform init && terraform plan && terraform apply -auto-approve

# state list 확인
terraform state list
aws_iam_user.myiam[0]
aws_iam_user.myiam[1]
aws_iam_user.myiam[2]

terraform console
> aws_iam_user.myiam[0]
{
  "arn" = "arn:aws:iam::xxxxxxxxxxxxx:user/myuser.0"
  "force_destroy" = false
  "id" = "myuser.0"
  "name" = "myuser.0"
  "path" = "/"
  "permissions_boundary" = tostring(null)
  "tags" = tomap(null) /* of string */
  "tags_all" = tomap({})
  "unique_id" = "xxxxxxxxxxxxxxxxxxxx"
}
> aws_iam_user.myiam[0].name
"myuser.0"

#삭제
terraform destroy -auto-approve

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

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

resource "aws_iam_user" "myiam" {
  count = length(var.user_names)
  name  = var.user_names[count.index]
}

output "first_arn" {
  value       = aws_iam_user.myiam[0].arn
  description = "The ARN for the first user"
}

output "all_arns" {
  value       = aws_iam_user.myiam[*].arn
  description = "The ARNs for all users"
}

# 테라폼 초기화/plan/실행
terraform init && terraform plan && terraform apply -auto-approve

# state list 확인
terraform state list
aws_iam_user.myiam[0]
aws_iam_user.myiam[1]
aws_iam_user.myiam[2]

#output 출력
terraform output
terraform output all_arns
all_arns = [
  "arn:aws:iam::xxxxxxxxxxxxx:user/gasida",
  "arn:aws:iam::xxxxxxxxxxxxx:user/akbun",
  "arn:aws:iam::xxxxxxxxxxxxx:user/ssoon",
]
first_arn = "arn:aws:iam::xxxxxxxxxxxxx:user/gasida"
[
  "arn:aws:iam::xxxxxxxxxxxxx:user/gasida",
  "arn:aws:iam::xxxxxxxxxxxxx:user/akbun",
  "arn:aws:iam::xxxxxxxxxxxxx:user/ssoon",
]

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
}


# 테라폼 초기화/plan/실행
terraform init && terraform plan && terraform apply -auto-approve

# state list 확인
terraform state list
aws_iam_user.myiam["akbun"]
aws_iam_user.myiam["gasida"]
aws_iam_user.myiam["ssoon"]

#output 출력
terraform output
all_users = {
  "akbun" = {
    "arn" = "arn:aws:iam::xxxxxxxxxxxxx:user/akbun"
    "force_destroy" = false
    "id" = "akbun"
    "name" = "akbun"
    "path" = "/"
....
}