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

Para usar Oracle Cloud Infrastructure (OCI) como proveedor de identidades de cargas de trabajo, intercambia un token de acceso de Oracle Identity Cloud Service (IDCS) por un token de acceso de OpenAI de corta duración. Una identidad principal de instancia de OCI firma la 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 en nombre de la cuenta de servicio de OpenAI a la que está asignada.

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 acceder a una aplicación personalizada.

Configurar la carga de trabajo de OCI

Ejecuta tu carga de trabajo en una instancia de OCI Compute con una identidad principal de instancia. Si usas Oracle Kubernetes Engine (OKE), confirma qué identidad firma la solicitud. El firmante estándar de la identidad principal de instancia suele identificar al nodo de trabajo en su conjunto, 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 mediante su dirección de enlace local:

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

La carga de trabajo también debe poder enviar 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 conexión a internet.

Solicitar un token de identidad de Oracle

Usa InstancePrincipalsSecurityTokenSigner del SDK de OCI para Python para firmar una solicitud OAuth de intercambio de tokens 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__ utiliza la autorización que ya tiene la identidad principal de instancia. Usa el token de acceso de IDCS que recibas como token de sujeto para la federación de identidades de cargas de trabajo de OpenAI. No sustituyas la audiencia del token de Oracle por https://api.openai.com/v1. Configura el proveedor de OpenAI con una audiencia que figure en el token emitido por Oracle.

Verificar el token

Asigna a TOKEN un token de acceso generado por la carga de trabajo de OCI que vas a usar. Luego, usa el decodificador local de JWT existente para examinar 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 examina el token sin verificar su firma. Trata los tokens sin procesar como datos sensibles. No los incluyas en los registros ni pegues tokens de producción en decodificadores de 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
}

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

Configurar la federación de identidades de cargas de trabajo

Crea un proveedor de identidades de cargas de trabajo para tu dominio de identidad de Oracle. Luego, agrega una asignación para la instancia o el compartimento de OCI que podrá usar la cuenta de servicio de OpenAI de destino.

Configurar el proveedor de identidades de cargas de trabajo

1. Crea el proveedor de identidades de cargas de trabajo. En Nombre, ingresa un valor único, como oracle-cloud-prod. En Descripción, ingresa un texto que identifique la carga de trabajo de confianza, como Production OCI instance principal.

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

3. Configura el descubrimiento OIDC específico del arrendatario cuando esté disponible. Si la opción Usar una URL personalizada para el descubrimiento OIDC aparece en Opciones avanzadas, actívala. En URL personalizada de descubrimiento OIDC, ingresa la URL del dominio de identidad 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 la opción de descubrimiento personalizado no aparece, activa Usar un JWKS cargado para verificar los tokens y carga el JWKS público que se encuentra en https://<identity-domain>/admin/v1/SigningCert/jwk.

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

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

Configurar la asignación de la cuenta de servicio

1. Crea una asignación de cuenta de servicio. En Nombre, ingresa 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 sola instancia, en Clave ingresa ipst_instance y en Valor ingresa el OCID exacto de la instancia que figura en el token verificado. Para conceder acceso a las instancias de un mismo compartimento, en Clave ingresa ipst_compartment y en Valor ingresa el OCID exacto del compartimento.

3. Limita el acceso por dominio y arrendamiento cuando sea necesario. Agrega filas de asignación para domain_id o ca_ocid si necesitas restringir la carga de trabajo a un dominio de identidad o arrendamiento específico de Oracle. Agrega sub_type con el valor instance si el token incluye esa declaración y quieres exigir una identidad principal de instancia. El token debe cumplir los criterios de todas las filas de la asignación.

4. Elige el destino en OpenAI. En Proyecto, selecciona el proyecto al que pertenece la cuenta de servicio. Luego, selecciona la Cuenta de servicio que podrá usar la carga de trabajo de OCI de confianza.

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

Usar 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

Asigna a OCI_IDENTITY_DOMAIN_URL la URL base del dominio de identidad que pertenece al mismo arrendamiento que la carga de trabajo. Asigna a OPENAI_IDENTITY_PROVIDER_ID y OPENAI_SERVICE_ACCOUNT_ID los ID correspondientes que figuran en el proveedor de OpenAI y en la asignación de la cuenta de servicio.

El siguiente ejemplo usa la identidad principal de instancia de OCI para firmar una solicitud de intercambio de tokens de Oracle. Devuelve el token de acceso de IDCS al SDK de OpenAI para que el SDK pueda intercambiarlo por un token de acceso de OpenAI de corta duración cuando lo necesite:

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 la 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 para OCI

• Si solo una carga de trabajo debe tener acceso, asigna una sola instancia mediante ipst_instance.
• Usa ipst_compartment solo cuando todas las instancias que cumplan los requisitos en ese compartimento deban compartir la asignación.
• Agrega domain_id o ca_ocid para restringir el acceso por dominio de identidad y arrendamiento.
• Usa una cuenta de servicio de OpenAI distinta para cada aplicación y entorno.
• Antes de confiar en el aislamiento a nivel de pod, verifica si el token de OKE representa a un nodo de trabajo.
• Usa la audiencia que figura en el token emitido por Oracle. No des por hecho que la audiencia es específica de OpenAI.
• Si tu dominio de identidad no puede usar el descubrimiento OIDC, rota las claves públicas cargadas cuando Oracle rote sus claves de firma.