Usa Idira Secure Workload Access (SWA) para llamar a la API de OpenAI sin almacenar una clave de API de OpenAI. SWA asigna un ID de SPIFFE a tu carga de trabajo y emite un JWT-SVID, un token firmado que representa esa identidad. El SDK de OpenAI intercambia ese token por un token de acceso de OpenAI de corta duración con los permisos de la cuenta de servicio asociada.
Esta guía describe cómo configurar la API de OpenAI. Para Codex, sigue los pasos de esta guía para entregar el token y luego sigue las instrucciones de Usar la identidad de la carga de trabajo con Codex.
Necesitas lo siguiente:
- Un despliegue de SWA con un dominio de confianza y una política de atestación que asigne el ID de SPIFFE esperado a tu carga de trabajo.
- Acceso desde la carga de trabajo al socket de la Workload API del agente de SWA.
- Permiso para administrar proveedores de identidad de cargas de trabajo, asignaciones de cuentas de servicio, proyectos y cuentas de servicio en tu organización de OpenAI.
- Un SDK de OpenAI compatible con credenciales de identidad de cargas de trabajo.
Completa la configuración de la infraestructura de SWA según los requisitos previos de la guía de Idira para la integración con OpenAI.
Obtén los valores de jwt.discovery_endpoints.oidc_discovery_url y jwt.discovery_endpoints.jwks_uri de tu dominio de confianza. Para encontrarlos, sigue las instrucciones de Idira para configurar OIDC.
OpenAI debe poder acceder al documento de descubrimiento y al conjunto de claves JWKS por HTTPS sin credenciales. El emisor es la URL HTTPS que aparece en el campo iss del token. El ID de SPIFFE del campo sub identifica tu carga de trabajo.
Elige una audiencia exclusiva para el acceso a OpenAI, como https://api.openai.com/v1. Usa el mismo valor al solicitar el JWT-SVID y al configurar el proveedor en OpenAI. La audiencia identifica al destinatario previsto del token. El punto de acceso para el intercambio de tokens se define por separado.
De forma predeterminada, SWA usa RS512 para firmar con una clave RSA de 4096 bits. El verificador de JWT de OpenAI acepta esta combinación. Para conocer otras opciones de firma de SWA, consulta los requisitos de Idira para los JWT.
Instala spiffe-helper en el entorno de la carga de trabajo para solicitar un JWT-SVID al agente de SWA y renovarlo. Guarda la siguiente configuración como helper.conf. El proceso auxiliar escribe el token en /var/run/spiffe/openai.jwt, la ruta que usan los ejemplos compartidos de SPIFFE para el SDK:
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"
}]
En Kubernetes, ejecuta el proceso auxiliar en un contenedor sidecar dentro del pod de la carga de trabajo. Comparte un volumen emptyDir en memoria en /var/run/spiffe y monta el directorio que contiene el socket de SWA, /tmp/swa-agent/public, en el contenedor auxiliar. En máquinas virtuales, usa /run/swa-agent/api.sock como valor de agent_address y mantén el directorio del token en un sistema de almacenamiento en memoria. Sigue las instrucciones de despliegue de Idira para el acceso al socket y la atestación.
Antes de iniciar el proceso auxiliar, crea el directorio del token y dale al proceso permiso de escritura. Inicia el proceso auxiliar con esta configuración en el sidecar o en el servicio de la máquina virtual:
spiffe-helper -config helper.conf
Restringe el acceso al archivo del token y al socket del agente a los procesos que los necesitan. Mantén el proceso auxiliar en ejecución para que reemplace el token antes de que venza.
Si tu lenguaje cuenta con un cliente de la SPIFFE Workload API, también puedes obtener un JWT-SVID nuevo desde el proveedor de tokens de sujeto. Consulta la opción de acceso directo a la Workload API en la guía de integración de Idira.
Desde la carga de trabajo, lee el token y guárdalo en una variable de entorno para que el decodificador local pueda acceder a él:
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) => {
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]))
Verifica estos campos antes de crear el proveedor en OpenAI:
| Campo |
Valor esperado |
Campo alg del encabezado |
El algoritmo de firma configurado, como RS512. |
Campo kid del encabezado |
El ID de una clave de firma del JWKS público del dominio de confianza. |
iss |
La URL HTTPS del emisor del dominio de confianza. |
sub |
El ID de SPIFFE asignado a esta carga de trabajo. |
aud |
Contiene la audiencia que elegiste para el acceso a OpenAI. |
iat y exp |
Las marcas de tiempo de emisión y vencimiento del token. Usa un token vigente. |
El decodificador lee los campos del token sin verificar la firma. No guardes el token en los registros ni lo pegues en un decodificador web. Elimina la variable de entorno TOKEN después de inspeccionar el token.
Ve a Configuración de la organización > Seguridad > Proveedor de identidad de cargas de trabajo y crea un proveedor con estos ajustes:
| Ajuste |
Valor |
| Nombre |
Un nombre único, como idira-prod. |
| Descripción |
La aplicación y el entorno que usan este proveedor. |
| URL del emisor OIDC |
El valor de iss del JWT-SVID. |
| Audiencia |
La audiencia que solicita el proceso auxiliar, como https://api.openai.com/v1. |
| Usar el JWKS cargado para verificar los tokens |
Mantén esta opción desactivada para usar el descubrimiento OIDC. |
| Transformaciones de atributos |
Deja este campo vacío si la asignación se basa directamente en sub. |
Al intercambiar tokens, la API de OpenAI ignora las barras finales al comparar las URL del emisor. Por ejemplo, https://issuer.example.com y https://issuer.example.com/ coinciden. Todos los demás caracteres deben coincidir, incluidos los del esquema y la ruta. Los valores de audiencia deben coincidir exactamente. Para mantener la coherencia de la configuración, copia el valor del emisor tal como aparece en el token.
Si OpenAI no puede acceder al documento de descubrimiento o al JWKS, sigue las instrucciones generales de configuración del proveedor para cargar un JWKS público. Actualiza las claves cargadas cuando SWA rote sus claves de firma.
- Crea una asignación de cuenta de servicio en el proveedor y dale un nombre, como
idira-production-workload.
- En Clave, ingresa
sub y, en Valor, ingresa el ID de SPIFFE exacto que figura en el token de la carga de trabajo, como spiffe://prod.example.com/k8s-nodegroup/ns/my-namespace/sa/my-service-account.
- Selecciona el Proyecto y la Cuenta de servicio que puede usar la carga de trabajo.
- Selecciona los Permisos que necesita la carga de trabajo, como
api.model.request para las solicitudes a modelos. Estos permisos solo pueden restringir el acceso que ya tiene la cuenta de servicio. Si dejas el campo de permisos vacío, no se agrega ninguna restricción específica de la federación de identidades de cargas de trabajo.
Usa una cuenta de servicio distinta para cada aplicación y entorno. De preferencia, usa un ID de SPIFFE exacto. Usa un comodín al final solo si todas las identidades con ese prefijo deben tener el mismo acceso. Evita las asignaciones que se superpongan. Para obtener más información, consulta Asignaciones de cuentas de servicio para SPIFFE.
En el entorno de la carga de trabajo, configura el ID de tu proveedor de OpenAI y el de la cuenta de servicio seleccionada:
export OPENAI_IDENTITY_PROVIDER_ID="<workload identity provider ID>"
export OPENAI_SERVICE_ACCOUNT_ID="<service account ID>"
Los siguientes ejemplos compartidos de SPIFFE leen /var/run/spiffe/openai.jwt. El proveedor de tokens de sujeto devuelve el token vigente cada vez que el SDK necesita intercambiarlo por un token de acceso de OpenAI o renovar ese token de acceso. SWA y el proceso auxiliar renuevan el JWT-SVID externo. El SDK de OpenAI administra el token de acceso de OpenAI.
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)
Ejecuta el ejemplo dentro de la carga de trabajo atestada, sin definir la variable OPENAI_API_KEY. Si la solicitud se completa correctamente, se imprime la respuesta del modelo. Confirma que las solicitudes sigan completándose correctamente después de que el proceso auxiliar reemplace el JWT-SVID y el SDK renueve su token de acceso de OpenAI.
| Síntoma |
Qué verificar |
| El proceso auxiliar no recibe ninguna identidad |
Verifica que la carga de trabajo cumpla con la política de atestación de SWA y pueda acceder al socket del agente. Ejecuta las comprobaciones en el contexto de la carga de trabajo. |
| El archivo del token no existe, está vacío o contiene un token vencido |
Verifica que el proceso auxiliar esté en ejecución, que el volumen compartido y la ruta del archivo coincidan con los configurados y que la carga de trabajo pueda leer el archivo. Mantén sincronizados los relojes de los hosts. |
| Falla la verificación del token |
Verifica los valores de iss, aud y kid, el vencimiento del token y el acceso al documento de descubrimiento y al JWKS. Aplica la regla de comparación del emisor descrita anteriormente. |
| No coincide ninguna asignación de cuenta de servicio |
Verifica el ID del proveedor, el ID de la cuenta de servicio, la asignación habilitada y el valor exacto de sub. |
| Coincide más de una asignación |
Restringe o desactiva las asignaciones que se superpongan para que coincida exactamente una asignación habilitada. |
| El intercambio se completa correctamente, pero la API rechaza la solicitud |
Verifica el proyecto y los permisos de la cuenta de servicio asociada, así como las políticas de acceso a la API que correspondan. |
Para diagnosticar problemas con el despliegue de SWA, consulta las instrucciones de Idira para solucionar problemas de integración.
