Salta ai contenuti

Identity Provider per siti web

Website authentication crea un user pool di Amazon Cognito e, per impostazione predefinita, solo gli utenti che hanno un nome utente e una password in quel pool possono accedere. Se il tuo personale o i tuoi clienti hanno già account presso un identity provider (IdP), come Okta, Auth0 o Microsoft Entra ID, altrimenti avrebbero bisogno di un secondo account solo per il tuo sito web.

Eseguire ts#website#auth con --federation=oidc ti consente di aggiungere identity provider OpenID Connect (OIDC) esterni al user pool. Elenchi gli identity provider nel tuo codice di infrastruttura: la prop oidcIdentityProviders di UserIdentity in CDK, o la variabile oidc_identity_providers del modulo user_identity in Terraform. La pagina di accesso mostra quindi un pulsante per ogni identity provider accanto al modulo di nome utente e password.

  • Il tuo sito web invia ancora gli utenti alla pagina di accesso di Cognito. La pagina ora ha un pulsante con il nome di ogni identity provider.
  • Un utente che sceglie un pulsante accede presso quell’identity provider. L’identity provider li rimanda a Cognito al suo URI di reindirizzamento, https://<cognito domain>/oauth2/idpresponse.
  • Cognito crea un utente nel tuo user pool per loro, un utente federato, e copia i claim che mappi (ad esempio email) negli attributi dell’utente.
  • Cognito quindi emette lo stesso tipo di token che emette per un utente locale. Le tue API, gli agenti e l’identity pool li accettano senza alcuna modifica.

Gli utenti con un nome utente e una password nel pool possono ancora accedere.

L’aggiunta di un identity provider può consentire l’accesso al tuo sito web a molte più persone di quanto ti aspetti. L’opzione allowSignup di ts#website#auth non si applica agli utenti federati. Cognito crea un utente federato la prima volta che qualcuno accede tramite l’identity provider, anche quando il user pool non consente agli utenti di registrarsi da soli. Ogni utente federato ottiene anche il ruolo autenticato dell’identity pool, quindi può chiamare le tue API e gli agenti come qualsiasi utente autenticato.

Gli identity provider si applicano all’intero user pool. Ogni sito web che utilizza il pool mostra i loro pulsanti e accetta i loro utenti.

L’identity provider decide quindi chi può accedere. Configuralo in modo che consenta l’accesso solo alle persone che hanno bisogno del tuo sito web:

  • Microsoft Entra ID: nelle proprietà dell’applicazione enterprise dell’applicazione, imposta “Assignment required?” su Yes e assegna solo gli utenti o i gruppi che necessitano di accesso. Con l’impostazione predefinita, No, ogni utente nel tuo tenant può accedere.
  • Okta: assegna l’applicazione solo ai gruppi che necessitano di accesso.
  • Auth0: disabilita le registrazioni su ogni connessione utilizzata dall’applicazione e abilita per l’applicazione solo le connessioni i cui utenti necessitano di accesso. Altrimenti chiunque si registri tramite una connessione abilitata, ad esempio una connessione social, può accedere.

Esegui il generatore ts#website#auth con --federation=oidc. Puoi eseguirlo su un sito web che non ha ancora l’autenticazione, o su un sito web che ce l’ha già. Entrambi danno lo stesso risultato.

Esegui questo generatore@aws/nx-plugin:ts#website#auth

pnpm nx g @aws/nx-plugin:ts#website#auth --federation=oidc
Componi il tuo comando6

Obbligatorio

Il generatore non aggiunge alcun identity provider. L’elenco inizia vuoto, quindi l’accesso funziona come prima finché non aggiungi una voce. Aggiungi gli identity provider al tuo codice di infrastruttura, quindi aggiungerne un secondo non richiede un’altra esecuzione del generatore.

Eseguire nuovamente il generatore con --federation=oidc non modifica alcun file. Eseguirlo con --federation=none, o senza --federation, mantiene la federazione che è già presente.

Aggiungi una voce per ogni identity provider, quindi esegui il deploy. Il client secret non va mai nel tuo codice. Lo memorizzi in AWS Secrets Manager e fornisci il suo nome, come descritto in Configurare il tuo identity provider.

Passa gli identity provider a UserIdentity nel tuo stack:

packages/infra/src/stacks/application-stack.ts
import { MyWebsite, UserIdentity } from '@my-scope/common-constructs';
const identity = new UserIdentity(this, 'Identity', {
oidcIdentityProviders: [
{
name: 'Okta',
issuerUrl: 'https://example.okta.com',
clientId: '0oa1example',
clientSecretName: 'okta-oidc-client-secret',
},
{
name: 'Entra',
issuerUrl: 'https://login.microsoftonline.com/<tenant-id>/v2.0',
clientId: '11111111-2222-3333-4444-555555555555',
clientSecretName: 'entra-oidc-client-secret',
identifiers: ['example.com'],
},
],
});
new MyWebsite(this, 'MyWebsite');

OidcIdentityProviderProps, il tipo di ogni voce, viene esportato dal tuo pacchetto di construct condivisi, quindi puoi costruire l’elenco altrove e importare il tipo.

Ogni identity provider nell’elenco ha queste proprietà. Le opzioni del generatore sono descritte in website authentication.

Prop CDKAttributo TerraformRichiestoPredefinitoDescrizione
namenameSìMostrato sul pulsante di accesso. Cognito prefissa i nomi utente federati con esso in minuscolo (<name>_<sub>). 3-32 lettere, cifre e trattini, iniziando con una lettera. Non COGNITO. Univoco nell’elenco, ignorando maiuscole/minuscole. In CDK deve essere una stringa letterale, non un token.
issuerUrlissuer_urlSìL’issuer esattamente come appare nel claim iss dei token dell’identity provider. Deve usare https://.
clientIdclient_idSìClient ID dell’applicazione registrata presso l’identity provider.
clientSecretNameclient_secret_nameSìNome del secret di Secrets Manager che contiene il client secret come stringa semplice. Un nome, non un ARN.
scopesscopesNoopenid, email, profileScope OAuth da richiedere. Deve includere openid.
attributeMappingattribute_mappingNoemail, given_name e family_name, ciascuno al claim con lo stesso nomeAttributo del user pool al claim dell’identity provider. Vedi Mappatura degli attributi.
identifiersidentifiersNoNessunoIdentificatori, come domini email, che Cognito può usare per inviare un utente a questo identity provider.

Il codice fornito controlla ogni voce prima che qualsiasi cosa venga distribuita:

UserIdentity genera un’eccezione quando lo crei con una voce che viola una regola, quindi cdk synth fallisce. La build del progetto infra esegue cdk synth. Il messaggio nomina la voce, ad esempio UserIdentity: oidcIdentityProviders[1] (Entra): Microsoft Entra ID issuers have no trailing slash. Use https://login.microsoftonline.com/<tenant-id>/v2.0.

Un valore che è un token, ad esempio uno letto da AWS Systems Manager Parameter Store, non viene controllato. Un valore errato fallisce quindi il deploy invece del synth. name non deve essere un token.

Le regole:

  • name: 3-32 lettere, cifre e trattini, iniziando con una lettera. Non COGNITO in qualsiasi caso, perché Cognito lo riserva per l’accesso con il user pool stesso.
  • I nomi sono univoci nell’elenco, ignorando maiuscole/minuscole, perché Cognito prefissa i nomi utente federati con il nome in minuscolo. Ad esempio, Okta e OKTA non possono essere entrambi nell’elenco. test-idp e testidp possono, perché i loro prefissi differiscono.
  • L’issuer usa https:// e non ha query, fragment, nome utente, password o spazi bianchi. In CDK deve anche essere analizzabile come URL. In Terraform un’espressione regolare lo controlla, che accetta alcuni URL malformati che CDK rifiuta.
  • Microsoft Entra ID: gli issuer multi-tenant (common, organizations, consumers e 9188040d-6c67-4c5b-b112-36a304b66dad) sono rifiutati, e l’issuer non deve terminare con una barra.
  • Auth0: un issuer su *.auth0.com deve terminare con una barra.
  • Il client ID non è vuoto.
  • Il nome del secret è 1-512 lettere, cifre e / _ + = . @ -. Queste sono le regole di denominazione di Secrets Manager, quindi un ARN è rifiutato.
  • Gli scope includono openid. In CDK ogni scope deve anche essere non vuoto e non avere spazi bianchi.
  • Le chiavi e i valori della mappatura degli attributi seguono le regole in Mappatura degli attributi.
  • Al massimo 50 identificatori. Ciascuno è 1-40 lettere, cifre, spazi o _ + = . @ -.

Con --federation=oidc il generatore aggiunge questi file e modifiche per il tuo provider iac selezionato:

  • Directorypackages/common/constructs/src/core
    • oidc-identity-providers.ts Il construct OidcIdentityProviders, le sue props e la validazione
    • index.ts Ora esporta oidc-identity-providers.ts
    • user-identity.ts Ora ha la prop oidcIdentityProviders e crea gli identity provider

Le modifiche consentono al web client del user pool, il client app di Cognito attraverso cui il tuo sito web accede, di accettare gli identity provider:

packages/common/constructs/src/core/user-identity.ts
import {
OidcIdentityProviders,
type OidcIdentityProviderProps,
} from './oidc-identity-providers.js';
readonly mfaSecondFactor?: MfaSecondFactor;
/**
* OpenID Connect identity providers users can sign in through, next to the user pool's own sign-in.
* Applies to every website that uses this user pool.
* ...
*/
readonly oidcIdentityProviders?: OidcIdentityProviderProps[];
}
mfaSecondFactor = { sms: true, otp: true },
oidcIdentityProviders = [],
}: UserIdentityProps = {},
this.userPoolDomain = this.createUserPoolDomain(this.userPool);
new OidcIdentityProviders(this, 'OidcIdentityProviders', {
userPool: this.userPool,
userPoolDomain: this.userPoolDomain,
providers: oidcIdentityProviders,
});
this.userPoolClient = this.createUserPoolClient(this.userPool);

UserIdentity crea gli identity provider prima del web client, quindi il web client li elenca, seguiti da COGNITO.

Il generatore non sovrascrive le tue modifiche ai nuovi file. Se hai modificato user-identity.ts, o main.tf o identity.tf, in modo che il generatore non lo riconosca più, il generatore lascia quei file invariati. Aggiunge comunque i nuovi file e stampa le righe da aggiungere manualmente.

Il deploy che aggiunge un identity provider legge il suo client secret da Secrets Manager. Se il secret non esiste, il deploy fallisce.

CloudFormation legge il secret con il ruolo di esecuzione dello stack, per impostazione predefinita cdk-hnb659fds-cfn-exec-role-<account>-<region>. Quel ruolo necessita di secretsmanager:GetSecretValue sul secret, più kms:Decrypt sulla chiave se il secret è crittografato con una chiave AWS KMS gestita dal cliente.

Segui questi passaggi in questo ordine. Il generatore li stampa anche quando termina.

  1. Esegui ts#website#auth con --federation=oidc ed esegui il deploy una volta.
  2. Trova l’URI di reindirizzamento del tuo user pool. Tutti gli identity provider del pool usano lo stesso.

Lo stack che contiene UserIdentity ha un output la cui chiave inizia con <id>OidcIdentityProvidersIdpRedirectUri, dove <id> è l’ID del construct che hai dato a UserIdentity, ad esempio IdentityOidcIdentityProvidersIdpRedirectUri. Puoi anche calcolarlo prima di eseguire il deploy, dal cognitoDomain che hai scelto per ts#website#auth, il tuo ID account AWS e la tua regione:

https://<cognitoDomain>-<account>.auth.<region>.amazoncognito.com/oauth2/idpresponse
  1. Registra un’applicazione presso l’identity provider con quell’URI di reindirizzamento e annota il suo client ID e client secret. Registra solo questo URI /oauth2/idpresponse presso l’identity provider. Gli URL del tuo sito web sono registrati con Cognito, non con l’identity provider.

  2. Memorizza il client secret in Secrets Manager. Passalo in un file, non come argomento della riga di comando. Un argomento rimane nella cronologia della shell e altri utenti dello stesso computer possono vederlo nell’elenco dei processi mentre il comando è in esecuzione:

    Finestra del terminale
    (
    umask 077
    d=$(mktemp -d) || exit
    trap 'rm -rf "$d"' EXIT
    trap 'exit 1' HUP INT TERM
    unset CLIENT_SECRET
    IFS= read -rs CLIENT_SECRET || exit 1
    printf '%s' "$CLIENT_SECRET" > "$d/secret" || exit 1
    unset CLIENT_SECRET
    aws secretsmanager create-secret --name okta-oidc-client-secret --secret-string "file://$d/secret" --region <region>
    )

    I comandi vengono eseguiti in una subshell, tra le parentesi. read attende che tu incolli il client secret e prema Invio, e non lo mostra. I due comandi unset mantengono il secret fuori dall’ambiente del comando aws, anche se hai esportato CLIENT_SECRET in precedenza. IFS= e -r mantengono il secret esattamente come lo incolli, inclusi gli spazi alle estremità e i backslash. mktemp -d crea una nuova directory che solo tu puoi aprire (modalità 700), e printf scrive il secret in essa senza un newline alla fine. L’AWS CLI legge il valore di --secret-string dal file denominato dopo file:// e lo passa invariato, quindi un newline alla fine del file diventerebbe parte del secret. Quando la subshell termina, i comandi trap eliminano la directory. Lo fanno anche se il comando aws fallisce o premi Ctrl-C. I comandi funzionano in bash e zsh, le shell predefinite su Linux e macOS. Per Windows, vedi Mitigate the risks of using the AWS CLI to store your AWS Secrets Manager secrets.

    Imposta --region sulla regione del tuo stack. Il secret deve esistere in quella regione prima del deploy che aggiunge l’identity provider. Memorizza il secret come stringa semplice, non JSON, perché Cognito riceve l’intero valore del secret come client secret. Nella console di Secrets Manager, scegli Plaintext, non Key/value.

  3. Aggiungi l’identity provider all’elenco, con il nome del secret come clientSecretName (client_secret_name in Terraform), come mostra Aggiungere identity provider. Quindi esegui il deploy.

Il user pool generato richiede gli attributi email, given_name e family_name. Cognito li riempie dai claim dell’identity provider ad ogni accesso. Se l’identity provider non ne invia uno, il primo accesso dell’utente fallisce. UserIdentity e la variabile Terraform quindi rifiutano una mappatura degli attributi che omette uno qualsiasi dei tre.

attributeMapping (attribute_mapping in Terraform) mappa gli attributi del user pool ai claim. Ogni chiave è un attributo del user pool e ogni valore è il nome del claim dell’identity provider, lungo 1-128 caratteri. Una mappatura che fornisci sostituisce quella predefinita. La mappatura predefinita mappa ogni attributo richiesto al claim con lo stesso nome:

attributeMapping: { email: 'email', given_name: 'given_name', family_name: 'family_name' },
  • Una chiave può essere qualsiasi attributo standard, come name o phone_number, phone_number_verified, o un attributo personalizzato come custom:department (fino a 20 lettere, cifre o underscore dopo custom:). Le chiavi usano i nomi degli attributi Cognito sia in CDK che in Terraform. username è rifiutato.
  • Cognito tratta un indirizzo email mappato come non verificato. Mappa email_verified solo da un identity provider che verifica gli indirizzi email da solo. Altrimenti un utente potrebbe impostare l’indirizzo di qualcun altro presso l’identity provider e farlo contrassegnare come verificato nel tuo pool.
  • Se l’indirizzo email di un utente cambia presso l’identity provider, Cognito scrive il nuovo indirizzo nel user pool al successivo accesso dell’utente. email_verified rimane false.
  • Un attributo personalizzato deve già esistere nel user pool e deve essere mutabile.

La risorsa identity provider Terraform, in identity/oidc-identity-providers.tf, imposta anche due valori che Cognito aggiunge quando restituisce l’identity provider: username = "sub" in attribute_mapping e attributes_url_add_attributes = "false" in provider_details. Poiché il file li imposta, un secondo terraform plan dopo il primo deploy non mostra alcuna modifica all’identity provider. Se un secondo plan mostra ancora una modifica in provider_details con un altro identity provider, aggiungi quella chiave al file con il valore che il plan mostra che Cognito restituisce.

Le impostazioni seguenti provengono dalla documentazione di ciascun fornitore. Okta è stato testato su AWS sia con CDK che con Terraform. Le impostazioni di Auth0 e Microsoft Entra ID sono state verificate rispetto al documento di discovery OpenID pubblicato da ciascun fornitore, ma non con un accesso reale.

Testato su AWS con CDK e Terraform. Crea un’applicazione Web OIDC in Okta, con il grant Authorization Code e un client secret. Imposta il suo URI di reindirizzamento di accesso sull’URI di reindirizzamento /oauth2/idpresponse dal passaggio 2 di Configurare il tuo identity provider. Non necessita di un URI di reindirizzamento di disconnessione. L’issuer è il tuo dominio Okta, https://<your-org>.okta.com, che è la forma che è stata testata. Un server di autorizzazione personalizzato, come https://<your-org>.okta.com/oauth2/default, ha anche un issuer, ma quella forma non è stata testata. Gli scope predefiniti, openid email profile, restituiscono email, given_name e family_name, quindi la mappatura predefinita funziona. Ogni utente necessita di un’email, un nome e un cognome impostati in Okta. Assegna l’applicazione solo agli utenti o ai gruppi che necessitano di accesso.

Verificato rispetto al documento di discovery di Auth0, non testato con un accesso reale. Crea una Regular Web Application in Auth0. L’issuer è https://<your-tenant>.auth0.com/, inclusa la barra finale.

Auth0 restituisce given_name e family_name solo quando la connessione dell’utente li fornisce. Gli utenti di una connessione senza di essi non possono accedere finché non mappi altri claim.

Verificato rispetto al documento di discovery di Microsoft, non testato con un accesso reale. Registra un’applicazione single-tenant in Entra ID. L’issuer è https://login.microsoftonline.com/<tenant-id>/v2.0. Il codice fornito rifiuta gli issuer multi-tenant (common, organizations e consumers), perché accettano utenti da qualsiasi tenant Entra ID. Rifiuta anche il tenant 9188040d-6c67-4c5b-b112-36a304b66dad, che accetta qualsiasi account Microsoft personale.

L’issuer non deve terminare con una barra: usa /v2.0, non /v2.0/. Il claim iss nei token Entra ID non ha la barra, quindi l’accesso fallirebbe. Il codice fornito rifiuta la forma con la barra.

Aggiungi email, given_name e family_name come claim opzionali al token ID dell’applicazione. Entra ID li invia solo se lo fai. Ogni utente necessita del campo Mail impostato. Altrimenti il claim email è vuoto e il primo accesso dell’utente fallisce, perché il user pool richiede email. Il claim email di Entra ID non è verificato, quindi non mappare email_verified da Entra ID.

Per testare con un altro user pool di Cognito come identity provider, usa l’issuer https://cognito-idp.<region>.amazonaws.com/<user pool id>. Dai al suo client app un client secret, il grant authorization code e gli scope openid email profile.

  • Identifica gli utenti tramite il claim sub (l’ID univoco dell’utente nel tuo user pool), mai tramite email. Un utente federato è un nuovo utente nel tuo pool con il proprio sub, anche quando la loro email corrisponde a un utente locale. Il codice generato dal plugin usa sub.
  • Usa un issuer single-tenant. Un issuer multi-tenant consente agli utenti di qualsiasi organizzazione di accedere.
  • Rimuovi gli URL di callback http://localhost dagli stage di produzione, come descritto in website authentication. La federazione non aggiunge alcun URL di callback.
  • L’MFA (autenticazione a più fattori) richiesta nel tuo user pool non si applica agli utenti federati. Cognito lascia la loro autenticazione all’identity provider, quindi applica l’MFA presso l’identity provider.

  • Disconnettersi dal tuo sito web termina solo la sessione Cognito. Non termina la sessione dell’utente presso un identity provider OIDC, quindi il successivo accesso tramite il pulsante può completarsi senza una password. Su un computer condiviso, gli utenti devono anche disconnettersi presso l’identity provider.

  • Il menu utente mostra il nome utente Cognito. Per un utente federato è il nome dell’identity provider, un underscore e il sub dell’utente presso l’identity provider, in minuscolo, ad esempio okta_00u1abcd.

  • Rimuovere o disabilitare un utente presso l’identity provider interrompe solo il suo prossimo accesso tramite esso. Cognito rinnova i token con il proprio refresh token e non chiede all’identity provider, e il sito web rinnova i token senza che l’utente se ne accorga. L’utente può quindi mantenere l’accesso fino alla scadenza del refresh token, fino a 30 giorni dopo il suo ultimo accesso. Per impedire all’utente di ottenere nuovi token, disconnettilo anche da ogni sessione e disabilitalo nel user pool. Il suo nome utente è <identity provider name in lowercase>_<sub>:

    Finestra del terminale
    aws cognito-idp admin-user-global-sign-out --user-pool-id <user pool id> --username okta_<sub>
    aws cognito-idp admin-disable-user --user-pool-id <user pool id> --username okta_<sub>

    Questo è stato testato su AWS. Dopo admin-user-global-sign-out e admin-disable-user, l’identity provider accede ancora l’utente, ma Cognito li rifiuta.

    Questi comandi non terminano l’accesso che l’utente ha già. admin-user-global-sign-out revoca i refresh token dell’utente, quindi il sito web non può ottenere nuovi token per loro, e admin-disable-user interrompe il loro prossimo accesso. I token ID e di accesso che Cognito ha già emesso rimangono validi fino alla scadenza, per impostazione predefinita un’ora dopo l’emissione (ID and access token validity). Le credenziali AWS che l’identity pool ha già fornito al sito web rimangono valide fino alla scadenza, un’ora dopo l’emissione (identity pools authentication flow). Fino alla scadenza, l’utente può ancora utilizzare il sito web e il ruolo autenticato dell’identity pool.

    Una validità del refresh token più breve sul web client (refreshTokenValidity in CDK, refresh_token_validity in Terraform) riduce il tempo in cui un utente rimosso mantiene l’accesso se non esegui questi comandi. Una validità del token ID e di accesso più breve (idTokenValidity e accessTokenValidity in CDK, id_token_validity e access_token_validity in Terraform) riduce il tempo in cui i token già emessi rimangono validi dopo aver eseguito i comandi, ma rimane sempre un po’ di tempo. Nessuno dei due è stato testato su AWS.

Cognito conserva il client secret nelle impostazioni dell’identity provider. Chiunque sia autorizzato a chiamare cognito-idp:DescribeIdentityProvider sul tuo user pool può leggerlo. Questo è il modo in cui funziona Cognito, qualunque sia il provider IaC che usi.

Il construct passa il secret a CloudFormation come riferimento dinamico, {{resolve:secretsmanager:<clientSecretName>:SecretString:::}}. Il template sintetizzato contiene solo quel riferimento. CloudFormation legge il secret quando crea o aggiorna l’identity provider. Se ruoti il secret, Cognito ottiene il nuovo valore solo quando la risorsa dell’identity provider cambia in un deploy successivo.

CloudFormation risolve il riferimento all’interno delle impostazioni dell’identity provider (ProviderDetails), quindi l’accesso federato funziona con il secret memorizzato e il template distribuito contiene ancora solo il riferimento. Dopo una rotazione, un deploy senza altre modifiche lascia il vecchio secret in Cognito. Entrambi sono stati verificati su AWS.

Per inviare un secret ruotato a Cognito:

Modifica la risorsa dell’identity provider nel deploy che segue la rotazione. Un modo è memorizzare il secret ruotato con un nuovo nome e impostare clientSecretName su quel nome. Il riferimento nel template cambia quindi, quindi CloudFormation aggiorna l’identity provider e legge il nuovo secret. Elimina il vecchio secret successivamente. Questo segue la documentazione di CloudFormation per i riferimenti dinamici e non è stato testato su AWS.

Un client app è la configurazione Cognito attraverso cui un’applicazione accede. Il generatore aggiunge gli identity provider solo al client app del sito web, il web client. Un altro client app nello stesso user pool accetta utenti federati solo se elenca anche gli identity provider. Ad esempio, il client app che crei per un DCR proxy (che consente ai client MCP, gli strumenti AI che usano il Model Context Protocol, di accedere tramite Cognito) ne ha bisogno. Altrimenti gli utenti federati non possono accedere al tuo server MCP.

Un client app che crei con identity.userPool.addClient(...) dopo UserIdentity, senza supportedIdentityProviders, elenca ogni identity provider del pool e COGNITO. L’esempio del DCR proxy fa questo. Se il tuo client app imposta supportedIdentityProviders, aggiungi gli identity provider del pool ad esso:

import { UserPoolClientIdentityProvider } from 'aws-cdk-lib/aws-cognito';
supportedIdentityProviders: [
UserPoolClientIdentityProvider.COGNITO,
...identity.userPool.identityProviders.map((p) =>
UserPoolClientIdentityProvider.custom(p.providerName),
),
],

Il target <agent>-chat di un TypeScript agent con autenticazione Cognito legge un token di accesso Cognito dalla variabile d’ambiente AGENT_ACCESS_TOKEN. Un utente federato non ha una password Cognito, quindi admin-initiate-auth non funziona per loro. Invece, accedi al tuo sito web, apri gli strumenti per sviluppatori del browser e copia access_token dalla voce oidc.user:... nella session storage.