> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-Identifier SDK API 레퍼런스
각종 프로그래밍 언어용 GS2-Identifier SDK의 모델 사양과 API 레퍼런스
## 모델
### Identifier
크레덴셜
GS2 API에 액세스하기 위해 사용되는 크레덴셜입니다.
크레덴셜은 클라이언트 ID와 클라이언트 시크릿으로 구성되며, 크레덴셜을 사용한 액세스는 크레덴셜 소유자인 사용자의 권한에 따라 액세스가 제한됩니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| clientId | string | | ✓ | UUID | ~ 256자 | 클라이언트ID |
| userName | string | | ✓ | | ~ 128자 | 사용자 이름
이 크레덴셜을 소유한 GS2-Identifier 사용자의 이름입니다. 크레덴셜은 이 사용자에게 연결된 보안 정책에 따라 권한을 상속받습니다. |
| clientSecret | string | | ✓ | UUID | ~ 100자 | 클라이언트 시크릿 |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeIdentifiers - 크리덴셜 목록 취득
createIdentifier - 크리덴셜을 신규 작성
getIdentifier - 크리덴셜을 취득
deleteIdentifier - 크리덴셜을 삭제
---
### Password
비밀번호
사용자의 권한에 따라 매니지먼트 콘솔에 로그인하기 위한 비밀번호입니다.
비밀번호를 설정하면 하나의 프로젝트에 서로 다른 계정으로 로그인할 수 있으며, 접근 가능한 정보에 제한을 둘 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| passwordId | string | | ※ | | ~ 1024자 | 패스워드 GRN
※ 서버가 자동으로 설정 |
| userId | string | | ✓ | | ~ 1024자 | GS2-Identifier 사용자 GRN |
| userName | string | | ✓ | | ~ 128자 | 사용자 이름
이 비밀번호를 소유하는 GS2-Identifier 사용자의 이름입니다. 사용자는 이 사용자 이름과 대응하는 비밀번호로 매니지먼트 콘솔에 로그인하며, 사용자에게 할당된 보안 정책에 따라 접근이 제한됩니다. |
| enableTwoFactorAuthentication | 문자열 열거형
enum {
"RFC6238",
"Disable"
}
| | | "Disable" | | 2단계 인증
이 비밀번호로 매니지먼트 콘솔에 로그인할 때 TOTP 기반 2단계 인증(RFC 6238)을 필요로 할지를 제어합니다. "RFC6238"로 설정하면 사용자는 비밀번호에 더해 인증 앱의 유효한 일회용 코드를 제공해야 합니다. "Disable"로 설정하면 비밀번호만 필요합니다.RFC6238: 활성화 / Disable: 비활성화 / |
| twoFactorAuthenticationSetting | [TwoFactorAuthenticationSetting](#twofactorauthenticationsetting) | {enableTwoFactorAuthentication} == "RFC6238" | | | | 2단계 인증 설정
이 비밀번호의 TOTP 설정으로, 공유 비밀 키와 설정 상태를 포함합니다. enableTwoFactorAuthentication이 "RFC6238"로 설정된 경우에만 존재합니다. 사용자가 인증 앱 설정을 완료했는지를 추적하는 검증 상태(Verifying/Enable)를 포함합니다.
※ enableTwoFactorAuthentication이(가) "RFC6238" 이면 활성화 |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
createPassword - 패스워드를 신규 작성
getPassword - 패스워드를 취득
enableMfa - MFA를 활성화
challengeMfa - MFA 유효성 확인
disableMfa - MFA를 비활성화
deletePassword - 패스워드를 삭제
---
### AttachSecurityPolicy
할당된 보안 정책
GS2-Identifier 사용자와 보안 정책의 연결을 관리합니다. 각 사용자는 해당 사용자에게 적용되는 보안 정책 GRN 목록을 포함하는 하나의 할당 레코드를 가집니다. 사용자의 크리덴셜이 API 접근에 사용될 때, 할당된 모든 정책이 평가되어 요청된 작업이 허용되는지 거부되는지가 판정됩니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ※ | | ~ 1024자 | GS2-Identifier 사용자 GRN
※ 서버가 자동으로 설정 |
| securityPolicyIds | List<string> | | | [] | 0 ~ 100 items | 보안 정책 GRN 목록
이 사용자에게 할당된 보안 정책 목록입니다. 여러 정책을 할당할 수 있으며, 그 권한은 결합(합집합)됩니다. 할당된 정책 중 하나라도 액션을 허용하면 해당 액션은 허용됩니다. 사용자당 최대 100개의 정책을 할당할 수 있습니다. |
| attachedAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
---
### User
GS2-Identifier 사용자
프로젝트에 접근 가능한 게임 개발자를 나타내는 엔티티입니다.
사용자는 프로그램에서 접근하기 위한 크리덴셜과,
사용자의 권한에 따라 매니지먼트 콘솔에 로그인하여 프로젝트를 관리할 수 있는 비밀번호를 등록할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ※ | | ~ 1024자 | GS2-Identifier 사용자 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | GS2-Identifier 사용자 이름
GS2-Identifier 사용자 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeUsers - 사용자 목록 취득
createUser - 사용자 신규 생성
updateUser - 사용자 갱신
getUser - 사용자 취득
deleteUser - 사용자 삭제
---
### SecurityPolicy
보안 정책
사용자가 사용할 수 있는 API의 종류와 접근 가능한 리소스의 제한을 정의합니다.
접근 제한 규칙은 정책 문서라는 JSON 형식의 정의 데이터를 사용합니다.
정책 문서의 사양에 대해서는 개발 문서 내 정책 문서에 대한 [설명 페이지](/ko/articles/tech/identifier/#보안-정책)를 참조하십시오.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| securityPolicyId | string | | ※ | | ~ 1024자 | 보안 정책 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 보안 정책 이름
보안 정책 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| policy | string | | ✓ | | ~ 524288자 | 정책 문서
이 보안 정책의 접근 제어 규칙을 정의하는 JSON 문서입니다. 어떤 GS2 API 액션을 허용 또는 거부할지, 그리고 규칙이 적용되는 리소스(GRN 패턴으로 식별)를 지정합니다. 여러 스테이트먼트를 조합하여 세밀한 접근 제어를 만들 수 있습니다. 최대 512KB입니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
**관련 메서드:**
getHasSecurityPolicy - 할당된 보안 정책 목록 취득
attachSecurityPolicy - 사용자에게 보안 정책을 할당
detachSecurityPolicy - 할당된 보안 정책을 사용자로부터 해제
describeSecurityPolicies - 보안 정책 목록 취득
describeCommonSecurityPolicies - GS2 정의 보안 정책 목록 취득
createSecurityPolicy - 보안 정책 신규 생성
updateSecurityPolicy - 보안 정책 갱신
getSecurityPolicy - 보안 정책 취득
deleteSecurityPolicy - 보안 정책 삭제
---
### ProjectToken
프로젝트 토큰
크리덴셜(클라이언트 ID와 클라이언트 시크릿)로 인증하여 발행되는 임시 접근 토큰입니다. 이 토큰은 프로젝트 내 모든 GS2 API 호출의 인가에 사용됩니다. 토큰에는 유효 기간이 있으며, 정기적으로 갱신해야 합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| token | string | | | | ~ 1024자 | 프로젝트 토큰
API 인증에 사용되는 토큰 문자열입니다. 크리덴셜로 로그인에 성공하면 생성됩니다. 최대 1024자입니다. |
**관련 메서드:**
loginByUser - GS2-Identifier 사용자를 지정하여 프로젝트 토큰을 취득
---
### TwoFactorAuthenticationSetting
2단계 인증 설정
매니지먼트 콘솔 비밀번호에 대한 TOTP 기반 2단계 인증(RFC 6238) 설정입니다. 시간 기반 일회용 비밀번호의 생성과 검증에 사용되는 공유 비밀 키를 저장합니다. 사용자가 인증 앱을 올바르게 설정했는지 확인하기 위해, 완전히 활성화되기 전에 검증 단계를 거칩니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| status | 문자열 열거형
enum {
"Verifying",
"Enable"
}
| | | "Verifying" | | 상태
2단계 인증 설정의 현재 상태입니다. "Verifying"은 사용자가 설정을 시작했지만 아직 인증 앱의 유효한 TOTP 코드를 확인하지 않았음을 나타냅니다. "Enable"은 설정이 완료되어 콘솔 로그인 시 2단계 인증이 실제로 적용되고 있음을 나타냅니다.Verifying: 검증 중 / Enable: 활성화 / |
**관련 모델:**
Password - 비밀번호
---
## 메서드
### describeIdentifiers
크리덴셜 목록 취득
지정된 사용자와 연결된 OAuth 크리덴셜(클라이언트 ID/시크릿 쌍)의 페이지네이션 리스트를 취득합니다.
크리덴셜은 Login API를 사용하여 프로젝트 토큰을 취득하기 위한 프로그램 방식의 인증에 사용됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | 사용자 이름 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 조회한 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Identifier>](#identifier) | 크리덴셜 리스트 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.DescribeIdentifiers(
&identifier.DescribeIdentifiersRequest {
UserName: pointy.String("user-0001"),
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DescribeIdentifiersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->describeIdentifiers(
(new DescribeIdentifiersRequest())
->withUserName("user-0001")
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DescribeIdentifiersRequest;
import io.gs2.identifier.result.DescribeIdentifiersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
DescribeIdentifiersResult result = client.describeIdentifiers(
new DescribeIdentifiersRequest()
.withUserName("user-0001")
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeIdentifiers(
new Gs2.Gs2Identifier.Request.DescribeIdentifiersRequest()
.WithUserName("user-0001")
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.describeIdentifiers(
new Gs2Identifier.DescribeIdentifiersRequest()
.withUserName("user-0001")
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.describe_identifiers(
identifier.DescribeIdentifiersRequest()
.with_user_name('user-0001')
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.describe_identifiers({
userName="user-0001",
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.describe_identifiers_async({
userName="user-0001",
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### createIdentifier
크리덴셜을 신규 작성
지정된 사용자에 대해 새로운 OAuth 크리덴셜(클라이언트 ID와 클라이언트 시크릿)을 생성합니다.
클라이언트 시크릿은 이 응답에서만 반환되며, 이후에는 다시 취득할 수 없습니다. 안전하게 보관하십시오.
크리덴셜은 Login API로 프로젝트 토큰을 취득하기 위한 프로그램 방식의 API 액세스에 사용할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | 사용자 이름
이 크레덴셜을 소유한 GS2-Identifier 사용자의 이름입니다. 크레덴셜은 이 사용자에게 연결된 보안 정책에 따라 권한을 상속받습니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Identifier](#identifier) | 작성한 크리덴셜 |
| clientSecret | string | 클라이언트 시크릿 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.CreateIdentifier(
&identifier.CreateIdentifierRequest {
UserName: pointy.String("user-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
clientSecret := result.ClientSecret
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\CreateIdentifierRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->createIdentifier(
(new CreateIdentifierRequest())
->withUserName("user-0001")
);
$item = $result->getItem();
$clientSecret = $result->getClientSecret();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.CreateIdentifierRequest;
import io.gs2.identifier.result.CreateIdentifierResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
CreateIdentifierResult result = client.createIdentifier(
new CreateIdentifierRequest()
.withUserName("user-0001")
);
Identifier item = result.getItem();
String clientSecret = result.getClientSecret();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateIdentifier(
new Gs2.Gs2Identifier.Request.CreateIdentifierRequest()
.WithUserName("user-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var clientSecret = result.ClientSecret;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.createIdentifier(
new Gs2Identifier.CreateIdentifierRequest()
.withUserName("user-0001")
);
const item = result.getItem();
const clientSecret = result.getClientSecret();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.create_identifier(
identifier.CreateIdentifierRequest()
.with_user_name('user-0001')
)
item = result.item
client_secret = result.client_secret
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.create_identifier({
userName="user-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
clientSecret = result.clientSecret;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.create_identifier_async({
userName="user-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
clientSecret = result.clientSecret;
```
---
### getIdentifier
크리덴셜을 취득
클라이언트 ID로 식별되는 특정 크리덴셜의 메타데이터를 취득합니다.
보안상의 이유로 클라이언트 시크릿은 응답에 포함되지 않습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | 사용자 이름
이 크레덴셜을 소유한 GS2-Identifier 사용자의 이름입니다. 크레덴셜은 이 사용자에게 연결된 보안 정책에 따라 권한을 상속받습니다. |
| clientId | string | | ✓| UUID | ~ 256자 | 클라이언트ID |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Identifier](#identifier) | 크리덴셜 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.GetIdentifier(
&identifier.GetIdentifierRequest {
UserName: pointy.String("user-0001"),
ClientId: pointy.String("client-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\GetIdentifierRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->getIdentifier(
(new GetIdentifierRequest())
->withUserName("user-0001")
->withClientId("client-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.GetIdentifierRequest;
import io.gs2.identifier.result.GetIdentifierResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
GetIdentifierResult result = client.getIdentifier(
new GetIdentifierRequest()
.withUserName("user-0001")
.withClientId("client-0001")
);
Identifier item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetIdentifier(
new Gs2.Gs2Identifier.Request.GetIdentifierRequest()
.WithUserName("user-0001")
.WithClientId("client-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.getIdentifier(
new Gs2Identifier.GetIdentifierRequest()
.withUserName("user-0001")
.withClientId("client-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.get_identifier(
identifier.GetIdentifierRequest()
.with_user_name('user-0001')
.with_client_id('client-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.get_identifier({
userName="user-0001",
clientId="client-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.get_identifier_async({
userName="user-0001",
clientId="client-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteIdentifier
크리덴셜을 삭제
지정된 크리덴셜을 무효화하여 삭제합니다.
삭제 후 클라이언트 ID와 클라이언트 시크릿은 인증에 사용할 수 없게 됩니다.
이 크리덴셜로 이미 취득한 프로젝트 토큰은 유효 기간까지 유효합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | 사용자 이름
이 크레덴셜을 소유한 GS2-Identifier 사용자의 이름입니다. 크레덴셜은 이 사용자에게 연결된 보안 정책에 따라 권한을 상속받습니다. |
| clientId | string | | ✓| UUID | ~ 256자 | 클라이언트ID |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Identifier](#identifier) | 크리덴셜 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.DeleteIdentifier(
&identifier.DeleteIdentifierRequest {
UserName: pointy.String("user-0001"),
ClientId: pointy.String("client-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DeleteIdentifierRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->deleteIdentifier(
(new DeleteIdentifierRequest())
->withUserName("user-0001")
->withClientId("client-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DeleteIdentifierRequest;
import io.gs2.identifier.result.DeleteIdentifierResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
DeleteIdentifierResult result = client.deleteIdentifier(
new DeleteIdentifierRequest()
.withUserName("user-0001")
.withClientId("client-0001")
);
Identifier item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteIdentifier(
new Gs2.Gs2Identifier.Request.DeleteIdentifierRequest()
.WithUserName("user-0001")
.WithClientId("client-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.deleteIdentifier(
new Gs2Identifier.DeleteIdentifierRequest()
.withUserName("user-0001")
.withClientId("client-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.delete_identifier(
identifier.DeleteIdentifierRequest()
.with_user_name('user-0001')
.with_client_id('client-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.delete_identifier({
userName="user-0001",
clientId="client-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.delete_identifier_async({
userName="user-0001",
clientId="client-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeAttachedGuards
할당된 GS2-Guard Namespace GRN 목록 취득
지정된 크리덴셜에 할당된 GS2-Guard 네임스페이스의 리스트를 취득합니다.
가드가 할당되어 있는 경우, 이 크리덴셜을 사용한 API 요청은 가드 서비스에서 정의된 추가 액세스 제어 검사(IP 기반 차단 등)의 대상이 됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| clientId | string | | ✓| UUID | ~ 256자 | 클라이언트ID |
| userName | string | | ✓| | ~ 128자 | GS2-Identifier 사용자 이름
GS2-Identifier 사용자 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | List<string> | GS2-Guard Namespace GRN의 리스트 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.DescribeAttachedGuards(
&identifier.DescribeAttachedGuardsRequest {
ClientId: pointy.String("client-0001"),
UserName: pointy.String("user-0001"),
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DescribeAttachedGuardsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->describeAttachedGuards(
(new DescribeAttachedGuardsRequest())
->withClientId("client-0001")
->withUserName("user-0001")
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DescribeAttachedGuardsRequest;
import io.gs2.identifier.result.DescribeAttachedGuardsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
DescribeAttachedGuardsResult result = client.describeAttachedGuards(
new DescribeAttachedGuardsRequest()
.withClientId("client-0001")
.withUserName("user-0001")
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeAttachedGuards(
new Gs2.Gs2Identifier.Request.DescribeAttachedGuardsRequest()
.WithClientId("client-0001")
.WithUserName("user-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.describeAttachedGuards(
new Gs2Identifier.DescribeAttachedGuardsRequest()
.withClientId("client-0001")
.withUserName("user-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.describe_attached_guards(
identifier.DescribeAttachedGuardsRequest()
.with_client_id('client-0001')
.with_user_name('user-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.describe_attached_guards({
clientId="client-0001",
userName="user-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.describe_attached_guards_async({
clientId="client-0001",
userName="user-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### attachGuard
크리덴셜에 GS2-Guard Namespace GRN을 할당
추가적인 액세스 제어를 위해 GS2-Guard 네임스페이스를 지정된 크리덴셜에 할당합니다.
할당 후, 이 크리덴셜을 사용한 API 요청은 가드의 차단 정책(IP 감지, 익명 IP 필터링, 평판 기반 필터링 등)으로 검증됩니다.
조작 후 크리덴셜에 할당된 가드 네임스페이스의 전체 리스트를 반환합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | GS2-Identifier 사용자 이름
GS2-Identifier 사용자 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clientId | string | | ✓| UUID | ~ 256자 | 클라이언트ID |
| guardNamespaceId | string | | ✓| | ~ 1024자 | 할당할 GS2-Guard Namespace GRN |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | List<string> | GS2-Guard Namespace GRN의 리스트 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.AttachGuard(
&identifier.AttachGuardRequest {
UserName: pointy.String("user-0001"),
ClientId: pointy.String("client-0001"),
GuardNamespaceId: pointy.String("guard-namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\AttachGuardRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->attachGuard(
(new AttachGuardRequest())
->withUserName("user-0001")
->withClientId("client-0001")
->withGuardNamespaceId("guard-namespace-0001")
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.AttachGuardRequest;
import io.gs2.identifier.result.AttachGuardResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
AttachGuardResult result = client.attachGuard(
new AttachGuardRequest()
.withUserName("user-0001")
.withClientId("client-0001")
.withGuardNamespaceId("guard-namespace-0001")
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.AttachGuard(
new Gs2.Gs2Identifier.Request.AttachGuardRequest()
.WithUserName("user-0001")
.WithClientId("client-0001")
.WithGuardNamespaceId("guard-namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.attachGuard(
new Gs2Identifier.AttachGuardRequest()
.withUserName("user-0001")
.withClientId("client-0001")
.withGuardNamespaceId("guard-namespace-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.attach_guard(
identifier.AttachGuardRequest()
.with_user_name('user-0001')
.with_client_id('client-0001')
.with_guard_namespace_id('guard-namespace-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.attach_guard({
userName="user-0001",
clientId="client-0001",
guardNamespaceId="guard-namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.attach_guard_async({
userName="user-0001",
clientId="client-0001",
guardNamespaceId="guard-namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### detachGuard
GS2-Guard Namespace GRN을 크리덴셜에서 제외합니다
지정된 크리덴셜에서 GS2-Guard 네임스페이스를 삭제합니다.
삭제 후, 이 크리덴셜을 사용한 API 요청은 해당 가드의 액세스 제어 검사 대상이 아니게 됩니다.
크리덴셜에 계속 할당되어 있는 가드 네임스페이스의 리스트를 반환합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | GS2-Identifier 사용자 이름
GS2-Identifier 사용자 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clientId | string | | ✓| UUID | ~ 256자 | 클라이언트ID |
| guardNamespaceId | string | | ✓| | ~ 1024자 | GS2-Guard Namespace의 GRN |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | List<string> | GS2-Guard Namespace GRN의 리스트 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.DetachGuard(
&identifier.DetachGuardRequest {
UserName: pointy.String("user-0001"),
ClientId: pointy.String("client-0001"),
GuardNamespaceId: pointy.String("guard-namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DetachGuardRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->detachGuard(
(new DetachGuardRequest())
->withUserName("user-0001")
->withClientId("client-0001")
->withGuardNamespaceId("guard-namespace-0001")
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DetachGuardRequest;
import io.gs2.identifier.result.DetachGuardResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
DetachGuardResult result = client.detachGuard(
new DetachGuardRequest()
.withUserName("user-0001")
.withClientId("client-0001")
.withGuardNamespaceId("guard-namespace-0001")
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.DetachGuard(
new Gs2.Gs2Identifier.Request.DetachGuardRequest()
.WithUserName("user-0001")
.WithClientId("client-0001")
.WithGuardNamespaceId("guard-namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.detachGuard(
new Gs2Identifier.DetachGuardRequest()
.withUserName("user-0001")
.withClientId("client-0001")
.withGuardNamespaceId("guard-namespace-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.detach_guard(
identifier.DetachGuardRequest()
.with_user_name('user-0001')
.with_client_id('client-0001')
.with_guard_namespace_id('guard-namespace-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.detach_guard({
userName="user-0001",
clientId="client-0001",
guardNamespaceId="guard-namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.detach_guard_async({
userName="user-0001",
clientId="client-0001",
guardNamespaceId="guard-namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### getServiceVersion
마이크로서비스 버전 조회
#### Request
요청 파라미터: 없음
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | string | 버전 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.GetServiceVersion(
&identifier.GetServiceVersionRequest {
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\GetServiceVersionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->getServiceVersion(
(new GetServiceVersionRequest())
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.GetServiceVersionRequest;
import io.gs2.identifier.result.GetServiceVersionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
GetServiceVersionResult result = client.getServiceVersion(
new GetServiceVersionRequest()
);
String item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetServiceVersion(
new Gs2.Gs2Identifier.Request.GetServiceVersionRequest(),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.getServiceVersion(
new Gs2Identifier.GetServiceVersionRequest()
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.get_service_version(
identifier.GetServiceVersionRequest()
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.get_service_version({
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.get_service_version_async({
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### createPassword
패스워드를 신규 작성
지정된 GS2-Identifier 사용자의 패스워드 크리덴셜을 작성합니다.
작성 후, 사용자는 LoginByUser API를 사용하여 사용자 이름과 패스워드로 인증하고 프로젝트 토큰을 취득할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | 사용자 이름
이 비밀번호를 소유하는 GS2-Identifier 사용자의 이름입니다. 사용자는 이 사용자 이름과 대응하는 비밀번호로 매니지먼트 콘솔에 로그인하며, 사용자에게 할당된 보안 정책에 따라 접근이 제한됩니다. |
| password | string | | ✓| | ~ 1024자 | 비밀번호
매니지먼트 콘솔 인증에 사용되는 해시화된 비밀번호입니다. 비밀번호 생성 시 설정되며, 로그인 시 사용자 입력과 대조됩니다. 내부적으로 저장되며, API를 통해 반환되지 않습니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Password](#password) | 작성한 패스워드 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.CreatePassword(
&identifier.CreatePasswordRequest {
UserName: pointy.String("user-0001"),
Password: pointy.String("password-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\CreatePasswordRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->createPassword(
(new CreatePasswordRequest())
->withUserName("user-0001")
->withPassword("password-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.CreatePasswordRequest;
import io.gs2.identifier.result.CreatePasswordResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
CreatePasswordResult result = client.createPassword(
new CreatePasswordRequest()
.withUserName("user-0001")
.withPassword("password-0001")
);
Password item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreatePassword(
new Gs2.Gs2Identifier.Request.CreatePasswordRequest()
.WithUserName("user-0001")
.WithPassword("password-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.createPassword(
new Gs2Identifier.CreatePasswordRequest()
.withUserName("user-0001")
.withPassword("password-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.create_password(
identifier.CreatePasswordRequest()
.with_user_name('user-0001')
.with_password('password-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.create_password({
userName="user-0001",
password="password-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.create_password_async({
userName="user-0001",
password="password-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getPassword
패스워드를 취득
지정된 사용자의 패스워드 메타데이터를 취득합니다.
실제 패스워드 값은 반환되지 않습니다. MFA 설정이나 작성 시각 등의 메타데이터만 포함됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | 사용자 이름
이 비밀번호를 소유하는 GS2-Identifier 사용자의 이름입니다. 사용자는 이 사용자 이름과 대응하는 비밀번호로 매니지먼트 콘솔에 로그인하며, 사용자에게 할당된 보안 정책에 따라 접근이 제한됩니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Password](#password) | 비밀번호 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.GetPassword(
&identifier.GetPasswordRequest {
UserName: pointy.String("user-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\GetPasswordRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->getPassword(
(new GetPasswordRequest())
->withUserName("user-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.GetPasswordRequest;
import io.gs2.identifier.result.GetPasswordResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
GetPasswordResult result = client.getPassword(
new GetPasswordRequest()
.withUserName("user-0001")
);
Password item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetPassword(
new Gs2.Gs2Identifier.Request.GetPasswordRequest()
.WithUserName("user-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.getPassword(
new Gs2Identifier.GetPasswordRequest()
.withUserName("user-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.get_password(
identifier.GetPasswordRequest()
.with_user_name('user-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.get_password({
userName="user-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.get_password_async({
userName="user-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### enableMfa
MFA를 활성화
지정된 사용자의 TOTP(Time-based One-Time Password) 기반 다요소 인증 설정을 시작합니다.
TOTP 시크릿 키를 생성하고 MFA 상태를 "Verifying"으로 설정합니다.
TOTP 패스코드를 검증하여 설정을 완료하기 위해 ChallengeMfa API에서 사용할 챌린지 토큰을 반환합니다.
MFA가 이미 활성화되어 있는 경우 오류가 반환됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | 사용자 이름
이 비밀번호를 소유하는 GS2-Identifier 사용자의 이름입니다. 사용자는 이 사용자 이름과 대응하는 비밀번호로 매니지먼트 콘솔에 로그인하며, 사용자에게 할당된 보안 정책에 따라 접근이 제한됩니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Password](#password) | 업데이트한 패스워드 |
| challengeToken | string | Challenge Token |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.EnableMfa(
&identifier.EnableMfaRequest {
UserName: pointy.String("user-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
challengeToken := result.ChallengeToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\EnableMfaRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->enableMfa(
(new EnableMfaRequest())
->withUserName("user-0001")
);
$item = $result->getItem();
$challengeToken = $result->getChallengeToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.EnableMfaRequest;
import io.gs2.identifier.result.EnableMfaResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
EnableMfaResult result = client.enableMfa(
new EnableMfaRequest()
.withUserName("user-0001")
);
Password item = result.getItem();
String challengeToken = result.getChallengeToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.EnableMfa(
new Gs2.Gs2Identifier.Request.EnableMfaRequest()
.WithUserName("user-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var challengeToken = result.ChallengeToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.enableMfa(
new Gs2Identifier.EnableMfaRequest()
.withUserName("user-0001")
);
const item = result.getItem();
const challengeToken = result.getChallengeToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.enable_mfa(
identifier.EnableMfaRequest()
.with_user_name('user-0001')
)
item = result.item
challenge_token = result.challenge_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.enable_mfa({
userName="user-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
challengeToken = result.challengeToken;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.enable_mfa_async({
userName="user-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
challengeToken = result.challengeToken;
```
---
### challengeMfa
MFA 유효성 확인
6자리 TOTP(Time-based One-Time Password) 코드를 검증하여 MFA 설정을 완료합니다.
MFA 상태가 "Verifying"(EnableMfa로 설정됨)이어야 합니다. 그렇지 않으면 오류가 반환됩니다.
검증 성공 후 MFA 상태가 "Enable"로 변경되며, 이후 LoginByUser를 통한 로그인에는 TOTP 코드가 필요합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | 사용자 이름
이 비밀번호를 소유하는 GS2-Identifier 사용자의 이름입니다. 사용자는 이 사용자 이름과 대응하는 비밀번호로 매니지먼트 콘솔에 로그인하며, 사용자에게 할당된 보안 정책에 따라 접근이 제한됩니다. |
| passcode | string | | ✓| | 6 ~ 6자 | 일회용 비밀번호 코드 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Password](#password) | 업데이트한 패스워드 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.ChallengeMfa(
&identifier.ChallengeMfaRequest {
UserName: pointy.String("user-0001"),
Passcode: pointy.String("012345"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\ChallengeMfaRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->challengeMfa(
(new ChallengeMfaRequest())
->withUserName("user-0001")
->withPasscode("012345")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.ChallengeMfaRequest;
import io.gs2.identifier.result.ChallengeMfaResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
ChallengeMfaResult result = client.challengeMfa(
new ChallengeMfaRequest()
.withUserName("user-0001")
.withPasscode("012345")
);
Password item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.ChallengeMfa(
new Gs2.Gs2Identifier.Request.ChallengeMfaRequest()
.WithUserName("user-0001")
.WithPasscode("012345"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.challengeMfa(
new Gs2Identifier.ChallengeMfaRequest()
.withUserName("user-0001")
.withPasscode("012345")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.challenge_mfa(
identifier.ChallengeMfaRequest()
.with_user_name('user-0001')
.with_passcode('012345')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.challenge_mfa({
userName="user-0001",
passcode="012345",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.challenge_mfa_async({
userName="user-0001",
passcode="012345",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### disableMfa
MFA를 비활성화
지정된 사용자의 다요소 인증을 비활성화합니다.
TOTP 시크릿 키와 MFA 설정이 초기화됩니다. 이후 로그인에서는 패스워드 인증만 필요하게 됩니다.
MFA가 이미 비활성화되어 있는 경우 오류가 반환됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | 사용자 이름
이 비밀번호를 소유하는 GS2-Identifier 사용자의 이름입니다. 사용자는 이 사용자 이름과 대응하는 비밀번호로 매니지먼트 콘솔에 로그인하며, 사용자에게 할당된 보안 정책에 따라 접근이 제한됩니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Password](#password) | 업데이트한 패스워드 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.DisableMfa(
&identifier.DisableMfaRequest {
UserName: pointy.String("user-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DisableMfaRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->disableMfa(
(new DisableMfaRequest())
->withUserName("user-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DisableMfaRequest;
import io.gs2.identifier.result.DisableMfaResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
DisableMfaResult result = client.disableMfa(
new DisableMfaRequest()
.withUserName("user-0001")
);
Password item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.DisableMfa(
new Gs2.Gs2Identifier.Request.DisableMfaRequest()
.WithUserName("user-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.disableMfa(
new Gs2Identifier.DisableMfaRequest()
.withUserName("user-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.disable_mfa(
identifier.DisableMfaRequest()
.with_user_name('user-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.disable_mfa({
userName="user-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.disable_mfa_async({
userName="user-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deletePassword
패스워드를 삭제
지정된 사용자의 패스워드 크리덴셜을 삭제합니다.
삭제 후, 사용자는 LoginByUser API로 인증할 수 없게 됩니다. MFA 설정도 함께 삭제됩니다.
Login API를 통한 크리덴셜 기반 인증(클라이언트 ID/시크릿)은 영향을 받지 않습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | 사용자 이름
이 비밀번호를 소유하는 GS2-Identifier 사용자의 이름입니다. 사용자는 이 사용자 이름과 대응하는 비밀번호로 매니지먼트 콘솔에 로그인하며, 사용자에게 할당된 보안 정책에 따라 접근이 제한됩니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Password](#password) | 비밀번호 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.DeletePassword(
&identifier.DeletePasswordRequest {
UserName: pointy.String("user-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DeletePasswordRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->deletePassword(
(new DeletePasswordRequest())
->withUserName("user-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DeletePasswordRequest;
import io.gs2.identifier.result.DeletePasswordResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
DeletePasswordResult result = client.deletePassword(
new DeletePasswordRequest()
.withUserName("user-0001")
);
Password item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeletePassword(
new Gs2.Gs2Identifier.Request.DeletePasswordRequest()
.WithUserName("user-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.deletePassword(
new Gs2Identifier.DeletePasswordRequest()
.withUserName("user-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.delete_password(
identifier.DeletePasswordRequest()
.with_user_name('user-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.delete_password({
userName="user-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.delete_password_async({
userName="user-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getHasSecurityPolicy
할당된 보안 정책 목록 취득
지정된 사용자에게 현재 할당되어 있는 모든 보안 정책을 취득합니다.
할당된 정책의 조합에 따라 사용자의 유효한 API 권한이 결정됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | GS2-Identifier 사용자 이름
GS2-Identifier 사용자 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SecurityPolicy>](#securitypolicy) | 보안 정책 목록 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.GetHasSecurityPolicy(
&identifier.GetHasSecurityPolicyRequest {
UserName: pointy.String("user-0001"),
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\GetHasSecurityPolicyRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->getHasSecurityPolicy(
(new GetHasSecurityPolicyRequest())
->withUserName("user-0001")
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.GetHasSecurityPolicyRequest;
import io.gs2.identifier.result.GetHasSecurityPolicyResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
GetHasSecurityPolicyResult result = client.getHasSecurityPolicy(
new GetHasSecurityPolicyRequest()
.withUserName("user-0001")
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetHasSecurityPolicy(
new Gs2.Gs2Identifier.Request.GetHasSecurityPolicyRequest()
.WithUserName("user-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.getHasSecurityPolicy(
new Gs2Identifier.GetHasSecurityPolicyRequest()
.withUserName("user-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.get_has_security_policy(
identifier.GetHasSecurityPolicyRequest()
.with_user_name('user-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.get_has_security_policy({
userName="user-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.get_has_security_policy_async({
userName="user-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### attachSecurityPolicy
사용자에게 보안 정책을 할당
GRN을 지정하여 보안 정책을 사용자에게 할당합니다.
할당 전에 정책이 로드 및 검증됩니다. 커스텀 정책과 GS2에서 정의한 공통 정책 모두 할당할 수 있습니다.
사용자에게는 여러 정책을 할당할 수 있으며, 유효한 권한은 할당된 모든 정책의 합집합이 됩니다.
작업 후 사용자에게 현재 할당되어 있는 보안 정책의 전체 목록을 반환합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | GS2-Identifier 사용자 이름
GS2-Identifier 사용자 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| securityPolicyId | string | | ✓| | ~ 1024자 | 할당할 보안 정책의 GRN |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SecurityPolicy>](#securitypolicy) | 사용자에게 할당한 보안 정책 목록 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.AttachSecurityPolicy(
&identifier.AttachSecurityPolicyRequest {
UserName: pointy.String("user-0001"),
SecurityPolicyId: pointy.String("securityPolicyId-0001"),
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\AttachSecurityPolicyRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->attachSecurityPolicy(
(new AttachSecurityPolicyRequest())
->withUserName("user-0001")
->withSecurityPolicyId("securityPolicyId-0001")
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.AttachSecurityPolicyRequest;
import io.gs2.identifier.result.AttachSecurityPolicyResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
AttachSecurityPolicyResult result = client.attachSecurityPolicy(
new AttachSecurityPolicyRequest()
.withUserName("user-0001")
.withSecurityPolicyId("securityPolicyId-0001")
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.AttachSecurityPolicy(
new Gs2.Gs2Identifier.Request.AttachSecurityPolicyRequest()
.WithUserName("user-0001")
.WithSecurityPolicyId("securityPolicyId-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.attachSecurityPolicy(
new Gs2Identifier.AttachSecurityPolicyRequest()
.withUserName("user-0001")
.withSecurityPolicyId("securityPolicyId-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.attach_security_policy(
identifier.AttachSecurityPolicyRequest()
.with_user_name('user-0001')
.with_security_policy_id('securityPolicyId-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.attach_security_policy({
userName="user-0001",
securityPolicyId="securityPolicyId-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.attach_security_policy_async({
userName="user-0001",
securityPolicyId="securityPolicyId-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### detachSecurityPolicy
할당된 보안 정책을 사용자로부터 해제
GRN을 지정하여 보안 정책을 사용자로부터 해제합니다.
해제 후, 사용자는 이 정책으로 부여되었던 권한을 잃게 됩니다.
작업 후 사용자에게 계속 할당되어 있는 보안 정책의 리스트를 반환합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | GS2-Identifier 사용자 이름
GS2-Identifier 사용자 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| securityPolicyId | string | | ✓| | ~ 1024자 | 해제할 보안 정책의 GRN |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SecurityPolicy>](#securitypolicy) | 해제한 후 사용자에게 계속 할당되어 있는 보안 정책 목록 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.DetachSecurityPolicy(
&identifier.DetachSecurityPolicyRequest {
UserName: pointy.String("user-0001"),
SecurityPolicyId: pointy.String("securityPolicyId-0001"),
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DetachSecurityPolicyRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->detachSecurityPolicy(
(new DetachSecurityPolicyRequest())
->withUserName("user-0001")
->withSecurityPolicyId("securityPolicyId-0001")
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DetachSecurityPolicyRequest;
import io.gs2.identifier.result.DetachSecurityPolicyResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
DetachSecurityPolicyResult result = client.detachSecurityPolicy(
new DetachSecurityPolicyRequest()
.withUserName("user-0001")
.withSecurityPolicyId("securityPolicyId-0001")
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.DetachSecurityPolicy(
new Gs2.Gs2Identifier.Request.DetachSecurityPolicyRequest()
.WithUserName("user-0001")
.WithSecurityPolicyId("securityPolicyId-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.detachSecurityPolicy(
new Gs2Identifier.DetachSecurityPolicyRequest()
.withUserName("user-0001")
.withSecurityPolicyId("securityPolicyId-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.detach_security_policy(
identifier.DetachSecurityPolicyRequest()
.with_user_name('user-0001')
.with_security_policy_id('securityPolicyId-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.detach_security_policy({
userName="user-0001",
securityPolicyId="securityPolicyId-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.detach_security_policy_async({
userName="user-0001",
securityPolicyId="securityPolicyId-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### describeUsers
사용자 목록 취득
현재 프로젝트 하위의 GS2-Identifier 사용자에 대한 페이지네이션 리스트를 취득합니다.
사용자는 API 접근 제어를 위한 크리덴셜(클라이언트 ID/시크릿), 비밀번호, 보안 정책을 보유할 수 있는 엔티티입니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<User>](#user) | 사용자 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.DescribeUsers(
&identifier.DescribeUsersRequest {
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DescribeUsersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->describeUsers(
(new DescribeUsersRequest())
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DescribeUsersRequest;
import io.gs2.identifier.result.DescribeUsersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
DescribeUsersResult result = client.describeUsers(
new DescribeUsersRequest()
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeUsers(
new Gs2.Gs2Identifier.Request.DescribeUsersRequest()
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.describeUsers(
new Gs2Identifier.DescribeUsersRequest()
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.describe_users(
identifier.DescribeUsersRequest()
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.describe_users({
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.describe_users_async({
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### createUser
사용자 신규 생성
지정된 이름과 설명으로 새로운 GS2-Identifier 사용자를 생성합니다.
생성 후, API 접근 권한을 제어하기 위해 크리덴셜, 비밀번호, 보안 정책을 할당할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓| | ~ 128자 | GS2-Identifier 사용자 이름
GS2-Identifier 사용자 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [User](#user) | 생성한 사용자 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.CreateUser(
&identifier.CreateUserRequest {
Name: pointy.String("user-0001"),
Description: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\CreateUserRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->createUser(
(new CreateUserRequest())
->withName("user-0001")
->withDescription(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.CreateUserRequest;
import io.gs2.identifier.result.CreateUserResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
CreateUserResult result = client.createUser(
new CreateUserRequest()
.withName("user-0001")
.withDescription(null)
);
User item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateUser(
new Gs2.Gs2Identifier.Request.CreateUserRequest()
.WithName("user-0001")
.WithDescription(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.createUser(
new Gs2Identifier.CreateUserRequest()
.withName("user-0001")
.withDescription(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.create_user(
identifier.CreateUserRequest()
.with_name('user-0001')
.with_description(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.create_user({
name="user-0001",
description=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.create_user_async({
name="user-0001",
description=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateUser
사용자 갱신
기존 GS2-Identifier 사용자의 설명을 갱신합니다.
사용자 이름은 생성 후 변경할 수 없습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | GS2-Identifier 사용자 이름
GS2-Identifier 사용자 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [User](#user) | 갱신 후 사용자 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.UpdateUser(
&identifier.UpdateUserRequest {
UserName: pointy.String("user-0001"),
Description: pointy.String("description1"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\UpdateUserRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->updateUser(
(new UpdateUserRequest())
->withUserName("user-0001")
->withDescription("description1")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.UpdateUserRequest;
import io.gs2.identifier.result.UpdateUserResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
UpdateUserResult result = client.updateUser(
new UpdateUserRequest()
.withUserName("user-0001")
.withDescription("description1")
);
User item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateUser(
new Gs2.Gs2Identifier.Request.UpdateUserRequest()
.WithUserName("user-0001")
.WithDescription("description1"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.updateUser(
new Gs2Identifier.UpdateUserRequest()
.withUserName("user-0001")
.withDescription("description1")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.update_user(
identifier.UpdateUserRequest()
.with_user_name('user-0001')
.with_description('description1')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.update_user({
userName="user-0001",
description="description1",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.update_user_async({
userName="user-0001",
description="description1",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getUser
사용자 취득
사용자 이름을 지정하여 특정 GS2-Identifier 사용자의 상세 정보를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | GS2-Identifier 사용자 이름
GS2-Identifier 사용자 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [User](#user) | 사용자 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.GetUser(
&identifier.GetUserRequest {
UserName: pointy.String("user-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\GetUserRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->getUser(
(new GetUserRequest())
->withUserName("user-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.GetUserRequest;
import io.gs2.identifier.result.GetUserResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
GetUserResult result = client.getUser(
new GetUserRequest()
.withUserName("user-0001")
);
User item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetUser(
new Gs2.Gs2Identifier.Request.GetUserRequest()
.WithUserName("user-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.getUser(
new Gs2Identifier.GetUserRequest()
.withUserName("user-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.get_user(
identifier.GetUserRequest()
.with_user_name('user-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.get_user({
userName="user-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.get_user_async({
userName="user-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteUser
사용자 삭제
GS2-Identifier 사용자와 크리덴셜, 비밀번호, 보안 정책 할당을 포함한 모든 관련 데이터를 삭제합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | GS2-Identifier 사용자 이름
GS2-Identifier 사용자 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [User](#user) | 삭제한 사용자 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.DeleteUser(
&identifier.DeleteUserRequest {
UserName: pointy.String("user-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DeleteUserRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->deleteUser(
(new DeleteUserRequest())
->withUserName("user-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DeleteUserRequest;
import io.gs2.identifier.result.DeleteUserResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
DeleteUserResult result = client.deleteUser(
new DeleteUserRequest()
.withUserName("user-0001")
);
User item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteUser(
new Gs2.Gs2Identifier.Request.DeleteUserRequest()
.WithUserName("user-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.deleteUser(
new Gs2Identifier.DeleteUserRequest()
.withUserName("user-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.delete_user(
identifier.DeleteUserRequest()
.with_user_name('user-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.delete_user({
userName="user-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.delete_user_async({
userName="user-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeSecurityPolicies
보안 정책 목록 취득
현재 프로젝트에서 정의된 커스텀 보안 정책의 페이지네이션 리스트를 취득합니다.
보안 정책은 사용자가 실행할 수 있는 GS2 API 조작을 제어하는 인가 규칙을 정의하는 JSON 문서입니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SecurityPolicy>](#securitypolicy) | 보안 정책 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.DescribeSecurityPolicies(
&identifier.DescribeSecurityPoliciesRequest {
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DescribeSecurityPoliciesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->describeSecurityPolicies(
(new DescribeSecurityPoliciesRequest())
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DescribeSecurityPoliciesRequest;
import io.gs2.identifier.result.DescribeSecurityPoliciesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
DescribeSecurityPoliciesResult result = client.describeSecurityPolicies(
new DescribeSecurityPoliciesRequest()
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSecurityPolicies(
new Gs2.Gs2Identifier.Request.DescribeSecurityPoliciesRequest()
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.describeSecurityPolicies(
new Gs2Identifier.DescribeSecurityPoliciesRequest()
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.describe_security_policies(
identifier.DescribeSecurityPoliciesRequest()
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.describe_security_policies({
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.describe_security_policies_async({
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### describeCommonSecurityPolicies
GS2 정의 보안 정책 목록 취득
GS2가 제공하는 내장 보안 정책의 페이지네이션 리스트를 취득합니다.
이러한 공통 정책은 일반적인 사용 사례를 커버하며, 커스텀 정책과 함께 사용자에게 할당할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SecurityPolicy>](#securitypolicy) | 보안 정책 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.DescribeCommonSecurityPolicies(
&identifier.DescribeCommonSecurityPoliciesRequest {
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DescribeCommonSecurityPoliciesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->describeCommonSecurityPolicies(
(new DescribeCommonSecurityPoliciesRequest())
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DescribeCommonSecurityPoliciesRequest;
import io.gs2.identifier.result.DescribeCommonSecurityPoliciesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
DescribeCommonSecurityPoliciesResult result = client.describeCommonSecurityPolicies(
new DescribeCommonSecurityPoliciesRequest()
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeCommonSecurityPolicies(
new Gs2.Gs2Identifier.Request.DescribeCommonSecurityPoliciesRequest()
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.describeCommonSecurityPolicies(
new Gs2Identifier.DescribeCommonSecurityPoliciesRequest()
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.describe_common_security_policies(
identifier.DescribeCommonSecurityPoliciesRequest()
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.describe_common_security_policies({
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.describe_common_security_policies_async({
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### createSecurityPolicy
보안 정책 신규 생성
이름, 설명, JSON 정책 문서를 사용하여 새로운 커스텀 보안 정책을 생성합니다.
정책 문서는 허용 또는 거부할 GS2 API 작업을 제어하는 인가 규칙을 정의합니다.
생성 후 AttachSecurityPolicy API를 사용하여 사용자에게 정책을 할당할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓| | ~ 128자 | 보안 정책 이름
보안 정책 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| policy | string | | ✓| | ~ 524288자 | 정책 문서
이 보안 정책의 접근 제어 규칙을 정의하는 JSON 문서입니다. 어떤 GS2 API 액션을 허용 또는 거부할지, 그리고 규칙이 적용되는 리소스(GRN 패턴으로 식별)를 지정합니다. 여러 스테이트먼트를 조합하여 세밀한 접근 제어를 만들 수 있습니다. 최대 512KB입니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SecurityPolicy](#securitypolicy) | 생성한 보안 정책 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.CreateSecurityPolicy(
&identifier.CreateSecurityPolicyRequest {
Name: pointy.String("policy-0001"),
Description: nil,
Policy: pointy.String("{}"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\CreateSecurityPolicyRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->createSecurityPolicy(
(new CreateSecurityPolicyRequest())
->withName("policy-0001")
->withDescription(null)
->withPolicy("{}")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.CreateSecurityPolicyRequest;
import io.gs2.identifier.result.CreateSecurityPolicyResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
CreateSecurityPolicyResult result = client.createSecurityPolicy(
new CreateSecurityPolicyRequest()
.withName("policy-0001")
.withDescription(null)
.withPolicy("{}")
);
SecurityPolicy item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateSecurityPolicy(
new Gs2.Gs2Identifier.Request.CreateSecurityPolicyRequest()
.WithName("policy-0001")
.WithDescription(null)
.WithPolicy("{}"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.createSecurityPolicy(
new Gs2Identifier.CreateSecurityPolicyRequest()
.withName("policy-0001")
.withDescription(null)
.withPolicy("{}")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.create_security_policy(
identifier.CreateSecurityPolicyRequest()
.with_name('policy-0001')
.with_description(None)
.with_policy('{}')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.create_security_policy({
name="policy-0001",
description=nil,
policy="{}",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.create_security_policy_async({
name="policy-0001",
description=nil,
policy="{}",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateSecurityPolicy
보안 정책 갱신
기존 보안 정책의 설명과 정책 문서를 갱신합니다.
변경 사항은 이 정책이 할당되어 있는 모든 사용자에게 즉시 반영됩니다.
정책 이름은 생성 후 변경할 수 없습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| securityPolicyName | string | | ✓| | ~ 128자 | 보안 정책 이름
보안 정책 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| policy | string | | ✓| | ~ 524288자 | 정책 문서
이 보안 정책의 접근 제어 규칙을 정의하는 JSON 문서입니다. 어떤 GS2 API 액션을 허용 또는 거부할지, 그리고 규칙이 적용되는 리소스(GRN 패턴으로 식별)를 지정합니다. 여러 스테이트먼트를 조합하여 세밀한 접근 제어를 만들 수 있습니다. 최대 512KB입니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SecurityPolicy](#securitypolicy) | 갱신 후 보안 정책 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.UpdateSecurityPolicy(
&identifier.UpdateSecurityPolicyRequest {
SecurityPolicyName: pointy.String("policy-0001"),
Description: pointy.String("description1"),
Policy: pointy.String("{\"hoge\": \"fuga\"}"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\UpdateSecurityPolicyRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->updateSecurityPolicy(
(new UpdateSecurityPolicyRequest())
->withSecurityPolicyName("policy-0001")
->withDescription("description1")
->withPolicy("{\"hoge\": \"fuga\"}")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.UpdateSecurityPolicyRequest;
import io.gs2.identifier.result.UpdateSecurityPolicyResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
UpdateSecurityPolicyResult result = client.updateSecurityPolicy(
new UpdateSecurityPolicyRequest()
.withSecurityPolicyName("policy-0001")
.withDescription("description1")
.withPolicy("{\"hoge\": \"fuga\"}")
);
SecurityPolicy item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateSecurityPolicy(
new Gs2.Gs2Identifier.Request.UpdateSecurityPolicyRequest()
.WithSecurityPolicyName("policy-0001")
.WithDescription("description1")
.WithPolicy("{\"hoge\": \"fuga\"}"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.updateSecurityPolicy(
new Gs2Identifier.UpdateSecurityPolicyRequest()
.withSecurityPolicyName("policy-0001")
.withDescription("description1")
.withPolicy("{\"hoge\": \"fuga\"}")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.update_security_policy(
identifier.UpdateSecurityPolicyRequest()
.with_security_policy_name('policy-0001')
.with_description('description1')
.with_policy('{"hoge": "fuga"}')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.update_security_policy({
securityPolicyName="policy-0001",
description="description1",
policy="{\"hoge\": \"fuga\"}",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.update_security_policy_async({
securityPolicyName="policy-0001",
description="description1",
policy="{\"hoge\": \"fuga\"}",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getSecurityPolicy
보안 정책 취득
JSON 정책 문서를 포함하여 특정 보안 정책의 상세 정보를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| securityPolicyName | string | | ✓| | ~ 128자 | 보안 정책 이름
보안 정책 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SecurityPolicy](#securitypolicy) | 보안 정책 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.GetSecurityPolicy(
&identifier.GetSecurityPolicyRequest {
SecurityPolicyName: pointy.String("policy-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\GetSecurityPolicyRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->getSecurityPolicy(
(new GetSecurityPolicyRequest())
->withSecurityPolicyName("policy-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.GetSecurityPolicyRequest;
import io.gs2.identifier.result.GetSecurityPolicyResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
GetSecurityPolicyResult result = client.getSecurityPolicy(
new GetSecurityPolicyRequest()
.withSecurityPolicyName("policy-0001")
);
SecurityPolicy item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSecurityPolicy(
new Gs2.Gs2Identifier.Request.GetSecurityPolicyRequest()
.WithSecurityPolicyName("policy-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.getSecurityPolicy(
new Gs2Identifier.GetSecurityPolicyRequest()
.withSecurityPolicyName("policy-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.get_security_policy(
identifier.GetSecurityPolicyRequest()
.with_security_policy_name('policy-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.get_security_policy({
securityPolicyName="policy-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.get_security_policy_async({
securityPolicyName="policy-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteSecurityPolicy
보안 정책 삭제
커스텀 보안 정책을 삭제합니다.
이 정책이 아직 사용자에게 할당되어 있는 경우, 해당 사용자는 이 정책으로 부여되었던 권한을 잃게 됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| securityPolicyName | string | | ✓| | ~ 128자 | 보안 정책 이름
보안 정책 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SecurityPolicy](#securitypolicy) | 보안 정책 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.DeleteSecurityPolicy(
&identifier.DeleteSecurityPolicyRequest {
SecurityPolicyName: pointy.String("policy-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DeleteSecurityPolicyRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->deleteSecurityPolicy(
(new DeleteSecurityPolicyRequest())
->withSecurityPolicyName("policy-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DeleteSecurityPolicyRequest;
import io.gs2.identifier.result.DeleteSecurityPolicyResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
DeleteSecurityPolicyResult result = client.deleteSecurityPolicy(
new DeleteSecurityPolicyRequest()
.withSecurityPolicyName("policy-0001")
);
SecurityPolicy item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteSecurityPolicy(
new Gs2.Gs2Identifier.Request.DeleteSecurityPolicyRequest()
.WithSecurityPolicyName("policy-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.deleteSecurityPolicy(
new Gs2Identifier.DeleteSecurityPolicyRequest()
.withSecurityPolicyName("policy-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.delete_security_policy(
identifier.DeleteSecurityPolicyRequest()
.with_security_policy_name('policy-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.delete_security_policy({
securityPolicyName="policy-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.delete_security_policy_async({
securityPolicyName="policy-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### login
프로젝트 토큰 취득
OAuth2 클라이언트 크리덴셜(클라이언트 ID와 클라이언트 시크릿)을 사용하여 인증하고, 프로젝트 토큰(Bearer 토큰)을 반환합니다.
클라이언트 시크릿은 저장된 크리덴셜과 대조됩니다. 유효하지 않은 경우 Unauthorized 오류가 반환됩니다.
반환되는 토큰의 유효 기간은 36000초(10시간)이며, 이후의 모든 GS2 API 요청에서 Bearer 토큰으로 사용됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| client_id | string | | ✓| UUID | ~ 256자 | 클라이언트ID |
| client_secret | string | | ✓| UUID | ~ 100자 | 클라이언트 시크릿 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| access_token | string | 프로젝트 토큰 |
| token_type | string | Bearer |
| expires_in | int | 유효 기간(초) |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.Login(
&identifier.LoginRequest {
ClientId: pointy.String("client-0001"),
ClientSecret: pointy.String("secret-0001"),
}
)
if err != nil {
panic("error occurred")
}
accessToken := result.AccessToken
tokenType := result.TokenType
expiresIn := result.ExpiresIn
ownerId := result.OwnerId
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\LoginRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->login(
(new LoginRequest())
->withClientId("client-0001")
->withClientSecret("secret-0001")
);
$accessToken = $result->getAccessToken();
$tokenType = $result->getTokenType();
$expiresIn = $result->getExpiresIn();
$ownerId = $result->getOwnerId();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.LoginRequest;
import io.gs2.identifier.result.LoginResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
LoginResult result = client.login(
new LoginRequest()
.withClientId("client-0001")
.withClientSecret("secret-0001")
);
String accessToken = result.getAccessToken();
String tokenType = result.getTokenType();
int expiresIn = result.getExpiresIn();
String ownerId = result.getOwnerId();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.Login(
new Gs2.Gs2Identifier.Request.LoginRequest()
.WithClientId("client-0001")
.WithClientSecret("secret-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var accessToken = result.AccessToken;
var tokenType = result.TokenType;
var expiresIn = result.ExpiresIn;
var ownerId = result.OwnerId;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.login(
new Gs2Identifier.LoginRequest()
.withClientId("client-0001")
.withClientSecret("secret-0001")
);
const accessToken = result.getAccessToken();
const tokenType = result.getTokenType();
const expiresIn = result.getExpiresIn();
const ownerId = result.getOwnerId();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.login(
identifier.LoginRequest()
.with_client_id('client-0001')
.with_client_secret('secret-0001')
)
access_token = result.access_token
token_type = result.token_type
expires_in = result.expires_in
owner_id = result.owner_id
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.login({
clientId="client-0001",
clientSecret="secret-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
accessToken = result.accessToken;
tokenType = result.tokenType;
expiresIn = result.expiresIn;
ownerId = result.ownerId;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.login_async({
clientId="client-0001",
clientSecret="secret-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
accessToken = result.accessToken;
tokenType = result.tokenType;
expiresIn = result.expiresIn;
ownerId = result.ownerId;
```
---
### loginByUser
GS2-Identifier 사용자를 지정하여 프로젝트 토큰을 취득
GS2-Identifier의 사용자 이름과 비밀번호를 사용하여 인증하고, 프로젝트 토큰을 반환합니다.
사용자에게 다중 요소 인증(MFA)이 활성화되어 있는 경우, otp 필드에 유효한 TOTP 패스코드도 제공해야 합니다. 제공하지 않으면 "require" 오류가 반환됩니다.
비밀번호가 먼저 검증되고, MFA가 활성화되어 있는 경우 이어서 TOTP 패스코드가 검증됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userName | string | | ✓| | ~ 128자 | GS2-Identifier 사용자 이름 |
| password | string | | ✓| | ~ 1024자 | GS2-Identifier 사용자의 비밀번호 |
| otp | string | | | | 6 ~ 6자 | 패스코드 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ProjectToken](#projecttoken) | 프로젝트 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/identifier"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := identifier.Gs2IdentifierRestClient{
Session: &session,
}
result, err := client.LoginByUser(
&identifier.LoginByUserRequest {
UserName: pointy.String("user-name"),
Password: pointy.String("password"),
Otp: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\LoginByUserRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdentifierRestClient(
$session
);
try {
$result = $client->loginByUser(
(new LoginByUserRequest())
->withUserName("user-name")
->withPassword("password")
->withOtp(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.LoginByUserRequest;
import io.gs2.identifier.result.LoginByUserResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdentifierRestClient client = new Gs2IdentifierRestClient(session);
try {
LoginByUserResult result = client.loginByUser(
new LoginByUserRequest()
.withUserName("user-name")
.withPassword("password")
.withOtp(null)
);
ProjectToken item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2IdentifierRestClient(session);
AsyncResult asyncResult = null;
yield return client.LoginByUser(
new Gs2.Gs2Identifier.Request.LoginByUserRequest()
.WithUserName("user-name")
.WithPassword("password")
.WithOtp(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Identifier.Gs2IdentifierRestClient(session);
try {
const result = await client.loginByUser(
new Gs2Identifier.LoginByUserRequest()
.withUserName("user-name")
.withPassword("password")
.withOtp(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import identifier
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = identifier.Gs2IdentifierRestClient(session)
try:
result = client.login_by_user(
identifier.LoginByUserRequest()
.with_user_name('user-name')
.with_password('password')
.with_otp(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('identifier')
api_result = client.login_by_user({
userName="user-name",
password="password",
otp=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('identifier')
api_result_handler = client.login_by_user_async({
userName="user-name",
password="password",
otp=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---