Autenticazione e autorizzazione
Implementi meccanismi sicuri di autenticazione degli utenti (ad esempio JWT) e di autorizzazione per proteggere gli endpoint del Suo servizio web.
Autenticazione e autorizzazione è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 3 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 3 lezioni in totale.
Proteggere i servizi web
Benvenuto! In questa lezione approfondiremo autenticazione e autorizzazione, concetti fondamentali per creare servizi web sicuri in Rust.
Imparerà a proteggere gli endpoint delle API, assicurandosi che solo gli utenti legittimi possano accedervi e che possano farlo esclusivamente con le autorizzazioni corrette.
Autenticazione e autorizzazione a confronto
Questi due termini sembrano simili, ma hanno significati diversi:
- Autenticazione: verifica chi è Lei. È come mostrare un documento per entrare in un edificio.
- Autorizzazione: determina che cosa Le è consentito fare. Una volta dentro, stabilisce in quali stanze può entrare.
Implementeremo entrambe per proteggere i nostri servizi web Rust.
Perché proteggere le API?
Proteggere gli endpoint delle API è fondamentale per diversi motivi:
- Privacy dei dati: mantenere al sicuro i dati sensibili degli utenti impedendo gli accessi non autorizzati.
- Integrità del sistema: impedire ad attori malintenzionati di alterare o danneggiare i dati.
- Conformità: rispettare i requisiti legali e normativi (ad esempio GDPR e HIPAA).
Un solido livello di sicurezza rafforza la fiducia e protegge l'applicazione.
JSON Web Token (JWT)
Un metodo diffuso per l'autenticazione nei moderni servizi web consiste nell'usare i JSON Web Token (JWT), pronunciati "giot".
I JWT sono strumenti compatti e sicuri per gli URL che rappresentano le attestazioni da trasferire tra due parti. Vengono spesso usati per l'autenticazione stateless.
Ciò significa che il server non deve memorizzare le informazioni di sessione per ogni utente.
Dentro un JWT: header, payload e signature
Un JWT è composto da tre parti, separate da punti:
- Header: contiene i metadati sul token, come il tipo di token (JWT) e l'algoritmo di firma (ad esempio, HS256).
- Payload: contiene le "claims", ovvero dichiarazioni relative a un'entità (solitamente l'utente) e dati aggiuntivi.
- Signature: serve a verificare che il token non sia stato manomesso. Viene creata codificando l'header e il payload con una chiave segreta.
Generazione e verifica dei JWT in Rust
Vediamo come generare e verificare un JWT usando il crate jsonwebtoken in Rust. Ricordi che dovrà aggiungere jsonwebtoken, serde (con la funzionalità "derive") e chrono (con la funzionalità "serde") al file Cargo.toml.
Questo esempio genera un token e lo verifica subito dopo.
use jsonwebtoken::{encode, decode, Header, EncodingKey, DecodingKey, Validation};
use serde::{Deserialize, Serialize};
use chrono::{Utc, Duration};
#[derive(Debug, Serialize, Deserialize)]
struct Claims {
sub: String, // Subject (user ID)
company: String,
exp: usize, // Expiration time
}
fn main() {
// --- Setup (requires crates: jsonwebtoken, serde, chrono) ---
let secret_key = "my_super_secret_key";
// --- 1. Generate a JWT ---
let my_claims = Claims {
sub: "user123".to_string(),
company: "CoddyKit".to_string(),
exp: (Utc::now() + Duration::minutes(10)).timestamp() as usize,
};
let token = encode(
&Header::default(),
&my_claims,
&EncodingKey::from_secret(secret_key.as_ref()),
).expect("Failed to encode token");
println!("Generated JWT:\n{}", token);
println!("\n--- Verifying the Token ---");
// --- 2. Verify the JWT ---
let validation = Validation::default();
let decoded_result = decode::<Claims>(
&token,
&DecodingKey::from_secret(secret_key.as_ref()),
&validation,
);
match decoded_result {
Ok(token_data) => {
println!("Token valid!");
println!("Subject: {}", token_data.claims.sub);
println!("Company: {}", token_data.claims.company);
},
Err(err) => println!("Token invalid: {:?}", err),
}
}Autorizzazione: definizione dell'accesso
Una volta autenticato un utente (sappiamo chi è), l'autorizzazione determina a quali risorse o azioni può accedere.
I modelli di autorizzazione più comuni includono:
- Role-Based Access Control (RBAC): agli utenti vengono assegnati ruoli (ad esempio, "admin", "editor", "viewer") e ogni ruolo dispone di autorizzazioni specifiche.
- Attribute-Based Access Control (ABAC): l'accesso viene concesso in base agli attributi dell'utente, della risorsa o dell'ambiente.
Il concetto di middleware per l'autorizzazione
In un servizio web, l'autorizzazione viene spesso gestita da un middleware. Si tratta di codice eseguito prima del gestore principale della route.
Il middleware:
- estrae l'identità dell'utente autenticato (ad esempio, da un JWT);
- verifica i suoi ruoli o le sue autorizzazioni rispetto all'accesso richiesto dall'endpoint richiesto;
- se l'utente è autorizzato, consente alla richiesta di proseguire; in caso contrario, restituisce un errore "Unauthorized" o "Forbidden".
In questo modo i gestori delle route rimangono puliti e concentrati sulla logica di business.
Verifica delle conoscenze
Verifichiamo rapidamente la Sua comprensione dell'autenticazione e dell'autorizzazione.
Riepilogo: protezione dei servizi web
Ottimo lavoro! In questa lezione abbiamo esaminato gli elementi essenziali per proteggere i Suoi servizi web Rust:
- La differenza tra autenticazione (chi è Lei) e autorizzazione (che cosa può fare).
- L'importanza di proteggere gli endpoint API.
- Il funzionamento dei JSON Web Token (JWT) per l'autenticazione stateless, inclusa la loro struttura.
- Un esempio pratico in Rust per generare e verificare JWT.
- I concetti di Role-Based Access Control e il modo in cui il middleware può implementare i controlli di autorizzazione.
Ora è pronto per creare applicazioni Rust più sicure e robuste!
Domande Frequenti
La lezione «Autenticazione e autorizzazione» è gratuita?
Sì — il testo completo di «Autenticazione e autorizzazione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 3 lezioni in totale.
Cosa imparerò in «Autenticazione e autorizzazione»?
Implementi meccanismi sicuri di autenticazione degli utenti (ad esempio JWT) e di autorizzazione per proteggere gli endpoint del Suo servizio web. Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn Rust Coding?
Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 3.
Quanto tempo richiede la lezione «Autenticazione e autorizzazione»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?
Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- API REST con Actix-web/Rocket
- Integrazione con i database (SQLx/Diesel)
- Autenticazione e autorizzazione