web-dev-qa-db-de.com

Firebase-Authentifizierung gegen AWS Cognito

Wir erstellen eine Mobil- und Web-App auf AWS mit API Gateway und Lambda und prüfen derzeit, ob wir alle AWS Mobile Servcies (Cognito, Analytics, Mobile Hub usw.) verwenden sollten oder ob wir stattdessen Firebase verwenden sollten (was einige Vorteile bietet) wie remote config).

Ich denke, dass die Verwendung des nicht funktionalen Teils von Firebase wie Analytics, Remote Config, Absturzberichte und Benachrichtigung mit dem AWS-Backend in Ordnung sein sollte. Der Teil, bei dem ich nicht sicher bin, ist die Authentifizierungsebene.

AWS Cognito lässt sich gut in API Gateway und Lamdba integrieren, z. Nur authentifizierte Benutzer können bestimmte API-Aufrufe ausführen.

Kann dasselbe Verhalten erreicht werden, wenn stattdessen die Firebase-Authentifizierung verwendet wird? Irgendwelche guten oder schlechten Erfahrungen damit?

35
Tomas

wir machen das gleiche. Wir haben mit Cognito begonnen, sind aber zu Firebase gewechselt, weil wir mit der Art und Weise, wie AWS Android SDK den Authentifizierungsfluss mit Google und Facebook implementiert, nicht zufrieden waren: Der Code ist ziemlich alt, verwendet veraltete Methoden und erfordert im Allgemeinen eine Neuschreibung. Andererseits funktioniert die Firebase-Authentifizierung offensichtlich reibungslos. Wenn Sie Cognito nicht verwenden, müssen Sie Ihren benutzerdefinierten Authentifikator in AWS API Gateway implementieren. Dies ist recht einfach und wird unter https://aws.Amazon.com/blogs/mobile/ beschrieben. Integration von Amazon Cognito-Benutzerpools mit API-Gateway/ . Firebase-Anweisungen zur Token-Validierung finden Sie unter https://firebase.google.com/docs/auth/admin/verify-id-tokens .

Das Folgende ist ein Auszug aus dem Code meines Authentifizierers:

'use strict';

// Firebase initialization
// console.log('Loading function');
const admin = require("firebase-admin");
admin.initializeApp({
  credential: admin.credential.cert("xxx.json"),
  databaseURL: "https://xxx.firebaseio.com"
});
// Standard AWS AuthPolicy - don't touch !!
...
// END Standard AWS AuthPolicy - don't touch !!

exports.handler = (event, context, callback) => {
    // console.log('Client token:', event.authorizationToken);
    // console.log('Method ARN:', event.methodArn);

    // validate the incoming token
    // and produce the principal user identifier associated with the token

    // this is accomplished by Firebase Admin
    admin.auth().verifyIdToken(event.authorizationToken)
        .then(function(decodedToken) {
            let principalId = decodedToken.uid;
            // console.log(JSON.stringify(decodedToken));

            // if the token is valid, a policy must be generated which will allow or deny access to the client

            // if access is denied, the client will recieve a 403 Access Denied response
            // if access is allowed, API Gateway will proceed with the backend integration configured on the method that was called

            // build apiOptions for the AuthPolicy
            const apiOptions = {};
            const tmp = event.methodArn.split(':');
            const apiGatewayArnTmp = tmp[5].split('/');
            const awsAccountId = tmp[4];
            apiOptions.region = tmp[3];
            apiOptions.restApiId = apiGatewayArnTmp[0];
            apiOptions.stage = apiGatewayArnTmp[1];

            const method = apiGatewayArnTmp[2];
            let resource = '/'; // root resource
            if (apiGatewayArnTmp[3]) {
                resource += apiGatewayArnTmp[3];
            }


            // this function must generate a policy that is associated with the recognized principal user identifier.
            // depending on your use case, you might store policies in a DB, or generate them on the fly

            // keep in mind, the policy is cached for 5 minutes by default (TTL is configurable in the authorizer)
            // and will apply to subsequent calls to any method/resource in the RestApi
            // made with the same token

            // the policy below grants access to all resources in the RestApi
            const policy = new AuthPolicy(principalId, awsAccountId, apiOptions);
            policy.allowAllMethods();
            // policy.denyAllMethods();
            // policy.allowMethod(AuthPolicy.HttpVerb.GET, "/users/username");

            // finally, build the policy and exit the function
            callback(null, policy.build());
            })
        .catch(function(error) {
            // Firebase throws an error when the token is not valid
            // you can send a 401 Unauthorized response to the client by failing like so:
            console.error(error);
            callback("Unauthorized");
        });
};

Wir sind noch nicht in der Produktion, aber Tests mit dem Authentifikator zeigen, dass er sich bei der Authentifizierung mit Google, Facebook und Passwort korrekt verhält und auch sehr schnell ist (60 - 200 ms). Der einzige Nachteil, den ich sehe, ist, dass Ihnen die Lambda-Funktion des Authentifikators in Rechnung gestellt wird, während der in Cognito integrierte Authentifikator kostenlos ist.

30
pmosconi

TL; DR; Feuerbasis> Cognito

Wir haben zuerst mit Cognito begonnen, aber schließlich festgestellt, dass es bei der Verwendung von Verbundidentitäten (z. B. Google-Anmeldung, Facebook-Anmeldung usw.) einen fürchterlichen Geruch aufweist. Für Cognito-Benutzerpools (d. H. Die Anmeldung/Anmeldung eines Benutzers mit einem Benutzernamen und einem Kennwort) können Sie den integrierten API Gateway Cognito User Pool Authorizer verwenden, der problemlos funktioniert. Sie müssen keinen eigenen Autorisierer oder ähnliches schreiben.

Wenn Sie jedoch Verbundidentitäten unterstützen möchten, müssen Sie die Authentifizierung auf Ihrem API-Gateway auf IAM-Authentifizierung ändern und dann JEDEN Client sigv4 veranlassen, die Anforderungen zu unterzeichnen. Dies hat sich für uns als ein Dorn im Auge und kostete erhebliche Entwicklungszeit. Option 2 war, dass API Gateway für jeden Client Code für Ihre API-Aufrufe generiert ... was meiner Meinung nach ein Beweis für die umständliche Integration in Cognito ist.

Wir haben Firebase durch den benutzerdefinierten Authorizer für API Gateway arbeiten lassen. Auf allen Clients war dies ein Kinderspiel (iOS, Android und Web). Die API-Gateway-Endpunkte wurden mit Lambda-Funktionen verknüpft, die im Auftrag mit DynamoDB, S3 und anderen Webdiensten kommunizieren konnten Die Lambda-Funktionen wussten, wer der anrufende Benutzer war, da der benutzerdefinierte Autorisierer die E-Mail-Adresse in der JWT zurückgab.

Im Folgenden finden Sie einen einfachen benutzerdefinierten Firebase-Authorizer, der die Benutzer-E-Mail in der JWT als principalId zurückgibt:

'use strict';
console.log('Loading function');

var admin = require('firebase-admin');
var serviceAccount = require('./my-secret-json.json');

admin.initializeApp({
    credential: admin.credential.cert(serviceAccount),
    databaseURL: 'https://my-app.firebaseio.com'
});

exports.handler = (event, context, callback) => {
    var token = event.authorizationToken;

    if (token == null) {
        callback('Invalid token');
    }
    else {
        admin.auth().verifyIdToken(token)
            .then(function (decodedToken) {
                var email = decodedToken.email;
                var policy = generatePolicy(email);
                callback(null, policy);
            }).catch(function (error) {
                console.log(error);
                callback('Unauthorized'); 
            });
    }
};

var generatePolicy = function (email) {
    return {
        principalId: email,
        policyDocument: {
            Version: '2012-10-17',
            Statement: [
                {
                    Action: 'execute-api:Invoke',
                    Effect: email ? 'allow' : 'deny',
                    Resource: '*'
                }
            ]
        }
    };
}

Sie können dann $context.authorizer.principalId in Ihrer API-Gateway-Zuordnungsvorlage, um die E-Mail abzurufen und an Lambda X zu übergeben.

19
Aziz Javed

AWS-Dokumentation ist ziemlich verwirrt. Das Rückrufsystem für die verschiedenen Authentifizierungsschritte ist in Firebase besser dokumentiert. Das Ergebnis ist ein sauberer Code und eine bessere Kontrolle des Authentifizierungsflusses. Darüber hinaus ist die Firebase-Benutzeroberfläche benutzerfreundlicher. Wenn Sie Inhaltsanbieter und Synchronisationsadapter verwenden möchten, würde ich die Verwendung von Firebase empfehlen, da Sie über einfache Methoden zur Datensynchronisation zwischen der lokalen und der Remote-Datenbank (Firebase) verfügen

5
Nicola Gallazzi

aws cognito bietet mehr Möglichkeiten zur Authentifizierung von Benutzern als firebase. Insbesondere wenn Sie ein Spiel erstellen, können Sie sich über Google und iOS Game Center anmelden. Es bietet Synchronisierung Bestenlisten und Erfolge von Game Center bietet. Die automatische Statussynchronisierung ist in Cognito verfügbar. Aber auf jeden Fall ist es sehr verwirrend. Die Implementierung dauert zu lange. Andererseits lässt sich die Firebase-Authentifizierung ziemlich schnell implementieren.

2
sn.anurag

Nur für den Fall, dass Sie Unity verwenden, unterstützt das Unity SDK derzeit keinen Cognito User Pool. (Das heißt, eine von AWS gehostete Liste von Benutzern) Ich zögere derzeit aus diesem Grund. Siehe meinen Beitrag hier dass sie bestätigt haben, dass dies wahr ist. Derzeit (26/06/2017) ist die Funktion noch nicht verfügbar, was möglicherweise darauf hindeutet, dass Unity-Benutzer von ihnen nicht ausreichend berücksichtigt werden.

Wenn ich jedoch Firebase für Anmeldungen verwende, benötige ich weitere Integrationen für diese Anmeldeinformationen, um AWS-Dienste zu verwenden. (Ich möchte S3 und DynamoDB verwenden, kann es aber nur von angemeldeten Benutzern verwenden.) Dadurch wurde mir auch klar, dass ich alles auf Firebase verschieben sollte, um meine Zeit und Frustrationen so schnell wie möglich zu sparen. (Die Echtzeit-Datenbank ist teurer als S3/DynamoDB, Unity hat jedoch einen eigenen Ersatz für AWS MobileAnalytics.)

AWS S3 hat kürzlich eine schönere Benutzeroberfläche, was meiner Meinung nach in etwa dem Niveau von Google entspricht. Abgesehen davon finde ich, dass die Benutzeroberfläche von Firebase viel lustiger zu bedienen ist.

Außerdem ist die Firebase-Authentifizierung kostenlos, während Cognito bis zu 50.000 aktive Benutzer pro Monat kostenlos ist. (Die nächsten 50.000 kosten 0,0055, dh wenn Sie 100.000 MAU haben, sind es 50000 * 0,0055 = 275 USD https://aws.Amazon.com/cognito/pricing/ )

Eine weitere Sache, die AWS .NET Dokumentation ist meiner Meinung nach ein Albtraum zum Lesen/Suchen.

1
5argon