Perché il .NET 9.0 è una svolta per le API Minime in ASP.NET Core?

.NET 9.0 rappresenta un passo fondamentale nell'evoluzione della piattaforma .NET, con un focus su prestazioni avanzate e capacità di sviluppo più agili. Tra le innovazioni che questo nuovo rilascio porta, le API Minime in ASP.NET Core emergono come uno degli aspetti più rivoluzionari, riducendo notevolmente la quantità di codice boilerplate necessario per costruire API web, permettendo ai sviluppatori di concentrarsi sulle funzionalità centrali delle loro applicazioni.

Le API Minime in ASP.NET Core sono progettate per semplificare la costruzione di applicazioni web, eliminando la necessità di componenti complessi come i controller, le classi di avvio e la configurazione esplicita dei routing. L'introduzione di questo paradigma rappresenta un cambio di mentalità rispetto agli approcci tradizionali, che richiedevano una struttura di codice più complessa per gestire anche operazioni di base. Questo approccio più snodato riduce il tempo di sviluppo e rende più chiaro il flusso del codice, una vera e propria innovazione nel panorama della programmazione web moderna.

La facilità di creazione e gestione di API RESTful è uno degli aspetti che rende le API Minime così potenti. In questo contesto, l'utilizzo di Minimal APIs in .NET 9.0 è particolarmente vantaggioso in scenari in cui le prestazioni e la scalabilità sono fondamentali, come nelle applicazioni microservizi o nei sistemi cloud-based. La struttura delle Minimal API facilita la realizzazione di endpoint molto semplici, ma estremamente performanti, adatti a gestire richieste ad alta velocità.

Ma cosa significa tutto questo per uno sviluppatore? La vera forza di queste API sta nella combinazione di semplicità, efficienza e potenza. Grazie alla loro struttura minimale, è possibile concentrarsi su operazioni fondamentali come la gestione delle richieste HTTP, la validazione dei dati e la gestione degli errori senza dover gestire componenti intermedi complessi. Questo approccio non solo migliora la produttività, ma riduce anche il rischio di errori, poiché ogni parte del sistema è visibile, chiara e concisa.

Quando si parla di prestazioni, .NET 9.0 ha introdotto significativi miglioramenti, inclusi tempi di avvio ridotti e una maggiore efficienza nella gestione della memoria. Le API Minime beneficiano in modo diretto di questi miglioramenti, risultando più veloci e meno esigenti in termini di risorse rispetto alle implementazioni precedenti. Questo è particolarmente vantaggioso per le applicazioni che necessitano di gestire grandi volumi di richieste in tempo reale, come nelle soluzioni IoT o nelle piattaforme di streaming.

Oltre a queste ottimizzazioni, l'integrazione di funzionalità cloud avanzate e il supporto nativo per container in .NET 9.0 ampliano ulteriormente le possibilità delle API Minime, rendendo facile il loro utilizzo in ambienti distribuiti e in scenari di cloud computing. La possibilità di eseguire facilmente applicazioni in contenitori Docker o Kubernetes garantisce che le API siano non solo performanti, ma anche facilmente scalabili e pronte per l'implementazione in ambienti di produzione complessi.

Anche la sicurezza è stata migliorata in .NET 9.0. L'integrazione avanzata con strumenti di autenticazione e autorizzazione, come JWT e OAuth2, permette di costruire API sicure sin dal primo giorno. Inoltre, l'adozione di pratiche di sicurezza avanzate, come il rate limiting e la protezione contro attacchi di tipo DDoS, è fondamentale per la protezione delle API contro minacce esterne.

A livello pratico, imparare a utilizzare le API Minime di ASP.NET Core in .NET 9.0 richiede un approccio strutturato. Sebbene la sintassi ridotta possa sembrare inizialmente semplice, la corretta gestione delle dipendenze, la configurazione dei middleware e l'ottimizzazione delle prestazioni sono passaggi cruciali che devono essere compresi a fondo per ottenere il massimo da questa tecnologia. I developer devono comprendere che, pur essendo minimale, ogni API è parte di un sistema complesso, che può richiedere la gestione di autenticazione, connessioni a database e gestione degli errori in modo trasparente.

In sintesi, le API Minime in .NET 9.0 non solo semplificano la creazione di applicazioni web, ma offrono anche un approccio altamente efficiente e sicuro per gestire la comunicazione tra sistemi. Non solo gli sviluppatori troveranno una piattaforma potente e versatile, ma anche le aziende che adattano queste soluzioni saranno in grado di godere di vantaggi significativi in termini di velocità, scalabilità e sicurezza.

Come Creare una REST API Sicura con Autenticazione JWT in ASP.NET Core

La creazione di un'API sicura inizia dalla configurazione iniziale dei servizi. Utilizzando builder.Services.AddOpenApi(), possiamo aggiungere OpenAPI, un utile strumento per documentare e testare le nostre API. All'interno di questa configurazione, possiamo anche aggiungere un componente per gestire la sicurezza con JWT. La configurazione dell'API include l’aggiunta di uno schema di sicurezza che utilizza il formato "Bearer", tipico per JWT. La definizione di questo schema avviene all'interno di un trasformatore di documenti, il quale aggiunge le informazioni relative alla sicurezza, permettendo alla nostra API di essere facilmente documentata e testata.

csharp
Copy code
builder.Services.AddOpenApi(options => {

    options.AddDocumentTransformer((document, context, cancellationToken) => {
        document.Info.Title = "Secure REST API";
        document.Info.Version = "v1";
        document.Info.Description = "A secure REST API with JWT authentication";
        document.Components ??= new OpenApiComponents();
        document.Components.SecuritySchemes["Bearer"] = new OpenApiSecurityScheme
        {
            Type = SecuritySchemeType.Http,
            Scheme = "bearer",
            BearerFormat = "JWT",
            Description = "Enter JWT Bearer token"
        };
        return Task.CompletedTask;
    });
});

Una volta configurato il supporto per OpenAPI, è possibile passare all’integrazione dell’interfaccia grafica Scalar UI, che ci permette di visualizzare e testare facilmente le API. Aggiungendo il codice per abilitare Scalar UI prima di builder.Build(), possiamo configurare un’interfaccia utente dinamica che ci consente di interagire con la nostra API in modo efficiente.

csharp
Copy code
var app = builder.Build();

if (app.Environment.IsDevelopment()) {
    app.MapOpenApi();
    app.MapScalarApiReference(options => {
        options.Title = "Secure REST API";
        options.Theme = ScalarTheme.Purple;
        options.ShowSidebar = true;
        options.DefaultHttpClient = new(ScalarTarget.CSharp, ScalarClient.HttpClient);
    });
}

A questo punto, è fondamentale abilitare la gestione dell’autenticazione e autorizzazione, che si attiva con le linee di codice seguenti. Queste operazioni garantiscono che solo gli utenti autenticati possano accedere alle risorse protette della nostra API.

csharp
Copy code
app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();

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

Con il database e la connessione configurati correttamente, possiamo implementare gli endpoint per la registrazione e il login degli utenti. Il primo endpoint, quello per la registrazione, consente di creare nuovi utenti con password criptate, mentre il secondo endpoint autentica gli utenti e genera un token JWT valido per l’autenticazione successiva.

csharp
Copy code
app.MapPost("/register", async (AppDbContext dbContext, ApiUser usr) => {

    var user = new ApiUser {
        Username = usr.Username,
        Password = BC.HashPassword(usr.Password),
        Email = usr.Email,
        Name = usr.Name
    };
    dbContext.Users.Add(user);
    await dbContext.SaveChangesAsync();
    return Results.Ok();
});

Il login avviene confrontando la password fornita con quella memorizzata nel database (criptata), e, se l'autenticazione ha successo, viene generato un token JWT. Quest’ultimo sarà utilizzato per autenticare l'utente nelle successive richieste.

csharp
Copy code
app.MapPost("/login", (AppDbContext dbContext, IConfiguration configuration, User model) => {
    var usr = dbContext.Users.Where(o => o.Username == model.UserName).FirstOrDefault();
    if (usr != null && BC.Verify(model.Password, usr.Password)) {
        var key = configuration.GetValue<string>("AppSettings:Secret");
        var keyBytes = Encoding.ASCII.GetBytes(key);
        var expiredAt = DateTime.Now.AddDays(2);
        var tokenHandler = new JwtSecurityTokenHandler();
        var tokenDescriptor = new SecurityTokenDescriptor {
            Subject = new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, usr.Username) }),
            Expires = expiredAt,
            SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(keyBytes), SecurityAlgorithms.HmacSha256Signature)
        };
        var token = tokenHandler.CreateToken(tokenDescriptor);
        return new UserToken { Token = tokenHandler.WriteToken(token), ExpiredAt = expiredAt.ToString() };
    }
    return new UserToken { Message = "Invalid username or password" };
});

csharp
Copy code
app.MapGet("/profile", [Authorize] async (HttpContext httpContext, AppDbContext dbContext) => {
    var username = httpContext.User.Identity?.Name;
    var user = await dbContext.Users.FirstOrDefaultAsync(u => u.Username == username);

    return user != null ? Results.Ok(new { user.Username, user.Name, user.Email }) : Results.NotFound();

});

Per testare l'API, è possibile creare un file .http con i vari endpoint di registrazione, login e profilo. Questo file facilita l’interazione con l’API, testando le funzionalità di autenticazione e visualizzazione del profilo tramite un client HTTP.

http
Copy code
### register
POST {{secrestapi_HostAddress}}/register
Content-Type: application/json
{
    "Email": "[email protected]",
    "Password": "pass123",
    "Username": "user1",
    "Name": "User 1"
}
### login
POST {{secrestapi_HostAddress}}/login
Content-Type: application/json
{
    "Password": "pass123",
    "Username": "user1"
}
### GET /profile
Authorization: Bearer {{token}}

Ogni passaggio di questa guida è un passo verso la creazione di una API REST sicura che utilizza JWT per l’autenticazione degli utenti. Tuttavia, è importante ricordare che la sicurezza delle informazioni non dipende solo dalla creazione di un token, ma dalla gestione continua di accessi, validità dei token, e dalla protezione delle informazioni sensibili, come la chiave segreta JWT, che dovrebbe essere mantenuta con la massima attenzione e sicurezza.