--- title: Usar WIF com Okta url: https://platform.claude.com/docs/pt-BR/manage-claude/wif-providers/okta description: Federe identidades de aplicativos de serviço do Okta para a Claude API com Workload Identity Federation. --- O Okta pode atuar como um provedor de identidade de workload emitindo tokens de acesso OIDC para um **service application** (aplicativo de serviço) por meio da concessão `client_credentials` do OAuth 2.0. Seu workload se autentica no Okta (normalmente com `private_key_jwt`, de modo que nenhum segredo compartilhado é armazenado), recebe um "JSON Web Token" (token web JSON), ou JWT, assinado e troca esse JWT com a Anthropic por um token de acesso de curta duração. A URL do emissor do servidor de autorização do Okta tem o formato `https://.okta.com/oauth2/`. Se você usar o servidor padrão integrado, o caminho é `/oauth2/default`. Você deve usar um **custom authorization server** (servidor de autorização personalizado) do Okta (incluindo o `default`). Tokens emitidos diretamente pelo servidor de autorização da organização Okta (o endpoint `/oauth2/v1/token` sem ID de servidor de autorização no caminho) não podem ser validados por terceiros porque o Okta não publica chaves de assinatura para eles. Existem muitas maneiras de configurar e autenticar no Okta que estão fora do escopo desta documentação. Certifique-se de que seus mecanismos de configuração e autenticação sigam as orientações e práticas de segurança da sua empresa. ## Pré-requisitos * Familiaridade com os [conceitos de WIF](https://platform.claude.com/docs/pt-BR/manage-claude/workload-identity-federation#concepts): contas de serviço, emissores de federação e regras de federação. * Uma organização Okta com API Access Management habilitado (necessário para servidores de autorização personalizados). * Permissão para criar contas de serviço, emissores de federação e regras de federação no Claude Console para sua organização Anthropic. * Um workload que possa solicitar um token do endpoint `/v1/token` do Okta e alcançar `api.anthropic.com`. ## Configurar o Okta Em linhas gerais, você precisa: 1. Criar um aplicativo de serviço do Okta. 2. Configurar seu servidor de autorização padrão (ou criar um novo servidor de autorização personalizado) com uma audiência, um escopo, uma política de acesso e quaisquer claims personalizadas nas quais você queira fazer correspondência. A navegação exata depende da configuração da sua organização Okta e da versão do console de administração. As etapas numeradas a seguir percorrem um caminho comum: 1. **Crie uma integração de aplicativo de serviço.** No Okta Admin Console, crie uma nova integração de aplicativo do tipo **API Services** (OIDC, máquina a máquina). Anote o **Client ID** gerado. 2. **Configure a autenticação do cliente.** Para uma configuração sem chaves, escolha **Public key / Private key** (`private_key_jwt`) e registre a JWK pública do seu workload. Como alternativa, use um segredo de cliente se seu ambiente puder armazená-lo com segurança. Para o exemplo a seguir, talvez você precise desabilitar o requisito de DPoP no aplicativo; certifique-se de que sua configuração de produção esteja em conformidade com os requisitos de segurança da sua organização. 3. **Defina a audiência.** No seu servidor de autorização personalizado, defina a audiência como `https://api.anthropic.com` para que os tokens de acesso emitidos carreguem essa claim `aud`. A Anthropic valida `aud` em relação a esse valor fixo. 4. **Conceda um escopo.** No seu servidor de autorização personalizado, garanta que exista pelo menos um escopo que o aplicativo de serviço tenha permissão para solicitar (por exemplo, `anthropic.access`). O Okta rejeita solicitações `client_credentials` que não incluam um escopo concedido. 5. **Crie uma política de acesso.** No seu servidor de autorização personalizado, crie uma política de acesso com pelo menos uma regra que permita que seu aplicativo de serviço solicite o escopo concedido na etapa 4. 6. **(Opcional) Adicione claims personalizadas.** Se você quiser fazer correspondência em algo diferente do Client ID, adicione uma claim ao token de acesso na aba **Claims** do seu servidor de autorização. Para um aplicativo de serviço usando `client_credentials`, o Okta define a claim `sub` do token de acesso emitido como o **Client ID** do aplicativo, e `iss` como a URL do emissor do servidor de autorização. ## Configurar a Anthropic No Claude Console, acesse a página [Workload identity](https://platform.claude.com/settings/workload-identity-federation) (`platform.claude.com/settings/workload-identity-federation`), clique em **Connect workload** e selecione **Custom OIDC**. O assistente orienta você no registro do emissor, na criação de uma conta de serviço e na criação de uma regra de federação. O assistente cria esses recursos para você. Use os seguintes valores, seja inserindo-os no assistente ou enviando-os para a [Admin API](https://platform.claude.com/docs/pt-BR/manage-claude/wif-admin-api): **Emissor de federação:** Use a URL do seu servidor de autorização personalizado do Okta e o modo de descoberta. A Anthropic lê o documento de descoberta `.well-known/openid-configuration` do Okta e busca o JWKS a partir do `jwks_uri` que ele anuncia. ```json { "name": "okta-prod", "issuer_url": "https://acme.okta.com/oauth2/aus1a2b3c4d5e6f7g8h9", "jwks": { "type": "discovery" } } ``` **Regra de federação:** Faça correspondência na claim `sub` do Okta, que é o Client ID do aplicativo de serviço. Se você definiu claims personalizadas no Okta, pode fazer correspondência nelas em vez disso, com o mapa `claims` ou uma `condition` CEL. ```json { "name": "okta-pipeline", "issuer_id": "fdis_...", "match": { "subject_prefix": "0oa1b2c3d4e5f6g7h8i9", "audience": "https://api.anthropic.com" }, "target": { "type": "service_account", "service_account_id": "svac_..." }, "workspace_id": "wrkspc_...", "oauth_scope": "workspace:developer", "token_lifetime_seconds": 600 } ``` ## Obter um token e chamar a Claude API Diferentemente dos provedores nativos de plataforma (AWS, Google Cloud, Kubernetes), que disponibilizam um token dentro do runtime do workload (por meio de um arquivo projetado ou endpoint de metadados local), o Okta não faz isso. Seu workload deve chamar o endpoint de token do Okta para obter um JWT e, em seguida, passar esse JWT ao SDK da Anthropic como o token de identidade. ```bash cURL # 1. Solicite um token de acesso ao Okta (client_credentials com private_key_jwt). OKTA_JWT=$(curl -sS "https://acme.okta.com/oauth2/aus1a2b3c4d5e6f7g8h9/v1/token" \ -d grant_type=client_credentials \ -d scope=anthropic.access \ -d client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer \ --data-urlencode client_assertion="$SIGNED_CLIENT_ASSERTION" \ | jq -r .access_token) # 2. Troque o JWT do Okta por um token de acesso da Anthropic. ACCESS_TOKEN=$(curl -sS https://api.anthropic.com/v1/oauth/token \ -H "content-type: application/json" \ -d @- < str: response = httpx2.post( f"{os.environ['OKTA_ISSUER']}/v1/token", data={ "grant_type": "client_credentials", "scope": "anthropic.access", "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", # Cria o JWT client_assertion da RFC 7523 assinado com a chave privada do seu app Okta "client_assertion": build_signed_client_assertion(), }, ) response.raise_for_status() return response.json()["access_token"] client = anthropic.Anthropic( credentials=WorkloadIdentityCredentials( identity_token_provider=fetch_okta_token, federation_rule_id=os.environ["ANTHROPIC_FEDERATION_RULE_ID"], organization_id=os.environ["ANTHROPIC_ORGANIZATION_ID"], service_account_id=os.environ["ANTHROPIC_SERVICE_ACCOUNT_ID"], workspace_id=os.environ.get("ANTHROPIC_WORKSPACE_ID"), ), ) message = client.messages.create( model="claude-opus-5-5", max_tokens=1024, messages=[{"role": "user", "content": "Hello, Claude"}], ) print(next(block.text for block in message.content if block.type == "text")) ``` ```typescript TypeScript import Anthropic from "@anthropic-ai/sdk"; import { oidcFederationProvider } from "@anthropic-ai/sdk/lib/credentials/oidc-federation"; async function fetchOktaToken(): Promise { const response = await fetch(`${process.env.OKTA_ISSUER}/v1/token`, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ grant_type: "client_credentials", scope: "anthropic.access", client_assertion_type: "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", // Cria o JWT client_assertion da RFC 7523 assinado com a chave privada do seu app Okta client_assertion: buildSignedClientAssertion() }) }); const body = (await response.json()) as { access_token: string }; return body.access_token; } const client = new Anthropic({ credentials: oidcFederationProvider({ identityTokenProvider: fetchOktaToken, federationRuleId: process.env.ANTHROPIC_FEDERATION_RULE_ID!, organizationId: process.env.ANTHROPIC_ORGANIZATION_ID!, serviceAccountId: process.env.ANTHROPIC_SERVICE_ACCOUNT_ID, workspaceId: process.env.ANTHROPIC_WORKSPACE_ID, baseURL: "https://api.anthropic.com", fetch }) }); const message = await client.messages.create({ model: "claude-opus-5-5", max_tokens: 1024, messages: [{ role: "user", content: "Hello, Claude" }] }); for (const block of message.content) { if (block.type === "text") { console.log(block.text); } } ``` ```go Go package main import ( "context" "encoding/json" "fmt" "net/http" "net/url" "os" "strings" "github.com/anthropics/anthropic-sdk-go" "github.com/anthropics/anthropic-sdk-go/option" ) func fetchOktaToken(ctx context.Context) (string, error) { form := url.Values{ "grant_type": {"client_credentials"}, "scope": {"anthropic.access"}, "client_assertion_type": {"urn:ietf:params:oauth:client-assertion-type:jwt-bearer"}, // Cria o JWT client_assertion da RFC 7523 assinado com a chave privada do seu app Okta "client_assertion": {buildSignedClientAssertion()}, } req, err := http.NewRequestWithContext(ctx, http.MethodPost, os.Getenv("OKTA_ISSUER")+"/v1/token", strings.NewReader(form.Encode())) if err != nil { return "", err } req.Header.Set("content-type", "application/x-www-form-urlencoded") resp, err := http.DefaultClient.Do(req) if err != nil { return "", err } defer resp.Body.Close() var body struct { AccessToken string `json:"access_token"` } if err := json.NewDecoder(resp.Body).Decode(&body); err != nil { return "", err } return body.AccessToken, nil } func main() { client := anthropic.NewClient( option.WithFederationTokenProvider(option.IdentityTokenFunc(fetchOktaToken), option.FederationOptions{ FederationRuleID: os.Getenv("ANTHROPIC_FEDERATION_RULE_ID"), OrganizationID: os.Getenv("ANTHROPIC_ORGANIZATION_ID"), ServiceAccountID: os.Getenv("ANTHROPIC_SERVICE_ACCOUNT_ID"), WorkspaceID: os.Getenv("ANTHROPIC_WORKSPACE_ID"), }), ) message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 1024, Messages: []anthropic.MessageParam{ anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")), }, }) if err != nil { panic(err) } for _, block := range message.Content { if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok { fmt.Println(textBlock.Text) break } } } ``` ```java Java import com.anthropic.config.AuthenticationConfig; import com.anthropic.config.AuthenticationType; import com.anthropic.config.IdentityTokenConfig; import com.anthropic.config.InMemoryProfileConfigProvider; import com.anthropic.config.ProfileConfig; // ... import com.fasterxml.jackson.databind.ObjectMapper; import java.net.URI; import java.net.URLEncoder; import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.util.Map; import java.util.stream.Collectors; import static java.nio.charset.StandardCharsets.UTF_8; void main() throws Exception { var form = Map.of( "grant_type", "client_credentials", "scope", "anthropic.access", "client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", // Cria o JWT client_assertion da RFC 7523 assinado com a chave privada do seu app Okta "client_assertion", buildSignedClientAssertion()) .entrySet().stream() .map(entry -> entry.getKey() + "=" + URLEncoder.encode(entry.getValue(), UTF_8)) .collect(Collectors.joining("&")); var request = HttpRequest.newBuilder(URI.create(System.getenv("OKTA_ISSUER") + "/v1/token")) .header("content-type", "application/x-www-form-urlencoded") .POST(HttpRequest.BodyPublishers.ofString(form)) .build(); // O SDK Java recebe o próprio token ou um caminho de arquivo, não uma função; com // source("value"), path(...) contém o token. O SDK envia esse mesmo token // a cada renovação do token de acesso da Anthropic, o que falha quando ele // expira ou, se tiver uma claim jti, já foi usado. Para um processo de longa duração, // passe source("file") e grave um novo token no arquivo antes de // cada renovação. var response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString()); String oktaToken = new ObjectMapper().readTree(response.body()).get("access_token").asText(); AnthropicClient client = AnthropicOkHttpClient.builder() .configurationProvider(InMemoryProfileConfigProvider.of(ProfileConfig.builder() .organizationId(System.getenv("ANTHROPIC_ORGANIZATION_ID")) .workspaceId(System.getenv("ANTHROPIC_WORKSPACE_ID")) .authentication(AuthenticationConfig.builder() .type(AuthenticationType.OIDC_FEDERATION) .federationRuleId(System.getenv("ANTHROPIC_FEDERATION_RULE_ID")) .serviceAccountId(System.getenv("ANTHROPIC_SERVICE_ACCOUNT_ID")) .identityToken(IdentityTokenConfig.builder() .source("value") .path(oktaToken) .build()) .build()) .build())) .build(); var message = client.messages().create(MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(1024) .addUserMessage("Hello, Claude") .build()); IO.println(message.content()); } ``` ```csharp C# using Anthropic.Credentials; // ... var credentials = new WorkloadIdentityCredentials(new WorkloadIdentityOptions { FederationRuleId = Environment.GetEnvironmentVariable("ANTHROPIC_FEDERATION_RULE_ID")!, OrganizationId = Environment.GetEnvironmentVariable("ANTHROPIC_ORGANIZATION_ID"), ServiceAccountId = Environment.GetEnvironmentVariable("ANTHROPIC_SERVICE_ACCOUNT_ID"), WorkspaceId = Environment.GetEnvironmentVariable("ANTHROPIC_WORKSPACE_ID"), IdentityTokenProvider = new OktaTokenProvider(), }); using var client = new AnthropicClient(new ClientOptions { Credentials = credentials }); var message = await client.Messages.Create(new() { Model = Model.ClaudeOpus5_5, MaxTokens = 1024, Messages = [new() { Role = Role.User, Content = "Hello, Claude" }], }); foreach (var block in message.Content) { if (block.Value is TextBlock textBlock) { Console.WriteLine(textBlock.Text); } } class OktaTokenProvider : IIdentityTokenProvider { private static readonly HttpClient Http = new(); public async Task GetIdentityTokenAsync(CancellationToken ct = default) { var form = new FormUrlEncodedContent(new Dictionary { ["grant_type"] = "client_credentials", ["scope"] = "anthropic.access", ["client_assertion_type"] = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", // Cria o JWT client_assertion da RFC 7523 assinado com a chave privada do seu app Okta ["client_assertion"] = BuildSignedClientAssertion(), }); var response = await Http.PostAsync( $"{Environment.GetEnvironmentVariable("OKTA_ISSUER")}/v1/token", form, ct); response.EnsureSuccessStatusCode(); using var json = await JsonDocument.ParseAsync( await response.Content.ReadAsStreamAsync(ct), default, ct); return json.RootElement.GetProperty("access_token").GetString()!; } } ``` ```bash CLI # 1. Solicite um token de acesso ao Okta e grave-o em um arquivo temporário. ANTHROPIC_IDENTITY_TOKEN_FILE=$(mktemp) curl -sS "$OKTA_ISSUER/v1/token" \ -d grant_type=client_credentials \ -d scope=anthropic.access \ -d client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer \ --data-urlencode client_assertion="$SIGNED_CLIENT_ASSERTION" \ | jq -r .access_token > "$ANTHROPIC_IDENTITY_TOKEN_FILE" export ANTHROPIC_IDENTITY_TOKEN_FILE # 2. Chame a API do Claude. A CLI lê ANTHROPIC_FEDERATION_RULE_ID, # ANTHROPIC_ORGANIZATION_ID, ANTHROPIC_SERVICE_ACCOUNT_ID, ANTHROPIC_WORKSPACE_ID e # ANTHROPIC_IDENTITY_TOKEN_FILE e realiza a troca. ant messages create \ --model claude-opus-5-5 \ --max-tokens 1024 \ --message '{role: user, content: "Hello, Claude"}' ``` ```php PHP use Anthropic\Client; use Anthropic\Lib\Credentials\CredentialResult; use Anthropic\Lib\Credentials\IdentityTokenProvider; use Anthropic\Lib\Credentials\TokenCache; use Anthropic\Lib\Credentials\WorkloadIdentityCredentials; class OktaIdentityToken implements IdentityTokenProvider { public function getIdentityToken(): string { $ch = curl_init(getenv('OKTA_ISSUER') . '/v1/token'); curl_setopt_array($ch, [ CURLOPT_RETURNTRANSFER => true, CURLOPT_POSTFIELDS => http_build_query([ 'grant_type' => 'client_credentials', 'scope' => 'anthropic.access', 'client_assertion_type' => 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer', // Cria o JWT client_assertion da RFC 7523 assinado com a chave privada do seu app Okta 'client_assertion' => buildSignedClientAssertion(), ]), ]); $body = json_decode(curl_exec($ch), true); curl_close($ch); return $body['access_token']; } } $client = new Client( credentials: new CredentialResult( provider: new TokenCache(new WorkloadIdentityCredentials( identityProvider: new OktaIdentityToken(), federationRuleId: getenv('ANTHROPIC_FEDERATION_RULE_ID'), organizationId: getenv('ANTHROPIC_ORGANIZATION_ID'), serviceAccountId: getenv('ANTHROPIC_SERVICE_ACCOUNT_ID'), workspaceId: getenv('ANTHROPIC_WORKSPACE_ID') ?: null, )), ), ); $message = $client->messages->create( model: 'claude-opus-5-5', maxTokens: 1024, messages: [['role' => 'user', 'content' => 'Hello, Claude']], ); echo array_find($message->content, static fn ($block): bool => $block->type === 'text')->text, PHP_EOL; ``` ```ruby Ruby require "anthropic" require "json" require "net/http" def fetch_okta_token uri = URI("#{ENV.fetch('OKTA_ISSUER')}/v1/token") response = Net::HTTP.post_form( uri, "grant_type" => "client_credentials", "scope" => "anthropic.access", "client_assertion_type" => "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", # Cria o JWT client_assertion da RFC 7523 assinado com a chave privada do seu app Okta "client_assertion" => build_signed_client_assertion ) JSON.parse(response.body).fetch("access_token") end client = Anthropic::Client.new( credentials: Anthropic::WorkloadIdentityCredentials.new( identity_token_provider: -> { fetch_okta_token }, federation_rule_id: ENV.fetch("ANTHROPIC_FEDERATION_RULE_ID"), organization_id: ENV.fetch("ANTHROPIC_ORGANIZATION_ID"), service_account_id: ENV.fetch("ANTHROPIC_SERVICE_ACCOUNT_ID"), workspace_id: ENV["ANTHROPIC_WORKSPACE_ID"] ) ) message = client.messages.create( model: "claude-opus-5-5", max_tokens: 1024, messages: [{role: "user", content: "Hello, Claude"}] ) puts message.content.find { it.type == :text }.text ``` Exceto em Java (consulte o comentário nesse exemplo), o exemplo do SDK passa a sua busca de token do Okta para `identity_token_provider` (typescript: `identityTokenProvider`; php: `identityProvider`; csharp: `IdentityTokenProvider`; go: `option.WithFederationTokenProvider`; java: `IdentityTokenConfig`) como um provedor de token. O SDK do Claude o chama sempre que o token de acesso da Anthropic está perto de expirar, portanto sua função de busca do Okta deve retornar um token novo a cada chamada, em vez de armazenar um em cache indefinidamente. A CLI `ant` relê `ANTHROPIC_IDENTITY_TOKEN_FILE` a cada troca, então atualize esse arquivo periodicamente em shells de longa duração. ## Verificar a configuração Uma troca bem-sucedida retorna um `access_token` começando com `sk-ant-oat01-` e um valor `expires_in` em segundos. Se a troca falhar com a resposta opaca `401` `authentication_error` (mensagem `Authentication failed`), verifique a [página de histórico de autenticação](https://platform.claude.com/settings/workload-identity-federation?tab=history) no Claude Console para ver o motivo da negação e consulte [Solucionar problemas de uma troca com falha](https://platform.claude.com/docs/pt-BR/manage-claude/wif-reference#troubleshoot-a-failed-exchange); a causa mais comum do lado do Okta é uma incompatibilidade de `issuer_url` (ela deve incluir o caminho `/oauth2/`; o servidor de autorização da organização Okta não pode ser usado). ## Delimitar o escopo da sua regra Vários aplicativos de serviço sob o mesmo servidor de autorização do Okta compartilham o mesmo emissor. Uma regra que omite `subject_prefix` corresponde a todos os aplicativos de serviço nesse servidor, portanto qualquer equipe que possa registrar um poderia obter um token federado da Anthropic. Restrinja o bloco `match` da regra ao escopo mais estreito que atenda ao seu caso de uso: * **Fixe o Client ID exato:** Defina `subject_prefix` como o Client ID completo do aplicativo de serviço, sem `*` no final. * **Fixe a audiência:** Faça correspondência com o valor de `audience` que você configurou no servidor de autorização para que tokens emitidos para uma audiência diferente sejam rejeitados. * **Faça correspondência em claims personalizadas:** Para um escopo mais granular, adicione claims na aba **Claims** do servidor de autorização e faça correspondência nelas com o mapa `claims` da regra ou uma `condition` CEL. * **Use uma regra por aplicativo de serviço:** Crie uma regra de federação separada para cada aplicativo de serviço em vez de compartilhar uma regra entre aplicativos. ## Próximos passos * Revise a [referência de WIF](https://platform.claude.com/docs/pt-BR/manage-claude/wif-reference) para a ordem completa de resolução de credenciais e a configuração de perfis. * Consulte a [referência de WIF](https://platform.claude.com/docs/pt-BR/manage-claude/wif-reference#rule-matching-semantics) para fazer correspondência em claims personalizadas do Okta com expressões CEL.