Firebase authentication vs AWS Cognito

nous faisons la même chose. Nous avons commencé avec Cognito mais nous sommes passés à Firebase parce que nous n'étions pas satisfaits de la façon dont AWS Android SDK implémente le flux d'authentification avec Google et Facebook: le code est assez ancien, il utilise des méthodes dépréciées et nécessite généralement une réécriture. D'un autre côté, L'authentification Firebase fonctionne de toute évidence de façon transparente. Lorsque vous n'utilisez pas Cognito, vous devez mettre en œuvre votre authentificateur personnalisé dans AWS API Gateway qui est assez facile et est décrit en https://aws.amazon.com/blogs/mobile/integrating-amazon-cognito-user-pools-with-api-gateway/. Les instructions Firebase pour la validation des Tokens sont enhttps://firebase.google.com/docs/auth/admin/verify-id-tokens

voici un extrait du code de mon authentificateur:

'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");
        });
};

nous ne sommes pas encore en production, mais des tests sur l'authentificateur montrent qu'il se comporte correctement avec Google, Facebook et l'authentification par mot de passe et il est également très rapide (60-200 ms). Le seul inconvénient que je peux voir est que vous serez facturé pour la fonction d'authentification lambda, tandis que L'authentificateur intégré Cognito est gratuit.