#Supporto per HTTP/3

Salvo fornisce supporto per HTTP/3, che può essere abilitato tramite la feature quinn. HTTP/3 si basa sul protocollo QUIC e offre latenza ridotta e prestazioni migliori rispetto ai tradizionali HTTP/1.1 e HTTP/2, specialmente in ambienti di rete instabili.

#Abilitazione del Supporto HTTP/3

Per abilitare il supporto HTTP/3 in Salvo, è necessario attivare la feature quinn nel file Cargo.toml:

salvo = { workspace = true, features = ["quinn"] }

#Casi d'Uso di HTTP/3

HTTP/3 è particolarmente adatto per i seguenti scenari:

• Applicazioni su dispositivi mobili e in ambienti di rete instabili
• Applicazioni in tempo reale che richiedono bassa latenza
• Scenari che coinvolgono download paralleli di numerosi file di piccole dimensioni
• Applicazioni che necessitano di migrazione di connessione (ad esempio, passaggio senza interruzioni da WiFi a reti cellulari)

#Codice di Esempio

Di seguito è riportato un semplice esempio di server HTTP/3 che supporta sia HTTP/3 (QUIC) che HTTPS (TCP):

use salvo::conn::rustls::{Keycert, RustlsConfig};
use salvo::prelude::*;

// Funzione handler che risponde con "Hello World"
#[handler]
async fn hello() -> &'static str {
    "Hello World"
}

#[tokio::main]
async fn main() {
    // Inizializzazione del sistema di logging
    tracing_subscriber::fmt().init();

    // Caricamento del certificato TLS e della chiave privata da file PEM incorporati
    let cert = include_bytes!("../certs/cert.pem").to_vec();
    let key = include_bytes!("../certs/key.pem").to_vec();

    // Creazione di un router e aggiunta di un endpoint
    let router = Router::new().get(hello);

    // Configurazione delle impostazioni TLS utilizzando Rustls
    let config = RustlsConfig::new(Keycert::new().cert(cert.as_slice()).key(key.as_slice()));

    // Creazione di un listener TCP cifrato TLS sulla porta 8698
    let listener = TcpListener::new(("0.0.0.0", 8698)).rustls(config.clone());

    // Creazione di un listener QUIC e combinazione con il listener TCP
    let acceptor = QuinnListener::new(config.build_quinn_config().unwrap(), ("0.0.0.0", 8698))
        .join(listener)
        .bind()
        .await;

    // Avvio del server che supporta sia HTTP/3 (QUIC) che HTTPS (TCP)
    Server::new(acceptor).serve(router).await;
}

#Analisi del Codice Chiave

#Configurazione TLS

// Configurazione delle impostazioni TLS utilizzando Rustls
let config = RustlsConfig::new(Keycert::new().cert(cert.as_slice()).key(key.as_slice()));

Poiché HTTP/3 si basa sul protocollo QUIC, che richiede TLS 1.3 per la cifratura, è necessario configurare certificati e chiavi TLS. In Salvo, utilizziamo RustlsConfig per configurare TLS.

#Combinazione dei Listener

// Creazione di un listener TCP cifrato TLS
let listener = TcpListener::new(("0.0.0.0", 8698)).rustls(config.clone());

// Creazione di un listener QUIC e combinazione con il listener TCP
let acceptor = QuinnListener::new(config.build_quinn_config().unwrap(), ("0.0.0.0", 8698))
    .join(listener)
    .bind()
    .await;

Questo codice rappresenta la parte centrale della gestione di HTTP/3 in Salvo. Prima crea un listener TCP abilitato TLS (per HTTP/1.1 e HTTP/2), poi crea un listener QUIC (per HTTP/3). Il metodo join combina questi due listener, consentendo al server di gestire contemporaneamente richieste da protocolli diversi.

#Esecuzione dell'Esempio

Per eseguire questo esempio, sono necessari certificati TLS e chiavi private validi. In un ambiente di sviluppo, è possibile utilizzare certificati autofirmati. Il codice completo dell'esempio è disponibile nel repository GitHub di Salvo.

Si noti che poiché molti client non supportano ancora completamente HTTP/3, è essenziale che questo server supporti sia HTTP/3 che HTTPS.

#Considerazioni

1. HTTP/3 richiede il supporto di TLS 1.3, quindi è necessario configurare certificati e chiavi validi.
2. I client devono supportare il protocollo HTTP/3 per utilizzare questa funzionalità; altrimenti, ricadranno su HTTP/1.1 o HTTP/2.
3. In ambienti di produzione, è consigliabile utilizzare certificati emessi da un'Autorità di Certificazione (CA) attendibile anziché certificati autofirmati.