> For the complete documentation index, see [llms.txt](/llms.txt)

# GS2-Guard Deploy/CDK 레퍼런스

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




## 엔티티

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

### Namespace

네임스페이스<br>

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

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

#### Request

리소스 생성・갱신 요청

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

#### GetAttr

[!GetAttr](/articles/tech/deploy/#getattr) 태그로 취득 가능한 리소스 생성 결과

| | 타입 | 설명 |
| --- | --- | --- |
| Item | [Namespace](../sdk#namespace) | 생성한 네임스페이스

#### 구현 예제




**GS2-Deploy(YAML)**
```yaml

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

```

**Go**
```go

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

```

**PHP**
```php

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

```

**Java**
```java

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

```

**C#**
```csharp

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

```

**TypeScript**
```typescript

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

```

**Python**
```python

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

블로킹 정책<br>

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

|  | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| passServices | List&lt;string&gt; |  | ✓ |  | 1 ~ 100 items | 액세스 가능한 GS2 서비스 목록<br>이 가드 네임스페이스를 통해 클라이언트가 액세스할 수 있는 GS2 서비스 목록입니다. 이 목록에 포함된 서비스만 블로킹 정책의 보호 대상이 됩니다. 최소 하나 이상의 서비스를 지정해야 합니다. |
| defaultRestriction | 문자열 열거형<br>enum {<br>"Allow",<br>"Deny"<br>}<br> |  |  | "Allow" |  | 제한 방침<br>설정된 감지 규칙 중 어느 것에도 일치하지 않는 요청에 적용되는 기본 동작입니다. "Allow"는 일치하지 않는 모든 트래픽을 허용하고(블록리스트 방식), "Deny"는 일치하지 않는 모든 트래픽을 차단합니다(허용리스트 방식).Allow: 조건에 일치하지 않는 액세스를 허용 / Deny: 조건에 일치하지 않는 액세스를 거부 /  |
| locationDetection | 문자열 열거형<br>enum {<br>"Enable",<br>"Disable"<br>}<br> |  |  | "Disable" |  | 액세스 지역 감지<br>클라이언트의 액세스 지역 국가를 기반으로 한 지리적 제한을 활성화 또는 비활성화합니다. 활성화하면 국가별로 액세스가 필터링됩니다. 구체적인 국가와 허용/거부 동작은 locations 및 locationRestriction 필드에서 설정합니다.Enable: 활성화 / Disable: 비활성화 /  |
| locations | List&lt;string&gt; | {locationDetection} == "Enable" |  | [] | 1 ~ 100 items | 액세스를 감지할 국가 목록<br>지리적 제한 필터링에 사용되는 국가 목록입니다. 각 국가는 ISO 3166-1 alpha-2 국가 코드로 지정합니다. 이 국가들이 허용되는지 거부되는지는 locationRestriction 설정에 따라 결정됩니다. locationDetection이 활성화된 경우에만 적용됩니다.<br>※ locationDetection이(가) "Enable" 이면 활성화 |
| locationRestriction | 문자열 열거형<br>enum {<br>"Allow",<br>"Deny"<br>}<br> | {locationDetection} == "Enable" | ✓※ |  |  | 국가 목록 일치 시 동작<br>locations 목록에 포함된 국가에서 온 요청에 대해 실행할 동작입니다. "Allow"는 목록에 포함된 국가에서의 액세스만 허용하고(허용리스트), "Deny"는 목록에 포함된 국가에서의 액세스를 차단합니다(블록리스트). locationDetection 및 locations 목록과 함께 동작합니다.Allow: 액세스를 허용 / Deny: 액세스를 거부 / <br>※ locationDetection이(가) "Enable" 이면 필수 |
| anonymousIpDetection | 문자열 열거형<br>enum {<br>"Enable",<br>"Disable"<br>}<br> |  |  | "Disable" |  | 익명 IP 서비스 감지<br>Tor 출구 노드나 공개 프록시 등 익명 IP 서비스로부터의 액세스 감지를 활성화 또는 비활성화합니다. 활성화하면 이러한 소스로부터의 요청이 식별되어 평가됩니다.Enable: 활성화 / Disable: 비활성화 /  |
| anonymousIpRestriction | 문자열 열거형<br>enum {<br>"Deny"<br>}<br> | {anonymousIpDetection} == "Enable" |  | "Deny" |  | 익명 IP 감지 시 동작<br>익명 IP 서비스(Tor/공개 프록시)로부터의 액세스가 감지되었을 때 실행할 동작입니다. 현재는 해당 액세스를 차단하는 "Deny"만 지원합니다. anonymousIpDetection이 활성화된 경우에만 적용됩니다.Deny: 액세스를 거부 / <br>※ anonymousIpDetection이(가) "Enable" 이면 활성화 |
| hostingProviderIpDetection | 문자열 열거형<br>enum {<br>"Enable",<br>"Disable"<br>}<br> |  |  | "Disable" |  | 호스팅 서비스 감지<br>공개 VPN 서비스나 렌탈 서버 등 호스팅 제공업체의 IP 주소로부터의 액세스 감지를 활성화 또는 비활성화합니다. 활성화하면 최종 사용자 디바이스가 아닌 클라우드 인프라나 호스팅 서비스에서 발생한 트래픽이 식별되어 평가됩니다.Enable: 활성화 / Disable: 비활성화 /  |
| hostingProviderIpRestriction | 문자열 열거형<br>enum {<br>"Deny"<br>}<br> | {hostingProviderIpDetection} == "Enable" |  | "Deny" |  | 호스팅 서비스 감지 시 동작<br>호스팅 제공업체 IP(공개 VPN/렌탈 서버)로부터의 액세스가 감지되었을 때 실행할 동작입니다. 현재는 해당 액세스를 차단하는 "Deny"만 지원합니다. hostingProviderIpDetection이 활성화된 경우에만 적용됩니다.Deny: 액세스를 거부 / <br>※ hostingProviderIpDetection이(가) "Enable" 이면 활성화 |
| reputationIpDetection | 문자열 열거형<br>enum {<br>"Enable",<br>"Disable"<br>}<br> |  |  | "Disable" |  | 악의적인 액세스 원본 IP 감지<br>알려진 악평을 가진 IP 주소로부터의 액세스 감지를 활성화 또는 비활성화합니다. 활성화하면 봇, DDoS 공격 등 악의적인 활동과 연관된 IP가 식별되어 평가됩니다.Enable: 활성화 / Disable: 비활성화 /  |
| reputationIpRestriction | 문자열 열거형<br>enum {<br>"Deny"<br>}<br> | {reputationIpDetection} == "Enable" |  | "Deny" |  | 악의적인 액세스 원본 IP 감지 시 동작<br>악평을 가진 IP로부터의 액세스가 감지되었을 때 실행할 동작입니다. 현재는 해당 액세스를 차단하는 "Deny"만 지원합니다. reputationIpDetection이 활성화된 경우에만 적용됩니다.Deny: 액세스를 거부 / <br>※ reputationIpDetection이(가) "Enable" 이면 활성화 |
| ipAddressesDetection | 문자열 열거형<br>enum {<br>"Enable",<br>"Disable"<br>}<br> |  |  | "Disable" |  | 액세스 원본 IP 감지<br>커스텀 IP 주소 기반 액세스 필터링을 활성화 또는 비활성화합니다. 활성화하면 ipAddresses 필드에 지정된 커스텀 IP 주소 목록에 대해 요청이 평가됩니다. 허용/거부 동작은 ipAddressRestriction으로 제어됩니다.Enable: 활성화 / Disable: 비활성화 /  |
| ipAddresses | List&lt;string&gt; | {ipAddressesDetection} == "Enable" |  |  | 0 ~ 100 items | IP 주소 범위 목록<br>커스텀 IP 기반 액세스 필터링에 사용되는 CIDR 표기법의 IP 주소 범위 목록입니다. 수신되는 각 요청의 소스 IP가 이 범위들에 대해 평가됩니다. 일치하는 IP가 허용되는지 거부되는지는 ipAddressRestriction으로 제어됩니다. ipAddressesDetection이 활성화된 경우에만 적용됩니다.<br>※ ipAddressesDetection이(가) "Enable" 이면 활성화 |
| ipAddressRestriction | 문자열 열거형<br>enum {<br>"Allow",<br>"Deny"<br>}<br> | {ipAddressesDetection} == "Enable" | ✓※ |  |  | IP 주소 목록 일치 시 동작<br>요청의 소스 IP가 커스텀 IP 주소 목록에 일치했을 때 실행할 동작입니다. "Allow"는 목록에 포함된 IP로부터의 액세스만 허용하고(허용리스트), "Deny"는 목록에 포함된 IP로부터의 액세스를 차단합니다(블록리스트). ipAddressesDetection이 활성화된 경우에만 적용됩니다.Allow: 액세스를 허용 / Deny: 액세스를 거부 / <br>※ ipAddressesDetection이(가) "Enable" 이면 필수 |

---