Rust: mercato

Posizione

un'offerta aperta che ha superato il controllo di qualità e indica almeno due tecnologie

Candidato osservato

un candidato il cui stack contiene questa tecnologia; un dato aggregato: nessun singolo record esce dal perimetro

Candidato abbinabile

non ancora conteggiato

Finestra

offerte aperte nel momento in cui è stato creato lo snapshot

Le offerte Junior Rust sono QUASI ASSENTI: il mercato si aspetta esperienza di sistema in un altro linguaggio (C++/Go/Java) + un progetto personale Rust già pronto. Il salto Junior → Middle: padronanza di ownership/borrow checker + Tokio asincrono + lifetime in profondità. Il Senior è responsabile dell'architettura dei servizi Rust. Percorso di carriera: C++/Go Senior → Rust Middle in 6-12 mesi → Senior → Tech Lead in un'azienda Rust / Systems Architect.

I principali nel 5: rust, python, kubernetes, c++, linux. Rust edition 2021 (indispensabile) o 2024 (moderna). Tokio: runtime asincrono dominante (90%+ dei backend Rust). Web: Axum (moderno, nativo Tokio, in crescita 2024–2026) o Actix-web (maturo, leader delle prestazioni, ma più complesso). SQLx (asincrono + controlli SQL in compilazione: dominante moderno) o SeaORM (ORM asincrono). PostgreSQL. Redis (redis-rs). gRPC tramite tonic. Kafka tramite rdkafka. Cargo (indispensabile: sistema di build + package manager). Test: cargo test + cargo-nextest (più veloce) + cargo-tarpaulin (copertura). Crate tracing + OpenTelemetry Rust SDK. Docker + Kubernetes. La conoscenza di ownership/borrow checker + lifetime + fondamenti di async/await è indispensabile per un Senior. Profiling con cargo-flamegraph o perf.

Dove vince Rust: (1) sicurezza della memoria senza GC + astrazioni a costo zero: la combinazione migliore per ciò che è critico per prestazioni + sicurezza. (2) Strumenti di sistema (strumenti CLI, database, strumenti per il sistema operativo: Linkerd, Stalwart, SurrealDB). (3) Blockchain (Solana, Substrate, Move): nicchia premium. (4) Embedded/IoT con no_std (firmware). Go: cloud-native + k8s, compilazione più rapida, assunzioni più facili. C++: legacy, motori di gioco, HFT a prestazioni estreme (microsecondi). Rust sta sostituendo C++ nei nuovi progetti di sistema. Strategia: prima Go per una carriera cloud-native (dimensione del mercato), poi Rust per la nicchia premium. C++ → Rust: un passaggio naturale (~3-6 mesi).

Axum: framework moderno nativo di Tokio (dai maintainer di tokio-rs), domina nel 2024–2026. Middleware basati su Tower, ottima type safety tramite gli extractor, integra l'intero ecosistema Tokio. Tendenza in crescita. Actix-web: leader delle prestazioni nei benchmark (TechEmpower), ecosistema maturo dal 2017. Influenza del modello ad attori. Complessità maggiore dovuta agli attori. Rocket: dichiarativo in stile Spring. Svantaggi: non nativo di Tokio (runtime proprio), adozione più lenta. Strategia: prima Axum (moderno + dominante su Tokio nel 2024–2026), Actix-web per il legacy + i casi critici per le prestazioni, Rocket solo se lo stile dichiarativo fa per te.

Sì, il 57% delle offerte Rust è completamente da remoto o ibrido. La community Rust è molto favorevole al remoto. JetBrains SPb (RustRover): per lo più in sede. Aziende Rust internazionali: completamente da remoto: Cloudflare, Discord, 1Password, Figma, Linkerd, team Rust di AWS, Vercel. Hub per chi si trasferisce: Berlino, Amsterdam, Zurigo (UE favorevole a Rust), Dubai, Lisbona, Serbia. Inglese: indispensabile per il lavoro internazionale da remoto con un premio +30-50% (enorme mercato Rust da remoto negli USA + UE).

Rust Backend: sviluppo lato server: API REST/gRPC, logica di business, DB, I/O asincrono. Stack: Tokio + Axum + SQLx + PostgreSQL. Rust Blockchain: smart contract su Solana (framework Anchor), catene basate su Substrate (Polkadot, Kusama). Paradigma diverso: esecuzione deterministica, ottimizzazione del gas, mentalità orientata alla sicurezza. Vedi /research/blockchain. Rust Embedded: IoT/firmware in no_std (senza la libreria standard), microcontrollori. Stack: embedded-hal + framework RTIC. Nicchia, carriera a parte. Passaggio da Rust Backend a Blockchain in 6-12 mesi. Da Rust Backend a Embedded serve riapprendere la mentalità di sistema (nessuna allocazione sullo heap).

Si presuppone esperienza Backend Middle+ (Go/Java/C++/Python). Roadmap: 1) Sintassi di Rust: «The Rust Programming Language» (il libro ufficiale di Rust, gratuito), «Programming Rust» di Blandy/Orendorff. 2) Ownership + borrow checker + lifetime: la parte più difficile, richiederà 2-3 mesi di pratica. «Rust by Example», esercizi Rustlings. 3) Rust asincrono: «Asynchronous Programming in Rust» + Tokio Tutorial. 4) Cargo + gestione dei pacchetti. 5) SQLx: accesso asincrono al DB + controlli SQL in fase di compilazione. 6) Axum: tutorial ufficiale + un progetto personale (REST API con autenticazione + SQLx + PostgreSQL + Docker). 7) gRPC tramite tonic. 8) tracing + osservabilità. 9) Progetto personale end-to-end: Axum REST API + SQLx + PostgreSQL + Redis + producer Kafka + Docker + GitHub Actions. Corsi: Karpov.Courses, OTUS «Rust Developer», Rust Bootcamp (Letsgetrusty su YouTube: il migliore gratuito), Zero to Production in Rust (Pollak): un libro da leggere assolutamente. Backend Middle (Go/Java/C++) → Rust Middle: 6-12 mesi, per via del cambio di mentalità cruciale legato all'ownership.

109 active open Rust Backend positions — niche, but the fastest-growing segment. Geography: the US, Germany, the UK. Sources: hh.ru, Habr Career, getmatch, Djinni, LinkedIn (huge international Rust segment), Telegram, This Week in Rust newsletter, filtra.io Rust jobs, Reddit r/rust, JetBrains.com/Careers. The real market is broader than the sample thanks to huge international remote (Cloudflare/Discord/AWS). Time to close a Senior Rust role — 6-12 weeks (longer than Go due to specificity).

Un Senior Rust Backend gestisce l'intero ciclo + una mentalità da programmazione di sistema. Rust core: padronanza di ownership/borrow checker, lifetime (incluse le HRTB), trait avanzati (associated types, trait object vs generics, sealed trait), unsafe Rust + regole UCG, pattern di gestione degli errori (thiserror/anyhow/snafu). Async Rust: funzionamento interno di Tokio a fondo (modello dell'executor, scheduler work-stealing), pin/unpin per le future autoreferenziali, trait AsyncRead/AsyncWrite, cancellation safety. Architettura: servizi su Axum + middleware tower, microservizi gRPC tramite tonic, event sourcing tramite Kafka. Prestazioni: profiling tramite cargo-flamegraph/perf, hot path senza allocazioni, fairness asincrona. PostgreSQL: SQL avanzato, controlli in fase di compilazione con SQLx, tuning del connection pool. Cargo: workspace, build script personalizzati, compilazione condizionale tramite feature. Test: cargo-nextest, property-based tramite proptest. DevOps: build Docker multi-stage (i binari Rust spesso pesano 5-20MB), basi di Kubernetes. Soft skill: revisione del codice, mentoring (la curva di apprendimento di Rust è ripida). Inglese OBBLIGATORIO per Senior+: la community di Rust è prevalentemente anglofona.