[terraform] 테라폼으로 aws 프로비저닝하기

💡 provider 설정 및 terraform 사용법은 이전 포스팅에서 다루고 있습니다.

VPCs & NAT

"main" VPC를 생성하고, 두 가용영역에 public subnet, private subnet을 생성한다. 
 

# vpc.tf

# Internet VPC
resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  instance_tenancy     = "default"  # default: 물리적 하드웨어에 여러 인스턴스를 가질 수 있다.
  enable_dns_support   = "true"  # true: dns 활성화
  enable_dns_hostnames = "true"  # true: 내부 hostname 사용
  tags = {
    Name = "main"
  }
}

# Subnets
resource "aws_subnet" "main-public-1" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.1.0/24"
  map_public_ip_on_launch = "true"
  availability_zone       = "ap-northeast-2a"

  tags = {
    Name = "main-public-1"
  }
}

resource "aws_subnet" "main-public-2" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.2.0/24"
  map_public_ip_on_launch = "true"
  availability_zone       = "ap-northeast-2b"

  tags = {
    Name = "main-public-2"
  }
}


resource "aws_subnet" "main-private-1" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.4.0/24"
  map_public_ip_on_launch = "false"
  availability_zone       = "ap-northeast-2a"

  tags = {
    Name = "main-private-1"
  }
}

resource "aws_subnet" "main-private-2" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.5.0/24"
  map_public_ip_on_launch = "false"
  availability_zone       = "ap-northeast-2b"

  tags = {
    Name = "main-private-2"
  }
}

public subnet이 인터넷을 사용할 수 있도록 internet gateway를 생성하고, public subnet에 적용할 route table을 생성한다. 
public subnet은 외부 연결이 가능해야하므로, route table에서 내부 IP(해당 vpc 범위의 IP)를 제외한 모든 IP가 IGW로 라우팅되도록 설정한다.  모든 public subnet에 해당 route table을 연결해준다.
 

# vpc.tf

# Internet GW
resource "aws_internet_gateway" "main-gw" {
  vpc_id = aws_vpc.main.id

  tags = {
    Name = "main"
  }
}

# route tables
resource "aws_route_table" "main-public" {
  vpc_id = aws_vpc.main.id
  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.main-gw.id
  }

  tags = {
    Name = "main-public-1"
  }
}

# public subnet에 route table 연결
resource "aws_route_table_association" "main-public-1-a" {
  subnet_id      = aws_subnet.main-public-1.id
  route_table_id = aws_route_table.main-public.id
}

resource "aws_route_table_association" "main-public-2-a" {
  subnet_id      = aws_subnet.main-public-2.id
  route_table_id = aws_route_table.main-public.id
}

---

private subnet의 instance는 private ip만 가지게되고, 인터넷에 액세스할 수 있지만, 그 반대는 안되도록 설정해야한다. 이를 위해 NAT gateway를 생성한다.
 

# nat.tf

# nat를 위해 탄력적ip (고정ip) 생성
resource "aws_eip" "nat" {
  domain   = "vpc"
}

# public subnet에 nat gateway 생성
resource "aws_nat_gateway" "nat-gw" {
  allocation_id = aws_eip.nat.id
  subnet_id     = aws_subnet.main-public-1.id
  
  # IGW를 명시하는 것이 추천된다.
  depends_on    = [aws_internet_gateway.main-gw]
}

private subnet을 위한 route table을 생성한다. 내부 ip를 제외한 ip에 대한 요청은 NAT gateway로 전달될 것이다.

# nat.tf

# VPC setup for NAT
resource "aws_route_table" "main-private" {
  vpc_id = aws_vpc.main.id
  route {
    cidr_block     = "0.0.0.0/0"
    nat_gateway_id = aws_nat_gateway.nat-gw.id
  }

  tags = {
    Name = "main-private-1"
  }
}

# private subnet에 route table 연결
resource "aws_route_table_association" "main-private-1-a" {
  subnet_id      = aws_subnet.main-private-1.id
  route_table_id = aws_route_table.main-private.id
}

resource "aws_route_table_association" "main-private-2-a" {
  subnet_id      = aws_subnet.main-private-2.id
  route_table_id = aws_route_table.main-private.id
}

생성한 vpc 확인

$ aws ec2 describe-vpcs --filter 'Name=isDefault,Values=false'

---

EC2

생성한 VPC에 인스턴스를 생성하기에 앞서, security group 설정을 해보자. 
내 pc로부터의 SSH 접근을 위한 inboud 규칙을 생성하자.
 

# securitygroup.tf

resource "aws_security_group" "allow-ssh" {
  vpc_id      = aws_vpc.main.id    # 생성한 vpc id를 지정
  name        = "allow-ssh"
  description = "security group that allows ssh and all egress traffic"
  egress {
    from_port   = 0   # 모든 port
    to_port     = 0 
    protocol    = "-1"   # 모든 protocol
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["내 ip 지정"]
  }
  tags = {
    Name = "allow-ssh"
  }
}

 
인스턴스 접근을 위한 key pair 설정도 추가하자. ssh key를 생성하고 public key를 aws에 업로드해 해당 public key가 설치된 인스턴스를 설정할 수 있다. (좀 더 자세한 과정은 이전 포스팅 참고)

# key.tf

resource "aws_key_pair" "mykeypair" {
  key_name   = "mykeypair"
  public_key = file("mykey.pub")
}

 
생성했던 VPC 내에 security group, ssh key 정보와 함께 인스턴스를 생성해보자.

# instance.tf

resource "aws_instance" "example" {
  ami           = var.AMIS[var.AWS_REGION]
  instance_type = "t2.micro"

  # VPC subnet
  subnet_id = aws_subnet.main-public-1.id

  # security group
  vpc_security_group_ids = [aws_security_group.allow-ssh.id]

  # public SSH key
  key_name = aws_key_pair.mykeypair.key_name
}

output "ip" {
  value = aws_instance.example.public_ip
}

인스턴스가 생성되면, private key로 해당 인스턴스에 접속한다.

$ ssh -i mykey ubuntu@ec2-public-ip

---

EBS volume

인스턴스 생성시, ebs 볼륨을 연결하여 생성해보자. 인스턴스의 az와 같은 az에 ebs를 생성하고, 연결을 위해 resource "aws_volume_attachment" 을 사용한다.
 

# instance.tf (이 예시에서는 instance.tf에 이어서 작성)

# ebs volume
resource "aws_ebs_volume" "ebs-volume-1" {
  availability_zone = "ap-northeast-2a"
  size              = 20
  type              = "gp2"
  tags = {
    Name = "extra volume data"
  }
}

# 인스턴스에 ebs 연결
resource "aws_volume_attachment" "ebs-volume-1-attachment" {
  device_name                    = "/dev/xvdh"
  volume_id                      = aws_ebs_volume.ebs-volume-1.id
  instance_id                    = aws_instance.example.id
  stop_instance_before_detaching = true  # volume을 분리하기 전에, 인스턴스가 중지되었는지 확인
}

인스턴스 생성 후 접속

$ ssh -i mykey ubuntu@ec2-public-ip

스토리지 디바이스 확인

$ lsblk
NAME     MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
...
xvda     202:0    0     8G  0 disk
├─xvda1  202:1    0   7.9G  0 part /
├─xvda14 202:14   0     4M  0 part
└─xvda15 202:15   0   106M  0 part /boot/efi
xvdh     202:112  0    20G  0 disk

- / 에 mount된 8GB의 루트 저장공간을 확인할 수 있다.
- 연결된 디바이스 xvdh는 파일 시스템에 마운트되지 않은 상태
 
파일시스템 생성 및 마운트

$ mkfs.ext4 /dev/xvdh
$ mkdir /data
$ mount /dev/xvdh/data
$ df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/root       7.6G  1.6G  6.0G  21% /
...
/dev/xvdh        20G   24K   19G   1% /data

 
mount를 영구 등록하고 싶으면, /etc/fstab에 추가한다. 재부팅시에도 마운트를 유지할 수 있다.
하지만 만약 인스턴스를 종료하고 테라폼을 사용해서 인스턴스를 다시 시작하면 해당 내용도 유지할 수 없을 것이다. (/etc/fstab 은 / 에 기반하는데 / 가 사라지기 때문)
-> user_data를 사용하면, 시작할 때 스크립트를 사용할 수 있다. 

---

Userdata

aws에서 Userdata는, 시작할 때의 커스텀에 사용된다. 
- 추가 software를 설치할 때
- cluster에 join하기 위한 인스턴스를 준비할 때
- command, scripts를 실행할 때
- volume을 마운트할 때 
 
Userdata는 시작할 때 볼륨을 마운트하는 데에 유용하며, 인스턴스의 재부팅이 아닌 생성 시에만 실행된다. 

문자열 사용

# instance.tf

resource "aws_instance" "example" {
  ami           = var.AMIS[var.AWS_REGION]
  instance_type = "t2.micro"

  # VPC subnet
  subnet_id = aws_subnet.main-public-1.id

  # security group
  vpc_security_group_ids = [aws_security_group.allow-ssh.id]

  # public SSH key
  key_name = aws_key_pair.mykeypair.key_name

  # user data
  user_data     = <<-EOF
                    #!/bin/bash
                    echo "Hello, World!" > hello.txt
                  EOF
}

- 인스턴스 접속후 /hello.txt 확인 

File 사용

user_data에 file 등록 후 실행

# install_docker.sh

#! /bin/bash

sudo apt-get update
sudo apt-get -y install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release \
    unzip \
    jq

# Set up the repository
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker Engine
sudo apt-get update
sudo apt-get -y install docker-ce docker-ce-cli containerd.io docker-compose-plugin

sudo usermod -aG docker $USER

# instance.tf

 user_data     =  "${file("install_docker.sh")}"

template_file 함께 사용 예시

# instance.tf

resource "template_file" "user_data" {
  template = "${file("install_docker.sh")}"

  # 여기선 vars를 사용하지 않지만 변수를 전달하기 위한 예시로 둠.
  vars {
    package = "temp"
    command = "temp"
  }
}

resource "aws_instance" "example" {
  ami           = "ami-12345678"
  instance_type = "t2.micro"
  
  user_data     = "${template_file.user_data.rendered}"
}

 

---

cloud-init 을 사용해 인스턴스 초기화를 자동화해보자. 
init.cfg 에 첫번째 부팅 명령을 정의하자. 파일 상단에 #cloud-config 를 포함해야한다.

# scripts/init.cfg

#cloud-config

repo_update: true
repo_upgrade: all

packages:
  - lvm2

output:
  all: '| tee -a /var/log/cloud-init-output.log'

- 리눅스 volume manager인 lvm2를 설치한다. 
 
파일시스템에 볼륨을 마운트하는 bash script를 작성하자.

# scripts/volumes.sh

#!/bin/bash

set -ex 

vgchange -ay

DEVICE_FS=`blkid -o value -s TYPE ${DEVICE} || echo ""`
if [ "`echo -n $DEVICE_FS`" == "" ] ; then 
  # wait for the device to be attached
  DEVICENAME=`echo "${DEVICE}" | awk -F '/' '{print $3}'`
  DEVICEEXISTS=''
  while [[ -z $DEVICEEXISTS ]]; do
    echo "checking $DEVICENAME"
    DEVICEEXISTS=`lsblk |grep "$DEVICENAME" |wc -l`
    if [[ $DEVICEEXISTS != "1" ]]; then
      sleep 15
    fi
  done
  # make sure the device file in /dev/ exists
  count=0
  until [[ -e ${DEVICE} || "$count" == "60" ]]; do
   sleep 5
   count=$(expr $count + 1)
  done
  pvcreate ${DEVICE}
  vgcreate data ${DEVICE}
  lvcreate --name volume1 -l 100%FREE data
  mkfs.ext4 /dev/data/volume1
fi
mkdir -p /data
echo '/dev/data/volume1 /data ext4 defaults 0 0' >> /etc/fstab
mount /data

# install docker
curl https://get.docker.com | bash

# cloudinit.tf

data "template_file" "init-script" {
  template = "${file("scripts/init.cfg")}"
}

data "template_file" "shell-script" {
  template = "${file("scripts/volumes.sh")}"
  vars = {
    DEVICE = "${var.INSTANCE_DEVICE_NAME}"
  }
}

data "template_cloudinit_config" "cloudinit-example" {
  gzip          = false
  base64_encode = false

  part {
    filename     = "init.cfg"
    content_type = "text/cloud-config"
    content      = "${data.template_file.init-script.rendered}"
  }
  
  part {
    content_type = "text/x-shellscript"
    content = "${data.template_file.shell-script.rendered}"
  }
}

- datasource template_file 은 일반적으로 외부 파일에서 로드되는 템플릿 string으로부터 템플릿을 렌더링한다. vars를 통해 템플릿에 변수를 넘길 수 있다.

• template_file을 통해 $DEVICE 값을 넘겨준다. (var.INSTANCE_DEVICE_NAME)

# instance.tf

resource "aws_instance" "example" {
  ami           = var.AMIS[var.AWS_REGION]
  instance_type = "t2.micro"

  # VPC subnet
  subnet_id = aws_subnet.main-public-1.id

  # security group
  vpc_security_group_ids = [aws_security_group.allow-ssh.id]

  # public SSH key
  key_name = aws_key_pair.mykeypair.key_name

  user_data = data.template_cloudinit_config.cloudinit-example.rendered
}

resource "aws_ebs_volume" "ebs-volume-1" {
  availability_zone = "ap-northeast-2a"
  size              = 20
  type              = "gp2"
  tags = {
    Name = "extra volume data"
  }
}

# 인스턴스에 ebs 연결
resource "aws_volume_attachment" "ebs-volume-1-attachment" {
  device_name                    = var.INSTANCE_DEVICE_NAME
  volume_id                      = aws_ebs_volume.ebs-volume-1.id
  instance_id                    = aws_instance.example.id
  stop_instance_before_detaching = true  # volume을 분리하기 전에, 인스턴스가 중지되었는지 확인
}

output "ip" {
  value = aws_instance.example.public_ip
}

- user_data에 정의한 template_cloudinit_config 를 넘겨준다. 
 
나머지는 기존과 같다. terraform apply를 수행하면, 인스턴스 초기화시 script를 통해 volume을 마운트하고 docker를 설치할 것이다.

---

고정 IP, EIP, Route53

고정 private ip

보통 private ip는 서브넷의 범위 내에서 EC2 인스턴스에 자동으로 할당된다. 이 private ip를 지정할 수도 있다.

resource "aws_instance" "example" {
  ami           = var.AMIS[var.AWS_REGION]
  instance_type = "t2.micro"
  subnet_id = aws_subnet.main-public-1.id
  private_ip = "10.0.1.4"  # main-public-1 subnet의 범위 내에서 지정
}

EIP

인스턴스에 연결할 수 있는 고정 public ip

resource "aws_eip" "example-eip" {
  instance = "${aws_instance.example.id}"
  vpc = true
}

출력

output "ip" {
  value = aws_eip.example-eip.public_ip
  }

Route53

route53을 통해 aws에서 도메인 이름을 호스팅할 수 있다. 우선적으로 aws나 공인 등록 기관을 사용해 도메인 이름을 등록해야한다.
 
route53을 통해 example.com과 같은 영역을 만들고, xx.example.com과 같은 DNS 레코드를 추가할 수 있다.

resource "aws_route53_zone" "example-com" {
  name = "example.com"
}

resource "aws_route53_record" "xx-record" {
  zone_id = "${aws_route53_zone.example-com.zone_id}"
  name = "xx.example.com"
  type = "A"  # 호스트 이름을 ip로 결정하기 위함 
  ttl = "300"  # 캐시에 머무르는 시간(초)
  records = ["${aws_eip.example-eip.public_ip}"]  # public ip지정
}

# 특정 도메인의 네임서버 출력
output "nameservers" {
  value = aws_route53_zone.example-com.name_servers
}

host 정보 확인

출력되는 네임서버를 통해 도메인 정보를 물어볼 수 있다.

# host {record} {name server}
$ host xx.example.com ns-1111.awsdns-11.org

---

RDS

aws의 RDS(Relational Database Services)는 아마존에서 제공하는 관리형 데이터베이스 솔루션이다. 여러가지 유용한 기능을 제공한다.
- 쉬운 replication 설정 (고가용성, 서로 복제하는 두 개의 인스턴스 중 쉽게 마스터를 선택)
- 자동 snapshots (백업)
- 자동 보안 업데이트 (특정 시간에 인스턴스 업그레이드)
- 쉬운 인스턴스 교체 (수직 확장)
 
RDS 인스턴스를 생성하기 위해서는 다음과 같은 과정이 필요하다.
1. RDS 인스턴스가 배치될 서브넷 그룹 생성
2. 파라미터 그룹 생성

• 데이터베이스 설정을 위한 파라미터 지정 

3. RDS 인스턴스로 들어오는 트래픽 허용을 위한 security group 생성 
4. RDS 인스턴스 생성

---

위에서 생성한 example 인스턴스(public subnet)가 있다고 가정하고, example 인스턴스에서 접근 가능한 mariaDB 인스턴스를 생성할 것이다.
*aws에서 지원하는 RDS 인스턴스는 여러가지가 있다. 여기서는 mariaDB를 사용한다.

서브넷 그룹 생성

RDS 인스턴스가 배치될 서브넷 그룹 생성

# rds.tf
resource "aws_db_subnet_group" "mariadb-subnet" {
  name        = "mariadb-subnet"
  description = "RDS subnet group"
  subnet_ids  = [aws_subnet.main-private-1.id, aws_subnet.main-private-2.id]
}

 

파라미터 그룹 생성

mariadb의 파라미터를 지정
(인스턴스에 대한 access 권한이 없는 경우 db 설정을 변경하는 유일한 방법이 될 것이다.)

# rds.tf
resource "aws_db_parameter_group" "mariadb-parameters" {
  name        = "mariadb-parameters"
  family      = "mariadb10.4"  # mariaDB 버전
  description = "MariaDB parameter group"

  parameter {
    name  = "max_allowed_packet"
    value = "16777216"
  }
}

보안 그룹 생성

# securitygroup.tf

# ssh 접근을 위한 security group
resource "aws_security_group" "example-instance" {
  vpc_id      = aws_vpc.main.id
  name        = "allow-ssh"
  description = "security group that allows ssh and all egress traffic"
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  tags = {
    Name = "example-instance"
  }
}

# mariadb 인스턴스에 대한 security group
resource "aws_security_group" "allow-mariadb" {
  vpc_id      = aws_vpc.main.id
  name        = "allow-mariadb"
  description = "allow-mariadb"
  ingress {
    from_port       = 3306
    to_port         = 3306
    protocol        = "tcp"
    security_groups = [aws_security_group.example-instance.id] # allowing access from our example instance
  }
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
    self        = true
  }
  tags = {
    Name = "allow-mariadb"
  }
}

RDS 인스턴스 생성

# rds.tf
resource "aws_db_instance" "mariadb" {
  allocated_storage       = 100 # 100 GB of storage
  engine                  = "mariadb"
  engine_version          = "10.4"
  instance_class          = "db.t2.small" # free tier 사용시 micro로 지정
  identifier              = "mariadb"
  db_name                 = "mariadb"
  username                = "root"           # username
  password                = var.RDS_PASSWORD # password
  db_subnet_group_name    = aws_db_subnet_group.mariadb-subnet.name
  parameter_group_name    = aws_db_parameter_group.mariadb-parameters.name
  multi_az                = "false" # true로 지정하면, 서로를 동기화하는 두개의 인스턴스를 통해 고가용성을 가진다.
  vpc_security_group_ids  = [aws_security_group.allow-mariadb.id]
  storage_type            = "gp2"
  backup_retention_period = 30                                          # 백업 유지 기간
  availability_zone       = aws_subnet.main-private-1.availability_zone # AZ
  skip_final_snapshot     = true                                        # terraform destroy시, 마지막 snapshot은 스킵
  tags = {
    Name = "mariadb-instance"
  }
}

# output.tf
output "rds" {
  value = "${aws_db_instance.mariadb.endpoint}"
}

# vars.tf
variable "RDS_PASSWORD" {
}

*apply시 variable을 전달할 수 있다.

$ terraform apply -var RDS_PASSWORD=mypw

생성 후 접속

$ ssh -i mykey ubuntu@example-instance-ip

mysql client 설치

$ sudo apt-get install mysql-client

$ mysql -u root -h {출력된 mariadb endpoint} -p 'mypw'

mysql > show databases;

---

IAM

IAM은 aws의 리소스에 접근을 관리할 수 있는 서비스이다. 그룹, 사용자, 그리고 IAM에 대한 역할을 만들 수 있다. 

• 사용자는 그룹을 가질 수 있다. 예를 들어 admin 그룹은 사용자에게 admin 권한을 줄 수 있다. 
• 사용자는 login/password를 통해 인증할 수도 있고, access key와 secret key (API keys) 를 통해 인증할 수도 있다.

역할을 통해 사용자, 서비스에 임시 권한을 줄 수 있다. 
예를들어, mybucket-access란 역할을 생성해, ec2에 부팅시 해당 역할을 부여한다. 그리고 역할에 mybucket이란 버킷에 있는 item을 읽고 쓸 수 있는 권한을 준다. 그러면 로그인할 때 사용자 자격 증명을 하지 않아도, mybucket-access의 역할을 수행할 수 있다.
 
aws-cli를 사용하는 대신, 서비스가 역할을 대신할 수도 있다. 서비스가 aws sdk를 구현해서, s3 접근시 aws에 대한 api 호출이 발생하는 것이다. (???)
 

admin 권한

admin용 group을 생성하고, user를 해당 group에 설정한다.

# iam.tf

# admin group 생성
resource "aws_iam_group" "administrators" {
  name = "administrators"
}

# admin groupt에 admin policy를 부여한다.
resource "aws_iam_policy_attachment" "administrators-attach" {
  name       = "administrators-attach"
  groups     = [aws_iam_group.administrators.name]
  policy_arn = "arn:aws:iam::aws:policy/AdministratorAccess"  # 기본적으로 존재하는 policy
}

# user 생성
resource "aws_iam_user" "admin1" {
  name = "admin1"
}

# admin group에 user 설정
resource "aws_iam_group_membership" "administrators-users" {
  name = "administrators-users"
  users = [
    aws_iam_user.admin1.name
  ]
  group = aws_iam_group.administrators.name
}

---

ec2 인스턴스에 연결할 역할을 생성해보자.

iam role 생성

# iam.tf
resource "aws_iam_role" "s3-mybucket-role" {
  name               = "s3-mybucket-role"
  assume_role_policy = <<EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": "sts:AssumeRole",
      "Principal": {
        "Service": "ec2.amazonaws.com"
      },
      "Effect": "Allow",
      "Sid": ""
    }
  ]
}
EOF

}

instance profile 생성

참고
*콘솔을 통해 ec2 역할을 생성하면, 콘솔이 자동으로 인스턴스 프로파일을 생성하여, 해당 역할과 동일한 이름을 부여한다. 그 후 콘솔로 IAM 역할을 통해 인스턴스를 실행할 때는 인스턴스와 연결할 역할을 선택할 수 있는데, 콘솔에 표시되는 목록이 실제로 인스턴스 프로파일 이름의 목록이다.

# iam.tf
resource "aws_iam_instance_profile" "s3-mybucket-role-instanceprofile" {
  name = "s3-mybucket-role"
  role = aws_iam_role.s3-mybucket-role.name
}

instance에 iam instance profile 연결

resource "aws_instance" "example" {
  ami           = var.AMIS[var.AWS_REGION]
  instance_type = "t2.micro"

  # the VPC subnet
  subnet_id = aws_subnet.main-public-1.id

  # the security group
  vpc_security_group_ids = [aws_security_group.example-instance.id]

  # the public SSH key
  key_name = aws_key_pair.mykeypair.key_name

  # role:
  iam_instance_profile = aws_iam_instance_profile.s3-mybucket-role-instanceprofile.name
}

버킷 생성

# s3.tf
resource "aws_s3_bucket" "b" {
  bucket = "mybucket-c29df1"

  tags = {
    Name = "mybucket-c29df1"
  }
}

버킷에 대한 policy 생성

생성한 버킷에 대한 action을 허용하는 policy를 생성

# iam.tf
resource "aws_iam_role_policy" "s3-mybucket-role-policy" {
  name = "s3-mybucket-role-policy"
  role = aws_iam_role.s3-mybucket-role.id  # 위에서 만든 역할을 참조한다.
  policy = <<EOF
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
              "s3:*"    # 모든 s3 action
            ],
            "Resource": [
              "arn:aws:s3:::mybucket-c29df1",  # 생성한 bucket에 대한 권한
              "arn:aws:s3:::mybucket-c29df1/*"
            ]
        }
    ]
}
EOF

}

 

terraform apply를 수행하고 s3-mybucket-role이 부여된 위 인스턴스에 접속해보자. (*key, security group, vpc등의 설정은 위에 있는 내용과 다르지 않음.)

$ ssh -i mykey ubuntu@example-instance-ip

aws cli를 설치해주자.

$ sudo -s
$ apt-get install -y python-pip python-dev
$ pip install -y awscli

test용 파일을 하나 만들어, 생성한 bucket에 넣어준다.

$ echo "test" > test.txt
$ aws s3 cp test.txt s3://mybucket-c29df1/test.txt

로그인도 안하고, aws 자격 증명도 없이 업로드가 된다. 해당 bucket에 access가 가능하다.
 
이 자격 증명은 aws 메타 데이터에 저장되어 있다.

$ curl http://{ip}/latest/meta-data/iam/security-credentials

---

 
Autoscaling
 
ELB
 
ALB