Mit Idira Secure Workload Access (SWA) kannst du die OpenAI API aufrufen, ohne einen OpenAI-API-Schlüssel zu speichern. SWA weist deinem Workload eine SPIFFE-ID zu und stellt ein JWT-SVID aus. Dieses signierte Token steht für die Identität deines Workloads. Das OpenAI SDK tauscht das Token gegen ein kurzlebiges OpenAI-Zugriffstoken mit den Berechtigungen des zugeordneten Dienstkontos ein.
Diese Anleitung beschreibt, wie du die OpenAI API konfigurierst. Für Codex führst du die hier beschriebenen Schritte zur Bereitstellung des Tokens aus. Folge anschließend der Anleitung Workload-Identität mit Codex verwenden.
Du benötigst:
- Eine SWA-Bereitstellung mit einer Vertrauensdomäne und einer Attestierungsrichtlinie, die deinem Workload die erwartete SPIFFE-ID zuweist.
- Zugriff auf den Socket der Workload API des SWA-Agenten aus deinem Workload heraus.
- Die Berechtigung, Anbieter für Workload-Identitäten, Dienstkontozuordnungen, Projekte und Dienstkonten in deiner OpenAI-Organisation zu verwalten.
- Ein OpenAI SDK, das Anmeldedaten für Workload-Identitäten unterstützt.
Richte die SWA-Infrastruktur vollständig ein. Die Voraussetzungen findest du in der Idira-Anleitung zur OpenAI-Integration.
Ermittle für deine Vertrauensdomäne die Werte von jwt.discovery_endpoints.oidc_discovery_url und jwt.discovery_endpoints.jwks_uri. Wo du diese Werte findest, erfährst du in der Idira-Anleitung zur OIDC-Konfiguration.
OpenAI muss das Discovery-Dokument und das JWKS über HTTPS ohne Anmeldedaten abrufen können. Die HTTPS-URL im Claim iss des Tokens gibt den Aussteller an. Die SPIFFE-ID in sub identifiziert deinen Workload.
Wähle für den Zugriff auf OpenAI eine eigene Audience, etwa https://api.openai.com/v1. Verwende denselben Wert, wenn du das JWT-SVID anforderst und den Anbieter in OpenAI konfigurierst. Die Audience gibt an, für welchen Empfänger das Token bestimmt ist. Sie legt den Endpunkt für den Tokenaustausch nicht fest.
SWA signiert standardmäßig mit RS512 und einem 4096-Bit-RSA-Schlüssel. OpenAI akzeptiert diese Kombination bei der JWT-Prüfung. Weitere Signaturoptionen für SWA findest du in den JWT-Anforderungen von Idira.
Installiere spiffe-helper in der Umgebung deines Workloads. Damit kannst du beim SWA-Agenten ein JWT-SVID anfordern und es regelmäßig erneuern lassen. Speichere die folgende Konfiguration als helper.conf. Der Helper schreibt das Token in die Datei /var/run/spiffe/openai.jwt. Diesen Pfad verwenden auch die gemeinsamen SPIFFE-Beispiele für die SDKs.
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"
}]
Führe den Helper in Kubernetes als Sidecar im Pod des Workloads aus. Binde ein gemeinsames emptyDir-Volume im Arbeitsspeicher unter /var/run/spiffe ein. Binde außerdem das Verzeichnis des SWA-Sockets, /tmp/swa-agent/public, in den Sidecar-Container ein. Verwende auf VMs /run/swa-agent/api.sock als Wert für agent_address und lege das Tokenverzeichnis im Arbeitsspeicher ab. Befolge für den Socketzugriff und die Attestierung die Bereitstellungsanleitung von Idira.
Erstelle das Tokenverzeichnis, bevor du den Helper startest, und gib ihm Schreibzugriff darauf. Starte den Helper mit dieser Konfiguration im Sidecar oder im Dienst auf der VM:
spiffe-helper -config helper.conf
Beschränke den Zugriff auf die Tokendatei und den Socket des Agenten auf die Prozesse, die darauf angewiesen sind. Lass den Helper weiterlaufen, damit er das Token vor Ablauf ersetzt.
Wenn es für deine Programmiersprache einen Client für die SPIFFE Workload API gibt, kannst du ein aktuelles JWT-SVID auch direkt im Anbieter für das Subject-Token abrufen. Wie du die Workload API direkt nutzt, erfährst du in der Integrationsanleitung von Idira.
Lies das Token innerhalb des Workloads in eine Umgebungsvariable für den lokalen Decoder ein:
export TOKEN="$(cat /var/run/spiffe/openai.jwt)"
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: string) => {
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]))
Prüfe die folgenden Felder, bevor du den Anbieter in OpenAI erstellst:
| Feld |
Erwarteter Wert |
Header alg |
Der konfigurierte Signaturalgorithmus, etwa RS512. |
Header kid |
Die ID eines Signaturschlüssels im öffentlichen JWKS der Vertrauensdomäne. |
iss |
Die HTTPS-URL des Ausstellers für die Vertrauensdomäne. |
sub |
Die SPIFFE-ID, die diesem Workload zugewiesen wurde. |
aud |
Enthält die Audience, die du für den Zugriff auf OpenAI gewählt hast. |
iat und exp |
Ausstellungs- und Ablaufzeitpunkt des Tokens. Verwende ein Token, das noch gültig ist. |
Der Decoder liest die Claims aus, ohne die Signatur zu prüfen. Schreibe das Token nicht in Protokolle und füge es nicht in einen webbasierten Decoder ein. Entferne nach der Prüfung die Umgebungsvariable TOKEN.
Öffne Organisationseinstellungen > Sicherheit > Anbieter für Workload-Identitäten und erstelle einen Anbieter mit den folgenden Einstellungen:
| Einstellung |
Wert |
| Name |
Ein eindeutiger Name, etwa idira-prod. |
| Beschreibung |
Die Anwendung und die Umgebung, die diesen Anbieter verwenden. |
| OIDC-Aussteller-URL |
Der Wert von iss im JWT-SVID. |
| Audience |
Die vom Helper angeforderte Audience, etwa https://api.openai.com/v1. |
| Hochgeladenes JWKS zur Tokenprüfung verwenden |
Lass diese Option deaktiviert, um OIDC Discovery zu verwenden. |
| Attributtransformationen |
Lass dieses Feld leer, wenn die Zuordnung direkt über sub erfolgt. |
Beim Tokenaustausch über die OpenAI API werden abschließende Schrägstriche beim Vergleich der Aussteller-URLs ignoriert. So gelten https://issuer.example.com und https://issuer.example.com/ als identisch. Alle anderen Zeichen müssen übereinstimmen, auch im Schema und im Pfad. Die Audience-Werte müssen exakt übereinstimmen. Übernimm die Aussteller-URL so, wie sie im Token steht, damit deine Konfiguration konsistent bleibt.
Wenn OpenAI das Discovery-Dokument oder das JWKS nicht erreichen kann, folge den allgemeinen Hinweisen zur Anbieterkonfiguration für das Hochladen eines öffentlichen JWKS. Aktualisiere die hochgeladenen Schlüssel, wenn SWA seine Signaturschlüssel wechselt.
- Erstelle in der Anbieterkonfiguration eine Dienstkontozuordnung und gib ihr einen Namen, etwa
idira-production-workload.
- Setze Schlüssel auf
sub und Wert auf die exakte SPIFFE-ID aus dem Token des Workloads, etwa spiffe://prod.example.com/k8s-nodegroup/ns/my-namespace/sa/my-service-account.
- Wähle das Projekt und das Dienstkonto aus, die der Workload verwenden darf.
- Wähle die Berechtigungen aus, die der Workload benötigt, etwa
api.model.request für Modellanfragen. Damit kannst du die Zugriffsrechte des Dienstkontos für diesen Workload einschränken, aber nicht erweitern. Lässt du die Berechtigungen leer, gilt keine zusätzliche Einschränkung durch die Identitätsföderation.
Verwende für jede Anwendung und Umgebung ein eigenes Dienstkonto. Gib möglichst die exakte SPIFFE-ID an. Verwende einen Platzhalter am Ende der ID nur dann, wenn alle Identitäten mit diesem Präfix dieselben Zugriffsrechte erhalten sollen. Vermeide überlappende Zuordnungen. Weitere Informationen findest du im Abschnitt Dienstkontozuordnungen für SPIFFE.
Setze in der Umgebung des Workloads die IDs deines OpenAI-Anbieters und des ausgewählten Dienstkontos:
export OPENAI_IDENTITY_PROVIDER_ID="<workload identity provider ID>"
export OPENAI_SERVICE_ACCOUNT_ID="<service account ID>"
Die folgenden gemeinsamen SPIFFE-Beispiele lesen das Token aus /var/run/spiffe/openai.jwt. Der Anbieter für das Subject-Token gibt das aktuelle Token zurück, sobald das SDK es gegen ein OpenAI-Zugriffstoken eintauschen oder ein OpenAI-Zugriffstoken erneuern muss. SWA und der Helper erneuern das externe JWT-SVID. Das OpenAI SDK verwaltet das OpenAI-Zugriffstoken.
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: string) {
return {
tokenType: "jwt" as const,
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)
Führe das Beispiel innerhalb des attestierten Workloads aus. Dabei darf OPENAI_API_KEY nicht gesetzt sein. Bei einer erfolgreichen Anfrage gibt das Beispiel die Antwort des Modells aus. Prüfe, ob Anfragen weiterhin erfolgreich sind, nachdem der Helper das JWT-SVID ersetzt und das SDK sein OpenAI-Zugriffstoken erneuert hat.
| Symptom |
Was du prüfen solltest |
| Der Helper erhält keine Identität |
Prüfe, ob der Workload die SWA-Attestierungsrichtlinie erfüllt und auf den Socket des Agenten zugreifen kann. Führe diese Prüfungen im Kontext des Workloads aus. |
| Die Tokendatei fehlt, ist leer oder enthält ein abgelaufenes Token |
Prüfe, ob der Helper läuft, ob Helper und Workload dasselbe Volume und denselben Dateipfad verwenden und ob der Workload die Datei lesen kann. Halte die Systemuhren der Hosts synchron. |
| Die Tokenprüfung schlägt fehl |
Prüfe iss, aud, kid und den Ablaufzeitpunkt des Tokens. Prüfe außerdem, ob das Discovery-Dokument und das JWKS erreichbar sind. Beachte beim Vergleich der Aussteller-URLs die oben beschriebene Regel. |
| Keine Dienstkontozuordnung passt |
Prüfe die Anbieter-ID, die Dienstkonto-ID, die aktivierte Zuordnung und den exakten Wert von sub. |
| Mehrere Zuordnungen passen |
Grenze überlappende Zuordnungen ein oder deaktiviere sie, sodass genau eine aktivierte Zuordnung passt. |
| Der Tokenaustausch gelingt, aber die API lehnt die Anfrage ab |
Prüfe das Projekt und die Berechtigungen des zugeordneten Dienstkontos sowie die geltenden Richtlinien für den API-Zugriff. |
Hinweise zur Diagnose von Problemen mit der SWA-Bereitstellung findest du in der Idira-Anleitung zur Fehlerbehebung bei der Integration.