Trigger Lambda di federazione in entrata - Amazon Cognito
Panoramica del flussoParametersEsempio: appartenenza a un gruppoEsempio: troncare gli attributiEsempio: registrazione degli eventi

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Trigger Lambda di federazione in entrata

Il trigger di federazione in entrata trasforma gli attributi utente federati durante il processo di autenticazione con provider di identità esterni. Quando gli utenti si autenticano tramite provider di identità configurati, questo trigger consente di modificare le risposte dei provider SAML e OIDC esterni intercettando e trasformando i dati nel processo di autenticazione, fornendo il controllo programmatico su come i pool di utenti di Amazon Cognito gestiscono gli utenti federati e i relativi attributi.

Usa questo trigger per aggiungere, sovrascrivere o sopprimere gli attributi prima di creare nuovi utenti o aggiornare i profili utente federati esistenti. Questo trigger riceve gli attributi non elaborati del provider di identità come input e restituisce gli attributi modificati che Amazon Cognito applica al profilo utente.

Panoramica del flusso

Quando un utente si autentica con un provider di identità esterno, Amazon Cognito richiama il trigger di federazione in entrata prima di creare o aggiornare il profilo utente. Il trigger riceve gli attributi non elaborati dal provider di identità e può trasformarli prima che Amazon Cognito li memorizzi. Questo flusso si verifica sia per i nuovi utenti federati che per gli utenti esistenti che accedono nuovamente tramite la federazione.

Flusso di attivazione Lambda della federazione in entrata

Parametri di attivazione Lambda della federazione in entrata

La richiesta passata da Amazon Cognito a questa funzione Lambda è una combinazione dei parametri seguenti e dei parametri comuni aggiunti da Amazon Cognito a tutte le richieste.

JSON
{
    "version": "string",
    "triggerSource": "InboundFederation_ExternalProvider",
    "region": AWSRegion,
    "userPoolId": "string",
    "userName": "string",
    "callerContext": {
        "awsSdkVersion": "string",
        "clientId": "string"
    },
    "request": {
        "providerName": "string",
        "providerType": "string",
        "attributes": {
            "tokenResponse": {
                "access_token": "string",
                "token_type": "string",
                "expires_in": "string"
            },
            "idToken": {
                "sub": "string",
                "email": "string",
                "email_verified": "string"
            },
            "userInfo": {
                "email": "string",
                "given_name": "string",
                "family_name": "string"
            },
            "samlResponse": {
                "string": "string"
            }
        }
    },
    "response": {
        "userAttributesToMap": {
            "string": "string"
        }
    }
}

Parametri della richiesta di federazione in entrata

Nome del provider

Il nome del provider di identità esterno.

ProviderType

Il tipo di provider di identità esterno. Valori validi:OIDC,SAML,Facebook,Google,SignInWithApple,LoginWithAmazon.

attributes

Gli attributi non elaborati ricevuti dal provider di identità prima dell'elaborazione. La struttura varia in base al tipo di provider.

Attributes.tokenResponse

OAuth dati di risposta token dall'endpoint. /token Disponibile solo per OIDC e fornitori di servizi sociali. Contieneaccess_token,id_token,, refresh_token token_typeexpires_in, e. scope

Attributes.idToken

Token ID decodificato e convalidato dichiarato da JWT. Disponibile solo per OIDC e fornitori di servizi sociali. Contiene informazioni verificate sull'identità dell'utente, tra cui sub (identificatore utente univoco) emailname, iss (emittente), aud (pubblico), exp (scadenza) e iat (ora di emissione).

Attributes.userInfo

Informazioni estese sul profilo utente dall'endpoint. UserInfo Disponibile solo per OIDC e fornitori di servizi sociali. Contiene attributi dettagliati del profilo comegiven_name,, family_name pictureaddress, e altri campi specifici del provider. Può essere vuoto se l'IdP non supporta l' UserInfo endpoint o se la chiamata all'endpoint fallisce.

Attributi.samlResponse

Attributi di asserzione SAML. Disponibile solo per i provider SAML. Contiene gli attributi della risposta SAML.

Parametri di risposta della federazione in entrata

userAttributesToMappa

Gli attributi utente da applicare al profilo utente.

Importante

È necessario includere TUTTI gli attributi utente che si desidera conservare nella risposta, inclusi gli attributi che non si desidera modificare. Tutti gli attributi non inclusi nella userAttributesToMap risposta verranno eliminati e non archiviati nel profilo utente. Questo vale sia per gli attributi modificati che per quelli non modificati.

Comportamento di risposta vuoto

Se si restituisce un oggetto vuoto {} peruserAttributesToMap, tutti gli attributi originali del provider di identità vengono mantenuti invariati. Funziona come un no-op, come se la funzione Lambda non fosse mai stata eseguita. Ciò è diverso dall'omettere gli attributi, che li elimina.

Attributi specifici del provider

La struttura di request.attributes varia in base a. providerType IDC e i fornitori di servizi sociali includono tokenResponseidToken, e userInfo oggetti. I provider SAML includono solo l'oggetto. samlResponse

Esempio di federazione in entrata: gestione dell'appartenenza a un gruppo

Questo esempio mostra come mappare i gruppi di provider di identità federati ai gruppi di pool di utenti di Amazon Cognito. Questa funzione estrae l'appartenenza al gruppo dalla risposta federata e aggiunge automaticamente gli utenti ai gruppi Amazon Cognito corrispondenti, eliminando la necessità di trigger post-autenticazione.

Node.js
exports.handler = async (event) => {
    const { providerType, attributes } = event.request;
    
    // Extract user attributes based on provider type
    let userAttributesFromIdp = {};
    if (providerType === 'SAML') {
        userAttributesFromIdp = attributes.samlResponse || {};
    } else {
        // For OIDC and Social providers, merge userInfo and idToken
        userAttributesFromIdp = {
            ...(attributes.userInfo || {}),
            ...(attributes.idToken || {})
        };
    }
    
    // Extract groups from federated response
    const federatedGroups = userAttributesFromIdp.groups?.split(',') || [];
    
    // Map federated groups to Cognito groups
    const groupMapping = {
        'Domain Admins': 'Administrators',
        'Engineering': 'Developers',
        'Sales': 'SalesTeam'
    };
    
    // Filter to only in-scope groups
    const mappedGroups = federatedGroups
        .map(group => groupMapping[group.trim()])
        .filter(group => group); // Remove undefined values
    
    // Pass through attributes with mapped groups as custom attribute
    const attributesToMap = {
        ...userAttributesFromIdp,
        'custom:user_groups': mappedGroups.join(',')
    };
    
    // Remove original groups attribute
    delete attributesToMap.groups;
    
    event.response.userAttributesToMap = attributesToMap;
    return event;
};

Amazon Cognito trasferisce informazioni sugli eventi alla funzione Lambda. La funzione quindi restituisce a Amazon Cognito lo stesso oggetto evento con eventuali modifiche nella risposta. Nella console Lambda puoi configurare un evento di test con i dati pertinenti al trigger Lambda. Di seguito è riportato un evento di test per questo esempio di codice:

JSON
{
    "userPoolId": "us-east-1_XXXXXXXXX",
    "request": {
        "providerName": "CorporateAD",
        "providerType": "SAML",
        "attributes": {
            "samlResponse": {
                "email": "jane.smith@company.com",
                "given_name": "Jane",
                "family_name": "Smith",
                "groups": "Engineering,Domain Admins",
                "department": "Engineering"
            }
        }
    },
    "response": {
        "userAttributesToMap": {}
    }
}

Esempio di federazione in entrata: tronca gli attributi di grandi dimensioni

Questo esempio mostra come troncare i valori degli attributi che superano i limiti di archiviazione di Amazon Cognito. Questa funzione controlla ogni attributo del provider di identità. Se il valore di un attributo supera i 2048 caratteri, tronca il valore e aggiunge i puntini di sospensione per indicare il troncamento. Tutti gli altri attributi rimangono invariati.

Node.js
exports.handler = async (event) => {
    const MAX_ATTRIBUTE_LENGTH = 2048;
    
    // Get the identity provider attributes based on provider type
    const { providerType, attributes } = event.request;
    let idpAttributes = {};
    
    if (providerType === 'SAML') {
        idpAttributes = attributes.samlResponse || {};
    } else {
        // For OIDC and Social providers, merge userInfo and idToken
        idpAttributes = {
            ...(attributes.userInfo || {}),
            ...(attributes.idToken || {})
        };
    }
    
    const userAttributes = {};
    
    // Process each attribute
    for (const [key, value] of Object.entries(idpAttributes)) {
        if (typeof value === 'string' && value.length > MAX_ATTRIBUTE_LENGTH) {
            // Truncate the value and add ellipsis
            userAttributes[key] = value.substring(0, MAX_ATTRIBUTE_LENGTH - 3) + '...';
            console.log(`Truncated attribute ${key} from ${value.length} to ${userAttributes[key].length} characters`);
        } else {
            // Keep the original value
            userAttributes[key] = value;
        }
    }
    
    // Return the modified attributes
    event.response.userAttributesToMap = userAttributes;
    return event;
};

Amazon Cognito trasferisce informazioni sugli eventi alla funzione Lambda. La funzione quindi restituisce a Amazon Cognito lo stesso oggetto evento con eventuali modifiche nella risposta. Nella console Lambda puoi configurare un evento di test con i dati pertinenti al trigger Lambda. Di seguito è riportato un evento di test per questo esempio di codice:

JSON
{
    "version": "string",
    "triggerSource": "InboundFederation_ExternalProvider",
    "region": "us-east-1",
    "userPoolId": "us-east-1_XXXXXXXXX",
    "userName": "ExampleProvider_12345",
    "callerContext": {
        "awsSdkVersion": "string",
        "clientId": "string"
    },
    "request": {
        "providerName": "ExampleProvider",
        "providerType": "OIDC",
        "attributes": {
            "tokenResponse": {
                "access_token": "abcDE...",
                "token_type": "Bearer",
                "expires_in": "3600"
            },
            "idToken": {
                "sub": "12345",
                "email": "user@example.com"
            },
            "userInfo": {
                "email": "user@example.com",
                "given_name": "Example",
                "family_name": "User",
                "bio": "This is a very long biography that contains more than 2048 characters..."
            }
        }
    },
    "response": {
        "userAttributesToMap": {}
    }
}

Esempio di federazione in entrata: registrazione degli eventi di federazione

Questo esempio mostra come registrare gli eventi di autenticazione federata per il monitoraggio e il debug. Questa funzione di esempio acquisisce informazioni dettagliate sugli utenti federati e sui relativi attributi, fornendo visibilità sul processo di autenticazione.

Node.js
exports.handler = async (event) => {
    const { providerName, providerType, attributes } = event.request;
    
    // Extract user attributes based on provider type
    let userAttributesFromIdp = {};
    if (providerType === 'SAML') {
        userAttributesFromIdp = attributes.samlResponse || {};
    } else {
        // For OIDC and Social providers, merge userInfo and idToken
        userAttributesFromIdp = {
            ...(attributes.userInfo || {}),
            ...(attributes.idToken || {})
        };
    }
    
    // Log federated authentication details
    console.log(JSON.stringify({
        timestamp: new Date().toISOString(),
        providerName,
        providerType,
        userEmail: userAttributesFromIdp.email,
        attributeCount: Object.keys(userAttributesFromIdp).length,
        attributes: userAttributesFromIdp
    }));
    
    // Pass through all attributes unchanged
    event.response.userAttributesToMap = userAttributesFromIdp;
    return event;
};

Amazon Cognito trasferisce informazioni sugli eventi alla funzione Lambda. La funzione quindi restituisce a Amazon Cognito lo stesso oggetto evento con eventuali modifiche nella risposta. Nella console Lambda puoi configurare un evento di test con i dati pertinenti al trigger Lambda. Di seguito è riportato un evento di test per questo esempio di codice:

JSON
{
    "version": "string",
    "triggerSource": "InboundFederation_ExternalProvider",
    "region": "us-east-1",
    "userPoolId": "us-east-1_XXXXXXXXX",
    "userName": "CorporateAD_john.doe",
    "callerContext": {
        "awsSdkVersion": "string",
        "clientId": "string"
    },
    "request": {
        "providerName": "CorporateAD",
        "providerType": "SAML",
        "attributes": {
            "samlResponse": {
                "email": "john.doe@company.com",
                "given_name": "John",
                "family_name": "Doe",
                "department": "Engineering",
                "employee_id": "EMP12345"
            }
        }
    },
    "response": {
        "userAttributesToMap": {}
    }
}

Output previsto dei CloudWatch log:

JSON
{
    "timestamp": "2025-01-14T21:17:40.153Z",
    "providerName": "CorporateAD",
    "providerType": "SAML",
    "userEmail": "john.doe@company.com",
    "attributeCount": 5,
    "attributes": {
        "email": "john.doe@company.com",
        "given_name": "John",
        "family_name": "Doe",
        "department": "Engineering",
        "employee_id": "EMP12345"
    }
}