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 サービスのリストです。このリストに含まれるサービスのみがブロッキングポリシーの保護対象になります。少なくとも1つのサービスを指定する必要があります。

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” であれば必須