Configuración de la federación de identidades de carga de trabajo para Oracle Cloud Infrastructure

Usa Oracle Cloud Infrastructure (OCI) como proveedor de identidades de carga de trabajo al intercambiar un token de acceso de Oracle Identity Cloud Service (IDCS) por un token de acceso de OpenAI de corta duración. Una entidad principal de instancia de OCI firma una solicitud de intercambio de tokens dirigida a un dominio de identidad del mismo arrendamiento. OpenAI valida el token resultante y autoriza a la carga de trabajo de OCI a actuar como una cuenta de servicio de OpenAI asignada.

Para Codex, usa esta página para obtener e inspeccionar el token de Oracle. Luego, configura la identidad de carga de trabajo de Codex para escribir ese token en un archivo e indicarle a Codex dónde encontrarlo. La asignación de cuentas de servicio y los ejemplos del SDK de esta página se aplican a la API de OpenAI.

Esta configuración no requiere una clave de API de OpenAI, una aplicación de recursos OAuth personalizada de Oracle ni permisos de grupos dinámicos para una aplicación personalizada.

Configura la carga de trabajo de OCI

Ejecuta tu carga de trabajo en una instancia de OCI Compute con una entidad principal de instancia. Para Oracle Kubernetes Engine (OKE), confirma qué identidad firma la solicitud: el firmante estándar de entidades principales de instancia suele identificar al nodo de trabajo, no a un pod individual de Kubernetes.

El firmante obtiene las credenciales del servicio de metadatos de instancias de OCI. Verifica que la carga de trabajo pueda acceder al punto de acceso de metadatos local al enlace:

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

La carga de trabajo también debe poder realizar solicitudes HTTPS salientes al dominio de identidad de su arrendamiento. El punto de acceso de metadatos en sí no requiere una puerta de enlace NAT ni una conexión a Internet.

Solicita un token de identidad de Oracle

Usa InstancePrincipalsSecurityTokenSigner del SDK de OCI para Python para firmar una solicitud de intercambio de tokens OAuth dirigida a tu dominio de identidad:

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

El alcance urn:opc:idm:__myscopes__ usa la autorización existente de la entidad principal de instancia. Usa el token de acceso de IDCS devuelto como token de sujeto para la federación de identidades de carga de trabajo de OpenAI. No reemplaces la audiencia del token de Oracle por https://api.openai.com/v1; configura el proveedor de OpenAI con una audiencia que aparezca en el token real de Oracle.

Verifica el token

Establece TOKEN en un token de acceso generado por la carga de trabajo real de OCI y luego usa el decodificador JWT local existente para inspeccionar sus declaraciones:

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)

El decodificador inspecciona el token sin verificar su firma. Trata los tokens sin procesar como información confidencial, no los incluyas en registros y no pegues tokens de producción en decodificadores JWT de terceros.

Un token de acceso de Oracle decodificado puede contener las siguientes declaraciones:

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
}

Usa el token emitido por tu propio dominio de identidad como fuente de referencia. Configura el valor exacto de iss y uno de los valores de aud del token. Da preferencia a las declaraciones inmutables ipst_instance, ipst_compartment, domain_id y ca_ocid al autorizar una carga de trabajo.

Configura la federación de identidades de carga de trabajo

Crea un proveedor de identidades de carga de trabajo para tu dominio de identidad de Oracle y luego agrega una asignación para la instancia o el compartimento de OCI que puede usar la cuenta de servicio de OpenAI de destino.

Configura el proveedor de identidades de carga de trabajo

1. Crea el proveedor de identidades de carga de trabajo. Establece Nombre en un valor único, como oracle-cloud-prod. Usa Descripción, por ejemplo, Production OCI instance principal, para identificar la carga de trabajo de confianza.

2. Establece el emisor y la audiencia. Establece URL del emisor OIDC en la declaración iss del token, por ejemplo, https://identity.oraclecloud.com/. Establece Audiencia en uno de los valores de aud del mismo token.

3. Configura el descubrimiento OIDC específico del arrendatario cuando esté disponible. Si aparece Usar URL personalizada para el descubrimiento OIDC en Avanzado, activa esa opción. Establece URL personalizada de descubrimiento OIDC en el dominio de identidad específico de tu arrendatario, por ejemplo, https://idcs-example.identity.oraclecloud.com. OpenAI obtiene https://idcs-example.identity.oraclecloud.com/.well-known/openid-configuration y luego usa el valor de jwks_uri del documento de descubrimiento para obtener las claves públicas de firma del arrendatario. Si no aparece la opción de descubrimiento personalizado, activa Usar JWKS cargado para verificar tokens y carga el JWKS público de https://<identity-domain>/admin/v1/SigningCert/jwk en su lugar.

4. Agrega transformaciones de atributos solo cuando necesites atributos derivados. Puedes usar declaraciones de Oracle sin procesar, como ipst_instance, ipst_compartment, domain_id y ca_ocid, directamente en las aserciones de asignación de cuentas de servicio. Para un atributo de instancia derivado explícitamente, ingresa instance con la expresión assertion.ipst_instance para crear openai.instance.

La referencia de descubrimiento de OpenID Connect de Oracle muestra por qué es importante el descubrimiento personalizado: el documento de descubrimiento puede declarar el emisor global https://identity.oraclecloud.com/ y publicar el punto de acceso de tokens y jwks_uri en el dominio de identidad específico del arrendatario. Mantén el emisor global en URL del emisor OIDC y usa el dominio del arrendatario en URL personalizada de descubrimiento OIDC.

Configura la asignación de cuentas de servicio

1. Crea una asignación de cuentas de servicio. Establece Nombre en un valor único, como oracle-instance-prod, y agrega una descripción que identifique la carga de trabajo de OCI de confianza.

2. Usa como criterio de coincidencia la identidad estable de OCI más específica. Para conceder acceso a una instancia, establece Clave en ipst_instance y Valor en el OCID exacto de la instancia que aparece en el token verificado. Para conceder acceso a las instancias de un compartimento, establece Clave en ipst_compartment y Valor en el OCID exacto del compartimento.

3. Agrega restricciones de dominio y arrendamiento cuando sea necesario. Agrega más filas de asignación para domain_id o ca_ocid a fin de limitar la carga de trabajo a un dominio de identidad o arrendamiento de Oracle específico. Agrega sub_type con el valor instance cuando el token incluya esa declaración y quieras exigir una entidad principal de instancia. Todas las filas de asignación deben coincidir.

4. Elige el destino de OpenAI. Establece Proyecto en el proyecto al que pertenece la cuenta de servicio y luego selecciona la Cuenta de servicio que puede usar la carga de trabajo de OCI de confianza.

5. Restringe los permisos de la API si es necesario. Selecciona solo los Permisos que necesita la carga de trabajo. Los permisos de la asignación pueden restringir la cuenta de servicio seleccionada, pero no pueden otorgarle permisos que aún no tenga.

Usa el token en el código

Instala los paquetes de Python de OpenAI, OCI y Requests:

pip install openai oci requests

Para Ruby, instala las gemas de OpenAI y OCI:

gem install openai oci

Establece OCI_IDENTITY_DOMAIN_URL en la URL base del dominio de identidad que se encuentra en el mismo arrendamiento que la carga de trabajo. Establece OPENAI_IDENTITY_PROVIDER_ID y OPENAI_SERVICE_ACCOUNT_ID en los ID de tu proveedor de OpenAI y de la asignación de cuentas de servicio.

El siguiente ejemplo firma una solicitud de intercambio de tokens de Oracle con la entidad principal de instancia de OCI, devuelve el token de acceso de IDCS al SDK de OpenAI y permite que el SDK lo intercambie por un token de acceso de OpenAI de corta duración cuando sea necesario:

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)

El proveedor de tokens de sujeto solicita un nuevo token de Oracle cuando el SDK de OpenAI necesita renovar la credencial de identidad de carga de trabajo. Nunca imprimas ni guardes de forma persistente el token de sujeto de Oracle ni el token de acceso de OpenAI resultante.

Recomendaciones de seguridad de OCI

• Asigna una instancia con ipst_instance cuando solo una carga de trabajo deba tener acceso.
• Usa ipst_compartment solo cuando todas las instancias elegibles de ese compartimento deban compartir la asignación.
• Agrega domain_id o ca_ocid para aplicar restricciones de dominio de identidad y arrendamiento.
• Usa una cuenta de servicio de OpenAI independiente para cada aplicación y entorno.
• Verifica si un token de OKE representa a un nodo de trabajo antes de confiar en el aislamiento a nivel de pod.
• Usa la audiencia presente en el token de Oracle emitido en lugar de suponer una audiencia específica de OpenAI.
• Rota las claves públicas cargadas cuando Oracle rote sus claves de firma si tu dominio de identidad no puede usar el descubrimiento OIDC.