Idira용 워크로드 ID 페더레이션 구성

Idira Secure Workload Access(SWA)를 사용하면 OpenAI API 키를 저장하지 않고도 OpenAI API를 호출할 수 있습니다. SWA는 워크로드에 SPIFFE ID를 할당하고 해당 ID를 나타내는 서명된 토큰인 JWT-SVID를 발급합니다. OpenAI SDK는 이 토큰을 매핑된 서비스 계정의 권한을 가진 단기 OpenAI 액세스 토큰으로 교환합니다.

이 가이드에서는 OpenAI API 설정 방법을 설명합니다. Codex에서 사용하려면 이 가이드에 따라 워크로드에 토큰을 전달한 다음 Codex에서 워크로드 ID 사용의 안내를 따르세요.

시작하기 전에

다음 항목을 준비하세요.

신뢰 도메인과 워크로드에 의도한 SPIFFE ID를 할당하는 증명 정책이 구성된 SWA 배포 환경
워크로드에서 SWA 에이전트의 Workload API 소켓에 접근할 수 있는 권한
OpenAI 조직에서 워크로드 ID 공급자, 서비스 계정 매핑, 프로젝트, 서비스 계정을 관리할 수 있는 권한
워크로드 ID 자격 증명을 지원하는 OpenAI SDK

Idira의 OpenAI 통합 가이드에 명시된 사전 요구 사항에 따라 SWA 인프라 설정을 완료하세요.

발급자 및 서명 키 확인

신뢰 도메인의 jwt.discovery_endpoints.oidc_discovery_url과 jwt.discovery_endpoints.jwks_uri 값을 확인하세요. 이 값은 Idira의 OIDC 구성 안내에 따라 찾을 수 있습니다.

OpenAI가 자격 증명 없이 HTTPS로 디스커버리 문서와 JWKS에 접근할 수 있어야 합니다. 발급자는 토큰의 iss 클레임에 지정된 HTTPS URL입니다. sub의 SPIFFE ID는 워크로드를 식별합니다.

https://api.openai.com/v1과 같이 OpenAI 액세스 전용 대상 값을 선택하세요. JWT-SVID를 요청할 때와 OpenAI 공급자를 구성할 때 동일한 값을 사용하세요. 대상 값은 토큰을 받을 주체를 식별하며, 토큰 교환 엔드포인트를 지정하지는 않습니다.

SWA는 기본적으로 4096비트 RSA 키로 RS512 서명을 생성합니다. OpenAI의 JWT 검증기는 이 조합을 지원합니다. SWA의 다른 서명 옵션은 Idira의 JWT 요구 사항을 참고하세요.

워크로드에 최신 JWT-SVID 전달

워크로드 환경에 spiffe-helper를 설치해 SWA 에이전트에 JWT-SVID를 요청하고 갱신하세요. 다음 구성을 helper.conf로 저장하세요. 헬퍼는 SPIFFE SDK 공통 예제에서 사용하는 경로인 /var/run/spiffe/openai.jwt에 토큰을 씁니다.

12345678agent_address = "/tmp/swa-agent/public/api.sock"
cert_dir      = "/var/run/spiffe"
daemon_mode   = true

jwt_svids = [{
  jwt_audience       = "https://api.openai.com/v1"
  jwt_svid_file_name = "openai.jwt"
}]

Kubernetes에서는 워크로드의 파드에서 헬퍼를 사이드카로 실행하세요. 메모리 기반 emptyDir 볼륨을 /var/run/spiffe에 마운트해 워크로드와 헬퍼가 공유하도록 하고, SWA 소켓의 상위 디렉터리인 /tmp/swa-agent/public을 헬퍼에 마운트하세요. VM에서는 /run/swa-agent/api.sock을 agent_address 값으로 사용하고 토큰 디렉터리를 메모리 기반 스토리지에 두세요. 소켓 접근 및 워크로드 증명 설정은 Idira의 배포 안내를 따르세요.

헬퍼를 시작하기 전에 토큰 디렉터리를 만들고 헬퍼에 쓰기 권한을 부여하세요. 사이드카 또는 VM 서비스에서 이 구성으로 헬퍼를 시작하세요.

spiffe-helper -config helper.conf

토큰 파일과 에이전트 소켓에 대한 접근 권한은 각각 해당 리소스가 필요한 프로세스에만 부여하세요. 토큰이 만료되기 전에 헬퍼가 새 토큰으로 교체할 수 있도록 헬퍼를 계속 실행하세요.

사용하는 언어에 SPIFFE Workload API 클라이언트가 있다면 헬퍼 대신 주체 토큰 공급자에서 최신 JWT-SVID를 직접 가져올 수 있습니다. Idira의 통합 가이드에서 Workload API를 직접 사용하는 방법을 참고하세요.

토큰 확인

워크로드 안에서 토큰을 읽어 로컬 디코더가 사용할 환경 변수에 저장하세요.

export TOKEN="$(cat /var/run/spiffe/openai.jwt)"

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25const parts = process.env.TOKEN?.split(".") ?? [];
if (parts.length !== 3) {
  throw new Error("Expected a compact JWT with three segments");
}

const decode = (segment) => {
  if (!/^[A-Za-z0-9_-]+$/.test(segment) || segment.length % 4 === 1) {
    throw new Error("JWT segment is not valid Base64URL");
  }
  const bytes = Buffer.from(segment, "base64url");
  if (bytes.toString("base64url") !== segment) {
    throw new Error("JWT segment is not valid Base64URL");
  }
  const decoded = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
  const value = JSON.parse(decoded);
  if (value === null || Array.isArray(value) || typeof value !== "object") {
    throw new Error("JWT segment is not a JSON object");
  }
  return decoded;
};

console.log("Header:");
console.log(decode(parts[0]));
console.log("\nPayload:");
console.log(decode(parts[1]));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33import base64
import json
import os
import re


def reject_non_json_constant(value):
    raise ValueError(f"JWT segment contains non-JSON constant: {value}")


parts = os.environ.get("TOKEN", "").split(".")
if len(parts) != 3:
    raise ValueError("Expected a compact JWT with three segments")


def decode(segment):
    if re.fullmatch(r"[A-Za-z0-9_-]+", segment) is None or len(segment) % 4 == 1:
        raise ValueError("JWT segment is not valid Base64URL")
    padded_segment = segment + "=" * (-len(segment) % 4)
    decoded = base64.b64decode(padded_segment, altchars=b"-_", validate=True)
    if base64.urlsafe_b64encode(decoded).rstrip(b"=").decode("ascii") != segment:
        raise ValueError("JWT segment is not valid Base64URL")
    decoded_text = decoded.decode("utf-8")
    value = json.loads(decoded_text, parse_constant=reject_non_json_constant)
    if not isinstance(value, dict):
        raise ValueError("JWT segment is not a JSON object")
    return decoded_text


print("Header:")
print(decode(parts[0]))
print("\nPayload:")
print(decode(parts[1]))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84package main

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"os"
	"strings"
	"unicode/utf8"
)

func decodeSegment(segment string) (json.RawMessage, error) {
	if !isBase64URLSegment(segment) {
		return nil, fmt.Errorf("JWT segment is not valid Base64URL")
	}
	decoded, err := base64.RawURLEncoding.DecodeString(segment)
	if err != nil {
		return nil, err
	}
	if base64.RawURLEncoding.EncodeToString(decoded) != segment {
		return nil, fmt.Errorf("JWT segment is not valid Base64URL")
	}
	if !utf8.Valid(decoded) {
		return nil, fmt.Errorf("JWT segment is not valid UTF-8")
	}

	var value json.RawMessage
	if err := json.Unmarshal(decoded, &value); err != nil {
		return nil, err
	}
	if trimmed := bytes.TrimSpace(value); len(trimmed) == 0 || trimmed[0] != '{' {
		return nil, fmt.Errorf("JWT segment is not a JSON object")
	}
	return value, nil
}

func isBase64URLSegment(segment string) bool {
	if segment == "" || len(segment)%4 == 1 {
		return false
	}
	for _, character := range segment {
		if !('A' <= character && character <= 'Z') &&
			!('a' <= character && character <= 'z') &&
			!('0' <= character && character <= '9') &&
			character != '-' &&
			character != '_' {
			return false
		}
	}
	return true
}

func printJSON(label string, value json.RawMessage) error {
	formatted, err := json.MarshalIndent(value, "", "  ")
	if err != nil {
		return err
	}
	fmt.Printf("%s:\n%s\n", label, formatted)
	return nil
}

func main() {
	parts := strings.Split(os.Getenv("TOKEN"), ".")
	if len(parts) != 3 {
		panic("Expected a compact JWT with three segments")
	}

	header, err := decodeSegment(parts[0])
	if err != nil {
		panic(err)
	}
	payload, err := decodeSegment(parts[1])
	if err != nil {
		panic(err)
	}
	if err := printJSON("Header", header); err != nil {
		panic(err)
	}
	fmt.Println()
	if err := printJSON("Payload", payload); err != nil {
		panic(err)
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80// Add Jackson (com.fasterxml.jackson.core:jackson-databind) to your project.
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public final class DecodeJwtExample {
  private static final ObjectMapper JSON =
      new ObjectMapper().enable(DeserializationFeature.FAIL_ON_TRAILING_TOKENS);

  private DecodeJwtExample() {}

  static String decodeUtf8(byte[] bytes) throws IOException {
    try {
      return StandardCharsets.UTF_8
          .newDecoder()
          .onMalformedInput(CodingErrorAction.REPORT)
          .onUnmappableCharacter(CodingErrorAction.REPORT)
          .decode(ByteBuffer.wrap(bytes))
          .toString();
    } catch (CharacterCodingException exception) {
      throw new IOException("JWT segment is not valid UTF-8", exception);
    }
  }

  static String decodeSegment(String segment) throws IOException {
    if (!isBase64UrlSegment(segment)) {
      throw new IllegalArgumentException("JWT segment is not valid Base64URL");
    }
    byte[] bytes = Base64.getUrlDecoder().decode(segment);
    if (!Base64.getUrlEncoder().withoutPadding().encodeToString(bytes).equals(segment)) {
      throw new IllegalArgumentException("JWT segment is not valid Base64URL");
    }
    String decoded = decodeUtf8(bytes);
    JsonNode value = JSON.readTree(decoded);
    if (value == null || value.isMissingNode() || !value.isObject()) {
      throw new IOException("JWT segment is not a JSON object");
    }
    return decoded;
  }

  static boolean isBase64UrlSegment(String segment) {
    if (segment.isEmpty() || segment.length() % 4 == 1) {
      return false;
    }
    return segment
        .chars()
        .allMatch(
            character ->
                character >= 'A' && character <= 'Z'
                    || character >= 'a' && character <= 'z'
                    || character >= '0' && character <= '9'
                    || character == '-'
                    || character == '_');
  }

  static String[] requireCompactJwt(String token) {
    if (token == null) {
      throw new IllegalArgumentException("Expected a compact JWT with three segments");
    }
    String[] parts = token.split("\\.", -1);
    if (parts.length != 3) {
      throw new IllegalArgumentException("Expected a compact JWT with three segments");
    }
    return parts;
  }

  public static void main(String[] args) throws IOException {
    String[] parts = requireCompactJwt(System.getenv("TOKEN"));
    System.out.println("Header:");
    System.out.println(decodeSegment(parts[0]));
    System.out.println("\nPayload:");
    System.out.println(decodeSegment(parts[1]));
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62using System.Text;
using System.Text.Json;

static string DecodeSegment(string segment)
{
    if (
        segment.Length % 4 == 1 ||
        segment.Any(
            character =>
                !(
                    character is >= 'A' and <= 'Z' ||
                    character is >= 'a' and <= 'z' ||
                    character is >= '0' and <= '9' ||
                    character is '-' or '_'
                )
        )
    )
    {
        throw new FormatException("JWT segment is not valid Base64URL");
    }

    byte[] decoded = Convert.FromBase64String(
        segment.Replace('-', '+').Replace('_', '/') +
        new string('=', (4 - segment.Length % 4) % 4)
    );
    string canonicalSegment = Convert
        .ToBase64String(decoded)
        .TrimEnd('=')
        .Replace('+', '-')
        .Replace('/', '_');
    if (canonicalSegment != segment)
    {
        throw new FormatException("JWT segment is not valid Base64URL");
    }
    string decodedJson = new UTF8Encoding(false, true).GetString(decoded);
    using JsonDocument document = JsonDocument.Parse(decodedJson);
    if (document.RootElement.ValueKind is not JsonValueKind.Object)
    {
        throw new FormatException("JWT segment is not a JSON object");
    }
    return decodedJson;
}

string? token = Environment.GetEnvironmentVariable("TOKEN");
if (token is null)
{
    throw new InvalidOperationException(
        "Expected a compact JWT with three segments"
    );
}
string[] parts = token.Split('.');
if (parts.Length != 3)
{
    throw new InvalidOperationException(
        "Expected a compact JWT with three segments"
    );
}

Console.WriteLine("Header:");
Console.WriteLine(DecodeSegment(parts[0]));
Console.WriteLine("\nPayload:");
Console.WriteLine(DecodeSegment(parts[1]));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34require "base64"
require "json"

parts = ENV.fetch("TOKEN", "").split(".", -1)
raise "Expected a compact JWT with three segments" unless parts.length == 3

decode = lambda do |segment|
  unless segment.match?(/\A[A-Za-z0-9_-]+\z/) && segment.length % 4 != 1
    raise "JWT segment is not valid Base64URL"
  end

  padded = segment.ljust((segment.length + 3) & ~3, "=")
  begin
    decoded = Base64.urlsafe_decode64(padded)
  rescue ArgumentError
    raise "JWT segment is not valid Base64URL"
  end
  unless Base64.urlsafe_encode64(decoded, padding: false) == segment
    raise "JWT segment is not valid Base64URL"
  end

  decoded.force_encoding(Encoding::UTF_8)
  raise "JWT segment is not valid UTF-8" unless decoded.valid_encoding?

  value = JSON.parse(decoded)
  raise "JWT segment is not a JSON object" unless value.is_a?(Hash)

  decoded
end

puts("Header:")
puts(decode.call(parts[0]))
puts("\nPayload:")
puts(decode.call(parts[1]))

OpenAI 공급자를 만들기 전에 다음 필드를 확인하세요.

필드	예상 값
헤더 `alg`	`RS512` 등 구성된 서명 알고리즘입니다.
헤더 `kid`	신뢰 도메인의 공개 JWKS에 포함된 서명 키의 ID입니다.
`iss`	신뢰 도메인의 HTTPS 발급자 URL입니다.
`sub`	이 워크로드에 할당된 SPIFFE ID입니다.
`aud`	OpenAI 액세스용으로 선택한 대상 값이 포함되어야 합니다.
`iat` 및 `exp`	각각 토큰의 발급 시각과 만료 시각입니다. 만료되지 않은 토큰을 사용하세요.

디코더는 서명을 검증하지 않고 클레임을 읽습니다. 토큰을 로그에 기록하거나 웹 기반 디코더에 붙여 넣지 마세요. 확인을 마치면 TOKEN 환경 변수를 해제하세요.

OpenAI 워크로드 ID 페더레이션 구성

워크로드 ID 공급자 만들기

조직 설정 > 보안 > 워크로드 ID 공급자로 이동해 다음 설정으로 공급자를 만드세요.

설정	값
이름	`idira-prod`와 같이 고유한 이름을 입력하세요.
설명	이 공급자를 사용하는 애플리케이션과 환경을 기재하세요.
OIDC 발급자 URL	JWT-SVID의 `iss` 값을 입력하세요.
대상	`https://api.openai.com/v1`과 같이 헬퍼가 요청한 대상 값을 입력하세요.
업로드한 JWKS로 토큰 검증	OIDC 디스커버리를 사용하려면 이 옵션을 꺼 두세요.
속성 변환	`sub`에서 직접 매핑하는 경우 비워 두세요.

OpenAI API는 토큰을 교환할 때 발급자 URL 끝의 슬래시를 무시하고 비교합니다. 예를 들어 https://issuer.example.com과 https://issuer.example.com/은 일치하는 것으로 처리합니다. 스킴과 경로를 포함한 나머지 문자는 모두 일치해야 합니다. 대상 값은 완전히 일치해야 합니다. 구성을 일관되게 유지하려면 발급된 토큰의 발급자 값을 그대로 복사하세요.

OpenAI가 디스커버리 문서나 JWKS에 접근할 수 없다면 공통 공급자 구성 안내에 따라 공개 JWKS를 업로드하세요. SWA가 서명 키를 교체하면 업로드한 키도 업데이트하세요.

SPIFFE ID를 서비스 계정에 매핑

공급자에서 서비스 계정 매핑을 만들고 idira-production-workload와 같은 이름을 지정하세요.
키 항목을 sub로 설정하고, 값 항목에는 워크로드 토큰의 SPIFFE ID를 그대로 입력하세요. 예를 들면 spiffe://prod.example.com/k8s-nodegroup/ns/my-namespace/sa/my-service-account입니다.
워크로드가 사용할 수 있는 프로젝트와 서비스 계정을 선택하세요.
워크로드에 필요한 권한을 선택하세요. 예를 들어 모델 요청에는 api.model.request가 필요합니다. 여기서 서비스 계정의 접근 권한을 더 좁게 제한할 수 있지만, 서비스 계정에 부여된 범위를 넘어 권한을 부여할 수는 없습니다. 권한을 비워 두면 WIF에서 별도의 제한을 추가하지 않습니다.

애플리케이션과 환경별로 별도의 서비스 계정을 사용하세요. 가급적 SPIFFE ID 전체를 지정하세요. 같은 접두사로 시작하는 모든 ID에 동일한 접근 권한을 부여해야 할 때만 끝에 와일드카드를 사용하세요. 매핑이 겹치지 않도록 하세요. 자세한 내용은 SPIFFE 서비스 계정 매핑을 참고하세요.

코드에서 토큰 사용

OpenAI 공급자 ID와 선택한 서비스 계정 ID를 워크로드의 환경 변수에 설정하세요.

export OPENAI_IDENTITY_PROVIDER_ID="<workload identity provider ID>"
export OPENAI_SERVICE_ACCOUNT_ID="<service account ID>"

다음 SPIFFE 공통 예제는 /var/run/spiffe/openai.jwt에서 토큰을 읽습니다. SDK가 토큰을 교환해 OpenAI 액세스 토큰을 발급받거나 갱신해야 할 때마다 주체 토큰 공급자가 현재 JWT-SVID를 반환합니다. SWA와 헬퍼는 외부 JWT-SVID를 갱신하고, OpenAI SDK는 OpenAI 액세스 토큰을 관리합니다.

Idira에서 발급한 SPIFFE JWT-SVID로 인증

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40import { readFile } from "node:fs/promises";
import OpenAI from "openai";

const tokenPath = "/var/run/spiffe/openai.jwt";
const identityProviderId = process.env.OPENAI_IDENTITY_PROVIDER_ID;
const serviceAccountId = process.env.OPENAI_SERVICE_ACCOUNT_ID;

if (!identityProviderId || !serviceAccountId) {
  throw new Error(
    "Set OPENAI_IDENTITY_PROVIDER_ID and OPENAI_SERVICE_ACCOUNT_ID"
  );
}

function spiffeJwtSvidProvider(path) {
  return {
    tokenType: "jwt",
    getToken: async () => {
      const token = (await readFile(path, "utf8")).trim();
      if (!token) {
        throw new Error("The SPIFFE JWT-SVID file is empty.");
      }
      return token;
    },
  };
}

const client = new OpenAI({
  workloadIdentity: {
    identityProviderId,
    serviceAccountId,
    provider: spiffeJwtSvidProvider(tokenPath),
  },
});

const response = await client.responses.create({
  model: "gpt-5.6-terra",
  input: "Say hello from SPIFFE workload identity federation.",
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33import os
from pathlib import Path

from openai import OpenAI
from openai.auth import SubjectTokenProvider

TOKEN_PATH = "/var/run/spiffe/openai.jwt"


def spiffe_jwt_svid_provider(token_path: str) -> SubjectTokenProvider:
    def get_token() -> str:
        token = Path(token_path).read_text().strip()
        if not token:
            raise RuntimeError("The SPIFFE JWT-SVID file is empty.")
        return token

    return {"token_type": "jwt", "get_token": get_token}


client = OpenAI(
    workload_identity={
        "identity_provider_id": os.environ["OPENAI_IDENTITY_PROVIDER_ID"],
        "service_account_id": os.environ["OPENAI_SERVICE_ACCOUNT_ID"],
        "provider": spiffe_jwt_svid_provider(TOKEN_PATH),
    },
)

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Say hello from SPIFFE workload identity federation.",
)

print(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"strings"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/auth"
	"github.com/openai/openai-go/v3/option"
	"github.com/openai/openai-go/v3/responses"
)

const tokenPath = "/var/run/spiffe/openai.jwt"

type spiffeJWTSVIDProvider struct {
	path string
}

func (p spiffeJWTSVIDProvider) TokenType() auth.SubjectTokenType {
	return auth.SubjectTokenTypeJWT
}

func (p spiffeJWTSVIDProvider) GetToken(ctx context.Context, _ auth.HTTPDoer) (string, error) {
	data, err := os.ReadFile(p.path)
	if err != nil {
		return "", &auth.SubjectTokenProviderError{
			Provider: "spiffe",
			Message:  "failed to read SPIFFE JWT-SVID",
			Cause:    err,
		}
	}

	token := strings.TrimSpace(string(data))
	if token == "" {
		return "", &auth.SubjectTokenProviderError{
			Provider: "spiffe",
			Message:  "SPIFFE JWT-SVID file is empty",
		}
	}

	return token, nil
}

func main() {
	client := openai.NewClient(
		option.WithWorkloadIdentity(auth.WorkloadIdentity{
			IdentityProviderID: os.Getenv("OPENAI_IDENTITY_PROVIDER_ID"),
			ServiceAccountID:   os.Getenv("OPENAI_SERVICE_ACCOUNT_ID"),
			Provider: spiffeJWTSVIDProvider{
				path: tokenPath,
			},
		}),
	)

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: openai.ChatModelGPT4_1Mini,
		Input: responses.ResponseNewParamsInputUnion{
			OfString: openai.String("Say hello from SPIFFE workload identity federation."),
		},
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75import com.fasterxml.jackson.databind.json.JsonMapper;
import com.openai.auth.SubjectTokenProvider;
import com.openai.auth.SubjectTokenType;
import com.openai.auth.WorkloadIdentity;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.HttpClient;
import com.openai.errors.SubjectTokenProviderException;
import com.openai.models.responses.ResponseCreateParams;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.concurrent.CompletableFuture;

public final class SpiffeWorkloadIdentityExample {
  private static final String TOKEN_PATH = "/var/run/spiffe/openai.jwt";

  private SpiffeWorkloadIdentityExample() {}

  static final class SpiffeJwtSvidProvider implements SubjectTokenProvider {
    private final Path tokenPath;

    SpiffeJwtSvidProvider(String tokenPath) {
      this.tokenPath = Path.of(tokenPath);
    }

    @Override
    public SubjectTokenType tokenType() {
      return SubjectTokenType.JWT;
    }

    @Override
    public String getToken(HttpClient httpClient, JsonMapper jsonMapper) {
      String token;
      try {
        token = Files.readString(tokenPath).trim();
      } catch (Exception e) {
        throw new SubjectTokenProviderException("spiffe", "failed to read SPIFFE JWT-SVID", e);
      }

      if (token.isEmpty()) {
        throw new SubjectTokenProviderException("spiffe", "SPIFFE JWT-SVID file is empty", null);
      }

      return token;
    }

    @Override
    public CompletableFuture<String> getTokenAsync(HttpClient httpClient, JsonMapper jsonMapper) {
      return CompletableFuture.supplyAsync(() -> getToken(httpClient, jsonMapper));
    }
  }

  public static void main(String[] args) {
    WorkloadIdentity workloadIdentity =
        WorkloadIdentity.builder()
            .identityProviderId(System.getenv("OPENAI_IDENTITY_PROVIDER_ID"))
            .serviceAccountId(System.getenv("OPENAI_SERVICE_ACCOUNT_ID"))
            .provider(new SpiffeJwtSvidProvider(TOKEN_PATH))
            .build();

    OpenAIClient client = OpenAIOkHttpClient.builder().workloadIdentity(workloadIdentity).build();

    ResponseCreateParams params =
        ResponseCreateParams.builder()
            .model("gpt-5.6-terra")
            .input("Say hello from SPIFFE workload identity federation.")
            .build();

    client.responses().create(params).output().stream()
        .flatMap(item -> item.message().stream())
        .flatMap(message -> message.content().stream())
        .flatMap(content -> content.outputText().stream())
        .forEach(outputText -> System.out.println(outputText.text()));
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49require "openai"

TOKEN_PATH = "/var/run/spiffe/openai.jwt"

class SpiffeJWTSVIDProvider
  include OpenAI::Auth::SubjectTokenProvider

  def initialize(token_path:)
    @token_path = token_path
  end

  def token_type
    OpenAI::Auth::TokenType::JWT
  end

  def get_token
    token = File.read(@token_path).strip
    if token.empty?
      raise OpenAI::Errors::SubjectTokenProviderError.new(
        message: "SPIFFE JWT-SVID file is empty",
        provider: "spiffe"
      )
    end
    token
  rescue SystemCallError => e
    raise OpenAI::Errors::SubjectTokenProviderError.new(
      message: "Failed to read SPIFFE JWT-SVID: #{e.message}",
      provider: "spiffe",
      cause: e
    )
  end
end

provider = SpiffeJWTSVIDProvider.new(token_path: TOKEN_PATH)

workload_identity = OpenAI::Auth::WorkloadIdentity.new(
  identity_provider_id: ENV.fetch("OPENAI_IDENTITY_PROVIDER_ID"),
  service_account_id: ENV.fetch("OPENAI_SERVICE_ACCOUNT_ID"),
  provider: provider
)

client = OpenAI::Client.new(workload_identity: workload_identity)

response = client.responses.create(
  model: "gpt-5.6-terra",
  input: "Say hello from SPIFFE workload identity federation."
)

puts(response.output_text)

검증 및 문제 해결

증명을 마친 워크로드 안에서 OPENAI_API_KEY 환경 변수를 해제한 상태로 예제를 실행하세요. 요청이 성공하면 모델의 응답이 출력됩니다. 헬퍼가 JWT-SVID를 교체하고 SDK가 OpenAI 액세스 토큰을 갱신한 후에도 요청이 계속 성공하는지 확인하세요.

증상	확인할 사항
헬퍼가 워크로드 ID를 받지 못함	워크로드가 SWA 증명 정책의 조건을 충족하고 에이전트 소켓에 접근할 수 있는지 확인하세요. 워크로드의 실행 컨텍스트에서 점검하세요.
토큰 파일이 없거나 비어 있거나 파일에 저장된 토큰이 만료됨	헬퍼가 실행 중인지, 헬퍼와 워크로드의 공유 볼륨 및 파일 경로가 일치하는지, 워크로드가 파일을 읽을 수 있는지 확인하세요. 호스트의 시계를 동기화된 상태로 유지하세요.
토큰 검증 실패	`iss`, `aud`, `kid` 값과 토큰 만료 여부를 확인하고 디스커버리 문서와 JWKS에 접근할 수 있는지 점검하세요. 앞에서 설명한 발급자 비교 규칙을 적용하세요.
일치하는 서비스 계정 매핑이 없음	공급자 ID와 서비스 계정 ID를 확인하세요. 매핑이 활성화되어 있는지, `sub` 값이 정확히 일치하는지도 확인하세요.
일치하는 매핑이 여러 개임	겹치는 매핑의 범위를 좁히거나 해당 매핑을 비활성화해 활성화된 매핑 중 하나만 일치하도록 하세요.
토큰 교환에는 성공하지만 API가 요청을 거부함	매핑된 서비스 계정의 프로젝트와 권한, 적용되는 API 접근 정책을 확인하세요.

SWA 배포 환경을 진단하는 방법은 Idira의 통합 문제 해결 안내를 참고하세요.

추천

시작하기

핵심 개념

SDK 및 CLI

클라우드 제공업체

자료

레거시 API

모델 선택하기

텍스트 및 코드

프롬프트 작성

추론

이미지

실시간 처리 및 오디오

특화 모델

Agents API

Agents SDK

ChatKit

검색 및 정보 조회

도구와 데이터 연결하기

도구를 활용한 워크플로우 구축하기

컴퓨터 및 코드

미디어

GPT-Live

Realtime API

음성 기능 개발

연결

오디오 처리

서비스 출시하기

성능 및 품질

평가

비용 및 처리량

안전 및 거버넌스

인프라 및 접근 권한

운영

핵심 개념

기획

개발

테스트 및 게시

전환 명세

가이드

자료

사용자 식별

ChatGPT 요금제 사용량

가이드

파일 업로드

API

성과 측정

광고주 API

API 레퍼런스

시작하기

시작하기

기초

둘러보기

지원 플랫폼

릴리스

워크플로우

주요 기능

Sites

dot

ChatGPT 스페이스

레퍼런스

맞춤 설정

설정 파일

에이전트 설정

ChatGPT와 Codex 확장하기

Linux

Windows

개발 워크플로우

확장 및 자동화

환경

Codex Cloud

Codex로 개발하기

서드 파티 통합

레퍼런스

권한

Codex Security

사이버 안전

시작하기

기능 설정

ID 및 액세스