Como configurar a federação de identidades de cargas de trabalho com SPIFFE

Use o SPIFFE como provedor de identidade de cargas de trabalho para trocar um JWT-SVID do SPIFFE por um token de acesso de curta duração da OpenAI. Assim, cargas de trabalho autenticadas pelo SPIRE ou por outro provedor de identidade compatível com SPIFFE podem chamar a API da OpenAI sem armazenar chaves de API de longa duração.

Se você usa o Idira Secure Workload Access, siga o guia de configuração do Idira para configurar o agente e a entrega de tokens.

A OpenAI aceita JWT-SVIDs do SPIFFE que possam ser validados como tokens de sujeito JWT, com emissor, público-alvo, data e hora de expiração, data e hora de emissão e assinatura verificável por meio de um JWKS. A OpenAI não aceita X.509-SVIDs do SPIFFE como tokens de sujeito na 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 o campo kid no cabeçalho. Assim, a OpenAI pode 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 os metadados de descoberta e as chaves do JWKS para que a OpenAI possa validar o JWT-SVID. Isso não altera a semântica do token definida pelo SPIFFE nem exige um fluxo de login OIDC.

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

Como configurar o SPIFFE

Configure seu provedor SPIFFE para emitir JWT-SVIDs para as cargas de trabalho que precisam chamar a API da OpenAI. Estas instruções usam a terminologia do SPIRE, mas a configuração na OpenAI é a mesma para qualquer provedor compatível com SPIFFE que emita JWT-SVIDs e forneça um emissor e chaves de assinatura em um JWKS que a OpenAI possa usar na validação.

Sua configuração do SPIFFE deve fornecer os seguintes elementos:

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 exclusivo para acesso à OpenAI, como https://api.openai.com/v1 ou outro valor opaco de sua escolha.
Uma URL de emissor JWT que conste na declaração iss do JWT-SVID para que a OpenAI possa validá-lo.
Um JWKS público com as chaves de assinatura dos JWT-SVIDs, disponibilizado por descoberta OIDC ou por upload.
Um mecanismo que permita à própria carga de trabalho obter JWT-SVIDs atualizados da SPIFFE Workload API.

O público-alvo é um identificador que exige correspondência exata. Ele não precisa ser um endpoint que receba o JWT-SVID. Você pode usar https://api.openai.com/v1 ou outro valor específico do serviço, desde que o valor na solicitação à SPIFFE Workload API seja idêntico ao da configuração do provedor na OpenAI.

Sempre que possível, disponibilize o emissor SPIFFE por meio do SPIRE OIDC Discovery Provider. Defina jwt_issuer no SPIRE Server e jwt_issuer no OIDC Discovery Provider com a mesma URL HTTPS de emissor que você vai 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 exige uma fonte de material criptográfico, como server_api, workload_api ou file, e 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 distintos. Neste exemplo, o sujeito do JWT-SVID é um ID SPIFFE no domínio de confiança example.org, enquanto o emissor é identificado pela URL HTTPS:

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 de JWKS que a OpenAI pode usar quando a opção Usar o JWKS enviado para verificar tokens está desativada.

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

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

Para inspecionar um JWT-SVID a partir de uma carga de trabalho que possa chamar a SPIFFE Workload API, solicite um token para o mesmo público-alvo que você vai configurar na OpenAI. Execute o 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 sua carga de trabalho tiver mais de um ID SPIFFE, especifique a identidade na solicitação:

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 na variável TOKEN e execute um dos exemplos a seguir localmente para inspecionar o cabeçalho e as declarações do token:

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.

O cabeçalho e as declarações de um JWT-SVID do SPIFFE, depois de decodificados, terão formato semelhante ao deste exemplo:

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
}

Antes de trocar o token recebido, compare os valores do token decodificado com a configuração na OpenAI. Confira 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 de JWTs no SPIRE Server.

Como configurar a 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. Em seguida, 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. Em Nome, insira um valor exclusivo, como spiffe-prod. Em Descrição, insira um texto como Production SPIFFE workloads para ajudar os administradores a identificar o provedor.
Defina o emissor e o público-alvo. Em URL do emissor OIDC, insira o valor exato da declaração iss do JWT-SVID, como https://spire-oidc.example.org. Em Público-alvo, insira o valor de público-alvo usado na solicitação à SPIFFE Workload API. Neste exemplo, o valor é https://api.openai.com/v1.
Escolha a origem do JWKS. Deixe a opção Usar o JWKS enviado para verificar tokens desativada se a OpenAI conseguir acessar seu SPIRE OIDC Discovery Provider. A OpenAI usa a descoberta OIDC para localizar o JWKS e verificar as assinaturas dos JWT-SVIDs com as chaves desse conjunto.

Se a OpenAI não conseguir acessar o emissor, ative Usar o JWKS enviado para verificar tokens e, em JWKS em JSON, insira 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 chave privada.
Adicione transformações de atributos somente se precisar de atributos derivados para o mapeamento. O mapeamento direto a partir de sub dispensa transformações de atributos. 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 como funcionam as transformações.

Configure o mapeamento da conta de serviço

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

Para cargas de trabalho privilegiadas, prefira a correspondência exata do ID SPIFFE. Use um curinga no final somente se todos os IDs SPIFFE com esse prefixo deverem ter permissão para 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. Em Projeto, selecione o projeto da OpenAI ao qual pertence a conta de serviço de destino. Em Conta de serviço, selecione 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 conta de serviço para esse mapeamento em vez de reutilizar uma conta existente.
Restrinja as permissões da API, se necessário. Em Permissões, selecione as permissões adequadas, como api.model.request e api.vector_store.read, para restringir ainda mais o acesso concedido pelos tokens gerados com esse mapeamento. Deixe o campo de permissões em branco para evitar uma restrição de escopo específica da federação. O token continua autorizando o acesso com a identidade da conta de serviço mapeada.

Como usar o token no código

Configure o cliente do SDK da OpenAI para trocar um JWT-SVID atualizado do SPIFFE por um token de acesso emitido pela OpenAI.

Os exemplos de uso do SDK a seguir pressupõem que sua integração com o SPIFFE atualize o JWT-SVID e o grave em /var/run/spiffe/openai.jwt. Restrinja a permissão de leitura do arquivo à carga de trabalho. Como os JWT-SVIDs têm validade curta, atualize o arquivo antes que o token expire. Como alternativa, quando possível, use uma biblioteca SPIFFE para a sua linguagem no provedor de tokens de sujeito. Assim, ele pode obter o JWT-SVID diretamente da SPIFFE Workload API e evitar o uso de 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 na OpenAI, e OPENAI_SERVICE_ACCOUNT_ID identifica a conta de serviço de destino na OpenAI. Com base nas declarações do token, a OpenAI localiza um mapeamento correspondente a esse provedor e a essa conta de serviço.

Autenticação 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)

Boas práticas para o SPIFFE

Use JWT-SVIDs para a federação de identidades de cargas de trabalho com a OpenAI. Os X.509-SVIDs são úteis para TLS mútuo, mas o endpoint de troca de tokens da OpenAI não os aceita.
Use um único público-alvo exclusivo para acesso à OpenAI. Evite públicos-alvo abrangentes, como um domínio de confiança inteiro ou o nome de um ambiente.
Sempre que possível, exija correspondência exata dos IDs SPIFFE. Use mapeamentos com curingas somente quando as cargas de trabalho compartilharem intencionalmente o mesmo limite de confiança.
Use prazos de validade curtos para os JWT-SVIDs a fim de reduzir o risco de ataques de repetição com tokens de portador. Os tokens de acesso da OpenAI nunca permanecem válidos além da expiração do token de sujeito externo usado na troca.
Faça a rotação das chaves de assinatura com cuidado. Durante o período de rotação, publique as chaves públicas antigas e novas por meio da descoberta OIDC 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 sejam rejeitados por parecerem ter sido emitidos há muito tempo, já ter expirado ou ainda não ter entrado em vigor.
Proteja o socket da SPIFFE Workload API. Um processo capaz de obter o JWT-SVID de uma carga de trabalho pode tentar trocá-lo por um token de acesso à OpenAI.
Alinhe os limites de acesso 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 as falhas na troca de tokens para identificar divergências de emissor, público-alvo, chave de assinatura ou mapeamento.

Sugestões

Primeiros passos

Conceitos fundamentais

SDKs e CLI

Provedores de nuvem

Recursos

APIs legadas

Escolha um modelo

Texto e código

Como escrever prompts

Raciocínio

Imagens

Tempo real e áudio

Modelos especializados

API de agentes

SDK de agentes

ChatKit

Busca e recuperação de informações

Conecte ferramentas e dados

Crie fluxos de trabalho com ferramentas

Computador e código

Mídia

GPT-Live

Realtime API

Desenvolver aplicações de voz

Conexões

Processamento de áudio

Coloque em produção

Desempenho e qualidade

Avaliação

Custo e taxa de processamento

Segurança e governança

Infraestrutura e acesso

Operações

Conceitos fundamentais

Planejar

Desenvolver

Testar e publicar

Especificações de conversão

Guias

Recursos

Identidade

Uso do plano do ChatGPT

Guias

Envio de arquivos

API

Mensuração

API para anunciantes

Referência da API

Primeiros passos

Primeiros passos

Fundamentos

Explorar

Disponível em

Versões

Fluxos de trabalho

Capacidades

Sites

dots

ChatGPT Space

Referência

Personalização

Arquivo de configuração

Configuração de agentes

Ampliar os recursos do ChatGPT e do Codex

Linux

Windows

Fluxos de trabalho de desenvolvimento

Ampliar recursos e automatizar tarefas

Ambientes

Codex Cloud

Desenvolver com o Codex

Integrações de terceiros

Referência

Permissões

Codex Security

Segurança cibernética

Primeiros passos

Configuração de recursos

Identidade e acesso