Configuração da federação de identidades de cargas de trabalho para SPIFFE

Use o SPIFFE como provedor de identidade de cargas de trabalho trocando um JWT-SVID do SPIFFE por um token de acesso da OpenAI de curta duração. Isso permite que cargas de trabalho autenticadas pelo SPIRE ou por outro provedor de identidade compatível com SPIFFE chamem a API da OpenAI sem armazenar chaves de API de longa duração.

Para o Codex, use esta página para obter e inspecionar o JWT-SVID. Depois, configure a identidade de cargas de trabalho do Codex para gravar esse token em um arquivo e indicar sua localização ao Codex. O mapeamento de contas de serviço e os exemplos de SDK desta página se aplicam à API da OpenAI.

A OpenAI oferece suporte a JWT-SVIDs do SPIFFE que podem ser validados como tokens de sujeito JWT com emissor, público-alvo, expiração, data e hora de emissão e assinatura verificável por JWKS. A OpenAI não oferece suporte a X.509-SVIDs do SPIFFE como tokens de sujeito para a federação de identidades de cargas de trabalho.

A especificação JWT-SVID exige as declarações sub, aud e exp. Para usar um JWT-SVID com a OpenAI, o token também deve incluir as declarações iss e iat e um cabeçalho kid, para que a OpenAI possa validar o token com base na configuração do provedor de identidade de cargas de trabalho.

Um JWT-SVID não é um token de ID do OpenID Connect. O SPIRE OIDC Discovery Provider fornece metadados de descoberta e chaves JWKS para que a OpenAI possa validar o JWT-SVID; ele não altera a semântica SPIFFE do token nem exige um fluxo de login OIDC.

Para conhecer a terminologia do SPIFFE e os requisitos dos tokens, consulte a especificação JWT-SVID e a especificação Workload API do SPIFFE.

Configuração do SPIFFE

Configure seu provedor SPIFFE para emitir JWT-SVIDs para cargas de trabalho que precisam chamar a API da OpenAI. Estas instruções usam a terminologia do SPIRE, mas a mesma configuração da OpenAI se aplica a qualquer provedor compatível com SPIFFE que emita JWT-SVIDs com um emissor e material de assinatura JWKS que a OpenAI possa validar.

Sua configuração do SPIFFE deve fornecer:

Um ID SPIFFE estável para a carga de trabalho, como spiffe://example.org/ns/production/sa/openai-wif.
Um único público-alvo de JWT-SVID dedicado ao acesso à OpenAI, como https://api.openai.com/v1 ou outro valor opaco de sua escolha.
Uma URL do emissor JWT que apareça na declaração iss do JWT-SVID para validação pela OpenAI.
Um JWKS público para as chaves de assinatura dos JWT-SVIDs, disponibilizado por descoberta OIDC ou por upload de um JWKS.
Uma forma de a carga de trabalho buscar novos JWT-SVIDs na SPIFFE Workload API.

O público-alvo é um identificador que exige correspondência exata, não necessariamente um endpoint que recebe o JWT-SVID. Você pode usar https://api.openai.com/v1 ou outro valor específico do serviço, desde que os valores na solicitação à SPIFFE Workload API e na configuração do provedor na OpenAI sejam iguais.

Quando possível, exponha o emissor SPIFFE por meio do seu SPIRE OIDC Discovery Provider. Configure jwt_issuer no SPIRE Server e jwt_issuer no OIDC Discovery Provider com a mesma URL HTTPS do emissor que você configurará na OpenAI.

Na configuração do SPIRE Server:

1234server {
  trust_domain = "example.org"
  jwt_issuer   = "https://spire-oidc.example.org"
}

Na configuração separada do SPIRE OIDC Discovery Provider:

123# Relevant issuer fields only
domains    = ["spire-oidc.example.org"]
jwt_issuer = "https://spire-oidc.example.org"

A configuração do OIDC Discovery Provider também precisa de uma fonte de material de chaves, como server_api, workload_api ou file, e de um mecanismo para disponibilizar o serviço, como ACME, um certificado TLS ou um socket Unix. Consulte a documentação do SPIRE OIDC Discovery Provider para ver todas as opções de configuração.

O domínio de confiança do SPIFFE e o emissor JWT são conceitos diferentes. Neste exemplo, o sujeito do JWT-SVID é um ID SPIFFE no domínio de confiança example.org, enquanto o emissor é a URL HTTPS do emissor:

1234{
  "sub": "spiffe://example.org/ns/production/sa/openai-wif",
  "iss": "https://spire-oidc.example.org"
}

O SPIRE OIDC Discovery Provider disponibiliza um documento de descoberta OIDC e um endpoint JWKS que a OpenAI pode usar quando a opção Usar JWKS enviado para verificação de tokens está desativada.

Se a OpenAI não conseguir acessar o endpoint de descoberta do seu emissor, use o modo de JWKS enviado. Nesse modo, a OpenAI continua comparando o emissor do provedor de identidade de cargas de trabalho com a declaração iss do JWT-SVID, mas verifica as assinaturas com base no JSON do JWKS que você salva no provedor de identidade de cargas de trabalho.

Observação: A especificação JWT-SVID do SPIFFE torna o cabeçalho JWT kid opcional, mas a OpenAI exige que os tokens de sujeito JWT incluam um cabeçalho kid para poder selecionar a chave de assinatura no JWKS configurado. Se o seu provedor SPIFFE puder omitir kid, configure-o para incluir esse cabeçalho ao usar a federação de identidades de cargas de trabalho da OpenAI.

Para inspecionar um JWT-SVID de uma carga de trabalho que pode chamar a SPIFFE Workload API, solicite um token para o mesmo público-alvo que você configurará na OpenAI. Execute este comando no mesmo contexto de carga de trabalho do aplicativo, pois a autorização da Workload API depende da identidade do processo que faz a chamada.

1234TOKEN=$(spire-agent api fetch jwt \
  -socketPath /run/spire/sockets/agent.sock \
  -audience "https://api.openai.com/v1" | sed -n '2p')
export TOKEN

Se a sua carga de trabalho tiver mais de um ID SPIFFE, solicite a identidade específica:

12345TOKEN=$(spire-agent api fetch jwt \
  -socketPath /run/spire/sockets/agent.sock \
  -spiffeID "spiffe://example.org/ns/production/sa/openai-wif" \
  -audience "https://api.openai.com/v1" | sed -n '2p')
export TOKEN

Verifique o token

Antes de configurar a federação de identidades de cargas de trabalho, exporte o JWT-SVID como TOKEN e execute um destes exemplos localmente para inspecionar seu cabeçalho e suas declarações:

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]))

Cada exemplo decodifica o JWT sem verificar a assinatura do token. Use um decodificador local para tokens de produção e evite colá-los em ferramentas de terceiros.

Um JWT-SVID do SPIFFE decodificado terá uma estrutura semelhante a esta:

1234{
  "alg": "ES256",
  "kid": "jwt-svid-key-1"
}

1234567{
  "iss": "https://spire-oidc.example.org",
  "aud": ["https://api.openai.com/v1"],
  "sub": "spiffe://example.org/ns/production/sa/openai-wif",
  "iat": 1716235422,
  "exp": 1716235722
}

Use o token decodificado para comparar o token recebido com a configuração da OpenAI antes de trocá-lo. Verifique alg e kid no cabeçalho e iss, aud, sub, iat e exp no payload. O valor exato de alg depende da configuração da chave de assinatura JWT do seu SPIRE Server.

Configuração da federação de identidades de cargas de trabalho

Crie um provedor de identidade de cargas de trabalho na OpenAI para o emissor dos JWT-SVIDs do SPIFFE e adicione um mapeamento de conta de serviço que corresponda aos IDs SPIFFE em que você confia.

Configure o provedor de identidade de cargas de trabalho

Crie o provedor de identidade de cargas de trabalho. Defina Nome com um valor exclusivo, como spiffe-prod. Use Descrição, com um valor como Production SPIFFE workloads, para ajudar os administradores a identificar o provedor.
Defina o emissor e o público-alvo. Defina URL do emissor OIDC com o valor exato da declaração iss do JWT-SVID, como https://spire-oidc.example.org. Defina Público-alvo com o valor do público-alvo solicitado à SPIFFE Workload API. Neste exemplo, esse valor é https://api.openai.com/v1.
Escolha a fonte do JWKS. Deixe a opção Usar JWKS enviado para verificação de tokens desativada quando a OpenAI puder acessar seu SPIRE OIDC Discovery Provider. A OpenAI usa a descoberta OIDC e o JWKS encontrado para verificar as assinaturas dos JWT-SVIDs.

Se a OpenAI não puder acessar o emissor, ative Usar JWKS enviado para verificação de tokens e preencha JSON do JWKS com o conjunto de chaves públicas correspondente às chaves de assinatura dos JWT-SVIDs. Envie o objeto JWKS público completo, incluindo o array keys que contém as chaves. Não inclua material de chaves privadas.
Adicione transformações de atributos somente se precisar de atributos derivados para o mapeamento. As transformações de atributos não são necessárias ao mapear diretamente a partir de sub. Use-as somente quando precisar derivar um valor de mapeamento de uma ou mais declarações do token. Consulte o guia principal de federação de identidades de cargas de trabalho para entender o comportamento das transformações.

Configure o mapeamento de conta de serviço

Crie um mapeamento de conta de serviço. Defina Nome com um valor exclusivo dentro do provedor de identidade de cargas de trabalho, como production-openai-wif. Use Descrição, com um valor como Production SPIFFE workload for OpenAI API access, para explicar qual carga de trabalho pode usar o mapeamento.
Configure a correspondência com o ID SPIFFE. Defina Chave como sub e Valor como o ID SPIFFE da carga de trabalho, como spiffe://example.org/ns/production/sa/openai-wif.

Prefira a correspondência exata de IDs SPIFFE para cargas de trabalho privilegiadas. Use um curinga no final somente quando todos os IDs SPIFFE com esse prefixo devam poder gerar tokens de acesso da OpenAI. Por exemplo, spiffe://example.org/ns/production/sa/* permite qualquer caminho de conta de serviço de produção que corresponda a esse padrão.
Escolha o destino na OpenAI. Defina Projeto como o projeto da OpenAI ao qual pertence a conta de serviço de destino. Defina Conta de serviço como a conta de serviço da OpenAI que a carga de trabalho SPIFFE pode usar, como spiffe-prod-openai-wif. Marque Create a new service account in this project se quiser criar uma nova conta de serviço para esse mapeamento em vez de reutilizar uma existente.
Restrinja as permissões da API, se necessário. Selecione as Permissões apropriadas, como api.model.request e api.vector_store.read, para restringir ainda mais os tokens de acesso gerados a partir desse mapeamento. Deixe as permissões em branco para não adicionar uma restrição de escopo específica de WIF; o token continua autorizando o acesso como a conta de serviço mapeada.

Uso do token no código

Configure seu cliente do OpenAI SDK para trocar um novo JWT-SVID do SPIFFE por um token de acesso emitido pela OpenAI.

Os exemplos de SDK abaixo pressupõem que sua integração SPIFFE renova um JWT-SVID e o grava em /var/run/spiffe/openai.jwt. Restrinja a leitura do arquivo à carga de trabalho. Como os JWT-SVIDs têm curta duração, atualize o arquivo antes que o token expire. Como alternativa, quando possível, use uma biblioteca SPIFFE específica da linguagem no provedor de tokens de sujeito para buscar o JWT-SVID diretamente na SPIFFE Workload API e evitar arquivos de token desatualizados.

Defina OPENAI_IDENTITY_PROVIDER_ID e OPENAI_SERVICE_ACCOUNT_ID no ambiente da carga de trabalho. O arquivo de token contém o token de sujeito externo. OPENAI_IDENTITY_PROVIDER_ID identifica o provedor de identidade de cargas de trabalho da OpenAI, e OPENAI_SERVICE_ACCOUNT_ID identifica a conta de serviço de destino da OpenAI. Em seguida, a OpenAI encontra um mapeamento correspondente para esse provedor e essa conta de serviço com base nas declarações do token.

Autentique-se com um JWT-SVID do SPIFFE

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)

Práticas recomendadas para SPIFFE

Use JWT-SVIDs para a federação de identidades de cargas de trabalho da OpenAI. Os X.509-SVIDs são úteis para TLS mútuo, mas não são aceitos pelo endpoint de troca de tokens da OpenAI.
Use um único público-alvo dedicado ao acesso à OpenAI. Evite públicos-alvo amplos, como um domínio de confiança inteiro ou o nome de um ambiente.
Use correspondência exata de IDs SPIFFE sempre que possível. Use mapeamentos com curingas somente para limites de confiança compartilhados intencionalmente.
Mantenha curtos os prazos de validade dos JWT-SVIDs para reduzir o risco de ataques de repetição com tokens de portador. Os tokens de acesso da OpenAI nunca permanecem válidos por mais tempo que o token de sujeito externo usado na troca.
Faça a rotação das chaves de assinatura com cuidado. Publique tanto as chaves públicas antigas quanto as novas por meio da descoberta OIDC durante a janela de rotação, ou atualize o JWKS público enviado antes de emitir JWT-SVIDs com um novo kid.
Mantenha sincronizados os relógios do SPIRE Server e das cargas de trabalho. Uma diferença significativa entre os relógios pode fazer com que JWT-SVIDs válidos nos demais aspectos sejam rejeitados por ainda não serem válidos, serem antigos demais ou estarem expirados.
Proteja o socket da SPIFFE Workload API. Um processo capaz de buscar o JWT-SVID de uma carga de trabalho pode tentar trocá-lo por acesso à OpenAI.
Alinhe os limites das contas de serviço da OpenAI aos limites de permissão dos seus aplicativos e ambientes. Não compartilhe uma conta de serviço com privilégios elevados entre cargas de trabalho SPIFFE sem relação entre si.
Monitore falhas na troca de tokens para identificar divergências de emissor, público-alvo, chave de assinatura e mapeamento.

Sugestões

Primeiros passos

Conceitos fundamentais

SDKs e CLI

Recursos

APIs legadas

Escolha um modelo

Texto e código

Criação de prompts

Raciocínio

Imagens e vídeo

Tempo real e áudio

Modelos especializados

API de Agentes

SDK de Agentes

ChatKit

Pesquisa e recuperação

Conecte ferramentas e dados

Crie fluxos de trabalho com ferramentas

Computador e código

Mídia

GPT-Live

Realtime API

Desenvolva com voz

Conexões

Processamento de áudio

Entre em produção

Desempenho e qualidade

Custo e taxa de processamento

Segurança e governança

Infraestrutura e acesso

Operações

Conceitos fundamentais

Plan

Build

Test and publish

Conversion specs

Guias

Recursos

Primeiros passos

Guias

File Upload

API

Measurement

Advertiser API

Referência da API

Primeiros passos

Fundamentos

Explorar

Disponível em

Versões

Fluxos de trabalho

Capacidades

Referência

Personalização

Arquivo de configuração

Configuração de agentes

Amplie os recursos do ChatGPT e do Codex

Linux

Windows

Fluxos de trabalho de desenvolvimento

Amplie e automatize

Ambientes

Desenvolva com o Codex

Integrações de terceiros

Referência

Permissões

Codex Security

Segurança cibernética

Primeiros passos

ChatGPT Work

Identidade e autenticação

Acesso, política e modelos do workspace

Controles de plug-ins e conectores

Uso, governança e conformidade

Implantação e provedores de modelos

Comunidade

Blog

Comunidade

Blog