NAV Navbar
Python Java GS2-Formation
 

GS2-Key

暗号鍵を管理するサービス

GS2内の機密データや、署名作成に使用する暗号鍵を作成します。 暗号鍵のデータはGS2の外に取り出すことができないため、安全に処理を行えます。

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

モデル

Namespace

ネームスペース

ネームスペースは暗号鍵の管理単位を表現します。 1つのネームスペースには複数の暗号鍵を登録することができます。

ネームスペースを分けることによる弊害や、同一ネームスペースでなければいけない処理は存在しません。 暗号鍵のグルーピングとして利用してください。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
description string false 説明文
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

Key

暗号鍵

暗号化や署名の作成・検証に使用する暗号鍵

パラメータ データ型 必須 説明
keyId string true 暗号鍵
name string true 暗号鍵名
description string false 説明文
secret string true 暗号鍵
createdAt long true 作成日時
updatedAt long true 最終更新日時

GitHubApiKey

GitHub のAPIキー

GitHub からコードを取得するためのAPIキー

パラメータ データ型 必須 説明
apiKeyId string true GitHub のAPIキー
name string true GitHub APIキー名
description string false 説明文
apiKey string true APIキー
encryptionKeyName string true APIキーの暗号化に使用する暗号鍵名
createdAt long true 作成日時
updatedAt long true 最終更新日時

LogSetting

ロギング通知設定

パラメータ データ型 必須 説明
loggingNamespaceId string false ログの記録に使用する GS2-Log のネームスペース のGRN

初期化処理

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

import gs2_core_client.model.*
import gs2_key_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_key_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 = Gs2KeyRestClient(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.key.rest.Gs2KeyRestClient

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

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

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

import gs2_core_client.model.*
import gs2_key_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 = Gs2KeyWebSocketClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.key.webSocket.Gs2KeyWebSocketClient

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

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

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

import gs2_core_client.model.*
import gs2_key_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 = Gs2KeyWebSocketClient(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.key.webSocket.Gs2KeyWebSocketClient

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

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

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

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

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

終了処理

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

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

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

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

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

メソッド

createGitHubApiKey

同期処理

from gs2_key_client.request import CreateGitHubApiKeyRequest
from gs2_key_client.result import CreateGitHubApiKeyResult

result = client.create_git_hub_api_key(
    CreateGitHubApiKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('api-key-0001')\
        .with_api_key('secret-0001')\
        .with_encryption_key_name(key1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.CreateGitHubApiKeyRequest
import io.gs2.key.result.CreateGitHubApiKeyResult

result = client.createGitHubApiKey(
    CreateGitHubApiKeyRequest()
        .withNamespaceName("namespace-0001")
        .withName("api-key-0001")
        .withApiKey("secret-0001")
        .withEncryptionKeyName(key1.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_key_client.request import CreateGitHubApiKeyRequest
from gs2_key_client.result import CreateGitHubApiKeyResult

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

result = client.create_git_hub_api_key_async(
    CreateGitHubApiKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('api-key-0001')\
        .with_api_key('secret-0001')\
        .with_encryption_key_name(key1['name']),
    callback
)
import io.gs2.key.request.CreateGitHubApiKeyRequest
import io.gs2.key.result.CreateGitHubApiKeyResult

result = client.createGitHubApiKey(
    CreateGitHubApiKeyRequest()
        .withNamespaceName("namespace-0001")
        .withName("api-key-0001")
        .withApiKey("secret-0001")
        .withEncryptionKeyName(key1.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Key::GitHubApiKey
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  ApiKey: String
  EncryptionKeyName: String

GitHub のAPIキーを新規作成します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true GitHub APIキー名
description string false 説明文
apiKey string true APIキー
encryptionKeyName string true APIキーの暗号化に使用する暗号鍵名
パラメータ データ型 説明
item GitHubApiKey 作成したGitHub のAPIキー

createKey

同期処理

from gs2_key_client.request import CreateKeyRequest
from gs2_key_client.result import CreateKeyResult

result = client.create_key(
    CreateKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('key-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.CreateKeyRequest
import io.gs2.key.result.CreateKeyResult

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

非同期処理

from gs2_key_client.request import CreateKeyRequest
from gs2_key_client.result import CreateKeyResult

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

result = client.create_key_async(
    CreateKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('key-0001'),
    callback
)
import io.gs2.key.request.CreateKeyRequest
import io.gs2.key.result.CreateKeyResult

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

暗号鍵を新規作成します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true 暗号鍵名
description string false 説明文
パラメータ データ型 説明
item Key 作成した暗号鍵

createNamespace

同期処理

from gs2_key_client.request import CreateNamespaceRequest
from gs2_key_client.result import CreateNamespaceResult

result = client.create_namespace(
    CreateNamespaceRequest()\
        .with_name('namespace-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.CreateNamespaceRequest
import io.gs2.key.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespace-0001")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_key_client.request import CreateNamespaceRequest
from gs2_key_client.result import CreateNamespaceResult

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

result = client.create_namespace_async(
    CreateNamespaceRequest()\
        .with_name('namespace-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.key.request.CreateNamespaceRequest
import io.gs2.key.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespace-0001")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Key::Namespace
Properties:
  Name: String
  Description: Optional[String]
  LogSetting:
    LoggingNamespaceId: Optional[String]

ネームスペースを新規作成

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false 説明文
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

decrypt

同期処理

from gs2_key_client.request import DecryptRequest
from gs2_key_client.result import DecryptResult

result = client.decrypt(
    DecryptRequest()\
        .with_namespace_name('namespace-0001')\
        .with_key_name('key-0001')\
        .with_data('hoge')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.DecryptRequest
import io.gs2.key.result.DecryptResult

result = client.decrypt(
    DecryptRequest()
        .withNamespaceName("namespace-0001")
        .withKeyName("key-0001")
        .withData("hoge")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_key_client.request import DecryptRequest
from gs2_key_client.result import DecryptResult

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

result = client.decrypt_async(
    DecryptRequest()\
        .with_namespace_name('namespace-0001')\
        .with_key_name('key-0001')\
        .with_data('hoge'),
    callback
)
import io.gs2.key.request.DecryptRequest
import io.gs2.key.result.DecryptResult

result = client.decrypt(
    DecryptRequest()
        .withNamespaceName("namespace-0001")
        .withKeyName("key-0001")
        .withData("hoge"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

データを復号します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
keyName string true 暗号鍵名
data string true None
パラメータ データ型 説明
data string 復号済みデータ

deleteGitHubApiKey

同期処理

from gs2_key_client.request import DeleteGitHubApiKeyRequest
from gs2_key_client.result import DeleteGitHubApiKeyResult

result = client.delete_git_hub_api_key(
    DeleteGitHubApiKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_api_key_name('api-key-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.DeleteGitHubApiKeyRequest
import io.gs2.key.result.DeleteGitHubApiKeyResult

result = client.deleteGitHubApiKey(
    DeleteGitHubApiKeyRequest()
        .withNamespaceName("namespace-0001")
        .withApiKeyName("api-key-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_key_client.request import DeleteGitHubApiKeyRequest
from gs2_key_client.result import DeleteGitHubApiKeyResult

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

result = client.delete_git_hub_api_key_async(
    DeleteGitHubApiKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_api_key_name('api-key-0001'),
    callback
)
import io.gs2.key.request.DeleteGitHubApiKeyRequest
import io.gs2.key.result.DeleteGitHubApiKeyResult

result = client.deleteGitHubApiKey(
    DeleteGitHubApiKeyRequest()
        .withNamespaceName("namespace-0001")
        .withApiKeyName("api-key-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

GitHub のAPIキーを削除します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
apiKeyName string true GitHub APIキー名
パラメータ データ型 説明

deleteKey

同期処理

from gs2_key_client.request import DeleteKeyRequest
from gs2_key_client.result import DeleteKeyResult

result = client.delete_key(
    DeleteKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_key_name('key-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.DeleteKeyRequest
import io.gs2.key.result.DeleteKeyResult

result = client.deleteKey(
    DeleteKeyRequest()
        .withNamespaceName("namespace-0001")
        .withKeyName("key-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_key_client.request import DeleteKeyRequest
from gs2_key_client.result import DeleteKeyResult

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

result = client.delete_key_async(
    DeleteKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_key_name('key-0001'),
    callback
)
import io.gs2.key.request.DeleteKeyRequest
import io.gs2.key.result.DeleteKeyResult

result = client.deleteKey(
    DeleteKeyRequest()
        .withNamespaceName("namespace-0001")
        .withKeyName("key-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

暗号鍵を削除します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
keyName string true 暗号鍵名
パラメータ データ型 説明

deleteNamespace

同期処理

from gs2_key_client.request import DeleteNamespaceRequest
from gs2_key_client.result import DeleteNamespaceResult

result = client.delete_namespace(
    DeleteNamespaceRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.DeleteNamespaceRequest
import io.gs2.key.result.DeleteNamespaceResult

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

非同期処理

from gs2_key_client.request import DeleteNamespaceRequest
from gs2_key_client.result import DeleteNamespaceResult

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

result = client.delete_namespace_async(
    DeleteNamespaceRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.key.request.DeleteNamespaceRequest
import io.gs2.key.result.DeleteNamespaceResult

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

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

ネームスペースを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明

describeGitHubApiKeys

同期処理

from gs2_key_client.request import DescribeGitHubApiKeysRequest
from gs2_key_client.result import DescribeGitHubApiKeysResult

result = client.describe_git_hub_api_keys(
    DescribeGitHubApiKeysRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.DescribeGitHubApiKeysRequest
import io.gs2.key.result.DescribeGitHubApiKeysResult

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

非同期処理

from gs2_key_client.request import DescribeGitHubApiKeysRequest
from gs2_key_client.result import DescribeGitHubApiKeysResult

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

result = client.describe_git_hub_api_keys_async(
    DescribeGitHubApiKeysRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.key.request.DescribeGitHubApiKeysRequest
import io.gs2.key.result.DescribeGitHubApiKeysResult

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

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

GitHub のAPIキーの一覧を取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[GitHubApiKey] GitHub のAPIキーのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeKeys

同期処理

from gs2_key_client.request import DescribeKeysRequest
from gs2_key_client.result import DescribeKeysResult

result = client.describe_keys(
    DescribeKeysRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.DescribeKeysRequest
import io.gs2.key.result.DescribeKeysResult

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

非同期処理

from gs2_key_client.request import DescribeKeysRequest
from gs2_key_client.result import DescribeKeysResult

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

result = client.describe_keys_async(
    DescribeKeysRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.key.request.DescribeKeysRequest
import io.gs2.key.result.DescribeKeysResult

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

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

暗号鍵の一覧を取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Key] 暗号鍵のリスト
nextPageToken string リストの続きを取得するためのページトークン

describeNamespaces

同期処理

from gs2_key_client.request import DescribeNamespacesRequest
from gs2_key_client.result import DescribeNamespacesResult

result = client.describe_namespaces(
    DescribeNamespacesRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.DescribeNamespacesRequest
import io.gs2.key.result.DescribeNamespacesResult

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

非同期処理

from gs2_key_client.request import DescribeNamespacesRequest
from gs2_key_client.result import DescribeNamespacesResult

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

result = client.describe_namespaces_async(
    DescribeNamespacesRequest()\
    callback
)
import io.gs2.key.request.DescribeNamespacesRequest
import io.gs2.key.result.DescribeNamespacesResult

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

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

ネームスペースの一覧を取得

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

encrypt

同期処理

from gs2_key_client.request import EncryptRequest
from gs2_key_client.result import EncryptResult

result = client.encrypt(
    EncryptRequest()\
        .with_namespace_name('namespace-0001')\
        .with_key_name('key-0001')\
        .with_data('hoge')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.EncryptRequest
import io.gs2.key.result.EncryptResult

result = client.encrypt(
    EncryptRequest()
        .withNamespaceName("namespace-0001")
        .withKeyName("key-0001")
        .withData("hoge")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_key_client.request import EncryptRequest
from gs2_key_client.result import EncryptResult

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

result = client.encrypt_async(
    EncryptRequest()\
        .with_namespace_name('namespace-0001')\
        .with_key_name('key-0001')\
        .with_data('hoge'),
    callback
)
import io.gs2.key.request.EncryptRequest
import io.gs2.key.result.EncryptResult

result = client.encrypt(
    EncryptRequest()
        .withNamespaceName("namespace-0001")
        .withKeyName("key-0001")
        .withData("hoge"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

データを暗号化します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
keyName string true 暗号鍵名
data string true None
パラメータ データ型 説明
data string 暗号化済みデータ

getGitHubApiKey

同期処理

from gs2_key_client.request import GetGitHubApiKeyRequest
from gs2_key_client.result import GetGitHubApiKeyResult

result = client.get_git_hub_api_key(
    GetGitHubApiKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_api_key_name('api-key-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.GetGitHubApiKeyRequest
import io.gs2.key.result.GetGitHubApiKeyResult

result = client.getGitHubApiKey(
    GetGitHubApiKeyRequest()
        .withNamespaceName("namespace-0001")
        .withApiKeyName("api-key-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_key_client.request import GetGitHubApiKeyRequest
from gs2_key_client.result import GetGitHubApiKeyResult

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

result = client.get_git_hub_api_key_async(
    GetGitHubApiKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_api_key_name('api-key-0001'),
    callback
)
import io.gs2.key.request.GetGitHubApiKeyRequest
import io.gs2.key.result.GetGitHubApiKeyResult

result = client.getGitHubApiKey(
    GetGitHubApiKeyRequest()
        .withNamespaceName("namespace-0001")
        .withApiKeyName("api-key-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

GitHub のAPIキーを取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
apiKeyName string true GitHub APIキー名
パラメータ データ型 説明
item GitHubApiKey GitHub のAPIキー

getKey

同期処理

from gs2_key_client.request import GetKeyRequest
from gs2_key_client.result import GetKeyResult

result = client.get_key(
    GetKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_key_name('key-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.GetKeyRequest
import io.gs2.key.result.GetKeyResult

result = client.getKey(
    GetKeyRequest()
        .withNamespaceName("namespace-0001")
        .withKeyName("key-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_key_client.request import GetKeyRequest
from gs2_key_client.result import GetKeyResult

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

result = client.get_key_async(
    GetKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_key_name('key-0001'),
    callback
)
import io.gs2.key.request.GetKeyRequest
import io.gs2.key.result.GetKeyResult

result = client.getKey(
    GetKeyRequest()
        .withNamespaceName("namespace-0001")
        .withKeyName("key-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

暗号鍵を取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
keyName string true 暗号鍵名
パラメータ データ型 説明
item Key 暗号鍵

getNamespace

同期処理

from gs2_key_client.request import GetNamespaceRequest
from gs2_key_client.result import GetNamespaceResult

result = client.get_namespace(
    GetNamespaceRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.GetNamespaceRequest
import io.gs2.key.result.GetNamespaceResult

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

非同期処理

from gs2_key_client.request import GetNamespaceRequest
from gs2_key_client.result import GetNamespaceResult

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

result = client.get_namespace_async(
    GetNamespaceRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.key.request.GetNamespaceRequest
import io.gs2.key.result.GetNamespaceResult

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

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

ネームスペースを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Namespace ネームスペース

getNamespaceStatus

同期処理

from gs2_key_client.request import GetNamespaceStatusRequest
from gs2_key_client.result import GetNamespaceStatusResult

result = client.get_namespace_status(
    GetNamespaceStatusRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.GetNamespaceStatusRequest
import io.gs2.key.result.GetNamespaceStatusResult

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

非同期処理

from gs2_key_client.request import GetNamespaceStatusRequest
from gs2_key_client.result import GetNamespaceStatusResult

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

result = client.get_namespace_status_async(
    GetNamespaceStatusRequest()\
    callback
)
import io.gs2.key.request.GetNamespaceStatusRequest
import io.gs2.key.result.GetNamespaceStatusResult

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

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

ネームスペースを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
status string

updateGitHubApiKey

同期処理

from gs2_key_client.request import UpdateGitHubApiKeyRequest
from gs2_key_client.result import UpdateGitHubApiKeyResult

result = client.update_git_hub_api_key(
    UpdateGitHubApiKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_api_key_name('api-key-0001')\
        .with_description('description1')\
        .with_api_key('secret-0004')\
        .with_encryption_key_name(key2['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.UpdateGitHubApiKeyRequest
import io.gs2.key.result.UpdateGitHubApiKeyResult

result = client.updateGitHubApiKey(
    UpdateGitHubApiKeyRequest()
        .withNamespaceName("namespace-0001")
        .withApiKeyName("api-key-0001")
        .withDescription("description1")
        .withApiKey("secret-0004")
        .withEncryptionKeyName(key2.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_key_client.request import UpdateGitHubApiKeyRequest
from gs2_key_client.result import UpdateGitHubApiKeyResult

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

result = client.update_git_hub_api_key_async(
    UpdateGitHubApiKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_api_key_name('api-key-0001')\
        .with_description('description1')\
        .with_api_key('secret-0004')\
        .with_encryption_key_name(key2['name']),
    callback
)
import io.gs2.key.request.UpdateGitHubApiKeyRequest
import io.gs2.key.result.UpdateGitHubApiKeyResult

result = client.updateGitHubApiKey(
    UpdateGitHubApiKeyRequest()
        .withNamespaceName("namespace-0001")
        .withApiKeyName("api-key-0001")
        .withDescription("description1")
        .withApiKey("secret-0004")
        .withEncryptionKeyName(key2.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

GitHub のAPIキーを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
apiKeyName string true GitHub APIキー名
description string false 説明文
apiKey string true APIキー
encryptionKeyName string true APIキーの暗号化に使用する暗号鍵名
パラメータ データ型 説明
item GitHubApiKey 更新したGitHub のAPIキー

updateKey

同期処理

from gs2_key_client.request import UpdateKeyRequest
from gs2_key_client.result import UpdateKeyResult

result = client.update_key(
    UpdateKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_key_name('key-0001')\
        .with_description('description1')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.UpdateKeyRequest
import io.gs2.key.result.UpdateKeyResult

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

非同期処理

from gs2_key_client.request import UpdateKeyRequest
from gs2_key_client.result import UpdateKeyResult

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

result = client.update_key_async(
    UpdateKeyRequest()\
        .with_namespace_name('namespace-0001')\
        .with_key_name('key-0001')\
        .with_description('description1'),
    callback
)
import io.gs2.key.request.UpdateKeyRequest
import io.gs2.key.result.UpdateKeyResult

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

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

暗号鍵を更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
keyName string true 暗号鍵名
description string false 説明文
パラメータ データ型 説明
item Key 更新した暗号鍵

updateNamespace

同期処理

from gs2_key_client.request import UpdateNamespaceRequest
from gs2_key_client.result import UpdateNamespaceResult

result = client.update_namespace(
    UpdateNamespaceRequest()\
        .with_namespace_name('namespace-0001')\
        .with_description('description1')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.key.request.UpdateNamespaceRequest
import io.gs2.key.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_key_client.request import UpdateNamespaceRequest
from gs2_key_client.result import UpdateNamespaceResult

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

result = client.update_namespace_async(
    UpdateNamespaceRequest()\
        .with_namespace_name('namespace-0001')\
        .with_description('description1')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.key.request.UpdateNamespaceRequest
import io.gs2.key.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ネームスペースを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
description string false 説明文
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

GS2-Script トリガーイベント

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

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

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

GS2-Key の制限・制約

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