Come gestire le transazioni nei database relazionali e NoSQL in un'applicazione ASP.NET Core

Nel contesto della gestione dei database nelle applicazioni moderne, è fondamentale comprendere come implementare e gestire transazioni, soprattutto quando si lavora con tecnologie come Entity Framework Core (EF Core) per i database relazionali o MongoDB per i database NoSQL. Questi strumenti offrono metodi robusti per garantire la consistenza dei dati, ma le loro applicazioni e le best practices differiscono significativamente in base al tipo di database utilizzato. In questa sezione, esploreremo come configurare e utilizzare EF Core per gestire transazioni su database SQL Server, per poi ampliare il discorso introducendo i database NoSQL e il loro impiego nelle moderne architetture software.

Il codice sottostante mostra come implementare una transazione utilizzando il framework EF Core all'interno di un'applicazione ASP.NET Core:

csharp
Copy code
app.MapPost("/createorder", async (AppDbContext dbContext, Order order) => {
    using var transaction = await dbContext.Database.BeginTransactionAsync();
    try {
        dbContext.Orders.Add(order);
        await dbContext.SaveChangesAsync();
        await transaction.CommitAsync();
        return Results.Ok(order);
    } catch {
        // Rollback della transazione in caso di errore
        await transaction.RollbackAsync();
        throw;
    }
});

Per quanto riguarda la configurazione del database, si inizia creando il contesto del database (AppDbContext.cs), che gestisce le entità degli ordini e dei prodotti, ed è configurato per usare SQL Server:

csharp
Copy code
public class AppDbContext : DbContext {

    public DbSet<Order> Orders { get; set; }

    public DbSet<Product> Products { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder) {

        base.OnModelCreating(modelBuilder);
        modelBuilder.Entity<Product>()
            .Property(product => product.Price)
            .HasPrecision(18, 2);  // Definisce la precisione per i valori decimali
    }
}

La configurazione del contesto richiede anche la connessione al database attraverso il file di configurazione Program.cs:

csharp
Copy code
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("MyDB")));

Questa configurazione imposta la connessione al database, che viene poi utilizzata per eseguire operazioni CRUD e transazionali.

Oltre alle operazioni sui database relazionali, è importante considerare l'uso dei database NoSQL, come MongoDB, che offrono un approccio alternativo per la gestione dei dati non strutturati. Mentre i database relazionali sono ideali per operazioni che richiedono forti relazioni tra i dati, i database NoSQL sono più adatti per architetture che gestiscono enormi volumi di dati eterogenei o per applicazioni che necessitano di scalabilità orizzontale, come quelle di social media o analisi dei big data.

I database NoSQL, come MongoDB, sono caratterizzati da una grande flessibilità, poiché non richiedono schemi rigidi e possono gestire dati semi-strutturati come documenti JSON. Le applicazioni moderne, in particolare quelle in cloud, traggono grande vantaggio da questa flessibilità. MongoDB, ad esempio, è particolarmente adatto per la gestione di contenuti multimediali, dati di log, o informazioni provenienti da sensori, dove la struttura del dato può variare nel tempo.

Un altro tipo di database NoSQL è quello basato su grafi, come Neo4j. Questi sono particolarmente utili in scenari come la rilevazione di frodi, le reti sociali o i sistemi di raccomandazione, dove le relazioni tra entità sono fondamentali. I database NoSQL sono progettati per essere scalabili orizzontalmente, il che significa che è possibile distribuire i dati su più server per migliorare le prestazioni in scenari ad alta richiesta.

Quando si integra un database NoSQL come MongoDB in un'applicazione ASP.NET Core, l'approccio cambia rispetto ai database relazionali. MongoDB, ad esempio, offre una grande scalabilità e flessibilità nella gestione di dati senza schema, ma si deve fare attenzione a come vengono gestiti i dati, poiché il modello di consistenza è diverso da quello dei tradizionali RDBMS, dove la coerenza è garantita da transazioni forti. MongoDB offre invece una coerenza eventuale, che potrebbe non essere adatta a tutte le applicazioni.

I database NoSQL offrono un vantaggio notevole nelle applicazioni che richiedono una gestione flessibile e scalabile dei dati. Tuttavia, la loro implementazione e gestione comportano anche sfide legate alla consistenza dei dati e alla loro struttura dinamica. È quindi essenziale scegliere il database giusto in base alle esigenze dell'applicazione.

Come proteggere i dati sensibili con la gestione delle chiavi in un'applicazione .NET

Per garantire la protezione dei dati sensibili in un'applicazione, è essenziale adottare un approccio robusto alla gestione delle chiavi. Questo processo include l'uso di un provider personalizzato per la protezione dei dati, che si basa su un database per memorizzare le chiavi di protezione. Di seguito, descriverò i passaggi fondamentali per implementare questa protezione in un'applicazione .NET, utilizzando una configurazione di database SQL Server per archiviare e gestire le chiavi.

Configurazione dei servizi di protezione dei dati

La prima operazione da eseguire consiste nella configurazione dei servizi di protezione dei dati. Poiché le chiavi di protezione dei dati vengono archiviate nel database, è necessario configurare un provider personalizzato che gestisca queste chiavi. Questo si ottiene creando una classe che implementa l'interfaccia IDataProtectionProvider, la quale interagirà con il database per ottenere e creare nuove chiavi, se necessario. Il codice di questa classe, chiamata SqlServerDataProtectionProvider, appare nel seguente esempio:

csharp
Copy code
using Microsoft.AspNetCore.DataProtection;

using Microsoft.AspNetCore.DataProtection.EntityFrameworkCore;
namespace privdata.Models
{
    public class SqlServerDataProtectionProvider : IDataProtectionProvider
    {
        private readonly AppDbContext _dbContext;

        public SqlServerDataProtectionProvider(AppDbContext dbContext)

        {
            _dbContext = dbContext;
        }
        public IDataProtector CreateProtector(string purpose)
        {
            // Logica per recuperare o creare una nuova chiave nel database
            var key = _dbContext.DataProtectionKeys
                .FirstOrDefault(o => o.FriendlyName == purpose);
            if (key == null)
            {
                key = CreateNewKey(purpose);
            }
            var protector = DataProtectionProvider.Create(key.FriendlyName ?? purpose)
                .CreateProtector(purpose);
            return protector;
        }

        private DataProtectionKey CreateNewKey(string purpose)

        {
            var key = new DataProtectionKey { FriendlyName = purpose };
            _dbContext.DataProtectionKeys.Add(key);
            _dbContext.SaveChanges();
            return key;
        }
    }
}

In questo esempio, la funzione CreateProtector si occupa di creare un "protector" per un determinato scopo, mentre CreateNewKey è responsabile della creazione di una nuova chiave se questa non esiste nel database. La chiave di protezione viene quindi associata al "protector" che si occupa della cifratura e della decifrazione dei dati.

Servizio per la gestione dei dati sensibili

csharp
Copy code
public class SensitiveDataService
{
    private readonly IDataProtectionProvider _dataProtectionProvider;

    public SensitiveDataService(IDataProtectionProvider dataProtectionProvider)

    {
        _dataProtectionProvider = dataProtectionProvider;
    }
    public Employee EncryptEmployeeData(Employee employee)
    {
        var protector = _dataProtectionProvider.CreateProtector("EmployeeData");
        employee.Email = protector.Protect(employee.Email);
        employee.Phone = protector.Protect(employee.Phone);
        employee.Birthdate = protector.Protect(employee.Birthdate.ToString());
        return employee;
    }
    public Employee MaskEmployeeData(Employee employee)
    {
        var protector = _dataProtectionProvider.CreateProtector("EmployeeData");
        employee.Email = protector.Unprotect(employee.Email);
        employee.Phone = protector.Unprotect(employee.Phone);
        employee.Birthdate = protector.Unprotect(employee.Birthdate.ToString());
        return employee;
    }
}

Questa classe offre due funzionalità principali: cifrare i dati (nel metodo EncryptEmployeeData) e mascherarli (nel metodo MaskEmployeeData). I dati cifrati sono sicuri, mentre i dati mascherati sono visibili, ma non possono essere utilizzati in modo utile se non sono prima decifrati.

Configurazione del database e delle migrazioni

json
Copy code
{
  "ConnectionStrings": {
    "MyDB": "server=localhost; database=Training3DB; uid=tester; pwd=pass123; Tr"
  },
  "AppSettings": {
    "Secret": "aaaaabbbbbcccccddddd11234df4444sd"
  }
}

Successivamente, eseguire le migrazioni con i seguenti comandi:

bash
Copy code
dotnet ef migrations add InitialCreate

dotnet ef database update

Implementazione degli endpoint API

Una volta che la configurazione del database e la protezione dei dati sono pronte, è possibile implementare gli endpoint API per aggiungere e recuperare i dati degli impiegati. Qui di seguito un esempio di come potrebbero apparire:

csharp
Copy code
app.MapPost("/employees", (AppDbContext dbContext, SensitiveDataService service, Employee employee) =>
{
    dbContext.Employees.Add(service.EncryptEmployeeData(employee));
    dbContext.SaveChanges();
    return Results.Ok();
});
app.MapGet("/employees", (AppDbContext dbContext, SensitiveDataService service) =>
{
    var employees = dbContext.Employees.AsEnumerable().Select(service.MaskEmployeeData);
    return Results.Ok(employees);
});

In questo esempio, l'endpoint POST consente di aggiungere un nuovo impiegato cifrando i dati, mentre l'endpoint GET restituisce la lista degli impiegati mascherando i dati sensibili.

Interfaccia utente con Scalar

Per facilitare i test e l'interazione con l'API, è possibile configurare Scalar UI, un'interfaccia utente che permette di testare facilmente gli endpoint API. La configurazione avviene aggiungendo i seguenti servizi al file Program.cs:

csharp
Copy code
builder.Services.AddOpenApi();

var app = builder.Build();
if (app.Environment.IsDevelopment())
{
    app.MapOpenApi();
    app.MapScalarApiReference();
}

Una volta configurato, sarà possibile testare l'API direttamente dal browser tramite l'interfaccia di Scalar UI.

Importanza della protezione dei dati

Oltre alla protezione dei dati sensibili, è fondamentale garantire la corretta gestione e protezione delle chiavi stesse. La sicurezza del sistema dipende infatti dalla segretezza delle chiavi di protezione. In un ambiente di produzione, l'uso di un database sicuro per archiviare queste chiavi è cruciale. Inoltre, è importante eseguire regolari audit e aggiornamenti alle chiavi per ridurre i rischi di esposizione.