Integra l’autenticazione di Firebase nel tuo progetto .NET

Firebase offre un potente sistema di autenticazione che può essere facilmente integrato nei progetti .NET. In questa guida, imparerai come abilitare l’autenticazione tramite Firebase in un’applicazione .NET passo dopo passo. Vedremo come gestire l’autenticazione tramite email/password.

Prerequisiti

Prima di immergerci nell’integrazione dell’autenticazione di Firebase è fondamentale assicurarsi di avere tutto il necessario per iniziare. Ecco i prerequisiti che dovresti soddisfare:

• Account Firebase: Per utilizzare l’autenticazione di Firebase, avrai bisogno di un account Firebase attivo.
• Ambiente di sviluppo .NET configurato: Per lavorare con .NET, è importante avere un ambiente di sviluppo correttamente configurato sul tuo sistema. Ciò include l’installazione di un IDE o un editor di testo adatto per lo sviluppo .NET, come Visual Studio o Visual Studio Code. Inoltre, assicurati di avere il framework .NET installato e configurato correttamente sul tuo sistema.

Configurazione del progetto Firebase

Visita la Console di Firebase su https://console.firebase.google.com e accedi con il tuo account.

Una volta nella Console di Firebase, creiamo un nuovo progetto facendo clic sul pulsante “Aggiungi progetto”.

Durante la creazione del progetto Firebase, verrà richiesto se si desidera utilizzare Google Analytics. Per ora, possiamo escludere questo step e finalizzare la creazione.

Nella sezione “Authentication” della Console di Firebase, troverai una lista di metodi di accesso tra cui scegliere, come email/password, Google, Facebook e altri ancora.

Nel nostro caso useremmo accesso email/password.

Nuovo progetto .NET

Per inizializzare il progetto in .NET, è possibile utilizzare uno dei template proposti da Visual Studio. Nel nostro caso, utilizzeremo un template per creare una Web API che contiene il minimo indispensabile per poter continuare con il nostro esempio di autenticazione.

Servizio autenticazione

Creiamo un servizio chiamato AuthService e la sua interfaccia IAuthService che utilizzeremo per gestire l’autenticazione con Firebase. Questo servizio sarà responsabile di gestire le operazioni di registrazione, accesso, ottenimento delle informazioni dell’utente e logout.

AuthService.cs

public class AuthService(FirebaseAuthClient firebaseAuth) : IAuthService
{
    public async Task<string?> SignUp(string email, string password)
    {
        var userCredentials = await firebaseAuth.CreateUserWithEmailAndPasswordAsync(email, password);
        return userCredentials is null ? null : await userCredentials.User.GetIdTokenAsync();
    }
    public async Task<ClaimsIdentity?> Login(string email, string password)
    {
        var userCredentials = await firebaseAuth.SignInWithEmailAndPasswordAsync(email, password);

        var claims = new List<Claim>
        {
            new Claim("uid", userCredentials.User.Uid),
        };
        
        return new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme, "uid", null);
    }
    public Task<UserInfo> UserInfo()
    {
        return Task.FromResult(firebaseAuth.User.Info);
    }
    
    public void SignOut() => firebaseAuth.SignOut(); 
}

IAuthService.cs

public interface IAuthService
{
    public Task<string?> SignUp(string email, string password);
    public Task<ClaimsIdentity?> Login(string email, string password);
    public Task<UserInfo> UserInfo();
    public void SignOut();
}

Configurazione dei parametri di autenticazione di Firebase

Una volta creato il servizio AuthService, dobbiamo configurare alcune configurazioni di Firebase nel file appsettings.json della nostra applicazione:

• Accediamo alla Console di Firebase (https://console.firebase.google.com) e seleziona il progetto creato precedentemente.
• Andiamo nelle “Impostazioni del progetto” e facciamo clic su “Generale” nel menu di sinistra.
• Copiamo il valore della “Chiave API web” e l’ID Progetto che si trovano nella sezione “Il tuo progetto”
• Creiamo una nuova sezione relativa alla configurazione di Firebase nel file appsettings.json e aggiungi le seguenti chiavi:

"Firebase": {
  "ApiKey": "CHIAVE_API_WEB",
  "ProjectId": "<ID_PROGETTO>.firebaseapp.com"
}

Sostituisci "CHIAVE_API_WEB" con il valore della chiave API web che hai copiato da Firebase e "ID_PROGETTO" con l'ID del tuo progetto Firebase.

Dopo aver configurato correttamente le chiavi nel file appsettings.json, è necessario registrare il servizio di Firebase che utilizzerà i parametri appena aggiunti. Inoltre, dobbiamo anche registrare il servizio di autenticazione che abbiamo definito in precedenza. Per fare ciò, aggiungiamo le seguenti righe di codice nel file Program.cs:

// Registrazione del servizio di Firebase
builder.Services.AddSingleton(new FirebaseAuthClient(new FirebaseAuthConfig
{
    ApiKey = builder.Configuration.GetSection("Firebase:ApiKey").Value,
    AuthDomain = builder.Configuration.GetSection("Firebase:AuthDomain").Value,
    Providers = new List<IAuthProvider>
    {
        // Aggiungi qui i tipi di autenticazione definiti nella console di Firebase
        new EmailProvider()
    }
}));

// Registrazione del servizio di autenticazione
builder.Services.AddSingleton<IAuthService, AuthService>();

// Aggiungiamo uno schema di autenticazione
builder.Services.AddAuthentication(options =>
{
    options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
}).AddCookie();

Configurazione del controller per le operazioni di autenticazione

Dopo aver registrato tutti i servizi necessari, possiamo procedere alla creazione del controller AuthController per gestire le operazioni di autenticazione nel nostro servizio.

using System.Security.Claims;
using FirebaseAUTH.Interfaces;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity.Data;
using Microsoft.AspNetCore.Mvc;

namespace FirebaseAUTH.Controllers;

[Authorize]
[Route("/[controller]/[action]")]
public class AuthController(IAuthService authService) : ControllerBase
{
    [HttpPost, AllowAnonymous]
    public async Task<IActionResult> Login(LoginRequest loginRequest)
    {
        var claimsIdentity = await authService.Login(loginRequest.Email, loginRequest.Password);
        
        if (claimsIdentity is null) return Unauthorized("Failed to login");
        
        await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(claimsIdentity),
            new AuthenticationProperties
            {
                IsPersistent = true,
            });

        return Ok("Login successfully");
    }
    

    [HttpPost, AllowAnonymous]
    public async Task<IActionResult> SignUp(string email, string password)
    {
        return Ok(await authService.SignUp(email, password));
    }

    [HttpGet]
    public Task<IActionResult> UserInfo()
    {
        
        return Task.FromResult<IActionResult>(Ok(authService.UserInfo()));
    }

    [HttpGet]
    public new Task<IActionResult> SignOut()
    {
        authService.SignOut();
        HttpContext.SignOutAsync();
        return Task.FromResult<IActionResult>(Ok());
    }
}

Le azioni del controller sono definite come metodi pubblici e sono decorate con gli attributi [Authorize], [HttpPost], [HttpGet] e [AllowAnonymous] a seconda del tipo di richiesta HTTP e dei requisiti di autenticazione.

Avvio dell’applicazione e test delle API utilizzando Swagger

Siamo arrivati alla fine! Ora possiamo avviare la nostra applicazione e provare le API utilizzando Swagger.

Una volta avviata l’applicazione, apri il browser e visita l’URL del tuo servizio seguito da /swagger, ad esempio http://localhost:5000/swagger. Questo ti porterà all’interfaccia di Swagger.