Lambda-Trigger für eingehenden Verbund - Amazon Cognito
Überblick über den FlowParametersBeispiel: GruppenmitgliedschaftBeispiel: Attribute kürzenBeispiel: Ereignisse protokollieren

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Lambda-Trigger für eingehenden Verbund

Der eingehende Verbundauslöser transformiert föderierte Benutzerattribute während des Authentifizierungsprozesses mit externen Identitätsanbietern. Wenn Benutzer sich über konfigurierte Identitätsanbieter authentifizieren, ermöglicht Ihnen dieser Trigger, Antworten von externen SAML- und OIDC-Anbietern zu ändern, indem Sie Daten im Authentifizierungsprozess abfangen und transformieren, sodass Sie programmgesteuert steuern können, wie Amazon Cognito Cognito-Benutzerpools mit Verbundbenutzern und ihren Attributen umgehen.

Verwenden Sie diesen Trigger, um Attribute hinzuzufügen, zu überschreiben oder zu unterdrücken, bevor Sie neue Benutzer erstellen oder bestehende Verbundbenutzerprofile aktualisieren. Dieser Trigger empfängt unverarbeitete Identitätsanbieterattribute als Eingabe und gibt modifizierte Attribute zurück, die Amazon Cognito auf das Benutzerprofil anwendet.

Überblick über den Ablauf

Wenn sich ein Benutzer bei einem externen Identitätsanbieter authentifiziert, ruft Amazon Cognito den Trigger für eingehende Verbindungen auf, bevor das Benutzerprofil erstellt oder aktualisiert wird. Der Trigger empfängt die Rohattribute vom Identitätsanbieter und kann sie transformieren, bevor Amazon Cognito sie speichert. Dieser Ablauf findet sowohl für neue Verbundbenutzer als auch für bestehende Benutzer statt, die sich erneut über den Verbund anmelden.

Lambda-Triggerfluss für eingehenden Verbund

Lambda-Triggerparameter für eingehenden Verbund

Die Anforderung, die Amazon Cognito an diese Lambda-Funktion übergibt, ist eine Kombination der folgenden Parameter und der allgemeinen Parameter, die Amazon Cognito allen Anfragen hinzufügt.

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"
        }
    }
}

Parameter für eingehende Verbundanfragen

Name des Anbieters

Der Name des externen Identitätsanbieters.

Anbietertyp

Der Typ des externen Identitätsanbieters. Gültige Werte:OIDC,SAML,Facebook,Google,SignInWithApple,LoginWithAmazon.

Attribute

Die Rohattribute, die vor der Verarbeitung vom Identity Provider empfangen wurden. Die Struktur variiert je nach Anbietertyp.

Attributes.TokenResponse

OAuth Token-Antwortdaten vom Endpunkt. /token Nur für OIDC und soziale Anbieter verfügbar. Enthältaccess_token,id_token, refresh_token token_typeexpires_in, und. scope

attribute.idToken

Dekodiertes und validiertes ID-Token, das JWT behauptet. Nur für OIDC und soziale Anbieter verfügbar. Enthält verifizierte Informationen zur Benutzeridentität, einschließlich sub (eindeutige Benutzerkennung) emailname,, iss (Aussteller), aud (Zielgruppe), exp (Ablauf) und iat (Ausstellungszeit).

Attributes.UserInfo

Erweiterte Benutzerprofilinformationen vom Endpunkt aus. UserInfo Nur für OIDC und soziale Anbieter verfügbar. Enthält detaillierte Profilattribute wiegiven_name,, family_name pictureaddress, und andere anbieterspezifische Felder. Kann leer sein, wenn der IdP den Endpunkt nicht unterstützt oder wenn der UserInfo Endpunktaufruf fehlschlägt.

Attributes.samlResponse

SAML-Assertion-Attribute. Nur für SAML-Anbieter verfügbar. Enthält Attribute aus der SAML-Antwort.

Antwortparameter für eingehende Föderationen

userAttributesToKarte

Die Benutzerattribute, die auf das Benutzerprofil angewendet werden sollen.

Wichtig

Sie müssen ALLE Benutzerattribute, die Sie behalten möchten, in der Antwort angeben, einschließlich der Attribute, die Sie nicht ändern. Alle Attribute, die nicht in der userAttributesToMap Antwort enthalten sind, werden gelöscht und nicht im Benutzerprofil gespeichert. Dies gilt sowohl für modifizierte als auch für unveränderte Attribute.

Leeres Antwortverhalten

Wenn Sie ein leeres Objekt {} für zurückgebenuserAttributesToMap, werden alle ursprünglichen Attribute des Identity Providers unverändert beibehalten. Dies wirkt wie ein No-Op, als ob die Lambda-Funktion nie ausgeführt worden wäre. Dies unterscheidet sich vom Weglassen von Attributen, wodurch sie gelöscht werden.

Anbieterspezifische Attribute

Die Struktur von request.attributes variiert je nach. providerType Zu IDC und sozialen Anbietern gehören tokenResponseidToken, und userInfo Objekte. SAML-Anbieter schließen nur das Objekt ein. samlResponse

Beispiel für einen eingehenden Verbund: Verwaltung der Gruppenmitgliedschaft

Dieses Beispiel zeigt, wie föderierte Identitätsanbietergruppen Amazon Cognito-Benutzerpool-Gruppen zugeordnet werden. Diese Funktion extrahiert die Gruppenmitgliedschaft aus der Verbundantwort und fügt Benutzer automatisch zu den entsprechenden Amazon Cognito Cognito-Gruppen hinzu, sodass keine Trigger nach der Authentifizierung erforderlich sind.

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 übergibt Ereignisinformationen an Ihre Lambda-Funktion. Die Funktion gibt dann das gleiche Ereignisobjekt mit allen Änderungen in der Antwort an Amazon Cognito zurück. Sie können in der Lambda-Konsole ein Testereignis mit den für Ihren Lambda-Auslöser relevanten Daten einrichten. Das Folgende ist ein Testereignis für dieses Codebeispiel:

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": {}
    }
}

Beispiel für einen eingehenden Verbund: Große Attribute kürzen

Dieses Beispiel zeigt, wie Attributwerte gekürzt werden, die die Speicherlimits von Amazon Cognito überschreiten. Diese Funktion überprüft jedes Attribut des Identitätsanbieters. Wenn ein Attributwert 2048 Zeichen überschreitet, wird der Wert gekürzt und es werden Auslassungspunkte hinzugefügt, um auf die Kürzung hinzuweisen. Alle anderen Attribute werden unverändert übernommen.

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 übergibt Ereignisinformationen an Ihre Lambda-Funktion. Die Funktion gibt dann das gleiche Ereignisobjekt mit allen Änderungen in der Antwort an Amazon Cognito zurück. Sie können in der Lambda-Konsole ein Testereignis mit den für Ihren Lambda-Auslöser relevanten Daten einrichten. Das Folgende ist ein Testereignis für dieses Codebeispiel:

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": {}
    }
}

Beispiel für einen eingehenden Verbund: Protokollierung von Verbundereignissen

Dieses Beispiel zeigt, wie Verbundauthentifizierungsereignisse zur Überwachung und zum Debuggen protokolliert werden. Diese Beispielfunktion erfasst detaillierte Informationen zu Verbundbenutzern und ihren Attributen und bietet so Einblick in den Authentifizierungsprozess.

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 übergibt Ereignisinformationen an Ihre Lambda-Funktion. Die Funktion gibt dann das gleiche Ereignisobjekt mit allen Änderungen in der Antwort an Amazon Cognito zurück. Sie können in der Lambda-Konsole ein Testereignis mit den für Ihren Lambda-Auslöser relevanten Daten einrichten. Das Folgende ist ein Testereignis für dieses Codebeispiel:

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": {}
    }
}

Erwartete CloudWatch Protokollausgabe:

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"
    }
}