NAV Navbar
Python Java GS2-Formation
 

GS2-Identifier

GS2にアクセスするためのクレデンシャルや権限管理をおこないます。

GS2にアクセスするときにはクレデンシャルを使用してAPIを呼び出します。 その際にはクレデンシャルの所有者であるユーザーに割り当てられたセキュリティポリシーに基づいて処理されます。 複数のセキュリティポリシーをユーザーに割り当てている場合、いずれかのセキュリティポリシーによって操作が許可されていればAPIを利用できます。

GS2-Identifier のデータ構造は以下です。

モデル

User

ユーザ

GS2 の権限情報を持つエンティティです。

パラメータ データ型 必須 説明
userId string true ユーザ
ownerId string true オーナーID
name string true ユーザー名
description string false ユーザの説明
createdAt long true 作成日時
updatedAt long true 最終更新日時

SecurityPolicy

セキュリティポリシー

ユーザが利用できるAPIの種類やアクセスできるリソースの制限を定義します。 アクセス制限のルールはポリシードキュメントというJSON形式の定義データを使用します。 ポリシードキュメントの仕様については 開発資料内のポリシードキュメントについての解説ページを参照してください。

パラメータ データ型 必須 説明
securityPolicyId string true セキュリティポリシー
ownerId string true オーナーID
name string true セキュリティポリシー名
description string false セキュリティポリシーの説明
policy string true ポリシードキュメント
createdAt long true 作成日時
updatedAt long true 最終更新日時

Identifier

クレデンシャル

GS2のAPIにアクセスするために必要となるクレデンシャルです。 クレデンシャルはクライアントIDとクライアントシークレットからなり、 クレデンシャルを使用したアクセスは、クレデンシャルの所有者となるユーザの権限に基づいてアクセス制限が施されます。

パラメータ データ型 必須 説明
ownerId string true オーナーID
clientId string true クライアントID
userName string true ユーザー名
clientSecret string true クライアントシークレット
createdAt long true 作成日時

AttachSecurityPolicy

割り当てられたセキュリティポリシー

セキュリティポリシーはユーザーに割り当てることで機能します。

パラメータ データ型 必須 説明
userId string true ユーザ のGRN
securityPolicyIds list[string] true セキュリティポリシー のGRNのリスト
attachedAt long true 作成日時

ProjectToken

プロジェクトトークン

クレデンシャルを使用して取得する一時的なアクセスキーです。 GS2のAPIにアクセスする際には Authorization ヘッダにトークンを付与してアクセスする必要があります。

パラメータ データ型 必須 説明
token string false プロジェクトトークン

初期化処理

HTTPプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_identifier_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2IdentifierRestClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.identifier.rest.Gs2IdentifierRestClient

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)
session.connect()
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session)
初期化処理は不要です

HTTPプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_identifier_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2IdentifierRestClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.identifier.rest.Gs2IdentifierRestClient

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect_async(
    (result) => {
        Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session)
    }
)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_identifier_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2IdentifierWebSocketClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.identifier.webSocket.Gs2IdentifierWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect()
Gs2IdentifierWebSocketClient client = new Gs2IdentifierWebSocketClient(session)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_identifier_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2IdentifierWebSocketClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.identifier.webSocket.Gs2IdentifierWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect_async(
    (result) => {
        Gs2IdentifierWebSocketClient client = new Gs2IdentifierWebSocketClient(session)
    }
)
初期化処理は不要です

GS2-Identifier は HTTPプロトコル と WebSocketプロトコル の2種類のプロトコルをサポートしています。

HTTPプロトコル と WebSocketプロトコル の違いは以下に示すとおりです。

HTTP WebSocket
接続方式 都度接続 常時接続
応答性能 優れている
API制限 なし 大容量のデータをやりとりするAPIには使用不可(主にマスターデータ系処理)
利用料金 WebSocketと同一 HTTPと同一

終了処理

HTTPプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

WebSocketプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

session オブジェクトの切断処理を行って終了処理を行います。 同一 session オブジェクトを複数の異なる Client オブジェクトに渡すことができます。

メソッド

attachSecurityPolicy

同期処理

from gs2_identifier_client.request import AttachSecurityPolicyRequest
from gs2_identifier_client.result import AttachSecurityPolicyResult

result = client.attach_security_policy(
    AttachSecurityPolicyRequest()\
        .with_user_name('user-0001')\
        .with_security_policy_id(security_policy1['securityPolicyId'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.AttachSecurityPolicyRequest
import io.gs2.identifier.result.AttachSecurityPolicyResult

result = client.attachSecurityPolicy(
    AttachSecurityPolicyRequest()
        .withUserName("user-0001")
        .withSecurityPolicyId(security_policy1.get'SecurityPolicyId())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import AttachSecurityPolicyRequest
from gs2_identifier_client.result import AttachSecurityPolicyResult

def callback(async_result: AsyncResult[AttachSecurityPolicyResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.attach_security_policy_async(
    AttachSecurityPolicyRequest()\
        .with_user_name('user-0001')\
        .with_security_policy_id(security_policy1['securityPolicyId']),
    callback
)
import io.gs2.identifier.request.AttachSecurityPolicyRequest
import io.gs2.identifier.result.AttachSecurityPolicyResult

result = client.attachSecurityPolicy(
    AttachSecurityPolicyRequest()
        .withUserName("user-0001")
        .withSecurityPolicyId(security_policy1.get'SecurityPolicyId()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Identifier::AttachSecurityPolicy
Properties:
  UserName: String
  SecurityPolicyId: String

割り当てられたセキュリティポリシーを新しくユーザーに割り当てます

パラメータ データ型 必須 説明
userName string true ユーザー名
securityPolicyId string true 割り当てるセキュリティポリシーのGRN
パラメータ データ型 説明
items list[SecurityPolicy] 新しくユーザーに割り当てたセキュリティポリシーのリスト

createIdentifier

同期処理

from gs2_identifier_client.request import CreateIdentifierRequest
from gs2_identifier_client.result import CreateIdentifierResult

result = client.create_identifier(
    CreateIdentifierRequest()\
        .with_user_name(user1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.CreateIdentifierRequest
import io.gs2.identifier.result.CreateIdentifierResult

result = client.createIdentifier(
    CreateIdentifierRequest()
        .withUserName(user1.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import CreateIdentifierRequest
from gs2_identifier_client.result import CreateIdentifierResult

def callback(async_result: AsyncResult[CreateIdentifierResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_identifier_async(
    CreateIdentifierRequest()\
        .with_user_name(user1['name']),
    callback
)
import io.gs2.identifier.request.CreateIdentifierRequest
import io.gs2.identifier.result.CreateIdentifierResult

result = client.createIdentifier(
    CreateIdentifierRequest()
        .withUserName(user1.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Identifier::Identifier
Properties:
  UserName: String

クレデンシャルを新規作成します

パラメータ データ型 必須 説明
userName string true ユーザー名
パラメータ データ型 説明
item Identifier 作成したクレデンシャル
clientSecret string クライアントシークレット

createSecurityPolicy

同期処理

from gs2_identifier_client.request import CreateSecurityPolicyRequest
from gs2_identifier_client.result import CreateSecurityPolicyResult

result = client.create_security_policy(
    CreateSecurityPolicyRequest()\
        .with_name('policy-0001')\
        .with_policy('{}')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.CreateSecurityPolicyRequest
import io.gs2.identifier.result.CreateSecurityPolicyResult

result = client.createSecurityPolicy(
    CreateSecurityPolicyRequest()
        .withName("policy-0001")
        .withPolicy("{}")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import CreateSecurityPolicyRequest
from gs2_identifier_client.result import CreateSecurityPolicyResult

def callback(async_result: AsyncResult[CreateSecurityPolicyResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_security_policy_async(
    CreateSecurityPolicyRequest()\
        .with_name('policy-0001')\
        .with_policy('{}'),
    callback
)
import io.gs2.identifier.request.CreateSecurityPolicyRequest
import io.gs2.identifier.result.CreateSecurityPolicyResult

result = client.createSecurityPolicy(
    CreateSecurityPolicyRequest()
        .withName("policy-0001")
        .withPolicy("{}"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Identifier::SecurityPolicy
Properties:
  Name: String
  Description: Optional[String]
  Policy: String

セキュリティポリシーを新規作成します

パラメータ データ型 必須 説明
name string true セキュリティポリシー名
description string false セキュリティポリシーの説明
policy string true ポリシードキュメント
パラメータ データ型 説明
item SecurityPolicy 作成したセキュリティポリシー

createUser

同期処理

from gs2_identifier_client.request import CreateUserRequest
from gs2_identifier_client.result import CreateUserResult

result = client.create_user(
    CreateUserRequest()\
        .with_name('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.CreateUserRequest
import io.gs2.identifier.result.CreateUserResult

result = client.createUser(
    CreateUserRequest()
        .withName("user-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import CreateUserRequest
from gs2_identifier_client.result import CreateUserResult

def callback(async_result: AsyncResult[CreateUserResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_user_async(
    CreateUserRequest()\
        .with_name('user-0001'),
    callback
)
import io.gs2.identifier.request.CreateUserRequest
import io.gs2.identifier.result.CreateUserResult

result = client.createUser(
    CreateUserRequest()
        .withName("user-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Identifier::User
Properties:
  Name: String
  Description: Optional[String]

ユーザを新規作成します

パラメータ データ型 必須 説明
name string true ユーザー名
description string false ユーザの説明
パラメータ データ型 説明
item User 作成したユーザ

deleteIdentifier

同期処理

from gs2_identifier_client.request import DeleteIdentifierRequest
from gs2_identifier_client.result import DeleteIdentifierResult

result = client.delete_identifier(
    DeleteIdentifierRequest()\
        .with_user_name(user1['name'])\
        .with_client_id(identifier1['clientId'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.DeleteIdentifierRequest
import io.gs2.identifier.result.DeleteIdentifierResult

result = client.deleteIdentifier(
    DeleteIdentifierRequest()
        .withUserName(user1.get'Name())
        .withClientId(identifier1.get'ClientId())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import DeleteIdentifierRequest
from gs2_identifier_client.result import DeleteIdentifierResult

def callback(async_result: AsyncResult[DeleteIdentifierResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_identifier_async(
    DeleteIdentifierRequest()\
        .with_user_name(user1['name'])\
        .with_client_id(identifier1['clientId']),
    callback
)
import io.gs2.identifier.request.DeleteIdentifierRequest
import io.gs2.identifier.result.DeleteIdentifierResult

result = client.deleteIdentifier(
    DeleteIdentifierRequest()
        .withUserName(user1.get'Name())
        .withClientId(identifier1.get'ClientId()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

クレデンシャルを削除します

パラメータ データ型 必須 説明
userName string true ユーザー名
clientId string true クライアントID
パラメータ データ型 説明

deleteSecurityPolicy

同期処理

from gs2_identifier_client.request import DeleteSecurityPolicyRequest
from gs2_identifier_client.result import DeleteSecurityPolicyResult

result = client.delete_security_policy(
    DeleteSecurityPolicyRequest()\
        .with_security_policy_name('policy-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.DeleteSecurityPolicyRequest
import io.gs2.identifier.result.DeleteSecurityPolicyResult

result = client.deleteSecurityPolicy(
    DeleteSecurityPolicyRequest()
        .withSecurityPolicyName("policy-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import DeleteSecurityPolicyRequest
from gs2_identifier_client.result import DeleteSecurityPolicyResult

def callback(async_result: AsyncResult[DeleteSecurityPolicyResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_security_policy_async(
    DeleteSecurityPolicyRequest()\
        .with_security_policy_name('policy-0001'),
    callback
)
import io.gs2.identifier.request.DeleteSecurityPolicyRequest
import io.gs2.identifier.result.DeleteSecurityPolicyResult

result = client.deleteSecurityPolicy(
    DeleteSecurityPolicyRequest()
        .withSecurityPolicyName("policy-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

セキュリティポリシーを削除します

パラメータ データ型 必須 説明
securityPolicyName string true セキュリティポリシー名
パラメータ データ型 説明

deleteUser

同期処理

from gs2_identifier_client.request import DeleteUserRequest
from gs2_identifier_client.result import DeleteUserResult

result = client.delete_user(
    DeleteUserRequest()\
        .with_user_name('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.DeleteUserRequest
import io.gs2.identifier.result.DeleteUserResult

result = client.deleteUser(
    DeleteUserRequest()
        .withUserName("user-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import DeleteUserRequest
from gs2_identifier_client.result import DeleteUserResult

def callback(async_result: AsyncResult[DeleteUserResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_user_async(
    DeleteUserRequest()\
        .with_user_name('user-0001'),
    callback
)
import io.gs2.identifier.request.DeleteUserRequest
import io.gs2.identifier.result.DeleteUserResult

result = client.deleteUser(
    DeleteUserRequest()
        .withUserName("user-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザを削除します

パラメータ データ型 必須 説明
userName string true ユーザー名
パラメータ データ型 説明

describeCommonSecurityPolicies

同期処理

from gs2_identifier_client.request import DescribeCommonSecurityPoliciesRequest
from gs2_identifier_client.result import DescribeCommonSecurityPoliciesResult

result = client.describe_common_security_policies(
    DescribeCommonSecurityPoliciesRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.DescribeCommonSecurityPoliciesRequest
import io.gs2.identifier.result.DescribeCommonSecurityPoliciesResult

result = client.describeCommonSecurityPolicies(
    DescribeCommonSecurityPoliciesRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import DescribeCommonSecurityPoliciesRequest
from gs2_identifier_client.result import DescribeCommonSecurityPoliciesResult

def callback(async_result: AsyncResult[DescribeCommonSecurityPoliciesResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_common_security_policies_async(
    DescribeCommonSecurityPoliciesRequest()\
    callback
)
import io.gs2.identifier.request.DescribeCommonSecurityPoliciesRequest
import io.gs2.identifier.result.DescribeCommonSecurityPoliciesResult

result = client.describeCommonSecurityPolicies(
    DescribeCommonSecurityPoliciesRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

オーナーIDを指定してセキュリティポリシーの一覧を取得します

パラメータ データ型 必須 説明
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[SecurityPolicy] セキュリティポリシーのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeIdentifiers

同期処理

from gs2_identifier_client.request import DescribeIdentifiersRequest
from gs2_identifier_client.result import DescribeIdentifiersResult

result = client.describe_identifiers(
    DescribeIdentifiersRequest()\
        .with_user_name(user1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.DescribeIdentifiersRequest
import io.gs2.identifier.result.DescribeIdentifiersResult

result = client.describeIdentifiers(
    DescribeIdentifiersRequest()
        .withUserName(user1.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import DescribeIdentifiersRequest
from gs2_identifier_client.result import DescribeIdentifiersResult

def callback(async_result: AsyncResult[DescribeIdentifiersResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_identifiers_async(
    DescribeIdentifiersRequest()\
        .with_user_name(user1['name']),
    callback
)
import io.gs2.identifier.request.DescribeIdentifiersRequest
import io.gs2.identifier.result.DescribeIdentifiersResult

result = client.describeIdentifiers(
    DescribeIdentifiersRequest()
        .withUserName(user1.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

クレデンシャルの一覧を取得します

パラメータ データ型 必須 説明
userName string false ユーザー名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Identifier] クレデンシャルのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeSecurityPolicies

同期処理

from gs2_identifier_client.request import DescribeSecurityPoliciesRequest
from gs2_identifier_client.result import DescribeSecurityPoliciesResult

result = client.describe_security_policies(
    DescribeSecurityPoliciesRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.DescribeSecurityPoliciesRequest
import io.gs2.identifier.result.DescribeSecurityPoliciesResult

result = client.describeSecurityPolicies(
    DescribeSecurityPoliciesRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import DescribeSecurityPoliciesRequest
from gs2_identifier_client.result import DescribeSecurityPoliciesResult

def callback(async_result: AsyncResult[DescribeSecurityPoliciesResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_security_policies_async(
    DescribeSecurityPoliciesRequest()\
    callback
)
import io.gs2.identifier.request.DescribeSecurityPoliciesRequest
import io.gs2.identifier.result.DescribeSecurityPoliciesResult

result = client.describeSecurityPolicies(
    DescribeSecurityPoliciesRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

セキュリティポリシーの一覧を取得します

パラメータ データ型 必須 説明
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[SecurityPolicy] セキュリティポリシーのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeUsers

同期処理

from gs2_identifier_client.request import DescribeUsersRequest
from gs2_identifier_client.result import DescribeUsersResult

result = client.describe_users(
    DescribeUsersRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.DescribeUsersRequest
import io.gs2.identifier.result.DescribeUsersResult

result = client.describeUsers(
    DescribeUsersRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import DescribeUsersRequest
from gs2_identifier_client.result import DescribeUsersResult

def callback(async_result: AsyncResult[DescribeUsersResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_users_async(
    DescribeUsersRequest()\
    callback
)
import io.gs2.identifier.request.DescribeUsersRequest
import io.gs2.identifier.result.DescribeUsersResult

result = client.describeUsers(
    DescribeUsersRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザの一覧を取得します

パラメータ データ型 必須 説明
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[User] ユーザのリスト
nextPageToken string リストの続きを取得するためのページトークン

detachSecurityPolicy

同期処理

from gs2_identifier_client.request import DetachSecurityPolicyRequest
from gs2_identifier_client.result import DetachSecurityPolicyResult

result = client.detach_security_policy(
    DetachSecurityPolicyRequest()\
        .with_user_name('user-0001')\
        .with_security_policy_id(security_policy1['securityPolicyId'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.DetachSecurityPolicyRequest
import io.gs2.identifier.result.DetachSecurityPolicyResult

result = client.detachSecurityPolicy(
    DetachSecurityPolicyRequest()
        .withUserName("user-0001")
        .withSecurityPolicyId(security_policy1.get'SecurityPolicyId())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import DetachSecurityPolicyRequest
from gs2_identifier_client.result import DetachSecurityPolicyResult

def callback(async_result: AsyncResult[DetachSecurityPolicyResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.detach_security_policy_async(
    DetachSecurityPolicyRequest()\
        .with_user_name('user-0001')\
        .with_security_policy_id(security_policy1['securityPolicyId']),
    callback
)
import io.gs2.identifier.request.DetachSecurityPolicyRequest
import io.gs2.identifier.result.DetachSecurityPolicyResult

result = client.detachSecurityPolicy(
    DetachSecurityPolicyRequest()
        .withUserName("user-0001")
        .withSecurityPolicyId(security_policy1.get'SecurityPolicyId()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

割り当てられたセキュリティポリシーをユーザーから外します

パラメータ データ型 必須 説明
userName string true ユーザー名
securityPolicyId string true 剥奪するセキュリティポリシーのGRN
パラメータ データ型 説明
items list[SecurityPolicy] 剥奪したあとユーザーに引き続き割り当てられているセキュリティポリシーのリスト

getHasSecurityPolicy

同期処理

from gs2_identifier_client.request import GetHasSecurityPolicyRequest
from gs2_identifier_client.result import GetHasSecurityPolicyResult

result = client.get_has_security_policy(
    GetHasSecurityPolicyRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.GetHasSecurityPolicyRequest
import io.gs2.identifier.result.GetHasSecurityPolicyResult

result = client.getHasSecurityPolicy(
    GetHasSecurityPolicyRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import GetHasSecurityPolicyRequest
from gs2_identifier_client.result import GetHasSecurityPolicyResult

def callback(async_result: AsyncResult[GetHasSecurityPolicyResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_has_security_policy_async(
    GetHasSecurityPolicyRequest()\
    callback
)
import io.gs2.identifier.request.GetHasSecurityPolicyRequest
import io.gs2.identifier.result.GetHasSecurityPolicyResult

result = client.getHasSecurityPolicy(
    GetHasSecurityPolicyRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

割り当てられたセキュリティポリシーの一覧を取得します

パラメータ データ型 必須 説明
userName string true ユーザー名
パラメータ データ型 説明
items list[SecurityPolicy] セキュリティポリシーのリスト

getIdentifier

同期処理

from gs2_identifier_client.request import GetIdentifierRequest
from gs2_identifier_client.result import GetIdentifierResult

result = client.get_identifier(
    GetIdentifierRequest()\
        .with_user_name(user1['name'])\
        .with_client_id(identifier1['clientId'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.GetIdentifierRequest
import io.gs2.identifier.result.GetIdentifierResult

result = client.getIdentifier(
    GetIdentifierRequest()
        .withUserName(user1.get'Name())
        .withClientId(identifier1.get'ClientId())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import GetIdentifierRequest
from gs2_identifier_client.result import GetIdentifierResult

def callback(async_result: AsyncResult[GetIdentifierResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_identifier_async(
    GetIdentifierRequest()\
        .with_user_name(user1['name'])\
        .with_client_id(identifier1['clientId']),
    callback
)
import io.gs2.identifier.request.GetIdentifierRequest
import io.gs2.identifier.result.GetIdentifierResult

result = client.getIdentifier(
    GetIdentifierRequest()
        .withUserName(user1.get'Name())
        .withClientId(identifier1.get'ClientId()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

クレデンシャルを取得します

パラメータ データ型 必須 説明
userName string true ユーザー名
clientId string true クライアントID
パラメータ データ型 説明
item Identifier クレデンシャル

getSecurityPolicy

同期処理

from gs2_identifier_client.request import GetSecurityPolicyRequest
from gs2_identifier_client.result import GetSecurityPolicyResult

result = client.get_security_policy(
    GetSecurityPolicyRequest()\
        .with_security_policy_name('policy-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.GetSecurityPolicyRequest
import io.gs2.identifier.result.GetSecurityPolicyResult

result = client.getSecurityPolicy(
    GetSecurityPolicyRequest()
        .withSecurityPolicyName("policy-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import GetSecurityPolicyRequest
from gs2_identifier_client.result import GetSecurityPolicyResult

def callback(async_result: AsyncResult[GetSecurityPolicyResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_security_policy_async(
    GetSecurityPolicyRequest()\
        .with_security_policy_name('policy-0001'),
    callback
)
import io.gs2.identifier.request.GetSecurityPolicyRequest
import io.gs2.identifier.result.GetSecurityPolicyResult

result = client.getSecurityPolicy(
    GetSecurityPolicyRequest()
        .withSecurityPolicyName("policy-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

セキュリティポリシーを取得します

パラメータ データ型 必須 説明
securityPolicyName string true セキュリティポリシー名
パラメータ データ型 説明
item SecurityPolicy セキュリティポリシー

getUser

同期処理

from gs2_identifier_client.request import GetUserRequest
from gs2_identifier_client.result import GetUserResult

result = client.get_user(
    GetUserRequest()\
        .with_user_name('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.GetUserRequest
import io.gs2.identifier.result.GetUserResult

result = client.getUser(
    GetUserRequest()
        .withUserName("user-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import GetUserRequest
from gs2_identifier_client.result import GetUserResult

def callback(async_result: AsyncResult[GetUserResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_user_async(
    GetUserRequest()\
        .with_user_name('user-0001'),
    callback
)
import io.gs2.identifier.request.GetUserRequest
import io.gs2.identifier.result.GetUserResult

result = client.getUser(
    GetUserRequest()
        .withUserName("user-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザを取得します

パラメータ データ型 必須 説明
userName string true ユーザー名
パラメータ データ型 説明
item User ユーザ

login

同期処理

from gs2_identifier_client.request import LoginRequest
from gs2_identifier_client.result import LoginResult

result = client.login(
    LoginRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.LoginRequest
import io.gs2.identifier.result.LoginResult

result = client.login(
    LoginRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import LoginRequest
from gs2_identifier_client.result import LoginResult

def callback(async_result: AsyncResult[LoginResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.login_async(
    LoginRequest()\
    callback
)
import io.gs2.identifier.request.LoginRequest
import io.gs2.identifier.result.LoginResult

result = client.login(
    LoginRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

プロジェクトトークン を取得します

パラメータ データ型 必須 説明
client_id string true クライアントID
client_secret string true クライアントシークレット
パラメータ データ型 説明
access_token string プロジェクトトークン
token_type string Bearer
expires_in integer 有効期間(秒)

updateSecurityPolicy

同期処理

from gs2_identifier_client.request import UpdateSecurityPolicyRequest
from gs2_identifier_client.result import UpdateSecurityPolicyResult

result = client.update_security_policy(
    UpdateSecurityPolicyRequest()\
        .with_security_policy_name('policy-0001')\
        .with_description('description1')\
        .with_policy('{"hoge": "fuga"}')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.UpdateSecurityPolicyRequest
import io.gs2.identifier.result.UpdateSecurityPolicyResult

result = client.updateSecurityPolicy(
    UpdateSecurityPolicyRequest()
        .withSecurityPolicyName("policy-0001")
        .withDescription("description1")
        .withPolicy("{"hoge": "fuga"}")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import UpdateSecurityPolicyRequest
from gs2_identifier_client.result import UpdateSecurityPolicyResult

def callback(async_result: AsyncResult[UpdateSecurityPolicyResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_security_policy_async(
    UpdateSecurityPolicyRequest()\
        .with_security_policy_name('policy-0001')\
        .with_description('description1')\
        .with_policy('{"hoge": "fuga"}'),
    callback
)
import io.gs2.identifier.request.UpdateSecurityPolicyRequest
import io.gs2.identifier.result.UpdateSecurityPolicyResult

result = client.updateSecurityPolicy(
    UpdateSecurityPolicyRequest()
        .withSecurityPolicyName("policy-0001")
        .withDescription("description1")
        .withPolicy("{"hoge": "fuga"}"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

セキュリティポリシーを更新します

パラメータ データ型 必須 説明
securityPolicyName string true セキュリティポリシー名
description string false セキュリティポリシーの説明
policy string true ポリシードキュメント
パラメータ データ型 説明
item SecurityPolicy 更新後のセキュリティポリシー

updateUser

同期処理

from gs2_identifier_client.request import UpdateUserRequest
from gs2_identifier_client.result import UpdateUserResult

result = client.update_user(
    UpdateUserRequest()\
        .with_user_name('user-0001')\
        .with_description('description1')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.identifier.request.UpdateUserRequest
import io.gs2.identifier.result.UpdateUserResult

result = client.updateUser(
    UpdateUserRequest()
        .withUserName("user-0001")
        .withDescription("description1")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_identifier_client.request import UpdateUserRequest
from gs2_identifier_client.result import UpdateUserResult

def callback(async_result: AsyncResult[UpdateUserResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_user_async(
    UpdateUserRequest()\
        .with_user_name('user-0001')\
        .with_description('description1'),
    callback
)
import io.gs2.identifier.request.UpdateUserRequest
import io.gs2.identifier.result.UpdateUserResult

result = client.updateUser(
    UpdateUserRequest()
        .withUserName("user-0001")
        .withDescription("description1"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザを更新します

パラメータ データ型 必須 説明
userName string true ユーザー名
description string false ユーザの説明
パラメータ データ型 説明
item User 更新後のユーザ

GS2-Script トリガーイベント

GS2-Identifier が提供するスクリプトトリガーはありません

マスターデータフォーマット

マスターデータはありません

GS2-Identifier の制限・制約

利用いただくにあたって注意いただく制限・制約はありません