GS2-Guard Deploy/CDK 레퍼런스

GS2-Deploy의 스택을 생성할 때 사용하는 템플릿 포맷과, CDK를 이용한 각종 언어의 템플릿 출력 구현 예제

엔티티

Deploy 처리에서 조작 대상이 되는 리소스

Namespace

네임스페이스

네임스페이스는 하나의 프로젝트 내에서 동일한 서비스를 서로 다른 용도로 여러 개 사용하기 위한 엔티티입니다.
GS2의 각 서비스는 네임스페이스 단위로 관리됩니다. 네임스페이스가 다르면 동일한 서비스라도 완전히 독립된 데이터 공간으로 취급됩니다.

따라서 각 서비스를 사용하려면 먼저 네임스페이스를 생성해야 합니다.

Request

리소스 생성·갱신 요청

	타입	필수	값 제한	설명
name	string	✓	~ 128자	네임스페이스 이름 네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다.
description	string		~ 1024자	설명문
blockingPolicy	BlockingPolicyModel	✓		블로킹 정책 GS2 서비스에 대한 액세스를 제어하는 이 네임스페이스의 보안 정책 설정입니다. 액세스 가능한 서비스, 지리적 제한 규칙, 익명 IP 감지, 호스팅 제공업체 IP 감지, 평판 기반 IP 필터링, 커스텀 IP 주소 허용/거부 목록을 정의합니다.

GetAttr

!GetAttr 태그로 취득 가능한 리소스 생성 결과

	타입	설명
Item	Namespace	생성한 네임스페이스

구현 예제

Type: GS2::Guard::Namespace
Properties:
  Name: namespace-0001
  Description: null
  BlockingPolicy:
    PassServices:
    - account
    DefaultRestriction: Deny
    LocationDetection: Disable
    AnonymousIpDetection: Disable
    HostingProviderIpDetection: Disable
    ReputationIpDetection: Disable
    IpAddressesDetection: Enable
    IpAddresses:
    - 192.168.0.0/24
    IpAddressRestriction: Allow

import (
    "github.com/gs2io/gs2-golang-cdk/core"
    "github.com/gs2io/gs2-golang-cdk/guard"
)


SampleStack := core.NewStack()
guard.NewNamespace(
    &SampleStack,
    "namespace-0001",
    guard.BlockingPolicyModel{
        PassServices: []string{
            "account",
        },
        DefaultRestriction: guard.BlockingPolicyModelDefaultRestrictionDeny,
        LocationDetection: guard.BlockingPolicyModelLocationDetectionDisable,
        AnonymousIpDetection: guard.BlockingPolicyModelAnonymousIpDetectionDisable,
        HostingProviderIpDetection: guard.BlockingPolicyModelHostingProviderIpDetectionDisable,
        ReputationIpDetection: guard.BlockingPolicyModelReputationIpDetectionDisable,
        IpAddressesDetection: guard.BlockingPolicyModelIpAddressesDetectionEnable,
        IpAddresses: []string{
            "192.168.0.0/24",
        },
        IpAddressRestriction: guard.BlockingPolicyModelIpAddressRestrictionAllow.Pointer(),
    },
    guard.NamespaceOptions{},
)

println(SampleStack.Yaml())  // Generate Template

class SampleStack extends \Gs2Cdk\Core\Model\Stack
{
    function __construct() {
        parent::__construct();
        new \Gs2Cdk\Guard\Model\Namespace_(
            stack: $this,
            name: "namespace-0001",
            blockingPolicy: new \Gs2Cdk\Guard\Model\BlockingPolicyModel(
                passServices: [
                    "account",
                ],
                defaultRestriction: \Gs2Cdk\Guard\Model\Enums\BlockingPolicyModelDefaultRestriction::DENY,
                locationDetection: \Gs2Cdk\Guard\Model\Enums\BlockingPolicyModelLocationDetection::DISABLE,
                anonymousIpDetection: \Gs2Cdk\Guard\Model\Enums\BlockingPolicyModelAnonymousIpDetection::DISABLE,
                hostingProviderIpDetection: \Gs2Cdk\Guard\Model\Enums\BlockingPolicyModelHostingProviderIpDetection::DISABLE,
                reputationIpDetection: \Gs2Cdk\Guard\Model\Enums\BlockingPolicyModelReputationIpDetection::DISABLE,
                ipAddressesDetection: \Gs2Cdk\Guard\Model\Enums\BlockingPolicyModelIpAddressesDetection::ENABLE,
                options: new \Gs2Cdk\Guard\Model\Options\BlockingPolicyModelOptions(
                    ipAddresses: [
                        "192.168.0.0/24",
                    ],
                    ipAddressRestriction: \Gs2Cdk\Guard\Model\Enums\BlockingPolicyModelIpAddressRestriction::ALLOW
                )
            )
        );
    }
}

print((new SampleStack())->yaml());  // Generate Template

class SampleStack extends io.gs2.cdk.core.model.Stack
{
    public SampleStack() {
        super();
        new io.gs2.cdk.guard.model.Namespace(
                this,
                "namespace-0001",
                new io.gs2.cdk.guard.model.BlockingPolicyModel(
                Arrays.asList(
                    "account"
                ),
                io.gs2.cdk.guard.model.enums.BlockingPolicyModelDefaultRestriction.DENY,
                io.gs2.cdk.guard.model.enums.BlockingPolicyModelLocationDetection.DISABLE,
                io.gs2.cdk.guard.model.enums.BlockingPolicyModelAnonymousIpDetection.DISABLE,
                io.gs2.cdk.guard.model.enums.BlockingPolicyModelHostingProviderIpDetection.DISABLE,
                io.gs2.cdk.guard.model.enums.BlockingPolicyModelReputationIpDetection.DISABLE,
                io.gs2.cdk.guard.model.enums.BlockingPolicyModelIpAddressesDetection.ENABLE,
                new io.gs2.cdk.guard.model.options.BlockingPolicyModelOptions()
                    .withIpAddresses(
                        Arrays.asList(
                            "192.168.0.0/24"
                        )
                    )
                    .withIpAddressRestriction(
                        io.gs2.cdk.guard.model.enums.BlockingPolicyModelIpAddressRestriction.ALLOW
                    )
            )
        );
    }
}

System.out.println(new SampleStack().yaml());  // Generate Template

public class SampleStack : Gs2Cdk.Core.Model.Stack
{
    public SampleStack() {
        new Gs2Cdk.Gs2Guard.Model.Namespace(
            stack: this,
            name: "namespace-0001",
            blockingPolicy: new Gs2Cdk.Gs2Guard.Model.BlockingPolicyModel(
                passServices: new string[]
                {
                    "account"
                },
                defaultRestriction: Gs2Cdk.Gs2Guard.Model.Enums.BlockingPolicyModelDefaultRestriction.Deny,
                locationDetection: Gs2Cdk.Gs2Guard.Model.Enums.BlockingPolicyModelLocationDetection.Disable,
                anonymousIpDetection: Gs2Cdk.Gs2Guard.Model.Enums.BlockingPolicyModelAnonymousIpDetection.Disable,
                hostingProviderIpDetection: Gs2Cdk.Gs2Guard.Model.Enums.BlockingPolicyModelHostingProviderIpDetection.Disable,
                reputationIpDetection: Gs2Cdk.Gs2Guard.Model.Enums.BlockingPolicyModelReputationIpDetection.Disable,
                ipAddressesDetection: Gs2Cdk.Gs2Guard.Model.Enums.BlockingPolicyModelIpAddressesDetection.Enable,
                options: new Gs2Cdk.Gs2Guard.Model.Options.BlockingPolicyModelOptions
                {
                    ipAddresses = new string[]
                    {
                        "192.168.0.0/24"
                    },
                    ipAddressRestriction = Gs2Cdk.Gs2Guard.Model.Enums.BlockingPolicyModelIpAddressRestriction.Allow
                }
            )
        );
    }
}

Debug.Log(new SampleStack().Yaml());  // Generate Template

import core from "@/gs2cdk/core";
import guard from "@/gs2cdk/guard";

class SampleStack extends core.Stack
{
    public constructor() {
        super();
        new guard.model.Namespace(
            this,
            "namespace-0001",
            new guard.model.BlockingPolicyModel(
                [
                    "account",
                ],
                guard.model.BlockingPolicyModelDefaultRestriction.DENY,
                guard.model.BlockingPolicyModelLocationDetection.DISABLE,
                guard.model.BlockingPolicyModelAnonymousIpDetection.DISABLE,
                guard.model.BlockingPolicyModelHostingProviderIpDetection.DISABLE,
                guard.model.BlockingPolicyModelReputationIpDetection.DISABLE,
                guard.model.BlockingPolicyModelIpAddressesDetection.ENABLE,
                {
                    ipAddresses:
                    [
                        "192.168.0.0/24",
                    ],
                    ipAddressRestriction:
                    guard.model.BlockingPolicyModelIpAddressRestriction.ALLOW
                }
            )
        );
    }
}

console.log(new SampleStack().yaml());  // Generate Template

from gs2_cdk import Stack, core, guard

class SampleStack(Stack):

    def __init__(self):
        super().__init__()
        guard.Namespace(
            stack=self,
            name='namespace-0001',
            blocking_policy=guard.BlockingPolicyModel(
            pass_services=[
                'account',
            ],
            default_restriction=guard.BlockingPolicyModelDefaultRestriction.DENY,
            location_detection=guard.BlockingPolicyModelLocationDetection.DISABLE,
            anonymous_ip_detection=guard.BlockingPolicyModelAnonymousIpDetection.DISABLE,
            hosting_provider_ip_detection=guard.BlockingPolicyModelHostingProviderIpDetection.DISABLE,
            reputation_ip_detection=guard.BlockingPolicyModelReputationIpDetection.DISABLE,
            ip_addresses_detection=guard.BlockingPolicyModelIpAddressesDetection.ENABLE,
            options=guard.BlockingPolicyModelOptions(
                ip_addresses=[
                    '192.168.0.0/24',
                ],
                ip_address_restriction=guard.BlockingPolicyModelIpAddressRestriction.ALLOW,
            )
        ),
        )

print(SampleStack().yaml())  # Generate Template

BlockingPolicyModel

블로킹 정책

GS2-Guard 네임스페이스의 포괄적인 액세스 제어 규칙을 정의합니다. 서비스 수준 액세스 제어, 국가별 지리적 제한, 익명 IP 감지(Tor/프록시), 호스팅 제공업체 IP 감지(VPN/렌탈 서버), IP 평판 필터링, 커스텀 IP 주소 허용/거부 목록 등 여러 보안 계층을 결합합니다.

타입

활성화 조건

필수

기본값

값 제한

설명

passServices

List<string>

✓

1 ~ 100 items

액세스 가능한 GS2 서비스 목록

이 가드 네임스페이스를 통해 클라이언트가 액세스할 수 있는 GS2 서비스 목록입니다. 이 목록에 포함된 서비스만 블로킹 정책의 보호 대상이 됩니다. 최소 하나 이상의 서비스를 지정해야 합니다.

defaultRestriction

문자열 열거형
enum {
“Allow”,
“Deny”
}

“Allow”

제한 방침

설정된 감지 규칙 중 어느 것에도 일치하지 않는 요청에 적용되는 기본 동작입니다. “Allow"는 일치하지 않는 모든 트래픽을 허용하고(블록리스트 방식), “Deny"는 일치하지 않는 모든 트래픽을 차단합니다(허용리스트 방식).

정의	설명
Allow	조건에 일치하지 않는 액세스를 허용
Deny	조건에 일치하지 않는 액세스를 거부

locationDetection

문자열 열거형
enum {
“Enable”,
“Disable”
}

“Disable”

액세스 지역 감지

클라이언트의 액세스 지역 국가를 기반으로 한 지리적 제한을 활성화 또는 비활성화합니다. 활성화하면 국가별로 액세스가 필터링됩니다. 구체적인 국가와 허용/거부 동작은 locations 및 locationRestriction 필드에서 설정합니다.

정의	설명
Enable	활성화
Disable	비활성화

locations

List<string>

{locationDetection} == “Enable”

[]

1 ~ 100 items

액세스를 감지할 국가 목록

지리적 제한 필터링에 사용되는 국가 목록입니다. 각 국가는 ISO 3166-1 alpha-2 국가 코드로 지정합니다. 이 국가들이 허용되는지 거부되는지는 locationRestriction 설정에 따라 결정됩니다. locationDetection이 활성화된 경우에만 적용됩니다.

※ locationDetection이(가) “Enable” 이면 활성화

locationRestriction

문자열 열거형
enum {
“Allow”,
“Deny”
}

{locationDetection} == “Enable”

✓※

국가 목록 일치 시 동작

locations 목록에 포함된 국가에서 온 요청에 대해 실행할 동작입니다. “Allow"는 목록에 포함된 국가에서의 액세스만 허용하고(허용리스트), “Deny"는 목록에 포함된 국가에서의 액세스를 차단합니다(블록리스트). locationDetection 및 locations 목록과 함께 동작합니다.

정의	설명
Allow	액세스를 허용
Deny	액세스를 거부

※ locationDetection이(가) “Enable” 이면 필수

anonymousIpDetection

문자열 열거형
enum {
“Enable”,
“Disable”
}

“Disable”

익명 IP 서비스 감지

Tor 출구 노드나 공개 프록시 등 익명 IP 서비스로부터의 액세스 감지를 활성화 또는 비활성화합니다. 활성화하면 이러한 소스로부터의 요청이 식별되어 평가됩니다.

정의	설명
Enable	활성화
Disable	비활성화

anonymousIpRestriction

문자열 열거형
enum {
“Deny”
}

{anonymousIpDetection} == “Enable”

“Deny”

익명 IP 감지 시 동작

익명 IP 서비스(Tor/공개 프록시)로부터의 액세스가 감지되었을 때 실행할 동작입니다. 현재는 해당 액세스를 차단하는 “Deny"만 지원합니다. anonymousIpDetection이 활성화된 경우에만 적용됩니다.

정의	설명
Deny	액세스를 거부

※ anonymousIpDetection이(가) “Enable” 이면 활성화

hostingProviderIpDetection

문자열 열거형
enum {
“Enable”,
“Disable”
}

“Disable”

호스팅 서비스 감지

공개 VPN 서비스나 렌탈 서버 등 호스팅 제공업체의 IP 주소로부터의 액세스 감지를 활성화 또는 비활성화합니다. 활성화하면 최종 사용자 디바이스가 아닌 클라우드 인프라나 호스팅 서비스에서 발생한 트래픽이 식별되어 평가됩니다.

정의	설명
Enable	활성화
Disable	비활성화

hostingProviderIpRestriction

문자열 열거형
enum {
“Deny”
}

{hostingProviderIpDetection} == “Enable”

“Deny”

호스팅 서비스 감지 시 동작

호스팅 제공업체 IP(공개 VPN/렌탈 서버)로부터의 액세스가 감지되었을 때 실행할 동작입니다. 현재는 해당 액세스를 차단하는 “Deny"만 지원합니다. hostingProviderIpDetection이 활성화된 경우에만 적용됩니다.

정의	설명
Deny	액세스를 거부

※ hostingProviderIpDetection이(가) “Enable” 이면 활성화

reputationIpDetection

문자열 열거형
enum {
“Enable”,
“Disable”
}

“Disable”

악의적인 액세스 원본 IP 감지

알려진 악평을 가진 IP 주소로부터의 액세스 감지를 활성화 또는 비활성화합니다. 활성화하면 봇, DDoS 공격 등 악의적인 활동과 연관된 IP가 식별되어 평가됩니다.

정의	설명
Enable	활성화
Disable	비활성화

reputationIpRestriction

문자열 열거형
enum {
“Deny”
}

{reputationIpDetection} == “Enable”

“Deny”

악의적인 액세스 원본 IP 감지 시 동작

악평을 가진 IP로부터의 액세스가 감지되었을 때 실행할 동작입니다. 현재는 해당 액세스를 차단하는 “Deny"만 지원합니다. reputationIpDetection이 활성화된 경우에만 적용됩니다.

정의	설명
Deny	액세스를 거부

※ reputationIpDetection이(가) “Enable” 이면 활성화

ipAddressesDetection

문자열 열거형
enum {
“Enable”,
“Disable”
}

“Disable”

액세스 원본 IP 감지

커스텀 IP 주소 기반 액세스 필터링을 활성화 또는 비활성화합니다. 활성화하면 ipAddresses 필드에 지정된 커스텀 IP 주소 목록에 대해 요청이 평가됩니다. 허용/거부 동작은 ipAddressRestriction으로 제어됩니다.

정의	설명
Enable	활성화
Disable	비활성화

ipAddresses

List<string>

{ipAddressesDetection} == “Enable”

0 ~ 100 items

IP 주소 범위 목록

커스텀 IP 기반 액세스 필터링에 사용되는 CIDR 표기법의 IP 주소 범위 목록입니다. 수신되는 각 요청의 소스 IP가 이 범위들에 대해 평가됩니다. 일치하는 IP가 허용되는지 거부되는지는 ipAddressRestriction으로 제어됩니다. ipAddressesDetection이 활성화된 경우에만 적용됩니다.

※ ipAddressesDetection이(가) “Enable” 이면 활성화

ipAddressRestriction

문자열 열거형
enum {
“Allow”,
“Deny”
}

{ipAddressesDetection} == “Enable”

✓※

IP 주소 목록 일치 시 동작

요청의 소스 IP가 커스텀 IP 주소 목록에 일치했을 때 실행할 동작입니다. “Allow"는 목록에 포함된 IP로부터의 액세스만 허용하고(허용리스트), “Deny"는 목록에 포함된 IP로부터의 액세스를 차단합니다(블록리스트). ipAddressesDetection이 활성화된 경우에만 적용됩니다.

정의	설명
Allow	액세스를 허용
Deny	액세스를 거부

※ ipAddressesDetection이(가) “Enable” 이면 필수