Como configurar a federação de identidades de cargas de trabalho para a Oracle Cloud Infrastructure

Para usar a Oracle Cloud Infrastructure (OCI) como provedor de identidade de cargas de trabalho, troque um token de acesso do Oracle Identity Cloud Service (IDCS) por um token de acesso de curta duração da OpenAI. Um principal de instância da OCI assina a solicitação de troca de token enviada a um domínio de identidade na mesma tenancy. A OpenAI valida o token obtido e autoriza a carga de trabalho da OCI a atuar como a conta de serviço da OpenAI definida no mapeamento.

Essa configuração dispensa o uso de uma chave de API da OpenAI, a criação de um aplicativo de recursos OAuth personalizado na Oracle e a concessão de permissões a grupos dinâmicos para acessar um aplicativo personalizado.

Configure a carga de trabalho da OCI

Execute a carga de trabalho em uma instância do OCI Compute com um principal de instância. Se você usa o Oracle Kubernetes Engine (OKE), confirme qual identidade assina a solicitação. O assinador padrão do principal de instância geralmente identifica o node de trabalho, e não um pod específico do Kubernetes.

O assinador obtém as credenciais do serviço de metadados de instância da OCI. Verifique se a carga de trabalho consegue acessar o endpoint de metadados pelo endereço link-local:

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

A carga de trabalho também precisa conseguir enviar solicitações HTTPS ao domínio de identidade da sua tenancy. O acesso ao endpoint de metadados em si dispensa o uso de um gateway NAT ou de uma conexão com a internet.

Solicite um token de identidade da Oracle

Use InstancePrincipalsSecurityTokenSigner do SDK da OCI para Python para assinar uma solicitação OAuth de troca de token destinada ao 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 que o principal de instância já tem. Use o token de acesso retornado pelo IDCS como token do sujeito na federação de identidades de cargas de trabalho da OpenAI. Não substitua o público do token da Oracle por https://api.openai.com/v1. Configure o provedor da OpenAI com um público presente no token emitido pela Oracle.

Verifique o token

Atribua a TOKEN um token de acesso gerado pela própria carga de trabalho da OCI. Em seguida, use o decodificador JWT local existente para examinar as declarações do token:

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 examina o token sem verificar a assinatura. Trate os tokens originais como dados sensíveis. Não os registre em logs nem cole tokens de produção em decodificadores JWT de terceiros.

Um token de acesso da Oracle, depois de 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 referência. Configure o valor exato de iss e um dos valores de aud desse token. Ao autorizar uma carga de trabalho, dê preferência às declarações imutáveis ipst_instance, ipst_compartment, domain_id e ca_ocid.

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

Crie um provedor de identidade de cargas de trabalho para o seu domínio de identidade da Oracle. Em seguida, adicione um mapeamento para a instância ou o compartimento da OCI que poderá 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. Em Nome, informe um valor exclusivo, como oracle-cloud-prod. Use o campo Descrição para identificar a carga de trabalho confiável, por exemplo, Production OCI instance principal.

2. Defina o emissor e o público. Em URL do emissor OIDC, informe o valor da declaração iss do token, por exemplo, https://identity.oraclecloud.com/. Em Público, informe um dos valores de aud do mesmo token.

3. Configure a descoberta OIDC específica do tenant, se disponível. Se a opção Usar URL personalizada para descoberta OIDC aparecer em Avançado, ative-a. Em URL personalizada de descoberta OIDC, informe a URL do domínio de identidade do seu tenant, como https://idcs-example.identity.oraclecloud.com. A OpenAI consulta 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 faça upload do JWKS público obtido em https://<identity-domain>/admin/v1/SigningCert/jwk.

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

A documentação da Oracle sobre descoberta OpenID Connect explica a importância da descoberta personalizada. O documento de descoberta pode declarar o emissor global https://identity.oraclecloud.com/ e, ao mesmo tempo, publicar o endpoint de token 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 da conta de serviço

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

2. Use a identidade estável da OCI com o escopo mais restrito possível. Para conceder acesso a uma única instância, defina Chave como ipst_instance e, em Valor, informe o OCID exato da instância que consta no token verificado. Para conceder acesso às instâncias de um compartimento, defina Chave como ipst_compartment e, em Valor, informe o OCID exato do compartimento.

3. Restrinja o domínio e a tenancy quando necessário. Adicione linhas ao mapeamento para domain_id ou ca_ocid para restringir 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 se o token contiver essa declaração e você quiser exigir um principal de instância. O token precisa atender aos critérios de todas as linhas do mapeamento.

4. Escolha a conta de destino na OpenAI. Em Projeto, selecione o projeto ao qual a conta de serviço pertence. Em seguida, selecione a Conta de serviço que a carga de trabalho confiável da OCI poderá usar.

5. Restrinja as permissões da API, se necessário. Selecione apenas as Permissões de que a carga de trabalho precisa. O mapeamento pode restringir as permissões da conta de serviço selecionada, mas não pode conceder permissões que a conta ainda não tenha.

Use o token no código

Instale os pacotes Python da OpenAI e da OCI, além do Requests:

pip install openai oci requests

Para Ruby, instale as gems da OpenAI e da OCI:

gem install openai oci

Defina OCI_IDENTITY_DOMAIN_URL como a URL base do domínio de identidade que está na mesma tenancy da carga de trabalho. Atribua a OPENAI_IDENTITY_PROVIDER_ID e OPENAI_SERVICE_ACCOUNT_ID os IDs do provedor da OpenAI e da conta de serviço associada no mapeamento, respectivamente.

O exemplo a seguir usa o principal de instância da OCI para assinar uma solicitação de troca de token da Oracle e retorna o token de acesso do IDCS ao SDK da OpenAI. Quando necessário, o SDK troca esse token por um token de acesso de curta duração da OpenAI:

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 do sujeito solicita um novo token da Oracle quando o SDK da OpenAI precisa renovar a credencial de identidade da carga de trabalho. Nunca imprima nem armazene de forma persistente o token do sujeito da Oracle ou o token de acesso da OpenAI obtido na troca.

Recomendações de segurança para a OCI

• Mapeie uma única instância com ipst_instance quando apenas uma carga de trabalho deve ter acesso.
• Use ipst_compartment somente quando todas as instâncias elegíveis desse compartimento devem compartilhar o mapeamento.
• Adicione domain_id ou ca_ocid para aplicar as restrições de domínio de identidade e de tenancy.
• Use uma conta de serviço da OpenAI separada para cada aplicativo e ambiente.
• Antes de contar com o isolamento no nível do pod, verifique se o token do OKE representa um node de trabalho.
• Use o público presente no token emitido pela Oracle. Não presuma que o público seja específico da OpenAI.
• Se o seu domínio de identidade não puder usar a descoberta OIDC, substitua as chaves públicas enviadas sempre que a Oracle fizer a rotação das chaves de assinatura.