--- title: Usare WIF con Okta url: https://platform.claude.com/docs/it/manage-claude/wif-providers/okta description: Federa le identità delle applicazioni di servizio Okta verso la Claude API con Workload Identity Federation. --- Okta può agire come provider di identità per workload emettendo token di accesso OIDC a una **service application** (applicazione di servizio) tramite il grant OAuth 2.0 `client_credentials`. Il tuo workload si autentica presso Okta (tipicamente con `private_key_jwt`, così non viene memorizzato alcun segreto condiviso), riceve un JSON Web Token (JWT) firmato e scambia quel JWT con Anthropic per ottenere un token di accesso di breve durata. L'URL dell'issuer dell'authorization server di Okta ha la forma `https://.okta.com/oauth2/`. Se usi il server predefinito integrato, il percorso è `/oauth2/default`. Devi usare un **custom authorization server** (server di autorizzazione personalizzato) di Okta (incluso quello `default`). I token emessi direttamente dall'authorization server dell'organizzazione Okta (l'endpoint `/oauth2/v1/token` senza ID dell'authorization server nel percorso) non possono essere validati da parti esterne perché Okta non pubblica le chiavi di firma per essi. Esistono molti modi per configurare Okta e autenticarsi presso di esso che esulano dall'ambito di questa documentazione. Assicurati che la tua configurazione e i tuoi meccanismi di autenticazione seguano le linee guida e le pratiche di sicurezza della tua azienda. ## Prerequisiti * Familiarità con i [concetti di WIF](https://platform.claude.com/docs/it/manage-claude/workload-identity-federation#concepts): service account, federation issuer e federation rule. * Un'organizzazione Okta con API Access Management abilitato (necessario per i custom authorization server). * Permesso di creare service account, federation issuer e federation rule nella Claude Console per la tua organizzazione Anthropic. * Un workload in grado di richiedere un token dall'endpoint `/v1/token` di Okta e di raggiungere `api.anthropic.com`. ## Configurare Okta Ad alto livello devi: 1. Creare una service application Okta. 2. Configurare il tuo authorization server predefinito (o creare un nuovo custom authorization server) con un'audience, uno scope, una access policy e qualsiasi claim personalizzato su cui vuoi effettuare la corrispondenza. La navigazione esatta dipende dalla configurazione della tua organizzazione Okta e dalla versione della console di amministrazione. I seguenti passaggi numerati illustrano un percorso comune: 1. **Crea un'integrazione di app di servizio.** Nella Okta Admin Console, crea una nuova integrazione di app di tipo **API Services** (OIDC, machine-to-machine). Prendi nota del **Client ID** generato. 2. **Configura l'autenticazione del client.** Per una configurazione senza chiavi, scegli **Public key / Private key** (`private_key_jwt`) e registra la JWK pubblica del tuo workload. In alternativa, usa un client secret se il tuo ambiente può memorizzarlo in modo sicuro. Per l'esempio seguente potresti dover disabilitare il requisito DPoP sull'applicazione; assicurati che la tua configurazione di produzione rispetti i requisiti di sicurezza della tua organizzazione. 3. **Imposta l'audience.** Sul tuo custom authorization server, imposta l'audience su `https://api.anthropic.com` in modo che i token di accesso emessi contengano quel claim `aud`. Anthropic valida `aud` rispetto a questo valore fisso. 4. **Concedi uno scope.** Sul tuo custom authorization server, assicurati che esista almeno uno scope che la service app sia autorizzata a richiedere (ad esempio, `anthropic.access`). Okta rifiuta le richieste `client_credentials` che non includono uno scope concesso. 5. **Crea una access policy.** Sul tuo custom authorization server, crea una access policy con almeno una regola che consenta alla tua service app di richiedere lo scope concesso al passaggio 4. 6. **(Facoltativo) Aggiungi claim personalizzati.** Se vuoi effettuare la corrispondenza su qualcosa di diverso dal client ID, aggiungi un claim al token di accesso nella scheda **Claims** del tuo authorization server. Per una service app che usa `client_credentials`, Okta imposta il claim `sub` del token di accesso emesso sul **Client ID** dell'applicazione, e `iss` sull'URL dell'issuer dell'authorization server. ## Configurare Anthropic Nella Claude Console, vai alla pagina [Workload identity](https://platform.claude.com/settings/workload-identity-federation) (`platform.claude.com/settings/workload-identity-federation`), fai clic su **Connect workload** e seleziona **Custom OIDC**. La procedura guidata ti accompagna nella registrazione dell'issuer, nella creazione di un service account e nella creazione di una federation rule. La procedura guidata crea queste risorse per te. Usa i seguenti valori sia che tu li inserisca nella procedura guidata sia che li invii all'[Admin API](https://platform.claude.com/docs/it/manage-claude/wif-admin-api): **Federation issuer:** Usa l'URL del tuo custom authorization server Okta e la modalità discovery. Anthropic legge il documento di discovery `.well-known/openid-configuration` di Okta e recupera il JWKS dal `jwks_uri` che esso pubblica. ```json { "name": "okta-prod", "issuer_url": "https://acme.okta.com/oauth2/aus1a2b3c4d5e6f7g8h9", "jwks": { "type": "discovery" } } ``` **Federation rule:** Effettua la corrispondenza sul claim `sub` di Okta, che è il Client ID della service app. Se hai definito claim personalizzati in Okta, puoi invece effettuare la corrispondenza su quelli con la mappa `claims` o una `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 } ``` ## Acquisire un token e chiamare la Claude API A differenza dei provider nativi della piattaforma (AWS, Google Cloud, Kubernetes), che rendono disponibile un token all'interno del runtime del workload (tramite un file proiettato o un endpoint di metadati locale), Okta non lo fa. Il tuo workload deve chiamare l'endpoint token di Okta per ottenere un JWT, quindi passare quel JWT all'SDK Anthropic come identity token. ```bash cURL # 1. Richiedi un token di accesso a Okta (client_credentials con 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. Scambia il JWT di Okta con un token di accesso 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", # Crea il JWT client_assertion RFC 7523 firmato con la chiave privata della tua 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", // Crea il JWT client_assertion RFC 7523 firmato con la chiave privata della tua 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"}, // Crea il JWT client_assertion RFC 7523 firmato con la chiave privata della tua 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", // Crea il JWT client_assertion RFC 7523 firmato con la chiave privata della tua 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(); // L'SDK Java accetta il token stesso o un percorso di file, non una funzione; con // source("value"), path(...) contiene il token. L'SDK invia lo stesso token // a ogni aggiornamento del token di accesso Anthropic, il che fallisce una volta // scaduto o, se ha un claim jti, già usato. Per un processo di lunga durata, // passa source("file") e scrivi un nuovo token nel file prima di // ogni aggiornamento. 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", // Crea il JWT client_assertion RFC 7523 firmato con la chiave privata della tua 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. Richiedi un token di accesso a Okta e scrivilo in un file temporaneo. 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. Chiama la Claude API. La CLI legge ANTHROPIC_FEDERATION_RULE_ID, # ANTHROPIC_ORGANIZATION_ID, ANTHROPIC_SERVICE_ACCOUNT_ID, ANTHROPIC_WORKSPACE_ID e # ANTHROPIC_IDENTITY_TOKEN_FILE ed esegue lo scambio. 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', // Crea il JWT client_assertion RFC 7523 firmato con la chiave privata della tua 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", # Crea il JWT client_assertion RFC 7523 firmato con la chiave privata della tua 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 ``` Tranne che in Java (vedi il commento in quell'esempio), l'esempio dell'SDK passa il recupero del token Okta a `identity_token_provider` (typescript: `identityTokenProvider`; php: `identityProvider`; csharp: `IdentityTokenProvider`; go: `option.WithFederationTokenProvider`; java: `IdentityTokenConfig`) come token provider. L'SDK di Claude lo chiama ogni volta che il token di accesso Anthropic si avvicina alla scadenza, quindi la tua funzione di recupero Okta dovrebbe restituire un token nuovo a ogni chiamata anziché memorizzarne uno nella cache a tempo indeterminato. La CLI `ant` rilegge `ANTHROPIC_IDENTITY_TOKEN_FILE` a ogni scambio, quindi aggiorna quel file periodicamente per le shell di lunga durata. ## Verificare la configurazione Uno scambio riuscito restituisce un `access_token` che inizia con `sk-ant-oat01-` e un valore `expires_in` in secondi. Se lo scambio fallisce con la risposta opaca `401` `authentication_error` (messaggio `Authentication failed`), controlla la [pagina della cronologia di autenticazione](https://platform.claude.com/settings/workload-identity-federation?tab=history) nella Claude Console per il motivo del rifiuto e consulta [Risolvere i problemi di uno scambio fallito](https://platform.claude.com/docs/it/manage-claude/wif-reference#troubleshoot-a-failed-exchange); la causa più comune lato Okta è una mancata corrispondenza di `issuer_url` (deve includere il percorso `/oauth2/`; l'authorization server dell'organizzazione Okta non è utilizzabile). ## Delimitare l'ambito della regola Più service app sotto lo stesso authorization server Okta condividono lo stesso issuer. Una regola che omette `subject_prefix` corrisponde a ogni service app su quel server, quindi qualsiasi team in grado di registrarne una potrebbe ottenere un token Anthropic federato. Vincola il blocco `match` della regola all'ambito più ristretto adatto al tuo caso d'uso: * **Fissa il Client ID esatto:** Imposta `subject_prefix` sul Client ID completo della service app senza `*` finale. * **Fissa l'audience:** Fai corrispondere il valore `audience` che hai configurato sull'authorization server in modo che i token emessi per un'audience diversa vengano rifiutati. * **Effettua la corrispondenza su claim personalizzati:** Per una delimitazione più granulare, aggiungi claim nella scheda **Claims** dell'authorization server e falli corrispondere con la mappa `claims` della regola o una `condition` CEL. * **Usa una regola per service app:** Crea una federation rule separata per ogni service app anziché condividere una regola tra più app. ## Passaggi successivi * Consulta il [riferimento WIF](https://platform.claude.com/docs/it/manage-claude/wif-reference) per l'ordine completo di risoluzione delle credenziali e la configurazione dei profili. * Consulta il [riferimento WIF](https://platform.claude.com/docs/it/manage-claude/wif-reference#rule-matching-semantics) per effettuare la corrispondenza su claim Okta personalizzati con espressioni CEL.