이전 글에서는 terraform의 기초적인 사용법을 알아보았습니다. 이번 글에서는 terraform을 활용하여 AWS 리소스들을 생성해보고 EKS Cluster를 배포해보도록 하겠습니다.
VPC 배포
terraform 소스 생성
vpc.tf 파일 생성
touch vpc.tf
vpc.tf를 생성합니다.
terraform 코드 작성
provider "aws" {
region = "ap-northeast-2"
}
resource "aws_vpc" "myvpc" {
cidr_block = "10.10.0.0/16"
tags = {
Name = "aews-study"
}
}
위의 코드를 통해 vpc를 생성하는 terraform 코드를 작성합니다.
terraform 실행
init & plan & apply
terraform init && terraform plan && terraform apply -auto-approve
위의 명령어를 통해 init, plan, apply를 동시에 실행합니다.
그럼 위의 사진처럼 aws_vpc.myvpc가 정상적으로 생성된 것을 확인하실 수 있습니다.
terraform 확인
terraform으로 생성된 목록 확인
terraform state list
위의 명령어를 통해 terraform으로 생성한 리소스 목록을 확인합니다.
awscli를 통해 확인
aws ec2 describe-vpcs --filter 'Name=isDefault,Values=false' | jq
awscli의 ec2 describe-vpcs를 통해 기본적으로 생성된 vpc를 제외한 vpc를 확인합니다.
AWS Managed Console에서 확인
위의 사진과 같이 AWS Managed Console에서 vpc 메뉴에 접근하신 후 확인해보시면 aews-study라는 이름으로 vpc가 생성된 것을 확인하실 수 있습니다.
VPC 수정
VPC DNS 옵션을 주기 위하여 vpc.tf 코드 내용을 수정하도록 하겠습니다.
terraform 소스 수정
terraform 코드 수정
provider "aws" {
region = "ap-northeast-2"
}
resource "aws_vpc" "myvpc" {
cidr_block = "10.10.0.0/16"
enable_dns_support = true
enable_dns_hostnames = true
tags = {
Name = "aews-study"
}
}
VPC DNS 옵션을 주기 위해 enable_dns_support, enable_dns_hostnames 옵션을 true로 수정합니다.
terraform 실행
plan & apply
terraform plan && terraform apply -auto-approve
위의 명령어를 통해 plan, apply를 동시에 실행합니다.
changed가 1로 카운트되며 정상적으로 수정된 것을 확인하실 수 있습니다.
AWS Managed Console 확인
AWS Managed Console에서 해당 VPC의 세부 정보를 확인해보면, DNS 호스트 이름과 DNS 확인의 값이 활성화된 것을 확인하실 수 있습니다.
서브넷 2개 생성 추가
terraform 소스 수정
terraform 코드 작성
resource "aws_vpc" "myvpc" {
cidr_block = "10.10.0.0/16"
enable_dns_support = true
enable_dns_hostnames = true
tags = {
Name = "aews-study"
}
}
## 추가
resource "aws_subnet" "mysubnet1" {
vpc_id = aws_vpc.myvpc.id
cidr_block = "10.10.1.0/24"
availability_zone = "ap-northeast-2a"
tags = {
Name = "t101-subnet1"
}
}
resource "aws_subnet" "mysubnet2" {
vpc_id = aws_vpc.myvpc.id
cidr_block = "10.10.2.0/24"
availability_zone = "ap-northeast-2c"
tags = {
Name = "aews-subnet2"
}
}
output "aws_vpc_id" {
value = aws_vpc.myvpc.id
}
이전에 작성한 VPC 생성하는 terraform 코드에 aws_subnet resource를 추가합니다.
terraform 실행
plan & apply
terraform plan && terraform apply -auto-approve
위의 명령어를 통해 plan, apply를 동시에 실행합니다.
그럼 위의 사진처럼 aws_subnet.mysubnet2와 aws_subnet.mysubnet1이 생성되었고, Outputs이 출력되는 것을 확인하실 수 있습니다.
terraform 확인
terraform으로 생성된 목록 확인
terraform state list
위의 명령어를 통해 terraform으로 생성한 리소스 목록을 확인합니다.
awscli를 통해 확인
aws ec2 describe-subnets --filters "Name=vpc-id,Values=vpc-<자신의 VPC ID>"
awscli를 통해 현재 vpc에 생성된 subnet 목록을 확인하실 수 있습니다.
IGW 인터넷 게이트웨이 추가
terraform 소스 수정
terraform 코드 작성
resource "aws_vpc" "myvpc" {
cidr_block = "10.10.0.0/16"
enable_dns_support = true
enable_dns_hostnames = true
tags = {
Name = "aews-study"
}
}
resource "aws_subnet" "mysubnet1" {
vpc_id = aws_vpc.myvpc.id
cidr_block = "10.10.1.0/24"
availability_zone = "ap-northeast-2a"
tags = {
Name = "t101-subnet1"
}
}
resource "aws_subnet" "mysubnet2" {
vpc_id = aws_vpc.myvpc.id
cidr_block = "10.10.2.0/24"
availability_zone = "ap-northeast-2c"
tags = {
Name = "aews-subnet2"
}
}
## 추가
resource "aws_internet_gateway" "myigw" {
vpc_id = aws_vpc.myvpc.id
tags = {
Name = "t101-igw"
}
}
output "aws_vpc_id" {
value = aws_vpc.myvpc.id
}
이전에 작성한 terraform 코드에 aws_internet_gateway resource를 추가합니다.
terraform 실행
plan & apply
terraform plan && terraform apply -auto-approve
위의 명령어를 통해 plan, apply를 동시에 실행합니다.
그럼 위의 사진처럼 aws_internet_gateway.myigw가 생성된 것을 확인하실 수 있습니다.
terraform 확인
terraform으로 생성된 목록 확인
terraform state list
위의 명령어를 통해 terraform으로 생성한 리소스 목록을 확인합니다.
IGW 인터넷 게이트웨이로 전달하는 디폴트 라우팅 정보 추가
terraform 소스 수정
terraform 코드 작성
provider "aws" {
region = "ap-northeast-2"
}
resource "aws_vpc" "myvpc" {
cidr_block = "10.10.0.0/16"
enable_dns_support = true
enable_dns_hostnames = true
tags = {
Name = "t101-study"
}
}
resource "aws_subnet" "mysubnet1" {
vpc_id = aws_vpc.myvpc.id
cidr_block = "10.10.1.0/24"
availability_zone = "ap-northeast-2a"
tags = {
Name = "t101-subnet1"
}
}
resource "aws_subnet" "mysubnet2" {
vpc_id = aws_vpc.myvpc.id
cidr_block = "10.10.2.0/24"
availability_zone = "ap-northeast-2c"
tags = {
Name = "t101-subnet2"
}
}
resource "aws_internet_gateway" "myigw" {
vpc_id = aws_vpc.myvpc.id
tags = {
Name = "t101-igw"
}
}
## 추가
resource "aws_route_table" "myrt" {
vpc_id = aws_vpc.myvpc.id
tags = {
Name = "t101-rt"
}
}
resource "aws_route_table_association" "myrtassociation1" {
subnet_id = aws_subnet.mysubnet1.id
route_table_id = aws_route_table.myrt.id
}
resource "aws_route_table_association" "myrtassociation2" {
subnet_id = aws_subnet.mysubnet2.id
route_table_id = aws_route_table.myrt.id
}
resource "aws_route" "mydefaultroute" {
route_table_id = aws_route_table.myrt.id
destination_cidr_block = "0.0.0.0/0"
gateway_id = aws_internet_gateway.myigw.id
}
output "aws_vpc_id" {
value = aws_vpc.myvpc.id
}
이전에 작성한 terraform 코드에 aws_route_table과 aws_route_table_association, aws_route resource를 추가합니다.
terraform 실행
plan & apply
terraform plan && terraform apply -auto-approve
위의 명령어를 통해 plan, apply를 동시에 실행합니다.
terraform 확인
terraform으로 생성된 목록 확인
terraform state list
위의 명령어를 통해 terraform으로 생성한 리소스 목록을 확인합니다.
aws_route.mydefaultroute, aws_route_table.myrt aws_route_table_association.myrtassociation1, aws_route_table_association.myrtassociation2 이 생성된 것을 확인하실 수 있습니다.
보안그룹 생성
terraform 소스 생성
sg.tf 파일 생성
touch sg.tf
sg.tf를 생성합니다.
terraform 코드 작성
resource "aws_security_group" "mysg" {
vpc_id = aws_vpc.myvpc.id
name = "T101 SG"
description = "T101 Study SG"
}
resource "aws_security_group_rule" "mysginbound" {
type = "ingress"
from_port = 80
to_port = 80
protocol = "tcp"
cidr_blocks = ["0.0.0.0/0"]
security_group_id = aws_security_group.mysg.id
}
resource "aws_security_group_rule" "mysgoutbound" {
type = "egress"
from_port = 0
to_port = 0
protocol = "-1"
cidr_blocks = ["0.0.0.0/0"]
security_group_id = aws_security_group.mysg.id
}
aws_security_group resource를 생성하는 terraform 코드를 작성합니다.
terraform 실행
plan & apply
terraform plan && terraform apply -auto-approve
위의 명령어를 통해 plan, apply를 동시에 실행합니다.
terraform 확인
terraform으로 생성된 목록 확인
terraform state list
위의 명령어를 통해 terraform으로 생성한 리소스 목록을 확인합니다.
aws_security_group.mysg, aws_security_group_rule.mysginbound, aws_security_group_rule.mysgoutbound 이 생성된 것을 확인하실 수 있습니다.
terraform state show aws_security_group_rule.mysginbound
state show 명령어를 통해 생성된 리소스를 상세히 확인하실 수 있습니다.
EC2 생성
terraform 소스 생성
ec2.tf 파일 생성
touch ec2.tf
ec2.tf를 생성합니다.
terraform 코드 작성
data "aws_ami" "my_amazonlinux2" {
most_recent = true
filter {
name = "owner-alias"
values = ["amazon"]
}
filter {
name = "name"
values = ["amzn2-ami-hvm-*-x86_64-ebs"]
}
owners = ["amazon"]
}
resource "aws_instance" "myec2" {
depends_on = [
aws_internet_gateway.myigw
]
ami = data.aws_ami.my_amazonlinux2.id
associate_public_ip_address = true
instance_type = "t2.micro"
vpc_security_group_ids = ["${aws_security_group.mysg.id}"]
subnet_id = aws_subnet.mysubnet1.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
echo "Web Server</h1>" > index.html
nohup ./busybox httpd -f -p 80 &
EOF
user_data_replace_on_change = true
tags = {
Name = "t101-myec2"
}
}
output "myec2_public_ip" {
value = aws_instance.myec2.public_ip
description = "The public IP of the Instance"
}
ec2 resource를 생성하는 terraform 코드를 작성합니다.
data source를 보면 aws_ami로 정의된 것을 확인하실 수 있는데, ami의 모든 정보값을 참조해서 가져올 수 있습니다. 그래서 안에 정의되어 있는 설정 옵션에 따라 적절한 ami를 참조해서 가져오게 됩니다.
terraform 실행
plan & apply
terraform plan && terraform apply -auto-approve
위의 명령어를 통해 plan, apply를 동시에 실행합니다.
terraform 확인
terraform으로 생성된 목록 확인
terraform state list
위의 명령어를 통해 terraform으로 생성한 리소스 목록을 확인합니다.
data.aws_ami.my_amazonlinux2, aws_instance.myec2가 생성된 것을 확인하실 수 있습니다.
AWS Managed Console로 확인
AWS Managed Console에서 EC2 메뉴에 접근하신 뒤 인스턴스 목록을 보시면 위의 사진과 같이 t101-myec2 인스턴스가 정상적으로 생성된 것을 확인하실 수 있습니다.
생성된 EC2 접근
while true; do curl --connect-timeout 1 http://$MYIP/ ; echo "------------------------------"; date; sleep 1; done
위의 명령어를 통해 생성된 EC2의 public ip로 접근하는 명령어를 실행합니다.
정상적으로 잘 접근하여 Web Server라는 출력을 확인하실 수 있습니다.
EKS 배포하기
Terraform 코드 생성
이전 글에서 EKS를 생성할 때 환경 설정을 했던 대로 Terraform을 사용하여 배포하도록 하겠습니다.
eks.tf 파일 작성
data "aws_caller_identity" "current" {}
resource "aws_iam_policy" "external_dns_policy" {
name = "${var.ClusterBaseName}ExternalDNSPolicy"
description = "Policy for allowing ExternalDNS to modify Route 53 records"
policy = jsonencode({
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"route53:ChangeResourceRecordSets"
],
"Resource": [
"arn:aws:route53:::hostedzone/*"
]
},
{
"Effect": "Allow",
"Action": [
"route53:ListHostedZones",
"route53:ListResourceRecordSets"
],
"Resource": [
"*"
]
}
]
})
}
resource "aws_iam_role_policy_attachment" "external_dns_policy_attach" {
role = "${var.ClusterBaseName}-node-group-eks-node-group"
policy_arn = aws_iam_policy.external_dns_policy.arn
depends_on = [module.eks]
}
resource "aws_security_group" "node_group_sg" {
name = "${var.ClusterBaseName}-node-group-sg"
description = "Security group for EKS Node Group"
vpc_id = module.vpc.vpc_id
tags = {
Name = "${var.ClusterBaseName}-node-group-sg"
}
}
module "eks" {
source = "terraform-aws-modules/eks/aws"
version = "~>20.0"
cluster_name = var.ClusterBaseName
cluster_version = var.KubernetesVersion
cluster_endpoint_private_access = false
cluster_endpoint_public_access = true
cluster_addons = {
coredns = {
most_recent = true
}
kube-proxy = {
most_recent = true
}
vpc-cni = {
most_recent = true
}
}
vpc_id = module.vpc.vpc_id
enable_irsa = true
subnet_ids = module.vpc.public_subnets
eks_managed_node_groups = {
default = {
name = "${var.ClusterBaseName}-node-group"
use_name_prefix = false
instance_type = var.WorkerNodeInstanceType
desired_size = var.WorkerNodeCount
max_size = var.WorkerNodeCount + 2
min_size = var.WorkerNodeCount - 1
disk_size = var.WorkerNodeVolumesize
subnets = module.vpc.public_subnets
key_name = var.KeyName
vpc_security_group_ids = [aws_security_group.node_group_sg.id]
iam_role_name = "${var.ClusterBaseName}-node-group-eks-node-group"
iam_role_use_name_prefix = false
iam_role_additional_policies = {
"${var.ClusterBaseName}ExternalDNSPolicy" = aws_iam_policy.external_dns_policy.arn
}
}
}
access_entries = {
admin = {
kubernetes_groups = []
principal_arn = "${data.aws_caller_identity.current.arn}"
policy_associations = {
myeks = {
policy_arn = "arn:aws:eks::aws:cluster-access-policy/AmazonEKSClusterAdminPolicy"
access_scope = {
namespaces = []
type = "cluster"
}
}
}
}
}
tags = {
Environment = "${var.ClusterBaseName}-lab"
Terraform = "true"
}
}
irsa.tf
locals {
cluster_oidc_issuer_arn = "arn:aws:iam::${data.aws_caller_identity.current.account_id}:oidc-provider/${replace(module.eks.cluster_oidc_issuer_url, "https://", "")}"
}
module "eks-external-dns" {
source = "DNXLabs/eks-external-dns/aws"
version = "0.2.0"
cluster_name = var.ClusterBaseName
cluster_identity_oidc_issuer = module.eks.cluster_oidc_issuer_url
cluster_identity_oidc_issuer_arn = local.cluster_oidc_issuer_arn
enabled = false
}
module "aws_load_balancer_controller_irsa_role" {
source = "terraform-aws-modules/iam/aws//modules/iam-role-for-service-accounts-eks"
version = "5.3.1"
role_name = "${var.ClusterBaseName}-aws-load-balancer-controller"
attach_load_balancer_controller_policy = true
oidc_providers = {
ex = {
provider_arn = module.eks.oidc_provider_arn
namespace_service_accounts = ["kube-system:aws-load-balancer-controller"]
}
}
}
provider "kubernetes" {
host = module.eks.cluster_endpoint
token = data.aws_eks_cluster_auth.cluster.token
cluster_ca_certificate = base64decode(module.eks.cluster_certificate_authority_data)
}
data "aws_eks_cluster" "cluster" {
name = module.eks.cluster_name
depends_on = [module.eks]
}
data "aws_eks_cluster_auth" "cluster" {
name = module.eks.cluster_name
depends_on = [module.eks]
}
resource "kubernetes_service_account" "aws_lb_controller" {
metadata {
name = "aws-load-balancer-controller"
namespace = "kube-system"
annotations = {
"eks.amazonaws.com/role-arn" = module.aws_load_balancer_controller_irsa_role.iam_role_arn
}
}
var.tf
variable "KeyName" {
description = "Name of an existing EC2 KeyPair to enable SSH access to the instances."
type = string
}
variable "ClusterBaseName" {
description = "Base name of the cluster."
type = string
default = "myeks"
}
variable "KubernetesVersion" {
description = "Kubernetes version for the EKS cluster."
type = string
default = "1.29"
}
variable "WorkerNodeInstanceType" {
description = "EC2 instance type for the worker nodes."
type = string
default = "t3.medium"
}
variable "WorkerNodeCount" {
description = "Number of worker nodes."
type = number
default = 3
}
variable "WorkerNodeVolumesize" {
description = "Volume size for worker nodes (in GiB)."
type = number
default = 30
}
variable "TargetRegion" {
description = "AWS region where the resources will be created."
type = string
default = "ap-northeast-2"
}
variable "availability_zones" {
description = "List of availability zones."
type = list(string)
default = ["ap-northeast-2a", "ap-northeast-2b", "ap-northeast-2c"]
}
variable "VpcBlock" {
description = "CIDR block for the VPC."
type = string
default = "192.168.0.0/16"
}
variable "public_subnet_blocks" {
description = "List of CIDR blocks for the public subnets."
type = list(string)
default = ["192.168.1.0/24", "192.168.2.0/24", "192.168.3.0/24"]
}
variable "private_subnet_blocks" {
description = "List of CIDR blocks for the private subnets."
type = list(string)
default = ["192.168.11.0/24", "192.168.12.0/24", "192.168.13.0/24"]
}
provider "aws" {
region = var.TargetRegion
}
module "vpc" {
source = "terraform-aws-modules/vpc/aws"
version = "~>5.7"
name = "${var.ClusterBaseName}-VPC"
cidr = var.VpcBlock
azs = var.availability_zones
enable_dns_support = true
enable_dns_hostnames = true
public_subnets = var.public_subnet_blocks
private_subnets = var.private_subnet_blocks
enable_nat_gateway = true
single_nat_gateway = true
one_nat_gateway_per_az = false
map_public_ip_on_launch = true
igw_tags = {
"Name" = "${var.ClusterBaseName}-IGW"
}
nat_gateway_tags = {
"Name" = "${var.ClusterBaseName}-NAT"
}
public_subnet_tags = {
"Name" = "${var.ClusterBaseName}-PublicSubnet"
"kubernetes.io/role/elb" = "1"
}
private_subnet_tags = {
"Name" = "${var.ClusterBaseName}-PrivateSubnet"
"kubernetes.io/role/internal-elb" = "1"
}
tags = {
"Environment" = "${var.ClusterBaseName}-lab"
}
}
terraform 실행
init & plan & apply
terraform plan && terraform apply -auto-approve
위의 명령어를 통해 init & plan, apply를 동시에 실행합니다.
EKS 배포는 10분정도의 시간이 소요됩니다.
terraform 확인
terraform으로 생성된 목록 확인
terraform state list
위의 명령어를 통해 terraform으로 생성한 리소스 목록을 확인합니다.
목록들이 출력되는데 너무 많아 접은 글을 확인해주세요!
더보기
data.aws_caller_identity.current
data.aws_eks_cluster.cluster
data.aws_eks_cluster_auth.cluster
aws_iam_policy.external_dns_policy
aws_iam_role_policy_attachment.external_dns_policy_attach
aws_security_group.node_group_sg
kubernetes_service_account.aws_lb_controller
module.aws_load_balancer_controller_irsa_role.data.aws_caller_identity.current
module.aws_load_balancer_controller_irsa_role.data.aws_iam_policy_document.load_balancer_controller[0]
module.aws_load_balancer_controller_irsa_role.data.aws_iam_policy_document.this[0]
module.aws_load_balancer_controller_irsa_role.data.aws_partition.current
module.aws_load_balancer_controller_irsa_role.aws_iam_policy.load_balancer_controller[0]
module.aws_load_balancer_controller_irsa_role.aws_iam_role.this[0]
module.aws_load_balancer_controller_irsa_role.aws_iam_role_policy_attachment.load_balancer_controller[0]
module.eks.data.aws_caller_identity.current
module.eks.data.aws_eks_addon_version.this["coredns"]
module.eks.data.aws_eks_addon_version.this["kube-proxy"]
module.eks.data.aws_eks_addon_version.this["vpc-cni"]
module.eks.data.aws_iam_policy_document.assume_role_policy[0]
module.eks.data.aws_iam_session_context.current
module.eks.data.aws_partition.current
module.eks.data.tls_certificate.this[0]
module.eks.aws_cloudwatch_log_group.this[0]
module.eks.aws_ec2_tag.cluster_primary_security_group["Environment"]
module.eks.aws_ec2_tag.cluster_primary_security_group["Terraform"]
module.eks.aws_eks_access_entry.this["admin"]
module.eks.aws_eks_access_policy_association.this["admin_myeks"]
module.eks.aws_eks_addon.this["coredns"]
module.eks.aws_eks_addon.this["kube-proxy"]
module.eks.aws_eks_addon.this["vpc-cni"]
module.eks.aws_eks_cluster.this[0]
module.eks.aws_iam_openid_connect_provider.oidc_provider[0]
module.eks.aws_iam_policy.cluster_encryption[0]
module.eks.aws_iam_role.this[0]
module.eks.aws_iam_role_policy_attachment.cluster_encryption[0]
module.eks.aws_iam_role_policy_attachment.this["AmazonEKSClusterPolicy"]
module.eks.aws_iam_role_policy_attachment.this["AmazonEKSVPCResourceController"]
module.eks.aws_security_group.cluster[0]
module.eks.aws_security_group.node[0]
module.eks.aws_security_group_rule.cluster["ingress_nodes_443"]
module.eks.aws_security_group_rule.node["egress_all"]
module.eks.aws_security_group_rule.node["ingress_cluster_443"]
module.eks.aws_security_group_rule.node["ingress_cluster_4443_webhook"]
module.eks.aws_security_group_rule.node["ingress_cluster_6443_webhook"]
module.eks.aws_security_group_rule.node["ingress_cluster_8443_webhook"]
module.eks.aws_security_group_rule.node["ingress_cluster_9443_webhook"]
module.eks.aws_security_group_rule.node["ingress_cluster_kubelet"]
module.eks.aws_security_group_rule.node["ingress_nodes_ephemeral"]
module.eks.aws_security_group_rule.node["ingress_self_coredns_tcp"]
module.eks.aws_security_group_rule.node["ingress_self_coredns_udp"]
module.eks.time_sleep.this[0]
module.eks-external-dns.data.aws_region.current
module.vpc.aws_default_network_acl.this[0]
module.vpc.aws_default_route_table.default[0]
module.vpc.aws_default_security_group.this[0]
module.vpc.aws_eip.nat[0]
module.vpc.aws_internet_gateway.this[0]
module.vpc.aws_nat_gateway.this[0]
module.vpc.aws_route.private_nat_gateway[0]
module.vpc.aws_route.public_internet_gateway[0]
module.vpc.aws_route_table.private[0]
module.vpc.aws_route_table.public[0]
module.vpc.aws_route_table_association.private[0]
module.vpc.aws_route_table_association.private[1]
module.vpc.aws_route_table_association.private[2]
module.vpc.aws_route_table_association.public[0]
module.vpc.aws_route_table_association.public[1]
module.vpc.aws_route_table_association.public[2]
module.vpc.aws_subnet.private[0]
module.vpc.aws_subnet.private[1]
module.vpc.aws_subnet.private[2]
module.vpc.aws_subnet.public[0]
module.vpc.aws_subnet.public[1]
module.vpc.aws_subnet.public[2]
module.vpc.aws_vpc.this[0]
module.eks.module.eks_managed_node_group["default"].data.aws_caller_identity.current
module.eks.module.eks_managed_node_group["default"].data.aws_iam_policy_document.assume_role_policy[0]
module.eks.module.eks_managed_node_group["default"].data.aws_partition.current
module.eks.module.eks_managed_node_group["default"].aws_eks_node_group.this[0]
module.eks.module.eks_managed_node_group["default"].aws_iam_role.this[0]
module.eks.module.eks_managed_node_group["default"].aws_iam_role_policy_attachment.additional["myeksExternalDNSPolicy"]
module.eks.module.eks_managed_node_group["default"].aws_iam_role_policy_attachment.this["AmazonEC2ContainerRegistryReadOnly"]
module.eks.module.eks_managed_node_group["default"].aws_iam_role_policy_attachment.this["AmazonEKSWorkerNodePolicy"]
module.eks.module.eks_managed_node_group["default"].aws_iam_role_policy_attachment.this["AmazonEKS_CNI_Policy"]
module.eks.module.eks_managed_node_group["default"].aws_launch_template.this[0]
module.eks.module.kms.data.aws_caller_identity.current[0]
module.eks.module.kms.data.aws_iam_policy_document.this[0]
module.eks.module.kms.data.aws_partition.current[0]
module.eks.module.kms.aws_kms_alias.this["cluster"]
module.eks.module.kms.aws_kms_key.this[0]
module.eks.module.eks_managed_node_group["default"].module.user_data.null_resource.validate_cluster_service_cidr
AWS Managed Console로 확인
AWS Managed Console에 접근하여 EKS 메뉴에서 확인해보시면 정상적으로 EKS Cluster가 생성된 것을 확인하실 수 있습니다.
'스터디 이야기 > AWS EKS' 카테고리의 다른 글
| [AEWS] 8-2. Amazon EKS - IaC (Terraform 심화) (1) | 2024.04.26 |
|---|---|
| [AEWS] 8-1. Amazon EKS - IaC (Terraform 기초) (1) | 2024.04.26 |
| [AEWS] 7-2. Amazon EKS - CI/CD (ArgoCD/ArgoRollouts) (0) | 2024.04.16 |
| [AEWS] 7-1. Amazon EKS - CI/CD (Jenkins) (0) | 2024.04.16 |
