Configuração da federação de identidades de cargas de trabalho para Oracle Cloud Infrastructure

Use o Oracle Cloud Infrastructure (OCI) como provedor de identidade de cargas de trabalho, trocando um token de acesso do Oracle Identity Cloud Service (IDCS) por um token de acesso da OpenAI de curta duração. Um principal de instância do OCI assina uma solicitação de troca de tokens para um domínio de identidade na mesma tenancy. A OpenAI valida o token resultante e autoriza a carga de trabalho do OCI a atuar como uma conta de serviço da OpenAI mapeada.

Para o Codex, use esta página para obter e inspecionar o token da Oracle. Em seguida, configure a identidade de cargas de trabalho do Codex para gravar esse token em um arquivo e indicar ao Codex onde encontrá-lo. O mapeamento de contas de serviço e os exemplos de SDK desta página se aplicam à API da OpenAI.

Essa configuração não exige uma chave de API da OpenAI, um aplicativo de recurso OAuth personalizado da Oracle nem concessões de grupos dinâmicos a um aplicativo personalizado.

Configure a carga de trabalho do OCI

Execute sua carga de trabalho em uma instância do OCI Compute com um principal de instância. Para o Oracle Kubernetes Engine (OKE), confirme qual identidade assina a solicitação: o assinador padrão de principal de instância normalmente identifica o node de trabalho, e não um pod individual do Kubernetes.

O assinador obtém credenciais do serviço de metadados de instâncias do OCI. Verifique se a carga de trabalho consegue acessar o endpoint de metadados de link local:

123curl --fail --silent \
  --header "Authorization: Bearer Oracle" \
  http://169.254.169.254/opc/v2/instance/id

A carga de trabalho também deve conseguir fazer solicitações HTTPS de saída para o domínio de identidade em sua tenancy. O endpoint de metadados em si não exige um gateway NAT nem conexão com a internet.

Solicite um token de identidade da Oracle

Use InstancePrincipalsSecurityTokenSigner do SDK do OCI para Python para assinar uma solicitação de troca de tokens OAuth para seu domínio de identidade:

POST https://<identity-domain>/oauth2/v1/token
Content-Type: application/x-www-form-urlencoded;charset=utf-8

grant_type=urn:ietf:params:oauth:grant-type:token-exchange
scope=urn:opc:idm:__myscopes__
requested_token_type=urn:ietf:params:oauth:token-type:access_token

O escopo urn:opc:idm:__myscopes__ usa a autorização existente do principal de instância. Use o token de acesso do IDCS retornado como token de sujeito para a federação de identidades de cargas de trabalho da OpenAI. Não substitua o público-alvo do token da Oracle por https://api.openai.com/v1; configure o provedor da OpenAI com um público-alvo que conste no token real da Oracle.

Verifique o token

Defina TOKEN como um token de acesso gerado pela carga de trabalho real do OCI e, em seguida, use o decodificador JWT local existente para inspecionar suas declarações:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18const parts = process.env.TOKEN?.split(".") ?? [];
if (parts.length !== 3) {
  throw new Error("Expected a compact JWT with three segments");
}
if (!/^[A-Za-z0-9_-]+$/.test(parts[1]) || parts[1].length % 4 === 1) {
  throw new Error("JWT payload is not valid Base64URL");
}

const bytes = Buffer.from(parts[1], "base64url");
if (bytes.toString("base64url") !== parts[1]) {
  throw new Error("JWT payload is not valid Base64URL");
}
const decoded = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
const claims = JSON.parse(decoded);
if (claims === null || Array.isArray(claims) || typeof claims !== "object") {
  throw new Error("JWT payload is not a JSON object");
}
console.log(decoded);

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
26import base64
import json
import os
import re


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


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

payload = parts[1]
if re.fullmatch(r"[A-Za-z0-9_-]+", payload) is None or len(payload) % 4 == 1:
    raise ValueError("JWT payload is not valid Base64URL")
padded_payload = payload + "=" * (-len(payload) % 4)
decoded = base64.b64decode(padded_payload, altchars=b"-_", validate=True)
if base64.urlsafe_b64encode(decoded).rstrip(b"=").decode("ascii") != payload:
    raise ValueError("JWT payload is not valid Base64URL")
decoded_text = decoded.decode("utf-8")
claims = json.loads(decoded_text, parse_constant=reject_non_json_constant)
if not isinstance(claims, dict):
    raise ValueError("JWT payload is not a JSON object")
print(decoded_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 (
	"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 main() {
	parts := strings.Split(os.Getenv("TOKEN"), ".")
	if len(parts) != 3 {
		panic("Expected a compact JWT with three segments")
	}

	payload, err := decodeSegment(parts[1])
	if err != nil {
		panic(err)
	}
	formatted, err := json.MarshalIndent(payload, "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println(string(formatted))
}

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// 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 DecodeJwtPayloadExample {
  private static final ObjectMapper JSON =
      new ObjectMapper().enable(DeserializationFeature.FAIL_ON_TRAILING_TOKENS);

  private DecodeJwtPayloadExample() {}

  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(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
59using 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(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
26require "base64"
require "json"

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

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

begin
  payload = Base64.urlsafe_decode64(parts[1].ljust((parts[1].length + 3) & ~3, "="))
rescue ArgumentError
  raise "JWT payload is not valid Base64URL"
end
unless Base64.urlsafe_encode64(payload, padding: false) == parts[1]
  raise "JWT payload is not valid Base64URL"
end

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

claims = JSON.parse(payload)
raise "JWT payload is not a JSON object" unless claims.is_a?(Hash)

puts(payload)

O decodificador inspeciona o token sem verificar sua assinatura. Trate os tokens brutos como dados sensíveis, não os registre em logs e não cole tokens de produção em decodificadores JWT de terceiros.

Um token de acesso da Oracle decodificado pode conter as seguintes declarações:

123456789101112131415{
  "iss": "https://identity.oraclecloud.com/",
  "aud": [
    "https://idcs-example.us-phoenix-1.identity.oraclecloud.com",
    "https://idcs-example.identity.oraclecloud.com"
  ],
  "sub_type": "instance",
  "ipst_instance": "ocid1.instance.oc1.phx.<instance-id>",
  "ipst_compartment": "ocid1.compartment.oc1..<compartment-id>",
  "domain_id": "ocid1.domain.oc1..<domain-id>",
  "ca_ocid": "ocid1.tenancy.oc1..<tenancy-id>",
  "tenant": "idcs-example",
  "exp": 1782369434,
  "iat": 1782365834
}

Use o token emitido pelo seu próprio domínio de identidade como fonte de verdade. Configure o valor exato de iss e um dos valores de aud do token. Dê preferência às declarações imutáveis ipst_instance, ipst_compartment, domain_id e ca_ocid ao autorizar uma carga de trabalho.

Configure a federação de identidades de cargas de trabalho

Crie um provedor de identidade de cargas de trabalho para seu domínio de identidade da Oracle e adicione um mapeamento para a instância ou o compartimento do OCI que pode usar a conta de serviço de destino da OpenAI.

Configure o provedor de identidade de cargas de trabalho

1. Crie o provedor de identidade de cargas de trabalho. Defina Nome como um valor exclusivo, como oracle-cloud-prod. Use Descrição, com um valor como Production OCI instance principal, para identificar a carga de trabalho confiável.

2. Defina o emissor e o público-alvo. Defina URL do emissor OIDC como a declaração iss do token, como https://identity.oraclecloud.com/. Defina Público-alvo como um dos valores de aud no mesmo token.

3. Configure a descoberta OIDC específica do tenant quando disponível. Se Usar URL personalizada para descoberta OIDC aparecer em Avançado, ative essa opção. Defina URL personalizada de descoberta OIDC como o domínio de identidade específico do seu tenant, como https://idcs-example.identity.oraclecloud.com. A OpenAI obtém https://idcs-example.identity.oraclecloud.com/.well-known/openid-configuration e usa o jwks_uri do documento de descoberta para obter as chaves públicas de assinatura do tenant. Se a opção de descoberta personalizada não aparecer, ative Usar JWKS enviado para verificação de tokens e, em vez disso, envie o JWKS público de https://<identity-domain>/admin/v1/SigningCert/jwk.

4. Adicione transformações de atributos somente quando precisar de atributos derivados. Você pode usar declarações brutas da Oracle, como ipst_instance, ipst_compartment, domain_id e ca_ocid, diretamente nas asserções de mapeamento de contas de serviço. Para um atributo de instância explicitamente derivado, insira instance com a expressão assertion.ipst_instance para criar openai.instance.

A referência de descoberta do OpenID Connect da Oracle mostra por que a descoberta personalizada é importante: o documento de descoberta pode declarar o emissor global https://identity.oraclecloud.com/ e, ao mesmo tempo, publicar o endpoint de tokens e o jwks_uri no domínio de identidade específico do tenant. Mantenha o emissor global em URL do emissor OIDC e use o domínio do tenant em URL personalizada de descoberta OIDC.

Configure o mapeamento de contas de serviço

1. Crie um mapeamento de contas de serviço. Defina Nome como um valor exclusivo, como oracle-instance-prod, e adicione uma descrição que identifique a carga de trabalho confiável do OCI.

2. Faça a correspondência com a identidade estável do OCI de escopo mais restrito. Para conceder acesso a uma instância, defina Chave como ipst_instance e Valor como o OCID exato da instância presente no token verificado. Para conceder acesso às instâncias de um compartimento, defina Chave como ipst_compartment e Valor como o OCID exato do compartimento.

3. Adicione restrições de domínio e tenancy quando necessário. Adicione outras linhas de mapeamento para domain_id ou ca_ocid para limitar a carga de trabalho a um domínio de identidade ou a uma tenancy específica da Oracle. Adicione sub_type com o valor instance quando o token incluir essa declaração e você quiser exigir um principal de instância. Todas as linhas de mapeamento devem corresponder.

4. Escolha o destino na OpenAI. Defina Projeto como o projeto ao qual a conta de serviço pertence e selecione a Conta de serviço que a carga de trabalho confiável do OCI pode usar.

5. Restrinja as permissões de API se necessário. Selecione apenas as Permissões necessárias para a carga de trabalho. As permissões do mapeamento podem restringir a conta de serviço selecionada, mas não podem conceder permissões que ela ainda não tenha.

Use o token no código

Instale os pacotes Python OpenAI, OCI e Requests:

pip install openai oci requests

Para Ruby, instale as gems OpenAI e OCI:

gem install openai oci

Defina OCI_IDENTITY_DOMAIN_URL como a URL base do domínio de identidade na mesma tenancy da carga de trabalho. Defina OPENAI_IDENTITY_PROVIDER_ID e OPENAI_SERVICE_ACCOUNT_ID como os IDs do seu provedor e do mapeamento de contas de serviço da OpenAI.

O exemplo a seguir assina uma solicitação de troca de tokens da Oracle com o principal de instância do OCI, retorna o token de acesso do IDCS ao OpenAI SDK e permite que o SDK o troque por um token de acesso da OpenAI de curta duração quando necessário:

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
53import os

import oci
import requests
from openai import OpenAI
from openai.auth import SubjectTokenProvider


def oracle_instance_principal_token_provider(
    identity_domain_url: str,
) -> SubjectTokenProvider:
    def get_token() -> str:
        signer = oci.auth.signers.InstancePrincipalsSecurityTokenSigner()
        response = requests.post(
            f"{identity_domain_url.rstrip('/')}/oauth2/v1/token",
            data={
                "grant_type": "urn:ietf:params:oauth:grant-type:token-exchange",
                "scope": "urn:opc:idm:__myscopes__",
                "requested_token_type": "urn:ietf:params:oauth:token-type:access_token",
            },
            headers={
                "Content-Type": "application/x-www-form-urlencoded;charset=utf-8",
            },
            auth=signer,
            timeout=30,
        )
        response.raise_for_status()

        token = response.json().get("access_token")
        if not isinstance(token, str) or not token:
            raise RuntimeError("Oracle IDCS did not return an access token.")

        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": oracle_instance_principal_token_provider(
            os.environ["OCI_IDENTITY_DOMAIN_URL"]
        ),
    },
)

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Say hello from Oracle Cloud Infrastructure 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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105require "json"
require "net/http"
require "oci"
require "openai"
require "uri"

class OracleInstancePrincipalTokenProvider
  include OpenAI::Auth::SubjectTokenProvider

  def initialize(identity_domain_url:)
    @identity_domain_url = identity_domain_url.sub(%r{/+\z}, "")
  end

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

  def get_token
    uri = URI("#{@identity_domain_url}/oauth2/v1/token")
    unless uri.is_a?(URI::HTTPS)
      raise OpenAI::Errors::SubjectTokenProviderError.new(
        message: "Oracle identity domain URL must use HTTPS",
        provider: "oracle-instance-principal"
      )
    end

    body = URI.encode_www_form(
      grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
      scope: "urn:opc:idm:__myscopes__",
      requested_token_type: "urn:ietf:params:oauth:token-type:access_token"
    )
    headers = {
      "content-type": "application/x-www-form-urlencoded;charset=utf-8"
    }

    signer = OCI::Auth::Signers::InstancePrincipalsSecurityTokenSigner.new
    signer.sign(:post, uri.to_s, headers, body)

    request = Net::HTTP::Post.new(uri)
    headers.each { |name, value| request[name.to_s] = value }
    request.body = body

    response = Net::HTTP.start(
      uri.hostname,
      uri.port,
      use_ssl: true,
      open_timeout: 10,
      read_timeout: 30
    ) do |http|
      http.request(request)
    end

    unless response.is_a?(Net::HTTPSuccess)
      raise OpenAI::Errors::SubjectTokenProviderError.new(
        message: "Oracle identity token request failed with status #{response.code}",
        provider: "oracle-instance-principal"
      )
    end

    token = JSON.parse(response.body).fetch("access_token")
    unless token.is_a?(String) && !token.empty?
      raise OpenAI::Errors::SubjectTokenProviderError.new(
        message: "Oracle identity domain did not return an access token",
        provider: "oracle-instance-principal"
      )
    end

    token
  rescue JSON::ParserError
    raise OpenAI::Errors::SubjectTokenProviderError.new(
      message: "Oracle identity token response was not valid JSON",
      provider: "oracle-instance-principal"
    ), cause: nil
  rescue KeyError
    raise OpenAI::Errors::SubjectTokenProviderError.new(
      message: "Oracle identity domain did not return an access token",
      provider: "oracle-instance-principal"
    ), cause: nil
  rescue SystemCallError, Timeout::Error => error
    raise OpenAI::Errors::SubjectTokenProviderError.new(
      message: "Failed to request Oracle identity token: #{error.message}",
      provider: "oracle-instance-principal",
      cause: error
    )
  end
end

provider = OracleInstancePrincipalTokenProvider.new(
  identity_domain_url: ENV.fetch("OCI_IDENTITY_DOMAIN_URL")
)

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 Oracle Cloud Infrastructure workload identity federation."
)

puts(response.output_text)

O provedor de tokens de sujeito solicita um novo token da Oracle quando o OpenAI SDK precisa renovar a credencial de identidade de cargas de trabalho. Nunca imprima nem persista o token de sujeito da Oracle ou o token de acesso da OpenAI resultante.

Recomendações de segurança do OCI

• Mapeie uma instância com ipst_instance quando apenas uma carga de trabalho deva ter acesso.
• Use ipst_compartment somente quando todas as instâncias elegíveis desse compartimento devam compartilhar o mapeamento.
• Adicione domain_id ou ca_ocid para aplicar restrições de domínio de identidade e tenancy.
• Use uma conta de serviço da OpenAI separada para cada aplicativo e ambiente.
• Verifique se um token do OKE representa um node de trabalho antes de confiar no isolamento no nível de pod.
• Use o público-alvo presente no token emitido pela Oracle em vez de presumir um público-alvo específico da OpenAI.
• Faça a rotação das chaves públicas enviadas quando a Oracle fizer a rotação de suas chaves de assinatura, caso seu domínio de identidade não possa usar a descoberta OIDC.