Openflow 설정 - BYOC

Openflow 설정 - BYOC

기능 — 일반 사용 가능(Generally Available) Openflow BYOC 배포는 AWS 상용(Commercial) 리전의 모든 계정에서 사용할 수 있어요.

이 문서는 Openflow를 설정하는 단계를 설명해요.

Openflow를 설정하는 과정은 다음과 같은 단계로 이루어져요.

1. Openflow 배포(Deployment) 생성
2. Openflow 런타임(Runtime) 생성

출처: Set up Openflow - BYOC

본문

사전 요구 사항 (Prerequisites)

Snowflake와 AWS 계정에서 완료해야 하는 사전 요구 사항은 다음과 같아요.

Snowflake 계정

먼저 계정 수준에서 Openflow 관리자에게 필요한 권한을 부여해요.

Openflow 관리자에게 필요한 권한을 부여하려면 다음 SQL 명령을 실행해요. gen 1과 gen 2의 차이를 이해하려면 Openflow gen 1과 gen 2를 참고해요.

Gen 2:

USE ROLE ACCOUNTADMIN;

GRANT CREATE OPENFLOW DEPLOYMENT ON ACCOUNT TO ROLE openflow_admin;
GRANT CREATE DATABASE ON ACCOUNT TO ROLE openflow_admin;
-- Run these two after creating the database and schema for gen 2 objects:
-- GRANT CREATE OPENFLOW RUNTIME ON SCHEMA <db>.<schema> TO ROLE openflow_admin;
-- GRANT CREATE OPENFLOW CONNECTOR ON SCHEMA <db>.<schema> TO ROLE openflow_admin;

Gen 1 (기존 배포만 해당): 새 gen 1 배포는 만들 수 없어요. 기존 gen 1 배포가 있다면 이 권한을 부여해 그 위에 추가 런타임을 만들 수 있어요.

USE ROLE ACCOUNTADMIN;

GRANT CREATE OPENFLOW RUNTIME INTEGRATION ON ACCOUNT TO ROLE openflow_admin;

이 권한들은 기본 권한 집합의 일부로 ACCOUNTADMIN 역할에 할당되며, 해당 역할은 Openflow 관리자를 위해 코드에서 openflow_admin으로 표기된 자기 선택 역할에 이 권한들을 부여할 수 있어요.

다음으로 모든 Openflow 사용자에 대해 default_secondary_roles를 ALL로 설정해요.

1. Snowflake에 로그인하고 계정 관리자가 Openflow 사용을 위해 설정한 역할(예: openflow_admin)로 전환해요.
2. 이 역할은 ACCOUNTADMIN, ORGADMIN, GLOBALORGADMIN, SECURITYADMIN 중 어느 것도 아니어야 해요.
3. Openflow에 로그인할 때 빈 화면이 보이거나 "message: Invalid consent request" 오류가 나면, 이 목록에 없는 역할로 변경해요.

자세한 내용은 사전 요구 사항을 참고해요.

각 Openflow 사용자마다 <openflow_user>를 바꿔 다음 코드를 실행해요.

USE ROLE ACCOUNTADMIN;
ALTER USER <openflow_user> SET DEFAULT_SECONDARY_ROLES = ('ALL');

이 설정이 필요한 이유는 Openflow 작업이 기본 역할뿐 아니라 인증된 사용자의 모든 역할 중 하나로 승인되기 때문이에요.

배포 권한 (Deployment privileges)

배포(deployment) 객체는 하나 이상의 Snowflake Openflow 런타임을 배포하기 위해 프로비저닝된 리소스 집합을 나타내요. 자체 클라우드 리소스를 가져오는 조직의 경우, 배포는 관리형 Kubernetes 클러스터와 그에 연결된 노드를 나타내요.

계정에 대한 CREATE OPENFLOW DEPLOYMENT 권한이 있는 사용자는 배포 객체를 만들 수 있어요.

접근을 차별화하기 위해 배포 객체에 직접 추가 권한을 정의할 수 있어요.

배포 객체에 다음 권한을 부여할 수 있어요.

• OWNERSHIP: 배포 삭제를 포함한 배포 작업에 대한 완전한 제어를 활성화해요.
• USAGE: 런타임 하위 객체 생성을 활성화해요.

런타임 권한 (Runtime privileges)

런타임 객체는 플로우 정의를 실행하기 위해 프로비저닝된 하나 이상의 Snowflake Openflow 런타임 서버 클러스터를 나타내요. Kubernetes 배포의 경우, 런타임 객체는 네임스페이스에 배포된 Snowflake Openflow 런타임 컨테이너의 StatefulSet과 지원 구성 요소를 나타내요.

상위 배포 객체에 대한 OWNERSHIP 권한과 CREATE OPENFLOW RUNTIME INTEGRATION(gen 1) 또는 CREATE OPENFLOW RUNTIME(gen 2) 권한이 있는 사용자는 런타임을 만들 수 있어요. 런타임 객체에 직접 추가 권한을 정의할 수 있어요.

런타임 객체에 다음 권한을 부여할 수 있어요.

• OWNERSHIP: 연결된 런타임 삭제와 런타임 플로우 정의 수정을 포함한 런타임 작업에 대한 완전한 제어를 활성화해요.
• USAGE: 커넥터와 플로우 정의 생성·수정을 포함한 배포된 런타임에 대한 쓰기 접근을 활성화해요.
• MONITOR: 변경 없이 상태와 상태를 관찰하는 배포된 런타임에 대한 읽기 전용 접근을 활성화해요.

실행 역할 (Execute-as role)

실행 역할(execute-as role)은 특정 Openflow 런타임에 바인딩된 Snowflake 역할이에요. SNOWFLAKE_MANAGED 인증을 사용하는 커넥터는 이 역할의 권한(또는 이 역할에 부여된 하위 역할의 권한)으로 실행돼요. 실행 역할은 다음 작업에 사용돼요.

• Snowflake 리소스에 대한 접근 부여
• 커넥터별 리소스에 대한 접근 부여

실행 역할은 Openflow 관리 토큰과 연결되어 있으므로 Snowflake 인증을 위해 별도의 서비스 사용자와 키 페어를 만들 필요가 없어요. 대신 KEY_PAIR 인증 전략으로 커넥터를 배포한다면 Openflow - BYOC 배포의 키 페어 인증 설정을 참고해요.

참고: <RUNTIME_NAME>은 연결된 런타임의 이름을 나타내요.

실행 역할을 만들려면:

1. 역할을 생성해요.

USE ROLE ACCOUNTADMIN;
CREATE ROLE IF NOT EXISTS OPENFLOW_<RUNTIME_NAME>_EXECUTE_AS_RL;

2. 실행 역할에 웨어하우스 접근 권한을 부여해요. Snowflake는 데이터 수집에 전용 웨어하우스를 사용할 것을 권장해요. 이 웨어하우스는 이 실행 역할을 사용하는 런타임에 대해 커넥터를 구성할 때 사용해야 해요.

GRANT USAGE, OPERATE ON WAREHOUSE <OPENFLOW_INGEST_WAREHOUSE> TO ROLE OPENFLOW_<RUNTIME_NAME>_EXECUTE_AS_RL;

3. 실행 역할이 Snowflake 객체를 사용·생성하거나 접근할 수 있도록 해요.

참고: 생성 중인 Openflow 커넥터에 따라 필요한 기본 객체가 달라져요. 아래 예시는 설명 목적으로만 제공돼요.

GRANT USAGE ON DATABASE <OPENFLOW_DATABASE> TO ROLE OPENFLOW_<RUNTIME_NAME>_EXECUTE_AS_RL;
GRANT USAGE ON SCHEMA <OPENFLOW_SCHEMA> TO ROLE OPENFLOW_<RUNTIME_NAME>_EXECUTE_AS_RL;

4. 사용자가 실행 역할을 사용할 수 있도록 해요.

GRANT ROLE OPENFLOW_<RUNTIME_NAME>_EXECUTE_AS_RL TO USER <username>;

역할 설정 예시 (Example for role setup)

다음과 같은 역할을 설정해야 하는 시나리오를 생각해 봐요.

• accountadmin: Snowflake의 기본 제공 역할로, 다음 CREATE 권한이 있어요.
  • CREATE OPENFLOW DEPLOYMENT
  • CREATE OPENFLOW RUNTIME INTEGRATION (gen 1, 기존 gen 1 배포에서) / CREATE OPENFLOW RUNTIME (gen 2, 스키마에서)
• openflow_admin: 배포를 생성·관리·삭제할 수 있어요.
• deployment1_runtime_manager_1: 배포 1 내에서만 런타임을 만들 수 있어요. 배포 1에서 자신이 만든 런타임은 수정·삭제할 수 있지만, deployment1_runtime_manager_2가 만든 런타임은 할 수 없어요.
• deployment1_runtime_manager_2: 배포 1 내에서만 런타임을 만들 수 있어요. 배포 1에서 자신이 만든 런타임은 수정·삭제할 수 있지만, deployment1_runtime_manager_1이 만든 런타임은 할 수 없어요.
• deployment1_runtime_viewer_1: 배포 1 내에서 deployment1_runtime_manager_1이 만든 런타임 캔버스를 볼 수 있어요.
• deployment1_runtime_viewer_2: 배포 1 내에서 deployment1_runtime_manager_2가 만든 런타임 캔버스를 볼 수 있어요.
• deployment2_runtime_manager: 배포 2 내에서만 런타임을 만들 수 있어요.
• deployment2_runtime_viewer: 배포 2 내에서 런타임 캔버스를 볼 수 있어요.

이 역할들로 Openflow를 설정하려면 다음 단계를 따르세요.

새 역할을 만들고 관련 권한을 할당해요.

use role ACCOUNTADMIN;
create role if not exists openflow_admin;
create role if not exists deployment1_runtime_manager_1;
create role if not exists deployment1_runtime_manager_2;
create role if not exists deployment1_runtime_viewer_1;
create role if not exists deployment1_runtime_viewer_2;
create role if not exists deployment2_runtime_manager;
create role if not exists deployment2_runtime_viewer;

-- Assign create deployment privilege to roles. (This privilege cannot be granted in Openflow UI.)
grant create openflow deployment on account to role openflow_admin;

-- Assign create runtime privilege to roles. (This privilege cannot be granted in the Control Plane UI.)
-- Gen 1 (on existing gen 1 deployments):
grant create openflow runtime integration on account to role deployment1_runtime_manager_1;
grant create openflow runtime integration on account to role deployment1_runtime_manager_2;
grant create openflow runtime integration on account to role deployment2_runtime_manager;

-- Grant roles to users. (Repeat this step for each user.)

grant role <role name> to user <username>;

배포를 만들려면 다음 단계를 따르세요.

1. openflow_admin으로 Snowsight에 로그인해요.
2. 탐색 메뉴에서 Ingestion » Openflow를 선택해요.
3. 배포 1을 만들려면 Create a deployment를 선택하고 deployment1_runtime_manager_1과 deployment1_runtime_manager_2에 USAGE 권한을 부여해요.
4. 배포 2를 만들려면 Create a deployment를 선택하고 deployment2_runtime_manager에 USAGE 권한을 부여해요.

배포 1에 런타임을 만들려면 다음 단계를 따르세요.

1. deployment1_runtime_manager_1로 로그인해요.
2. 다음 섹션에서 설명하는 대로 런타임을 만들어요. deployment1_runtime_manager_1은 이 배포 내에서 런타임을 만들고 자신이 만든 런타임을 관리할 수 있어야 해요.
3. Openflow UI에서 deployment1_runtime_viewer_1을 선택하고 USAGE 권한을 부여해요.

AWS 계정

AWS 계정에서 다음을 확인해요.

• CloudFormation 스택을 만들 권한이 있는 AWS 계정이 있어요.
• 조직의 AWS 관리자가 CloudFormation 스크립트를 실행해 새 VPC(CloudFormation이 생성) 또는 기존 VPC 안에 Amazon Elastic Kubernetes Service(EKS)를 설정할 수 있어요. BYO-VPC(기존 VPC) 사전 요구 사항을 참고해요.

참고: Openflow 설치가 AWS 계정에서 어떻게 이루어지고 CloudFormation 템플릿이 구성하는 권한에 대해 알아보려면 설치 과정을 참고해요.

BYO-VPC(기존 VPC) 사전 요구 사항

기존 VPC와 자체 서브넷을 사용하려면 다음을 갖추고 있는지 확인해요.

Snowflake 관리 인그레스(Ingress)를 위한 두 개의 공용 서브넷:

• 서로 다른 가용 영역(Availability Zone)
• 32개의 사용 가능한 IP가 있는 최소 /27 CIDR 범위
• 목적지 0.0.0.0/0에 대한 경로와 인터넷 게이트웨이 또는 기타 인터넷으로의 아웃바운드 라우팅
• Openflow가 로드 밸런서를 만들 수 있게 하는 태그:
  • 키(Key): kubernetes.io/role/elb
  • 값(Value): 1
• 공용 서브넷이 다른 EKS 클러스터에서 사용된다면, Openflow가 다른 로드 밸런서와 함께 로드 밸런서를 만들 수 있게 하는 태그:
  • 키(Key): kubernetes.io/cluster/{deployment-key}
  • 값(Value): 1

참고: 자체 인그레스를 관리하면 공용 서브넷이 필요 없지만, AWS 계정에 추가 구성이 필요해요. 자세한 내용은 Openflow BYOC - 사용자 지정 인그레스 설정을 참고해요.

두 개의 프라이빗 서브넷:

• 서로 다른 가용 영역
• 255개의 사용 가능한 IP가 있는 최소 /24 CIDR 범위. 이는 만들 수 있는 런타임의 수와 규모를 제한하므로 배포에는 더 큰 범위를 사용하는 것이 더 적절할 수 있어요.
• Openflow 배포가 실행되는 Private Subnet 1에서 Snowflake와 AWS 서비스로의 연결
• 여러 옵션 중 NAT Gateway, Transit Gateway 또는 PrivateLink VPC 엔드포인트가 있는 라우팅 테이블로 연결할 수 있어요.
• 이 연결이 없으면 Openflow 배포가 초기화되거나 제대로 설정되지 않고 인프라도 프로비저닝되지 않아요.

Snowflake 관리 인그레스를 위해 프라이빗 서브넷이 TLS 인증서 프로비저닝을 위한 아웃바운드 연결을 갖추도록 해요. cert-manager는 DNS-01 검증을 사용하며, 이 검증은 다음이 필요해요.

• acme-v02.api.letsencrypt.org의 Let's Encrypt ACME API에 대한 HTTPS(포트 443)
• snowflake-customer.app과 그 하위 도메인의 DNS 해석. 네트워크는 공용 DNS 접근이 가능한 NAT Gateway 또는 snowflake-customer.app 도메인을 커버하도록 구성된 프라이빗 DNS 해석기를 통해 이러한 이름을 해석할 수 있어야 해요.
• 프라이빗 서브넷의 NAT Gateway 또는 유사한 아웃바운드 경로. 보안 그룹이나 네트워크 ACL이 아웃바운드 트래픽을 제한한다면 이러한 목적지를 허용하도록 해요.

중요: VPC에 공용 인터넷 아웃바운드가 없다면 Snowflake 관리 인그레스 대신 사용자 지정 인그레스를 사용해요. 사용자 지정 인그레스는 Let's Encrypt 의존성을 없애요. 프라이빗 배포 구성을 참고해요.

Openflow 서비스 약관 수락

이 단계는 조직당 한 번만 필요해요.

1. ORGADMIN 역할을 가진 사용자로 Snowflake에 로그인해요.
2. 탐색 메뉴에서 Ingestion » Openflow를 선택해요.
3. Openflow 서비스 약관을 수락해요.

이 옵션이 보이지 않으면 조직에 대해 약관이 이미 수락된 것이에요.

Openflow 배포 만들기 (Create an Openflow deployment)

Snowflake 계정에서 배포 구성

중요: Snowflake에 로그인하고 계정 관리자가 Openflow 사용을 위해 설정한 역할(예: openflow_admin)로 전환해요. 이 역할은 ACCOUNTADMIN, ORGADMIN, GLOBALORGADMIN, SECURITYADMIN 중 어느 것도 아니어야 해요. Openflow에 로그인할 때 빈 화면이 보이거나 "message: Invalid consent request" 오류가 나면 이 목록에 없는 역할로 변경해요. 자세한 내용은 사전 요구 사항을 참고해요.

1. 탐색 메뉴에서 Ingestion » Openflow를 선택해요.
2. Launch Openflow를 선택해요.
3. Openflow UI에서 Create a deployment를 선택해요.
4. Deployments 탭에서 Create a deployment를 선택해요. Creating a deployment 마법사가 열려요.
5. Prerequisites 단계에서 모든 요구 사항을 충족하는지 확인한 후 Next를 선택해요.
6. Deployment location 단계에서 배포 위치로 Amazon Web Services를 선택하고 배포 이름을 입력한 후 Next를 선택해요.
7. Configuration 단계에서 다음 옵션 중 하나를 선택해요.
   • Managed VPC: VPC를 Snowflake가 관리하게 하려면 이 옵션을 선택해요.
   • Bring your own VPC: 기존 VPC를 사용하려면 이 옵션을 선택해요.
8. PrivateLink 단계에서 프라이빗 링크를 통해 Snowflake와의 통신을 설정할지 선택할 수 있어요. 이 옵션을 활성화하려면 AWS 계정에 추가 설정이 필요해요. 자세한 내용은 AWS PrivateLink와 Snowflake를 참고해요.
   • PrivateLink 옵션이 활성화되면 End user authentication over PrivateLink 단계가 표시돼요.
   • 활성화하면 브라우저 기반 인증 리디렉션이 PrivateLink 엔드포인트를 사용해요.
   • 비활성화하면 최종 사용자 인증이 공용 Snowflake URL을 사용해요.
   • 이 설정과 관계없이 Snowflake로의 배포 통신은 PrivateLink를 사용해요.
   • PrivateLink URL로 Snowsight에 접속한다면 활성화해 두는 것이 좋아요.
   • PrivateLink가 아닌 URL로 Snowsight에 접속한다면 비활성화로 두는 것이 좋아요.
9. Custom Ingress 단계에서 Openflow 배포의 사용자 지정 인그레스 구성(예: 사용자 지정 보안 그룹, 로드 밸런서 설정, 기타 네트워크 제어)을 관리하도록 선택할 수 있어요. 이 옵션을 활성화하려면 AWS 계정에 추가 설정이 필요해요. 자세한 내용은 Openflow BYOC - 사용자 지정 인그레스 설정을 참고해요.
10. Create Deployment를 선택해요.

배포가 구성되면 AWS 계정에서 설정 과정을 완료하기 위해 CloudFormation 템플릿을 다운로드할 수 있는 대화 상자가 나타나요. 이 템플릿을 다운로드해요. Openflow는 CloudFormation 템플릿 수정을 지원하지 않아요. 템플릿 다운로드 후 드롭다운 옵션 선택 외에는 값을 수정하지 마세요.

(선택 사항) Openflow BYOC 배포의 EBS 볼륨을 암호화하려면 Openflow BYOC - 암호화된 EBS 볼륨 설정을 참고해요.

AWS 계정에서 CloudFormation 템플릿 적용

AWS 계정에서 이 템플릿을 사용해 새 CloudFormation 스택을 만들어요. Openflow 배포 에이전트의 Amazon Elastic Compute Cloud(EC2) 인스턴스가 생성된 후, infrastructure-as-code 스크립트를 사용해 나머지 설치 과정을 완료해요. 설치 진행 상황은 설치 진행 추적에서 설명하는 대로 추적할 수 있어요.

기존 VPC를 사용한다면 CloudFormation 템플릿 업로드 시 두 프라이빗 서브넷과 VPC에 대해 드롭다운 목록에서 각각의 값을 선택해요.

Snowflake 계정에 Openflow용 네트워크 규칙 생성

이 단계는 네트워크 정책을 사용해 Snowflake에 대한 접근을 제어하는 경우에만 필요해요. 네트워크 정책은 Snowflake 계정에 접근할 수 있는 IP 주소를 제어하는 규칙 집합이에요.

1. Snowflake 계정으로 이동해요.
2. CloudFormation 스택의 일부로 생성된 NAT 게이트웨이 공용 IP 주소를 식별해요. AWS 콘솔에서 NAT Gateway를 검색하거나 CloudFormation 스택 출력을 확인해 찾을 수 있어요. NAT 게이트웨이는 Data Plane Agent(DPA)와 EKS 둘 다의 Openflow 아웃바운드를 담당해요. DPA와 EKS 모두 설치의 Private Subnet 1에서 실행돼요.
3. Openflow용 네트워크 규칙을 만들고 기존 네트워크 정책에 추가해요. 다음 코드 스니펫에서 {$NAT_GATEWAY_PUBLIC_IP}를 CloudFormation 스택의 일부로 생성된 NAT 게이트웨이 공용 IP 주소로 바꿔요.

USE ROLE ACCOUNTADMIN;
USE DATABASE <openflow_db>;
USE SCHEMA <openflow_schema>;

CREATE NETWORK RULE allow_openflow_deployment
MODE = INGRESS
TYPE = IPV4
VALUE_LIST = ('{$NAT_GATEWAY_PUBLIC_IP}/32');

4. 현재 활성화된 네트워크 정책을 찾아요.

SHOW PARAMETERS LIKE 'NETWORK_POLICY' IN ACCOUNT;

5. 출력에서 value 열을 복사하고 이를 사용해 네트워크 규칙을 만들어요.

ALTER NETWORK POLICY {ENTER_YOUR_ACTIVE_NETWORK_POLICY_NAME} ADD ALLOWED_NETWORK_RULE_LIST = (allow_openflow_deployment);

(선택 사항) Openflow 전용 이벤트 테이블 구성

Openflow는 로그와 메트릭을 생성해 Snowflake 이벤트 테이블(Event Table)로 보내요. 이 원격 분석 데이터를 분석하는 데 유용한 쿼리는 Openflow 모니터링을 참고해요.

기본적으로 Openflow는 계정 이벤트 테이블(SNOWFLAKE.TELEMETRY.EVENTS)을 사용하지만 배포별로 Openflow 전용 이벤트 테이블을 구성할 수 있어요. 쿼리 성능 최적화, 세밀한 접근 제어, Openflow 모니터링·유지 관리 단순화를 위해 전용 이벤트 테이블을 권장해요.

다음 옵션 중 하나를 사용해요.

Openflow 전용 이벤트 테이블 생성:

USE ROLE ACCOUNTADMIN;
USE DATABASE <openflow_db>;
USE SCHEMA <openflow_schema>;

GRANT CREATE EVENT TABLE
  ON SCHEMA <openflow_db>.<openflow_schema>
  TO ROLE <role_of_deployment_owner>;
USE ROLE <role_of_deployment_owner>;
CREATE EVENT TABLE IF NOT EXISTS <openflow_db>.<openflow_schema>.openflow_events;

-- Find the deployment (gen 2: SHOW OPENFLOW DEPLOYMENTS; gen 1: SHOW OPENFLOW DATA PLANE INTEGRATIONS)
SHOW OPENFLOW DEPLOYMENTS;

-- Set event table (gen 2: ALTER OPENFLOW DEPLOYMENT; gen 1: ALTER OPENFLOW DATA PLANE INTEGRATION)
ALTER OPENFLOW DEPLOYMENT
  <deployment_name>
  SET EVENT_TABLE = '<openflow_db>.<openflow_schema>.openflow_events';

기존 계정별 이벤트 테이블 사용:

USE ROLE ACCOUNTADMIN;
ALTER ACCOUNT SET EVENT_TABLE = 'existing_database.existing_schema.existing_event_table';

배포 확인

탐색 메뉴에서 Ingestion » Openflow를 선택해요. AWS에서 배포를 만드는 데 약 45분이 걸려요. 생성되면 Openflow UI의 Deployments 탭에서 배포를 볼 수 있고 상태가 Active로 표시돼요.

Openflow 런타임 만들기 (Create an Openflow runtime)

1. Openflow Control Plane에서 Create a runtime을 선택해요. Create Runtime 대화 상자가 나타나요.
2. Deployment 드롭다운 목록에서 런타임을 만들 배포를 선택해요.
3. 런타임 이름을 입력해요.
4. Node type 드롭다운 목록에서 노드 유형을 선택해요. 이는 노드의 크기를 지정해요. 크기와 노드 수 선택에 대한 지침은 CDC 커넥터용 런타임 크기 및 패킹을 참고해요.
5. Min/Max node range 선택기에서 범위를 선택해요. 최솟값은 유휴 상태일 때 런타임이 시작하는 노드 수를, 최댓값은 데이터 볼륨이나 CPU 부하가 높을 때 런타임이 확장할 수 있는 노드 수를 지정해요.
6. Create를 선택해요. 런타임이 만들어지는 데 몇 분 정도 걸려요. 생성되면 Openflow Control Plane의 Runtimes 탭으로 이동해 런타임을 볼 수 있어요. 런타임을 클릭해 Openflow 캔버스를 열어요.

다음 단계

런타임에 커넥터를 배포해요. Openflow에서 사용 가능한 커넥터 목록은 Openflow 커넥터를 참고해요.

네트워킹 고려 사항: Openflow EKS에서 원본 시스템까지

BYOC 배포의 경우 다음 사항에 유의해요.

• Openflow CloudFormation 스택은 두 개의 공용 서브넷과 두 개의 프라이빗 서브넷을 가진 VPC 하나를 만들어요.
• 공용 서브넷은 나중에 생성되는 AWS Network Load Balancer를 호스팅해요. 프라이빗 서브넷은 EKS 클러스터와 노드 그룹을 지원하는 모든 EC2 인스턴스를 호스팅해요. Openflow 런타임은 Private subnet 1 내에서 실행돼요.
• NAT Gateway는 현재 DPA와 EKS 둘 다의 아웃바운드 경로예요. DPA와 EKS 모두 설치의 Private subnet 1에서 실행돼요.

BYO-VPC 배포의 경우 다음 사항에 유의해요.

• Openflow는 Openflow를 실행할 두 프라이빗 서브넷과 AWS Load Balancer용 두 공용 서브넷을 입력해야 해요.
• 그 프라이빗 서브넷에서 인터넷으로의 자체 아웃바운드 라우팅을 제공해야 하며, 이는 중앙 NAT Gateway일 수 있어요.
• Openflow는 인터넷 게이트웨이를 만들지 않아요. 적절한 공용 인터넷 아웃바운드 라우팅을 직접 제공해야 해요.

네트워크 연결은 일반적으로 다음과 같아요.

• Openflow EC2 인스턴스(에이전트 또는 EKS)는 프라이빗 서브넷에서 실행되며, 아웃바운드 트래픽을 Transit Gateway, PrivateLink VPC 엔드포인트 또는 인터넷 게이트웨이에 연결된 NAT Gateway로 보내는 라우팅 테이블 항목이 필요해요.

예시: 새 VPC를 가진 BYOC 배포가 같은 계정의 다른 VPC에 있는 RDS와 통신

Openflow EKS 클러스터와 RDS 인스턴스 간의 통신을 활성화하려면 새 보안 그룹을 만들되, RDS 연결 인바운드 규칙의 소스로 EKS 클러스터 보안 그룹을 지정하고 그 그룹을 RDS에 연결해야 해요.

1. EKS 클러스터 보안 그룹을 찾으려면 EKS로 이동해 배포 키를 찾아요. Openflow UI에서도 다음 단계로 찾을 수 있어요.
   • Openflow에 로그인해요.
   • Deployments 탭으로 이동해요.
   • 배포 옆의 More options 아이콘을 선택해요.
   • View details를 선택해요. Key 필드의 값이 배포 키예요.
2. 배포 키를 찾은 후 그 키 값으로 AWS 리소스를 필터링할 수 있어요.
3. 관련 데이터베이스 포트를 사용해 Openflow EKS 클러스터의 접근을 허용하는 새 보안 그룹을 만들어요. PostgreSQL의 기본 포트는 5432예요.
4. RDS에 새 보안 그룹으로 연결해요.

문제 해결이 필요하다면 Reachability Analyzer가 유용해요. AWS 플랫폼 내의 추적 기능을 사용해 연결을 차단하는 요인이 무엇인지에 대한 자세한 정보를 제공해요.

VPC 피어링으로 DB 인스턴스에 접근하고 관련 보안 그룹을 구성하는 방법은 다음 AWS 문서를 참고해요.

• VPC에서 DB 인스턴스에 접근하는 시나리오 - Amazon Relational Database Service
• 피어 보안 그룹을 참조하도록 보안 그룹 업데이트 - Amazon Virtual Private Cloud

AWS에서 PrivateLink 구성

이 섹션은 프라이빗 연결을 사용해 Openflow에 접근하고 구성하는 방법을 설명해요.

PrivateLink로 Openflow 접근

1. 프라이빗 링크 구성 전에 AWS PrivateLink와 Snowflake에 설명된 대로 계정에 PrivateLink를 활성화해요.
2. ACCOUNTADMIN 역할로 Snowflake 계정에서 SYSTEM$GET_PRIVATELINK_CONFIG 함수를 호출하고 openflow-privatelink-url 값을 식별해요. 이것이 PrivateLink로 Openflow에 접근하는 URL이에요.
3. DNS에 CNAME 레코드를 만들어 URL 값을 VPC 엔드포인트로 해석되게 해요.
4. DNS 설정이 값을 해석할 수 있는지 확인해요.
5. 브라우저에서 이 URL로 Openflow UI에 연결할 수 있는지 확인해요.

PrivateLink를 사용한 새 배포 구성

참고: Snowflake는 CloudFormation 템플릿을 적용하기 전에 Openflow 배포의 Bring your own VPC 버전을 사용하고 VPC에 VPC 엔드포인트를 만들 것을 권장해요.

PrivateLink 구성 전에 AWS PrivateLink와 Snowflake에 설명된 대로 계정에 PrivateLink가 활성화되어 있는지 확인해요.

다음 단계를 수행해요.

1. Snowflake의 VPC 엔드포인트 서비스 ID와 Openflow PrivateLink URL을 검색해요.
   • ACCOUNTADMIN 역할로 다음 SQL 명령을 실행해요.

SELECT SYSTEM$GET_PRIVATELINK_CONFIG()

• 출력에서 다음 키의 값을 식별하고 저장해요.
  • privatelink-vpce-id
  • openflow-privatelink-url
  • external-telemetry-privatelink-url

2. VPC 엔드포인트를 다음 매개변수로 만들어요.

   • 유형(Type): PrivateLink Ready partner services
   • 서비스(Service): 이전 단계에서 얻은 privatelink-vpce-id 값
   • VPC: Openflow 배포가 실행될 VPC
   • 서브넷(Subnets): Openflow 배포가 실행될 두 가용 영역과 프라이빗 서브넷을 선택해요.

3. Route 53 프라이빗 호스팅 영역을 다음 매개변수로 설정해요.

   • 도메인(Domain): privatelink.snowflakecomputing.com
   • 유형(Type): Private hosted zone
   • Openflow 배포가 실행될 리전과 VPC를 선택해요.

4. 첫 단계에서 식별한 URL에 대한 CNAME 레코드 두 개를 추가해요.

   • openflow-privatelink-url의 경우:
     • 레코드 이름(Record name): 첫 단계에서 얻은 openflow-privatelink-url 값
     • 레코드 유형(Record type): CNAME
     • 값(Value): VPC 엔드포인트의 DNS 이름
   • external-telemetry-privatelink-url의 경우:
     • 레코드 이름(Record name): 첫 단계에서 얻은 external-telemetry-privatelink-url 값
     • 레코드 유형(Record type): CNAME
     • 값(Value): VPC 엔드포인트의 DNS 이름

5. 배포용 전용 보안 그룹을 만들고 보안 그룹에서 VPC 엔드포인트로의 트래픽을 활성화해요.

   • VPC 엔드포인트와 연결된 보안 그룹을 엽니다.
   • 배포용으로 만든 보안 그룹에서 오는 All traffic을 허용하는 인바운드 규칙을 보안 그룹에 추가해요.

6. 새 배포를 만들고 Openflow 배포 만들기 섹션의 지침에 따라 CloudFormation 스택을 적용하면서 다음을 확인해요.

   • PrivateLink 옵션이 활성화되어 있어요. End user authentication over PrivateLink 옵션은 활성화하거나 비활성화할 수 있어요.
   • CloudFormation 스택을 만들 때 배포용으로 만든 보안 그룹이 사용돼요.

7. 배포용 EKS 클러스터가 생성될 때까지 기다려요. 성공적 생성 확인을 위해 AWS 콘솔의 Elastic Kubernetes Service로 이동합니다. <deployment-key>로 식별되는 클러스터가 상태 ACTIVE를 표시하는지 확인해요.

8. EKS에서 VPC 엔드포인트로의 트래픽을 허용해요.

   • VPC 엔드포인트와 연결된 보안 그룹을 엽니다.
   • EKS 클러스터에 할당된 보안 그룹에서 오는 All traffic을 허용하는 인바운드 규칙을 추가해요. EKS 클러스터의 보안 그룹은 eks-cluster-sg-<deployment-key>-로 시작해요.

AWS에서 S3용 VPC 게이트웨이 엔드포인트 구성

S3용 AWS VPC 게이트웨이 엔드포인트를 구성하는 것은 프라이빗 서브넷의 에이전트 EC2 인스턴스가 인터넷 게이트웨이, NAT 게이트웨이 또는 인스턴스의 공용 IP 없이 Amazon Linux 2023 리포지토리에 프라이빗하게 접근하도록 허용하는 기본 방법이에요. 에이전트 EC2 인스턴스는 이 리포지토리를 사용해 Docker 같은 의존성을 설치해요.

S3용 VPC 게이트웨이 엔드포인트를 구성하려면:

1. 브라우저에서 AWS VPC 대시보드를 엽니다.
2. 탐색 창에서 Endpoints를 선택해요.
3. Create endpoint를 클릭하고 다음 매개변수로 새 VPC 엔드포인트를 만들어요.
   • 유형(Type): AWS services
   • 서비스(Service): Gateway 유형의 com.amazonaws.<your-region>.s3
   • VPC: 배포의 VPC를 선택해요.
   • 라우팅 테이블(Route tables): 프라이빗 서브넷과 연결된 라우팅 테이블을 선택해요.
   • 정책(Policy): Full access를 선택해요.

프라이빗 배포 구성

프라이빗 배포는 공용 인터넷 인그레스나 아웃바운드 없이 VPC 안에서 Openflow를 배포할 수 있게 하는 기능이에요.

중요: 프라이빗 배포는 사용자 지정 인그레스를 사용해야 해요. Snowflake 관리 인그레스는 BYO-VPC(기존 VPC) 사전 요구 사항에 설명된 대로 snowflake-customer.app 하위 도메인의 DNS 해석과 Let's Encrypt ACME API로의 HTTPS 아웃바운드가 필요해요. 이 연결 없이 Snowflake 관리 인그레스를 사용하는 배포는 TLS 인증서를 발급하거나 갱신할 수 없고 업그레이드가 실패할 수 있어요.

프라이빗 배포를 구성하려면 새 배포를 만들 때 다음 옵션을 선택해야 해요.

1. Deployment location 단계에서 배포 위치로 Amazon Web Services를 선택해요.
2. VPC Configuration 단계에서 기존 VPC를 사용하려면 Bring your own VPC를 선택해요.
3. PrivateLink 단계에서 PrivateLink 기능을 활성화해요. 이 옵션을 활성화하려면 AWS 계정에 추가 설정이 필요해요. AWS에서 PrivateLink 구성을 참고해요. End user authentication over PrivateLink 옵션은 활성화하거나 비활성화할 수 있어요.
4. Custom ingress 단계에서 사용자 지정 인그레스 기능을 활성화해요. 이 옵션을 활성화하려면 AWS 계정에 추가 설정이 필요해요. 자세한 내용은 Openflow BYOC - 사용자 지정 인그레스 설정을 참고해요.

프라이빗 배포는 기존 VPC가 다음 도메인에 접근할 수 있어야 해요.

• *.amazonaws.com — 접근되는 서비스의 세부 목록은 다음과 같아요.
  • com.amazonaws.iam
  • com.amazonaws.<your-region>.s3
  • com.amazonaws.<your-region>.ec2
  • com.amazonaws.<your-region>.ecr.api
  • com.amazonaws.<your-region>.ecr.dkr
  • com.amazonaws.<your-region>.secretsmanager
  • com.amazonaws.<your-region>.sts
  • com.amazonaws.<your-region>.eks
  • com.amazonaws.<your-region>.autoscaling
• *.privatelink.snowflakecomputing.com
• oidc-eks.<your-region>.api.aws
• shield.us-east-1.amazonaws.com

BYOC 배포 사용자 지정 및 태깅 동작

Openflow BYOC는 생성된 CloudFormation 템플릿과 Openflow 배포 에이전트를 사용해 AWS 인프라를 만들고 관리해요. 일부 AWS 리소스 이름과 구성 선택은 배포가 일관되게 설치·업그레이드·운영되도록 Openflow가 제어해요.

컨테이너 이미지 소스

설치 과정의 일부로 Openflow 배포 에이전트는 Snowflake System Image Registry로 인증해 Openflow 컨테이너 이미지를 얻고, 모든 워크로드 이미지를 Snowflake 관리 리포지토리에서 가져오도록 클러스터를 구성해요. 고객 소유 AWS ECR 리포지토리에서 Openflow 이미지를 가져오는 것은 지원되지 않아요. AWS PrivateLink를 통해 Snowflake 이미지 레지스트리에 접근할 수는 있지만, 레지스트리 자체는 항상 Snowflake System Image Registry예요.

EKS 클러스터 이름 지정

Openflow는 생성된 배포 키를 BYOC 배포용으로 생성된 AWS 리소스의 안정적 식별자로 사용해요. EKS 클러스터 이름과 VPC, IAM 역할, Terraform 상태 S3 버킷, 노드 그룹 같은 관련 AWS 리소스 이름이 이 배포 키에서 파생돼요. EKS 클러스터 이름은 배포 생성 중에는 구성할 수 없어요.

AWS 리소스 태깅

Openflow BYOC를 배포할 때 AWS CloudFormation 스택 태그를 적용할 수 있어요. 이 태그는 비용 할당, 소유권 추적, 인벤토리, 거버넌스, 규정 준수 워크플로를 지원할 수 있어요.

Openflow는 CloudFormation 스택 태그를 BYOC 배포를 위해 생성된 AWS 수준 리소스로 전파해요, 다음 리소스를 포함해요.

• 배포 S3 버킷
• Openflow 에이전트 EC2 인스턴스
• EKS 워커 EC2 인스턴스
• EKS 클러스터
• EBS 볼륨
• Auto Scaling 그룹
• 로드 밸런서
• 배포의 일부로 생성된 기타 AWS 인프라 리소스

CloudFormation 스택 태그는 EKS 클러스터 내부의 Kubernetes 수준 객체(네임스페이스, 파드, 서비스, 배포, StatefulSet, ConfigMap, 시크릿, 서비스 계정, 영구 볼륨 클레임)에는 적용되지 않아요.

조직이 규정 준수, 인벤토리 또는 정책 시행을 위해 Kubernetes 수준 레이블이나 어노테이션을 요구한다면, Openflow BYOC를 배포하기 전에 AWS 수준 태깅이 제어 요구 사항을 충족하는지 검증해요. Kubernetes 수준 태깅 사용자 지정은 현재 지원되지 않아요.

설치 과정

CloudFormation 스택과 Openflow 에이전트 사이에는 BYOC 배포 설치 과정이 관리하는 여러 조정 단계가 있어요. 목표는 조직이 BYOC 배포에 입력을 쉽게 제공할 수 있게 하는 콜드 스타트(CloudFormation으로 해결)와 시간이 지나며 변경되어야 하는 배포와 핵심 소프트웨어 구성 요소의 구성(Openflow 에이전트로 해결) 사이의 책임을 분리하는 것이에요.

배포 에이전트는 Openflow 배포 인프라 생성을 지원하고 배포 서비스를 포함한 배포 소프트웨어 구성 요소 설치를 진행해요. 배포 에이전트는 Snowflake System Image Registry로 인증해 Openflow 컨테이너 이미지를 얻어요.

단계는 다음과 같아요.

참고: BYO-VPC를 사용할 때 템플릿에서 VPC ID와 두 프라이빗 서브넷 ID를 선택하며, CloudFormation 스택은 1a, 1b, 1c 단계에서 언급된 리소스를 만들지 않고 선택된 것을 사용해요.

CloudFormation 템플릿은 다음을 만들고 구성된 AWS 권한에 언급된 AWS 권한으로 구성해요:

• 두 개의 공용 서브넷과 두 개의 프라이빗 서브넷이 있는 VPC 하나. 공용 서브넷은 AWS Network Load Balancer(나중에 생성)를 호스팅해요. 프라이빗 서브넷은 EKS 클러스터와 NodeGroup을 지원하는 모든 EC2 인스턴스를 호스팅해요. Openflow 런타임은 프라이빗 서브넷 내에서 실행돼요.
• VPC 아웃바운드를 위한 인터넷 게이트웨이(Internet Gateway)
• 프라이빗 서브넷 아웃바운드를 위한 NAT 게이트웨이
• 사용자가 입력한 OIDC 구성용 AWS Secrets Manager 항목
• Openflow 에이전트가 EC2 인스턴스에서 사용할 IAM 역할과 인스턴스 프로파일
• 초기화 과정을 자동으로 실행하는 UserData 스크립트가 포함된 Openflow 배포 에이전트용 EC2 인스턴스. 이 스크립트는 입력 CloudFormation 매개변수에서 파생된 Openflow 배포 에이전트가 사용할 환경 변수를 설정해요.
• 필요할 때 Openflow 배포 에이전트가 배포를 업그레이드할 수 있는 EC2 Instance Connect 엔드포인트
  • BYO-VPC 사용 시 기본적으로 CloudFormation 스택은 EC2 Instance Connect 엔드포인트를 만들어요. 다만 이 기본 동작은 수정될 수 있어요. 관리형 VPC 옵션 사용 시 CloudFormation 스택은 항상 EC2 Instance Connect 엔드포인트를 만들어요.
  • Instance Connect 엔드포인트는 많은 VPC에서 공유될 수 있어요.
  • 배포가 삭제되면 CloudFormation 스택 삭제와 함께 엔드포인트도 제거돼요. 엔드포인트가 공유된다면 다른 BYO-VPC 에이전트의 접근을 차단할 수 있어요.
  • EC2 Instance Connect 엔드포인트를 추가하려면 AWS 계정에서 다음 단계를 수행해요.
    1. 왼쪽 탐색에서 VPC » Endpoints로 이동해요.
    2. Create Endpoint를 선택해요.
    3. 엔드포인트 유형으로 EC2 Instance Connect Endpoint를 선택해요.
    4. VPC를 선택해요. 기본 VPC 보안 그룹을 사용하려면 모든 보안 그룹을 비우세요(선택 안 함).
    5. 서브넷 선택 시 CloudFormation 매개변수의 Private Subnet 1과 같은 값을 사용해요.
    6. Create를 선택해요. 엔드포인트가 생성되는 데 약 5분 걸려요.
• Openflow 에이전트의 Terraform 상태, 로그, 출력을 저장하는 S3 버킷

Openflow 배포 에이전트는 다음을 만들어요:

• EKS 클러스터, 다음을 포함:
  • 노드 그룹(Node groups)
  • 오토스케일링 그룹(Autoscaling groups)
  • AWS VPC Container Network Interface(CNI) 애드온
  • Amazon Elastic Block Store(EBS) CSI 애드온
• PostgreSQL, OAuth 자격 증명 등의 Secrets Manager 레코드
• 다양한 K8s 서비스 계정이 AWS Secrets Manager에서 시크릿을 검색할 IAM 정책과 역할
• K8s 구성 요소
  • 네임스페이스
  • 클러스터 오토스케일러(Cluster autoscaler)
  • EBS CSI 확장 가능 스토리지
  • 공개적으로 접근 가능한 Network Load Balancer를 만드는 AWS Load Balancer Controller
  • Let's Encrypt 인증서 발급자
  • Let's Encrypt용으로 구성된 Nginx Ingress
  • 메트릭 서버(Metrics Server)
  • Jetstack의 인증서 관리자(Certificate manager)
  • 외부 시크릿 연산자(External secrets operator)
  • Temporal, 배포 서비스, OIDC용 서비스 계정
  • Temporal, 배포 서비스, OIDC용 시크릿 저장소
  • Temporal과 배포 서비스용 외부 시크릿. OIDC용 외부 시크릿은 런타임 연산자가 만들고 관리해요.
  • PostgreSQL
  • Temporal
  • 런타임 노드 간 통신용 자체 서명 인증서 발급자와 인그레스 구성
  • Openflow 런타임 연산자
  • Openflow 배포 서비스

기본적으로 모든 AWS 계정은 공용(IPv4) 인터넷 주소가 부족한 공용 리소스이기 때문에 리전당 다섯 개의 Elastic IP 주소 할당량을 가져요. Snowflake는 Elastic IP 주소를 주로 인스턴스 실패 시 주소를 다른 인스턴스로 다시 매핑하는 능력으로 사용하고, 다른 모든 노드 간 통신에는 DNS 호스트 이름을 사용할 것을 강력히 권장해요.

설치 진행 추적

CloudFormation 스택이 CREATE_COMPLETE 상태로 전환된 후, Openflow 에이전트가 나머지 인프라를 자동으로 만들어요.

각각 10~15분이 걸릴 수 있는 단계가 몇 가지 있어요, 예를 들어:

• EKS 클러스터 생성
• EKS 클러스터에 EBS CSI 애드온 설치
• RDS PostgreSQL 데이터베이스 생성

Openflow 에이전트에 대한 상태 보고는 아직 제공되지 않아요. 그동안 Openflow 에이전트의 로그를 보고 BYOC 배포가 런타임 준비가 되었는지 확인할 수 있어요. 이를 위해 다음 단계를 수행해요.

1. EC2 인스턴스 목록에서 다음 두 인스턴스를 찾아요.
   • openflow-agent-{data-plane-key}: 이는 런타임을 관리하는 데 사용할 Openflow 에이전트예요.
   • {data-plane-key}-mgmt-group: 이는 연산자와 기타 핵심 소프트웨어를 실행하는 BYOC 배포 EKS 클러스터의 노드예요.
2. openflow-agent-{data-plane-key} 인스턴스를 마우스 오른쪽 클릭하고 Connect를 선택해요.
3. EC2 Instance Connect에서 Connect using EC2 Instance Connect Endpoint로 전환해요. 기본 EC2 Instance Connect Endpoint를 그대로 둬요.
4. Connect를 클릭해요. 명령줄 인터페이스가 있는 새 브라우저 탭 또는 창이 나타나요.
5. 다음 명령을 실행해 배포를 구성하는 docker 이미지의 설치 로그를 tail 해요.

journalctl -xe -f -n 100 -u docker

6. 설치가 완료되면 다음 출력이 보여요.

{timestamp} - app stack applied successfully
{timestamp} - All resources applied successfully

구성된 AWS 권한

이 섹션은 Openflow BYOC 스택이 역할에 따라 구성하는 AWS 권한을 나열해요.

참고: {key}는 특정 배포에 대해 Openflow가 만들고 관리하는 클라우드 리소스를 고유하게 식별하는 배포 키를 나타내요.

관리 사용자 (Administrative user)

cloudformation 및 아래의 모든 권한.

IAM 역할: openflow-agent-role-{key}

이 역할은 인스턴스 프로파일 OpenflowAgentEC2InstanceProfile-{key}를 통해 Openflow 배포 에이전트 EC2 인스턴스가 수임해요. 다음 Openflow 관리 정책이 이 역할에 연결돼요.

Openflow 관리 정책: openflow-agent-ec2-policy-{key}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "ec2:CreateSecurityGroup",
        "ec2:AuthorizeSecurityGroupIngress",
        "ec2:AuthorizeSecurityGroupEgress",
        "ec2:RevokeSecurityGroupIngress",
        "ec2:RevokeSecurityGroupEgress",
        "ec2:DeleteSecurityGroup"
      ],
      "Condition": {
        "StringLike": {
          "aws:ResourceTag/Name": [
            "{key}-*",
            "k8s-traffic-{key}-*",
            "eks-cluster-sg-{key}-*"
          ]
        }
      },
      "Resource": "arn:aws:ec2:{Region}:{Account_ID}:security-group/*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "ec2:CreateLaunchTemplateVersion",
        "ec2:ModifyLaunchTemplate"
      ],
      "Condition": {
        "StringLike": {
          "aws:ResourceTag/Name": "{key}-*-group"
        }
      },
      "Resource": [
        "arn:aws:ec2:{Region}:{Account_ID}:launch-template/*"
      ]
    }
  ]
}

Openflow 관리 정책: openflow-agent-eks-policy-{key}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "eks:ListTagsForResource",
        "eks:TagResource",
        "eks:UntagResource",
        "eks:UpdateClusterVersion",
        "eks:UpdateNodegroupVersion"
      ],
      "Resource": [
        "arn:aws:eks:{Region}:{Account_ID}:cluster/{key}",
        "arn:aws:eks:{Region}:{Account_ID}:nodegroup/{key}/*",
        "arn:aws:eks:{Region}:{Account_ID}:addon/{key}/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "eks:DescribeAddonVersions"
      ],
      "Resource": "*"
    }
  ]
}

Openflow 관리 정책: openflow-agent-iam-policy-{key}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "iam:TagRole",
        "iam:UntagRole"
      ],
      "Resource": [
        "arn:aws:iam::{Account_ID}:role/{key}-*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "iam:ListOpenIDConnectProviderTags",
        "iam:TagOpenIDConnectProvider",
        "iam:UntagOpenIDConnectProvider"
      ],
      "Resource": "arn:aws:iam::{Account_ID}:oidc-provider/oidc.eks.{Region}.amazonaws.com/id/*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "iam:CreatePolicy",
        "iam:DeletePolicy",
        "iam:DeletePolicyVersion",
        "iam:GetPolicy",
        "iam:GetPolicyVersion",
        "iam:ListPolicyVersions",
        "iam:CreatePolicyVersion",
        "iam:TagPolicy",
        "iam:UntagPolicy"
      ],
      "Resource": [
        "arn:aws:iam::{Account_ID}:policy/*-role-policy-{key}"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "iam:AttachRolePolicy",
        "iam:CreateRole",
        "iam:UpdateRole",
        "iam:DeleteRole",
        "iam:DeleteRolePolicy",
        "iam:DetachRolePolicy",
        "iam:GetRolePolicy",
        "iam:ListAttachedRolePolicies",
        "iam:ListInstanceProfilesForRole",
        "iam:ListRolePolicies",
        "iam:PutRolePolicy",
        "iam:TagRole",
        "iam:UntagRole",
        "iam:UpdateAssumeRolePolicy"
      ],
      "Resource": [
        "arn:aws:iam::{Account_ID}:role/*-role-{key}",
        "arn:aws:iam::{Account_ID}:role/{key}-*"
      ]
    }
  ]
}

Openflow 관리 정책: openflow-agent-misc-policy-{key}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "secretsmanager:TagResource",
        "secretsmanager:UntagResource"
      ],
      "Resource": "arn:aws:secretsmanager:{Region}:{Account_ID}:secret:*-{key}*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "ssm:GetParameter"
      ],
      "Resource": [
        "arn:aws:ssm:{Region}::parameter/aws/service/eks/optimized-ami/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "elasticloadbalancing:DeleteTargetGroup"
      ],
      "Condition": {
        "StringEquals": {
          "aws:ResourceTag/elbv2.k8s.aws/cluster": "{key}"
        }
      },
      "Resource": "arn:aws:elasticloadbalancing:{Region}:{Account_ID}:targetgroup/*/*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "elasticloadbalancing:DescribeListeners",
        "elasticloadbalancing:DescribeLoadBalancers",
        "elasticloadbalancing:DescribeTags",
        "elasticloadbalancing:DescribeTargetGroups"
      ],
      "Resource": "*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "elasticloadbalancing:DeleteLoadBalancer",
        "elasticloadbalancing:SetSecurityGroups"
      ],
      "Resource": "arn:aws:elasticloadbalancing:{Region}:{Account_ID}:loadbalancer/net/runtime-ingress-{key}*"
    }
  ]
}

역할에는 다음 인라인 정책도 연결돼요.

인라인 정책: managed-policy-creation-permission

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "iam:CreatePolicy",
        "iam:DeletePolicy",
        "iam:DeletePolicyVersion",
        "iam:GetPolicy",
        "iam:GetPolicyVersion",
        "iam:ListPolicyVersions",
        "iam:CreatePolicyVersion",
        "iam:TagPolicy",
        "iam:UntagPolicy"
      ],
      "Resource": [
        "arn:aws:iam::{Account_ID}:policy/openflow-agent-ec2-policy-{key}",
        "arn:aws:iam::{Account_ID}:policy/openflow-agent-iam-policy-{key}",
        "arn:aws:iam::{Account_ID}:policy/openflow-agent-eks-policy-{key}",
        "arn:aws:iam::{Account_ID}:policy/openflow-agent-misc-policy-{key}"
      ]
    }
  ]
}

인라인 정책: OpenflowAgentPolicy

{
   "Version": "2012-10-17",
   "Statement": [
      {
            "Action": [
               "autoscaling:DescribeTags",
               "ec2:DescribeImages",
               "ec2:DescribeInstances",
               "ec2:DescribeLaunchTemplates",
               "ec2:DescribeLaunchTemplateVersions",
               "ec2:DescribeNetworkInterfaces",
               "ec2:DescribeSecurityGroups",
               "ec2:DescribeSubnets",
               "ec2:DescribeTags",
               "ec2:DescribeVolumes",
               "ec2:DescribeVpcs",
               "ec2:DescribeVpcAttribute",
               "iam:GetRole",
               "iam:GetOpenIDConnectProvider",
               "ec2:RunInstances",
               "ec2:CreateLaunchTemplate",
               "ec2:CreateSecurityGroup",
               "ec2:CreateTags",
               "ec2:DeleteTags"
            ],
            "Resource": "*",
            "Effect": "Allow"
      },
      {
            "Condition": {
               "StringLike": {
                  "aws:ResourceTag/Name": [
                        "{key}-oidc-provider"
                  ]
               }
            },
            "Action": [
               "iam:CreateOpenIDConnectProvider",
               "iam:DeleteOpenIDConnectProvider",
               "iam:TagOpenIDConnectProvider",
               "iam:UpdateOpenIDConnectProviderThumbprint"
            ],
            "Resource": "arn:aws:iam::{Account_ID}:oidc-provider/oidc.eks.{Region}.amazonaws.com/id/*",
            "Effect": "Allow"
      },
      {
            "Action": [
               "iam:CreatePolicy",
               "iam:DeletePolicy",
               "iam:DeletePolicyVersion",
               "iam:GetPolicy",
               "iam:GetPolicyVersion",
               "iam:ListPolicyVersions",
               "iam:CreatePolicyVersion",
               "iam:TagPolicy",
               "iam:UntagPolicy"
            ],
            "Resource": [
               "arn:aws:iam::{Account_ID}:policy/dp-service-role-policy-{key}",
               "arn:aws:iam::{Account_ID}:policy/oauth2-role-policy-{key}",
               "arn:aws:iam::{Account_ID}:policy/temporal-service-role-policy-{key}",
               "arn:aws:iam::{Account_ID}:policy/oidc-service-role-policy-{key}",
               "arn:aws:iam::{Account_ID}:policy/dps-temporal-role-policy-{key}",
               "arn:aws:iam::{Account_ID}:policy/dps-postgres-role-policy-{key}",
               "arn:aws:iam::{Account_ID}:policy/token-refresh-role-policy-{key}"
            ],
            "Effect": "Allow"
      },
      {
            "Action": [
               "iam:AttachRolePolicy",
               "iam:CreateRole",
               "iam:UpdateRole",
               "iam:DeleteRole",
               "iam:DeleteRolePolicy",
               "iam:DetachRolePolicy",
               "iam:GetRolePolicy",
               "iam:ListAttachedRolePolicies",
               "iam:ListInstanceProfilesForRole",
               "iam:ListRolePolicies",
               "iam:PutRolePolicy",
               "iam:TagRole",
               "iam:UntagRole",
               "iam:UpdateAssumeRolePolicy"
            ],
            "Resource": [
               "arn:aws:iam::{Account_ID}:role/openflow-agent-role-{key}",
               "arn:aws:iam::{Account_ID}:role/{key}-*",
               "arn:aws:iam::{Account_ID}:role/dps-temporal-role-{key}",
               "arn:aws:iam::{Account_ID}:role/dps-postgres-role-{key}",
               "arn:aws:iam::{Account_ID}:role/dp-service-role-{key}",
               "arn:aws:iam::{Account_ID}:role/oauth2-role-{key}",
               "arn:aws:iam::{Account_ID}:role/oidc-service-role-{key}",
               "arn:aws:iam::{Account_ID}:role/token-refresh-role-{key}"
            ],
            "Effect": "Allow"
      },
      {
            "Action": [
               "autoscaling:CreateOrUpdateTags",
               "autoscaling:DeleteTags"
            ],
            "Resource": "arn:aws:autoscaling:{Region}:{Account_ID}:autoScalingGroup:*:autoScalingGroupName/eks-{key}-*",
            "Effect": "Allow"
      },
      {
            "Condition": {
               "StringLike": {
                  "aws:ResourceTag/Name": [
                        "{key}-EC2SecurityGroup-*",
                        "k8s-traffic-{key}-*",
                        "eks-cluster-sg-{key}-*",
                        "{key}-cluster-sg",
                        "{key}-custom-ingress-default-sg"
                  ]
               }
            },
            "Action": [
               "ec2:AuthorizeSecurityGroupEgress",
               "ec2:AuthorizeSecurityGroupIngress",
               "ec2:RevokeSecurityGroupIngress",
               "ec2:RevokeSecurityGroupEgress",
               "ec2:DeleteSecurityGroup",
               "ec2:CreateTags",
               "ec2:DeleteTags",
               "ec2:CreateNetworkInterface",
               "ec2:DeleteNetworkInterface"
            ],
            "Resource": "arn:aws:ec2:{Region}:{Account_ID}:security-group/*",
            "Effect": "Allow"
      },
      {
            "Condition": {
               "StringLike": {
                  "aws:ResourceTag/elbv2.k8s.aws/cluster": "{key}"
               }
            },
            "Action": [
               "ec2:AuthorizeSecurityGroupEgress",
               "ec2:AuthorizeSecurityGroupIngress",
               "ec2:RevokeSecurityGroupEgress",
               "ec2:DeleteSecurityGroup",
               "ec2:CreateTags",
               "ec2:DeleteTags",
               "ec2:CreateNetworkInterface",
               "ec2:DeleteNetworkInterface"
            ],
            "Resource": "arn:aws:ec2:{Region}:{Account_ID}:security-group/*",
            "Effect": "Allow"
      },
      {
            "Action": [
               "ec2:CreateSecurityGroup"
            ],
            "Resource": "arn:aws:ec2:{Region}:{Account_ID}:vpc/{VPC_ID}",
            "Effect": "Allow"
      },
      {
            "Condition": {
               "StringLike": {
                  "ec2:ResourceTag/Name": "openflow-agent-{key}"
               }
            },
            "Action": [
               "ec2:AttachNetworkInterface"
            ],
            "Resource": "arn:aws:ec2:{Region}:{Account_ID}:instance/*",
            "Effect": "Allow"
      },
      {
            "Condition": {
               "StringLike": {
                  "aws:ResourceTag/Name": "{key}-*-group"
               }
            },
            "Action": [
               "ec2:DeleteLaunchTemplate"
            ],
            "Resource": "arn:aws:ec2:{Region}:{Account_ID}:launch-template/*",
            "Effect": "Allow"
      },
      {
            "Action": [
               "eks:CreateCluster",
               "eks:CreateAccessEntry",
               "eks:CreateAddon",
               "eks:CreateNodegroup",
               "eks:DeleteCluster",
               "eks:DescribeCluster",
               "eks:ListClusters",
               "eks:ListNodeGroups",
               "eks:DescribeUpdate",
               "eks:UpdateClusterConfig",
               "eks:TagResource"
            ],
            "Resource": "arn:aws:eks:{Region}:{Account_ID}:cluster/{key}",
            "Effect": "Allow"
      },
      {
            "Action": [
               "eks:DescribeAddon",
               "eks:DescribeAddonVersions",
               "eks:UpdateAddon",
               "eks:DeleteAddon",
               "eks:DescribeUpdate"
            ],
            "Resource": "arn:aws:eks:{Region}:{Account_ID}:addon/{key}/*",
            "Effect": "Allow"
      },
      {
            "Action": [
               "eks:DeleteNodegroup",
               "eks:DescribeNodegroup",
               "eks:ListNodegroups",
               "eks:UpdateNodegroupConfig",
               "eks:TagResource",
               "eks:DescribeUpdate"
            ],
            "Resource": "arn:aws:eks:{Region}:{Account_ID}:nodegroup/{key}/*",
            "Effect": "Allow"
      },
      {
            "Action": [
               "s3:CreateBucket",
               "s3:ListBucket"
            ],
            "Resource": "arn:aws:s3:::byoc-tf-state-{key}-{Region}",
            "Effect": "Allow"
      },
      {
            "Action": [
               "s3:DeleteObject",
               "s3:GetObject",
               "s3:PutObject"
            ],
            "Resource": "arn:aws:s3:::byoc-tf-state-{key}-{Region}/*",
            "Effect": "Allow"
      },
      {
            "Action": [
               "s3:PutBucketPublicAccessBlock",
               "s3:GetBucketPublicAccessBlock",
               "s3:PutBucketPolicy",
               "s3:GetBucketPolicy",
               "s3:DeleteBucketPolicy",
               "s3:PutEncryptionConfiguration",
               "s3:GetEncryptionConfiguration"
            ],
            "Resource": "arn:aws:s3:::byoc-tf-state-{key}-{Region}",
            "Effect": "Allow"
      },
      {
            "Action": [
               "secretsmanager:CreateSecret",
               "secretsmanager:DeleteSecret",
               "secretsmanager:DescribeSecret",
               "secretsmanager:GetResourcePolicy",
               "secretsmanager:GetSecretValue",
               "secretsmanager:PutSecretValue",
               "secretsmanager:UpdateSecretVersionStage",
               "secretsmanager:TagResource",
               "secretsmanager:UntagResource"
            ],
            "Resource": "arn:aws:secretsmanager:{Region}:{Account_ID}:secret:*-{key}*",
            "Effect": "Allow"
      },
      {
            "Condition": {
               "StringLike": {
                  "iam:AWSServiceName": "eks.amazonaws.com"
               }
            },
            "Action": [
               "iam:CreateServiceLinkedRole"
            ],
            "Resource": "arn:aws:iam::*:role/aws-service-role/eks.amazonaws.com/AWSServiceRoleForAmazonEKS",
            "Effect": "Allow"
      },
      {
            "Condition": {
               "StringLike": {
                  "iam:AWSServiceName": "eks-nodegroup.amazonaws.com"
               }
            },
            "Action": [
               "iam:CreateServiceLinkedRole"
            ],
            "Resource": "arn:aws:iam::*:role/aws-service-role/eks-nodegroup.amazonaws.com/AWSServiceRoleForAmazonEKSNodegroup",
            "Effect": "Allow"
      },
      {
            "Action": [
               "eks:AssociateAccessPolicy",
               "eks:ListAssociatedAccessPolicies",
               "eks:DisassociateAccessPolicy"
            ],
            "Resource": "arn:aws:eks:{Region}:{Account_ID}:access-entry/{key}/*",
            "Effect": "Allow"
      },
      {
            "Action": "iam:PassRole",
            "Resource": "*",
            "Effect": "Allow"
      },
      {
            "Action": [
               "iam:TagRole",
               "iam:UntagRole"
            ],
            "Resource": "arn:aws:iam::{Account_ID}:role/{key}-*",
            "Effect": "Allow"
      },
      {
            "Action": [
               "iam:UntagOpenIDConnectProvider"
            ],
            "Resource": "arn:aws:iam::{Account_ID}:oidc-provider/oidc.eks.{Region}.amazonaws.com/id/*",
            "Effect": "Allow"
      },
      {
            "Action": [
               "eks:TagResource",
               "eks:UntagResource",
               "eks:UpdateNodegroupVersion"
            ],
            "Resource": [
               "arn:aws:eks:{Region}:{Account_ID}:cluster/{key}",
               "arn:aws:eks:{Region}:{Account_ID}:nodegroup/{key}/*",
               "arn:aws:eks:{Region}:{Account_ID}:addon/{key}/*"
            ],
            "Effect": "Allow"
      },
      {
            "Condition": {
               "StringLike": {
                  "aws:ResourceTag/Name": "{key}-*-group"
               }
            },
            "Action": [
               "ec2:CreateLaunchTemplateVersion",
               "ec2:ModifyLaunchTemplate"
            ],
            "Resource": "arn:aws:ec2:{Region}:{Account_ID}:launch-template/*",
            "Effect": "Allow"
      },
      {
            "Action": [
               "ssm:GetParameter"
            ],
            "Resource": "arn:aws:ssm:{Region}::parameter/aws/service/eks/optimized-ami/*",
            "Effect": "Allow"
      }
   ]
}

IAM 역할: {key}-cluster-ServiceRole

AWS 관리 정책:

• AmazonEKSClusterPolicy
• AmazonEKSVPCResourceController

{
   "Version": "2012-10-17",
   "Statement": [
      {
            "Action": [
               "cloudwatch:PutMetricData"
            ],
            "Effect": "Allow",
            "Resource": "*"
      }
   ]
}
{
   "Version": "2012-10-17",
   "Statement": [
      {
            "Action": [
               "ec2:DescribeAccountAttributes",
               "ec2:DescribeAddresses",
               "ec2:DescribeInternetGateways"
            ],
            "Effect": "Allow",
            "Resource": "*"
      }
   ]
}

IAM 역할: {key}-addon-vpc-cni-Role

AWS 관리 정책:

• AmazonEKS_CNI_Policy

IAM 역할: {key}-eks-role

AWS 관리 정책:

• AmazonEBSCSIDriverPolicy
• AmazonEC2ContainerRegistryReadOnly
• AmazonEKS_CNI_Policy
• AmazonEKSWorkerNodePolicy
• AmazonSSMManagedInstanceCore
• AutoScalingFullAccess
• ElasticLoadBalancingFullAccess

{
   "Version": "2012-10-17",
   "Statement": [
      {
            "Action": [
               "ec2:CreateSecurityGroup",
               "ec2:CreateTags"
            ],
            "Effect": "Allow",
            "Resource": [
               "arn:aws:ec2:{Region}:{Account_ID}:security-group/*",
               "arn:aws:ec2:{Region}:{Account_ID}:vpc/{VPC_ID}"
            ],
            "Sid": "CreateOpenflowEKSSecurityGroupAndTags"
      },
      {
            "Action": [
               "ec2:AuthorizeSecurityGroupIngress",
               "ec2:DeleteSecurityGroup"
            ],
            "Condition": {
               "StringLike": {
                  "aws:ResourceTag/Name": "eks-cluster-sg-{key}-*"
               }
            },
            "Effect": "Allow",
            "Resource": [
               "arn:aws:ec2:{Region}:{Account_ID}:security-group/*"
            ],
            "Sid": "OpenflowManageEKSSecurityGroup"
      }
   ]
}

참고: {VPC_ID}는 BYOC가 만들었거나 BYO-VPC가 사용한 VPC의 식별자를 나타내요.

다음 역할은 Kubernetes 서비스 계정이 AWS Secrets Manager에서 시크릿을 읽는 데 사용돼요. 각 역할에는 역할 이름에 -policy 접미사가 붙은 이름과 일치하는 단일 Openflow 관리 정책이 연결돼 있어요(예: oidc-service-role-{key} 역할은 oidc-service-role-policy-{key} 정책을 사용해요).

IAM 역할: oidc-service-role-{key}

Openflow 관리 정책: oidc-service-role-policy-{key}

{
   "Statement": [
      {
            "Action": [
               "secretsmanager:GetSecretValue",
               "secretsmanager:DescribeSecret",
               "secretsmanager:GetResourcePolicy",
               "secretsmanager:ListSecretVersionIds"
            ],
            "Effect": "Allow",
            "Resource": [
               "arn:aws:secretsmanager:{Region}:{Account_ID}:secret:oidc-{key}*"
            ]
      }
   ],
   "Version": "2012-10-17"
}

IAM 역할: dps-postgres-role-{key}

Openflow 관리 정책: dps-postgres-role-policy-{key}

{
   "Statement": [
      {
            "Action": [
               "secretsmanager:GetSecretValue",
               "secretsmanager:DescribeSecret",
               "secretsmanager:GetResourcePolicy",
               "secretsmanager:ListSecretVersionIds"
            ],
            "Effect": "Allow",
            "Resource": [
               "arn:aws:secretsmanager:{Region}:{Account_ID}:secret:postgres_creds-{key}*"
            ]
      }
   ],
   "Version": "2012-10-17"
}

IAM 역할: dps-temporal-role-{key}

Openflow 관리 정책: dps-temporal-role-policy-{key}

{
   "Statement": [
      {
            "Action": [
               "secretsmanager:GetSecretValue",
               "secretsmanager:DescribeSecret",
               "secretsmanager:GetResourcePolicy",
               "secretsmanager:ListSecretVersionIds"
            ],
            "Effect": "Allow",
            "Resource": [
               "arn:aws:secretsmanager:{Region}:{Account_ID}:secret:temporal_creds-{key}*"
            ]
      }
   ],
   "Version": "2012-10-17"
}

IAM 역할: dp-service-role-{key}

Openflow 관리 정책: dp-service-role-policy-{key}

{
   "Statement": [
      {
            "Action": [
               "secretsmanager:GetSecretValue",
               "secretsmanager:DescribeSecret",
               "secretsmanager:GetResourcePolicy",
               "secretsmanager:ListSecretVersionIds"
            ],
            "Effect": "Allow",
            "Resource": [
               "arn:aws:secretsmanager:{Region}:{Account_ID}:secret:dps_creds-{key}*",
               "arn:aws:secretsmanager:{Region}:{Account_ID}:secret:snowflake-oauth2-{key}*"
            ]
      }
   ],
   "Version": "2012-10-17"
}

IAM 역할: oauth2-role-{key}

Openflow 관리 정책: oauth2-role-policy-{key}

{
   "Statement": [
      {
            "Action": [
               "secretsmanager:GetSecretValue",
               "secretsmanager:DescribeSecret",
               "secretsmanager:GetResourcePolicy",
               "secretsmanager:ListSecretVersionIds"
            ],
            "Effect": "Allow",
            "Resource": [
               "arn:aws:secretsmanager:{Region}:{Account_ID}:secret:snowflake-oauth2-{key}*"
            ]
      }
   ],
   "Version": "2012-10-17"
}

IAM 역할: token-refresh-role-{key}

Openflow 관리 정책: token-refresh-role-policy-{key}

{
   "Statement": [
      {
            "Action": [
               "secretsmanager:GetSecretValue",
               "secretsmanager:DescribeSecret",
               "secretsmanager:GetResourcePolicy",
               "secretsmanager:ListSecretVersionIds"
            ],
            "Effect": "Allow",
            "Resource": [
               "arn:aws:secretsmanager:{Region}:{Account_ID}:secret:snowflake-oauth2-{key}*"
            ]
      }
   ],
   "Version": "2012-10-17"
}

IAM 역할: {key}-nodegroup-NodeInstanceRole

AWS 관리 정책:

• AmazonEBSCSIDriverPolicy
• AmazonEC2ContainerRegistryReadOnly
• AmazonEKS_CNI_Policy
• AmazonEKSWorkerNodePolicy
• AmazonSSMManagedInstanceCore
• AutoScalingFullAccess
• ElasticLoadBalancingFullAccess

{
   "Version": "2012-10-17",
   "Statement": [
      {
            "Action": [
               "servicediscovery:CreateService",
               "servicediscovery:DeleteService",
               "servicediscovery:GetService",
               "servicediscovery:GetInstance",
               "servicediscovery:RegisterInstance",
               "servicediscovery:DeregisterInstance",
               "servicediscovery:ListInstances",
               "servicediscovery:ListNamespaces",
               "servicediscovery:ListServices",
               "servicediscovery:GetInstancesHealthStatus",
               "servicediscovery:UpdateInstanceCustomHealthStatus",
               "servicediscovery:GetOperation",
               "route53:GetHealthCheck",
               "route53:CreateHealthCheck",
               "route53:UpdateHealthCheck",
               "route53:ChangeResourceRecordSets",
               "route53:DeleteHealthCheck",
               "appmesh:*"
            ],
            "Effect": "Allow",
            "Resource": "*"
      }
   ]
}
{
   "Version": "2012-10-17",
   "Statement": [
      {
            "Action": [
               "autoscaling:DescribeAutoScalingGroups",
               "autoscaling:DescribeAutoScalingInstances",
               "autoscaling:DescribeLaunchConfigurations",
               "autoscaling:DescribeScalingActivities",
               "autoscaling:DescribeTags",
               "ec2:DescribeInstanceTypes",
               "ec2:DescribeLaunchTemplateVersions"
            ],
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "autoscaling:SetDesiredCapacity",
               "autoscaling:TerminateInstanceInAutoScalingGroup",
               "ec2:DescribeImages",
               "ec2:GetInstanceTypesFromInstanceRequirements",
               "eks:DescribeNodegroup"
            ],
            "Effect": "Allow",
            "Resource": "*"
      }
   ]
}
{
   "Version": "2012-10-17",
   "Statement": [
      {
            "Action": [
               "iam:CreateServiceLinkedRole"
            ],
            "Condition": {
               "StringEquals": {
                  "iam:AWSServiceName": "elasticloadbalancing.amazonaws.com"
               }
            },
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "ec2:DescribeAccountAttributes",
               "ec2:DescribeAddresses",
               "ec2:DescribeAvailabilityZones",
               "ec2:DescribeInternetGateways",
               "ec2:DescribeVpcs",
               "ec2:DescribeVpcPeeringConnections",
               "ec2:DescribeSubnets",
               "ec2:DescribeSecurityGroups",
               "ec2:DescribeInstances",
               "ec2:DescribeNetworkInterfaces",
               "ec2:DescribeTags",
               "ec2:GetCoipPoolUsage",
               "ec2:DescribeCoipPools",
               "elasticloadbalancing:DescribeLoadBalancers",
               "elasticloadbalancing:DescribeLoadBalancerAttributes",
               "elasticloadbalancing:DescribeListeners",
               "elasticloadbalancing:DescribeListenerCertificates",
               "elasticloadbalancing:DescribeSSLPolicies",
               "elasticloadbalancing:DescribeRules",
               "elasticloadbalancing:DescribeTargetGroups",
               "elasticloadbalancing:DescribeTargetGroupAttributes",
               "elasticloadbalancing:DescribeTargetHealth",
               "elasticloadbalancing:DescribeTags"
            ],
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "cognito-idp:DescribeUserPoolClient",
               "acm:ListCertificates",
               "acm:DescribeCertificate",
               "iam:ListServerCertificates",
               "iam:GetServerCertificate",
               "waf-regional:GetWebACL",
               "waf-regional:GetWebACLForResource",
               "waf-regional:AssociateWebACL",
               "waf-regional:DisassociateWebACL",
               "wafv2:GetWebACL",
               "wafv2:GetWebACLForResource",
               "wafv2:AssociateWebACL",
               "wafv2:DisassociateWebACL",
               "shield:GetSubscriptionState",
               "shield:DescribeProtection",
               "shield:CreateProtection",
               "shield:DeleteProtection"
            ],
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "ec2:AuthorizeSecurityGroupIngress",
               "ec2:RevokeSecurityGroupIngress"
            ],
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "ec2:CreateSecurityGroup"
            ],
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "ec2:CreateTags"
            ],
            "Condition": {
               "Null": {
                  "aws:RequestTag/elbv2.k8s.aws/cluster": "false"
               },
               "StringEquals": {
                  "ec2:CreateAction": "CreateSecurityGroup"
               }
            },
            "Effect": "Allow",
            "Resource": "arn:aws:ec2:*:*:security-group/*"
      },
      {
            "Action": [
               "ec2:CreateTags",
               "ec2:DeleteTags"
            ],
            "Condition": {
               "Null": {
                  "aws:RequestTag/elbv2.k8s.aws/cluster": "true",
                  "aws:ResourceTag/elbv2.k8s.aws/cluster": "false"
               }
            },
            "Effect": "Allow",
            "Resource": "arn:aws:ec2:*:*:security-group/*"
      },
      {
            "Action": [
               "ec2:AuthorizeSecurityGroupIngress",
               "ec2:RevokeSecurityGroupIngress",
               "ec2:DeleteSecurityGroup"
            ],
            "Condition": {
               "Null": {
                  "aws:ResourceTag/elbv2.k8s.aws/cluster": "false"
               }
            },
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "elasticloadbalancing:CreateLoadBalancer",
               "elasticloadbalancing:CreateTargetGroup"
            ],
            "Condition": {
               "Null": {
                  "aws:RequestTag/elbv2.k8s.aws/cluster": "false"
               }
            },
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "elasticloadbalancing:CreateListener",
               "elasticloadbalancing:DeleteListener",
               "elasticloadbalancing:CreateRule",
               "elasticloadbalancing:DeleteRule"
            ],
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "elasticloadbalancing:AddTags",
               "elasticloadbalancing:RemoveTags"
            ],
            "Condition": {
               "Null": {
                  "aws:RequestTag/elbv2.k8s.aws/cluster": "true",
                  "aws:ResourceTag/elbv2.k8s.aws/cluster": "false"
               }
            },
            "Effect": "Allow",
            "Resource": [
               "arn:aws:elasticloadbalancing:*:*:targetgroup/*/*",
               "arn:aws:elasticloadbalancing:*:*:loadbalancer/net/*/*",
               "arn:aws:elasticloadbalancing:*:*:loadbalancer/app/*/*"
            ]
      },
      {
            "Action": [
               "elasticloadbalancing:AddTags",
               "elasticloadbalancing:RemoveTags"
            ],
            "Effect": "Allow",
            "Resource": [
               "arn:aws:elasticloadbalancing:*:*:listener/net/*/*/*",
               "arn:aws:elasticloadbalancing:*:*:listener/app/*/*/*",
               "arn:aws:elasticloadbalancing:*:*:listener-rule/net/*/*/*",
               "arn:aws:elasticloadbalancing:*:*:listener-rule/app/*/*/*"
            ]
      },
      {
            "Action": [
               "elasticloadbalancing:ModifyLoadBalancerAttributes",
               "elasticloadbalancing:SetIpAddressType",
               "elasticloadbalancing:SetSecurityGroups",
               "elasticloadbalancing:SetSubnets",
               "elasticloadbalancing:DeleteLoadBalancer",
               "elasticloadbalancing:ModifyTargetGroup",
               "elasticloadbalancing:ModifyTargetGroupAttributes",
               "elasticloadbalancing:DeleteTargetGroup"
            ],
            "Condition": {
               "Null": {
                  "aws:ResourceTag/elbv2.k8s.aws/cluster": "false"
               }
            },
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "elasticloadbalancing:AddTags"
            ],
            "Condition": {
               "Null": {
                  "aws:RequestTag/elbv2.k8s.aws/cluster": "false"
               },
               "StringEquals": {
                  "elasticloadbalancing:CreateAction": [
                        "CreateTargetGroup",
                        "CreateLoadBalancer"
                  ]
               }
            },
            "Effect": "Allow",
            "Resource": [
               "arn:aws:elasticloadbalancing:*:*:targetgroup/*/*",
               "arn:aws:elasticloadbalancing:*:*:loadbalancer/net/*/*",
               "arn:aws:elasticloadbalancing:*:*:loadbalancer/app/*/*"
            ]
      },
      {
            "Action": [
               "elasticloadbalancing:RegisterTargets",
               "elasticloadbalancing:DeregisterTargets"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:elasticloadbalancing:*:*:targetgroup/*/*"
      },
      {
            "Action": [
               "elasticloadbalancing:SetWebAcl",
               "elasticloadbalancing:ModifyListener",
               "elasticloadbalancing:AddListenerCertificates",
               "elasticloadbalancing:RemoveListenerCertificates",
               "elasticloadbalancing:ModifyRule"
            ],
            "Effect": "Allow",
            "Resource": "*"
      }
   ]
}
{
   "Version": "2012-10-17",
   "Statement": [
      {
            "Action": [
               "route53:ChangeResourceRecordSets"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:route53:::hostedzone/*"
      }
   ]
}
{
   "Version": "2012-10-17",
   "Statement": [
      {
            "Action": [
               "route53:GetChange"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:route53:::change/*"
      }
   ]
}
{
   "Version": "2012-10-17",
   "Statement": [
      {
            "Action": [
               "route53:ListResourceRecordSets",
               "route53:ListHostedZonesByName"
            ],
            "Effect": "Allow",
            "Resource": "*"
      }
   ]
}
{
   "Version": "2012-10-17",
   "Statement": [
      {
            "Action": [
               "ec2:CreateSnapshot",
               "ec2:AttachVolume",
               "ec2:DetachVolume",
               "ec2:ModifyVolume",
               "ec2:DescribeAvailabilityZones",
               "ec2:DescribeInstances",
               "ec2:DescribeSnapshots",
               "ec2:DescribeTags",
               "ec2:DescribeVolumes",
               "ec2:DescribeVolumesModifications"
            ],
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "ec2:CreateTags"
            ],
            "Condition": {
               "StringEquals": {
                  "ec2:CreateAction": [
                        "CreateVolume",
                        "CreateSnapshot"
                  ]
               }
            },
            "Effect": "Allow",
            "Resource": [
               "arn:aws:ec2:*:*:volume/*",
               "arn:aws:ec2:*:*:snapshot/*"
            ]
      },
      {
            "Action": [
               "ec2:DeleteTags"
            ],
            "Effect": "Allow",
            "Resource": [
               "arn:aws:ec2:*:*:volume/*",
               "arn:aws:ec2:*:*:snapshot/*"
            ]
      },
      {
            "Action": [
               "ec2:CreateVolume"
            ],
            "Condition": {
               "StringLike": {
                  "aws:RequestTag/ebs.csi.aws.com/cluster": "true"
               }
            },
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "ec2:CreateVolume"
            ],
            "Condition": {
               "StringLike": {
                  "aws:RequestTag/CSIVolumeName": "*"
               }
            },
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "ec2:DeleteVolume"
            ],
            "Condition": {
               "StringLike": {
                  "ec2:ResourceTag/ebs.csi.aws.com/cluster": "true"
               }
            },
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "ec2:DeleteVolume"
            ],
            "Condition": {
               "StringLike": {
                  "ec2:ResourceTag/CSIVolumeName": "*"
               }
            },
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "ec2:DeleteVolume"
            ],
            "Condition": {
               "StringLike": {
                  "ec2:ResourceTag/kubernetes.io/created-for/pvc/name": "*"
               }
            },
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "ec2:DeleteSnapshot"
            ],
            "Condition": {
               "StringLike": {
                  "ec2:ResourceTag/CSIVolumeSnapshotName": "*"
               }
            },
            "Effect": "Allow",
            "Resource": "*"
      },
      {
            "Action": [
               "ec2:DeleteSnapshot"
            ],
            "Condition": {
               "StringLike": {
                  "ec2:ResourceTag/ebs.csi.aws.com/cluster": "true"
               }
            },
            "Effect": "Allow",
            "Resource": "*"
      }
   ]
}
{
   "Version": "2012-10-17",
   "Statement": [
      {
            "Action": [
               "route53:ChangeResourceRecordSets"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:route53:::hostedzone/*"
      }
   ]
}
{
   "Version": "2012-10-17",
   "Statement": [
      {
            "Action": [
               "route53:ListHostedZones",
               "route53:ListResourceRecordSets",
               "route53:ListTagsForResource"
            ],
            "Effect": "Allow",
            "Resource": "*"
      }
   ]
}

더 알아보기 (Learn more)

• Openflow 시작하기
• Openflow 관리하기