Föderation von Workload-Identitäten für Oracle Cloud Infrastructure konfigurieren

Nutze Oracle Cloud Infrastructure (OCI) als Anbieter für Workload-Identitäten, indem du ein Zugriffstoken des Oracle Identity Cloud Service (IDCS) gegen ein kurzlebiges OpenAI-Zugriffstoken austauschst. Ein OCI-Instanz-Principal signiert eine Token-Austauschanfrage an eine Identitätsdomain im selben Mandanten. OpenAI validiert das daraus resultierende Token und autorisiert den OCI-Workload, als zugeordnetes OpenAI-Dienstkonto zu handeln.

Für Codex erfährst du auf dieser Seite, wie du das Oracle-Token abrufst und prüfst. Konfiguriere anschließend die Workload-Identität für Codex, um das Token in eine Datei zu schreiben und Codex auf diese Datei zu verweisen. Die Dienstkontozuordnung und die SDK-Beispiele auf dieser Seite gelten für die OpenAI API.

Für dieses Setup benötigst du weder einen OpenAI-API-Schlüssel noch eine benutzerdefinierte Oracle-OAuth-Ressourcenanwendung oder Berechtigungen dynamischer Gruppen für eine benutzerdefinierte Anwendung.

OCI-Workload einrichten

Führe deinen Workload auf einer OCI-Compute-Instanz mit einem Instanz-Principal aus. Prüfe bei Oracle Kubernetes Engine (OKE), welche Identität die Anfrage signiert: Der standardmäßige Instanz-Principal-Signer identifiziert in der Regel den Worker-Node, nicht einen einzelnen Kubernetes-Pod.

Der Signer bezieht die Anmeldedaten vom OCI-Instanzmetadatendienst. Stelle sicher, dass der Workload den linklokalen Metadatenendpunkt erreichen kann:

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

Der Workload muss außerdem ausgehende HTTPS-Anfragen an die Identitätsdomain in seinem Mandanten senden können. Der Metadatenendpunkt selbst benötigt weder ein NAT-Gateway noch eine Internetverbindung.

Oracle-Identitätstoken anfordern

Verwende InstancePrincipalsSecurityTokenSigner aus dem OCI Python SDK, um eine OAuth-Token-Austauschanfrage an deine Identitätsdomain zu signieren:

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

Der Scope urn:opc:idm:__myscopes__ nutzt die bestehende Autorisierung des Instanz-Principals. Verwende das zurückgegebene IDCS-Zugriffstoken als Subjekttoken für die Föderation von Workload-Identitäten bei OpenAI. Ersetze die Zielgruppe des Oracle-Tokens nicht durch https://api.openai.com/v1. Konfiguriere den OpenAI-Anbieter mit einer Zielgruppe, die im tatsächlichen Oracle-Token enthalten ist.

Token prüfen

Setze TOKEN auf ein Zugriffstoken, das vom tatsächlichen OCI-Workload generiert wurde. Prüfe anschließend seine Claims mit dem vorhandenen lokalen JWT-Decoder:

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)

Der Decoder untersucht das Token, ohne seine Signatur zu verifizieren. Behandle unverarbeitete Tokens als vertraulich, protokolliere sie nicht und füge keine Tokens aus dem Produktivbetrieb in JWT-Decoder von Drittanbietern ein.

Ein decodiertes Oracle-Zugriffstoken kann die folgenden Claims enthalten:

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
}

Verwende das von deiner eigenen Identitätsdomain ausgestellte Token als maßgebliche Quelle. Konfiguriere den exakten Wert von iss und einen der aud-Werte des Tokens. Bevorzuge bei der Autorisierung eines Workloads die unveränderlichen Claims ipst_instance, ipst_compartment, domain_id und ca_ocid.

Föderation von Workload-Identitäten einrichten

Erstelle einen Anbieter für Workload-Identitäten für deine Oracle-Identitätsdomain. Füge anschließend eine Zuordnung für die OCI-Instanz oder das Compartment hinzu, die bzw. das das vorgesehene OpenAI-Dienstkonto nutzen darf.

Anbieter für Workload-Identitäten einrichten

1. Erstelle den Anbieter für Workload-Identitäten. Gib unter Name einen eindeutigen Wert ein, etwa oracle-cloud-prod. Kennzeichne den vertrauenswürdigen Workload unter Beschreibung, beispielsweise mit Production OCI instance principal.

2. Lege den Aussteller und die Zielgruppe fest. Setze OIDC-Aussteller-URL auf den iss-Claim des Tokens, etwa https://identity.oraclecloud.com/. Setze Zielgruppe auf einen der aud-Werte desselben Tokens.

3. Konfiguriere die mandantenspezifische OIDC-Erkennung, sofern verfügbar. Wenn unter Fortgeschritten die Option Benutzerdefinierte URL für die OIDC-Erkennung verwenden angezeigt wird, aktiviere sie. Setze Benutzerdefinierte OIDC-Erkennungs-URL auf deine mandantenspezifische Identitätsdomain, etwa https://idcs-example.identity.oraclecloud.com. OpenAI ruft https://idcs-example.identity.oraclecloud.com/.well-known/openid-configuration ab und verwendet anschließend den Wert von jwks_uri aus dem Erkennungsdokument, um die öffentlichen Signaturschlüssel des Mandanten abzurufen. Wenn die Option für die benutzerdefinierte Erkennung nicht angezeigt wird, aktiviere stattdessen Hochgeladenes JWKS zur Token-Verifizierung verwenden und lade das öffentliche JWKS von https://<identity-domain>/admin/v1/SigningCert/jwk hoch.

4. Füge Attributtransformationen nur hinzu, wenn du abgeleitete Attribute benötigst. Du kannst unverarbeitete Oracle-Claims wie ipst_instance, ipst_compartment, domain_id und ca_ocid direkt in den Assertions der Dienstkontozuordnung verwenden. Um ein Instanzattribut explizit abzuleiten, gib instance mit dem Ausdruck assertion.ipst_instance ein. Dadurch wird openai.instance erstellt.

Oracles Referenz zur OpenID-Connect-Erkennung zeigt, warum die benutzerdefinierte Erkennung wichtig ist: Das Erkennungsdokument kann den globalen Aussteller https://identity.oraclecloud.com/ angeben, während der Token-Endpunkt und jwks_uri unter der mandantenspezifischen Identitätsdomain veröffentlicht werden. Behalte den globalen Aussteller unter OIDC-Aussteller-URL bei und verwende die Mandantendomain für Benutzerdefinierte OIDC-Erkennungs-URL.

Dienstkontozuordnung einrichten

1. Erstelle eine Dienstkontozuordnung. Gib unter Name einen eindeutigen Wert ein, etwa oracle-instance-prod, und füge eine Beschreibung hinzu, die den vertrauenswürdigen OCI-Workload kennzeichnet.

2. Verwende für den Abgleich die engstmögliche stabile OCI-Identität. Um einer einzelnen Instanz Zugriff zu gewähren, setze Schlüssel auf ipst_instance und Wert auf die exakte Instanz-OCID aus dem geprüften Token. Um Instanzen innerhalb eines Compartments Zugriff zu gewähren, setze Schlüssel auf ipst_compartment und Wert auf die exakte Compartment-OCID.

3. Beschränke den Zugriff bei Bedarf auf eine Domain oder einen Mandanten. Füge weitere Zuordnungszeilen für domain_id oder ca_ocid hinzu, um den Workload auf eine bestimmte Oracle-Identitätsdomain oder einen bestimmten Mandanten zu beschränken. Füge sub_type mit dem Wert instance hinzu, wenn das Token diesen Claim enthält und du einen Instanz-Principal voraussetzen möchtest. Alle Zuordnungszeilen müssen übereinstimmen.

4. Wähle das Ziel bei OpenAI. Wähle unter Projekt das Projekt aus, zu dem das Dienstkonto gehört. Wähle anschließend das Dienstkonto aus, das der vertrauenswürdige OCI-Workload nutzen darf.

5. Schränke die API-Berechtigungen bei Bedarf ein. Wähle nur die Berechtigungen aus, die der Workload benötigt. Die Berechtigungen der Zuordnung können das ausgewählte Dienstkonto einschränken, ihm aber keine Berechtigungen gewähren, die es nicht bereits besitzt.

Token im Code verwenden

Installiere die Python-Pakete OpenAI, OCI und Requests:

pip install openai oci requests

Installiere für Ruby die Gems OpenAI und OCI:

gem install openai oci

Setze OCI_IDENTITY_DOMAIN_URL auf die Basis-URL der Identitätsdomain im selben Mandanten wie der Workload. Setze OPENAI_IDENTITY_PROVIDER_ID und OPENAI_SERVICE_ACCOUNT_ID auf die IDs aus deinem OpenAI-Anbieter und deiner Dienstkontozuordnung.

Das folgende Beispiel signiert eine Oracle-Token-Austauschanfrage mit dem OCI-Instanz-Principal und gibt das IDCS-Zugriffstoken an das OpenAI SDK zurück. Das SDK tauscht es bei Bedarf gegen ein kurzlebiges OpenAI-Zugriffstoken aus:

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)

Der Anbieter für Subjekttokens fordert ein neues Oracle-Token an, wenn das OpenAI SDK die Anmeldedaten der Workload-Identität erneuern muss. Gib das Oracle-Subjekttoken oder das daraus resultierende OpenAI-Zugriffstoken niemals aus und speichere sie niemals dauerhaft.

Sicherheitsempfehlungen für OCI

• Ordne mit ipst_instance eine einzelne Instanz zu, wenn nur ein Workload Zugriff haben soll.
• Verwende ipst_compartment nur, wenn alle infrage kommenden Instanzen in diesem Compartment dieselbe Zuordnung nutzen sollen.
• Füge domain_id oder ca_ocid hinzu, um die Beschränkung auf Identitätsdomains und Mandanten durchzusetzen.
• Verwende für jede Anwendung und Umgebung ein separates OpenAI-Dienstkonto.
• Prüfe, ob ein OKE-Token einen Worker-Node repräsentiert, bevor du dich auf eine Isolation auf Pod-Ebene verlässt.
• Verwende die im ausgestellten Oracle-Token enthaltene Zielgruppe, statt eine OpenAI-spezifische Zielgruppe anzunehmen.
• Wenn deine Identitätsdomain keine OIDC-Erkennung nutzen kann, rotiere die hochgeladenen öffentlichen Schlüssel, sobald Oracle seine Signaturschlüssel rotiert.