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.
Come funziona
Sezione intitolata “Come funziona”- 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.
Chi può accedere
Sezione intitolata “Chi può 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.
Utilizzo
Sezione intitolata “Utilizzo”Aggiungere la federazione OpenID Connect
Sezione intitolata “Aggiungere la federazione OpenID Connect”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 yarn nx g @aws/nx-plugin:ts#website#auth --federation=oidc npx nx g @aws/nx-plugin:ts#website#auth --federation=oidc bunx nx g @aws/nx-plugin:ts#website#auth --federation=oidc- Installa il Nx Console VSCode Plugin se non l'hai già fatto
- Apri la console Nx in VSCode
- Clicca su
Generate (UI)nella sezione "Common Nx Commands" - Cerca
@aws/nx-plugin - ts#website#auth - Compila i parametri richiesti
- federation: oidc
- Clicca su
Generate
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.
Aggiungere identity provider
Sezione intitolata “Aggiungere identity provider”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:
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.
Passa gli identity provider al modulo user_identity nel tuo modulo root e aggiungi un output per l’URI di reindirizzamento:
module "user_identity" { source = "../../common/terraform/src/core/user-identity"
oidc_identity_providers = [ { name = "Okta" issuer_url = "https://example.okta.com" client_id = "0oa1example" client_secret_name = "okta-oidc-client-secret" }, ]}
output "idp_redirect_uri" { value = module.user_identity.idp_redirect_uri}Per utilizzare identity provider diversi in ogni ambiente, dichiara una variabile root e impostala nel file .tfvars di ogni ambiente. La variabile root ha type = any, perché la variabile del modulo controlla il tipo:
variable "oidc_identity_providers" { type = any default = []}
# packages/infra/src/env/dev.tfvarsoidc_identity_providers = [ { name = "Okta", issuer_url = "https://example.okta.com", client_id = "0oa1example", client_secret_name = "okta-oidc-client-secret" },]
# packages/infra/src/main.tf, in module "user_identity"oidc_identity_providers = var.oidc_identity_providersOpzioni
Sezione intitolata “Opzioni”Ogni identity provider nell’elenco ha queste proprietà. Le opzioni del generatore sono descritte in website authentication.
| Prop CDK | Attributo Terraform | Richiesto | Predefinito | Descrizione |
|---|---|---|---|---|
name | name | Sì | 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. | |
issuerUrl | issuer_url | Sì | L’issuer esattamente come appare nel claim iss dei token dell’identity provider. Deve usare https://. | |
clientId | client_id | Sì | Client ID dell’applicazione registrata presso l’identity provider. | |
clientSecretName | client_secret_name | Sì | Nome del secret di Secrets Manager che contiene il client secret come stringa semplice. Un nome, non un ARN. | |
scopes | scopes | No | openid, email, profile | Scope OAuth da richiedere. Deve includere openid. |
attributeMapping | attribute_mapping | No | email, given_name e family_name, ciascuno al claim con lo stesso nome | Attributo del user pool al claim dell’identity provider. Vedi Mappatura degli attributi. |
identifiers | identifiers | No | Nessuno | Identificatori, come domini email, che Cognito può usare per inviare un utente a questo identity provider. |
Validazione
Sezione intitolata “Validazione”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.
La variabile oidc_identity_providers del modulo ha un blocco validation per ogni regola. I suoi messaggi di errore non nominano la voce che viola la regola.
Quando scrivi l’elenco come letterale nel blocco del modulo user_identity, terraform validate lo controlla. Il target validate del progetto esegue terraform validate. Quando l’elenco proviene da una variabile root, come nel pattern .tfvars sopra, terraform plan lo controlla invece.
Le regole:
name: 3-32 lettere, cifre e trattini, iniziando con una lettera. NonCOGNITOin 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,
OktaeOKTAnon possono essere entrambi nell’elenco.test-idpetestidppossono, 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,consumerse9188040d-6c67-4c5b-b112-36a304b66dad) sono rifiutati, e l’issuer non deve terminare con una barra. - Auth0: un issuer su
*.auth0.comdeve 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
_ + = . @ -.
Output del generatore
Sezione intitolata “Output del generatore”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
oidcIdentityProviderse crea gli identity provider
- oidc-identity-providers.ts Il construct
Directorypackages/common/terraform/src/core/user-identity
- oidc-identity-providers.tf La variabile
oidc_identity_providerscon la sua validazione, e l’outputidp_redirect_uri - main.tf Ora passa la variabile al modulo identity
Directoryidentity
- oidc-identity-providers.tf Gli identity provider, la data source che legge ogni client secret, e l’output
idp_redirect_uri - identity.tf Ora elenca gli identity provider sul web client
- oidc-identity-providers.tf Gli identity provider, la data source che legge ogni client secret, e l’output
- oidc-identity-providers.tf La variabile
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:
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.
mfa_second_factor_sms = var.mfa_second_factor_smsoidc_identity_providers = var.oidc_identity_providerssupported_identity_providers = ["COGNITO"]supported_identity_providers = concat(["COGNITO"], [for p in aws_cognito_identity_provider.oidc : p.provider_name])Ogni identity provider è un’istanza for_each indicizzata dal suo nome, ad esempio aws_cognito_identity_provider.oidc["Okta"]. Rinominare una voce sostituisce quindi quell’identity provider.
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.
Configurare il tuo identity provider
Sezione intitolata “Configurare il tuo identity provider”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.
L’identità che esegue terraform apply legge il secret. 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.
- Esegui
ts#website#authcon--federation=oidced esegui il deploy una volta. - 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/idpresponseIl dominio Cognito ha un suffisso casuale, quindi l’URI di reindirizzamento è noto solo dopo il deploy. Il modulo user_identity lo restituisce come idp_redirect_uri. Per vederlo, aggiungi un output al tuo modulo root, ad esempio packages/infra/src/main.tf:
output "idp_redirect_uri" { value = module.user_identity.idp_redirect_uri }-
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/idpresponsepresso l’identity provider. Gli URL del tuo sito web sono registrati con Cognito, non con l’identity provider. -
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 077d=$(mktemp -d) || exittrap 'rm -rf "$d"' EXITtrap 'exit 1' HUP INT TERMunset CLIENT_SECRETIFS= read -rs CLIENT_SECRET || exit 1printf '%s' "$CLIENT_SECRET" > "$d/secret" || exit 1unset CLIENT_SECRETaws 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.
readattende che tu incolli il client secret e prema Invio, e non lo mostra. I due comandiunsetmantengono il secret fuori dall’ambiente del comandoaws, anche se hai esportatoCLIENT_SECRETin precedenza.IFS=e-rmantengono il secret esattamente come lo incolli, inclusi gli spazi alle estremità e i backslash.mktemp -dcrea una nuova directory che solo tu puoi aprire (modalità 700), eprintfscrive il secret in essa senza un newline alla fine. L’AWS CLI legge il valore di--secret-stringdal file denominato dopofile://e lo passa invariato, quindi un newline alla fine del file diventerebbe parte del secret. Quando la subshell termina, i comanditrapeliminano la directory. Lo fanno anche se il comandoawsfallisce 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
--regionsulla 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. -
Aggiungi l’identity provider all’elenco, con il nome del secret come
clientSecretName(client_secret_namein Terraform), come mostra Aggiungere identity provider. Quindi esegui il deploy.
Mappatura degli attributi
Sezione intitolata “Mappatura degli attributi”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' },attribute_mapping = { email = "email", given_name = "given_name", family_name = "family_name" }- Una chiave può essere qualsiasi attributo standard, come
nameophone_number,phone_number_verified, o un attributo personalizzato comecustom:department(fino a 20 lettere, cifre o underscore dopocustom:). 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_verifiedsolo 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_verifiedrimanefalse. - 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.
Note sugli identity provider
Sezione intitolata “Note sugli identity provider”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.
Microsoft Entra ID
Sezione intitolata “Microsoft Entra ID”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.
Cognito user pool
Sezione intitolata “Cognito user pool”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.
Sicurezza
Sezione intitolata “Sicurezza”- Identifica gli utenti tramite il claim
sub(l’ID univoco dell’utente nel tuo user pool), mai tramiteemail. Un utente federato è un nuovo utente nel tuo pool con il propriosub, anche quando la loro email corrisponde a un utente locale. Il codice generato dal plugin usasub. - Usa un issuer single-tenant. Un issuer multi-tenant consente agli utenti di qualsiasi organizzazione di accedere.
- Rimuovi gli URL di callback
http://localhostdagli stage di produzione, come descritto in website authentication. La federazione non aggiunge alcun URL di callback.
Cosa non fa la federazione
Sezione intitolata “Cosa non fa la federazione”-
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
subdell’utente presso l’identity provider, in minuscolo, ad esempiookta_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-outeadmin-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-outrevoca i refresh token dell’utente, quindi il sito web non può ottenere nuovi token per loro, eadmin-disable-userinterrompe 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 (
refreshTokenValidityin CDK,refresh_token_validityin 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 (idTokenValidityeaccessTokenValidityin CDK,id_token_validityeaccess_token_validityin 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.
Il client secret
Sezione intitolata “Il client secret”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.
Il modulo legge il secret con una data source data "aws_secretsmanager_secret_version", quindi terraform plan lo mostra come (sensitive value). Lo stato di Terraform conserva comunque il secret in testo semplice, una volta per la data source e una volta per l’identity provider. Chiunque possa leggere l’oggetto di stato nel tuo bucket di stato può leggere il secret. Limita di conseguenza l’accesso in lettura al bucket di stato.
Un file di plan salvato, ad esempio da terraform plan -out, conserva anche il secret in testo semplice. Se il tuo bucket di stato ha il versioning attivato, le vecchie versioni dello stato mantengono il secret dopo terraform destroy. Elimina anche quelle versioni quando rimuovi lo stack. Dopo un test, ruota il client secret presso l’identity provider.
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.
Esegui terraform plan e terraform apply dopo la rotazione. La data source legge la versione corrente del secret ad ogni plan, quindi il plan mostra un aggiornamento in-place dell’identity provider, e apply invia il nuovo secret a Cognito. Nel sorgente del provider hashicorp/aws, una modifica a provider_details aggiorna l’identity provider in-place e non lo sostituisce. Questo non è stato testato su AWS.
Altri client app
Sezione intitolata “Altri client app”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), ),],Aggiungi il name di ogni identity provider ai supported_identity_providers del client app e fai dipendere il client app da module.user_identity, in modo che gli identity provider esistano prima.
Token per la chat dell’agente
Sezione intitolata “Token per la chat dell’agente”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.