![Example: axum
#[tokio::main]
async fn main() {
let app = Router::new()
.route("/", get(root));
let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
axum::Server::bind(&addr)
.serve(app.into_make_service())
.await
.unwrap();
}
async fn root() -> &'static str {
"Hello, World!"
}](https://image.slidesharecdn.com/melbournerustwebdevelopment-240618121604-1d7b6b1f/85/Rust-Melbourne-MeetUp-Rust-Web-Development-16-320.jpg)
![Example: axum
#[tokio::main]
async fn main() {
let app = Router::new()
.route("/", get(root));
let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
axum::Server::bind(&addr)
.serve(app.into_make_service())
.await
.unwrap();
}
async fn root() -> &'static str {
"Hello, World!"
}
Async runtime: tokio](https://image.slidesharecdn.com/melbournerustwebdevelopment-240618121604-1d7b6b1f/85/Rust-Melbourne-MeetUp-Rust-Web-Development-17-320.jpg)
![Example: axum
#[tokio::main]
async fn main() {
let app = Router::new()
.route("/", get(root));
let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
axum::Server::bind(&addr)
.serve(app.into_make_service())
.await
.unwrap();
}
async fn root() -> &'static str {
"Hello, World!"
}
Async runtime: tokio
async/await](https://image.slidesharecdn.com/melbournerustwebdevelopment-240618121604-1d7b6b1f/85/Rust-Melbourne-MeetUp-Rust-Web-Development-18-320.jpg)
![Example: axum
#[tokio::main]
async fn main() {
let app = Router::new()
.route("/", get(root));
let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
axum::Server::bind(&addr)
.serve(app.into_make_service())
.await
.unwrap();
}
async fn root() -> &'static str {
"Hello, World!"
}
Async runtime: tokio
async/await
Web framework: axum](https://image.slidesharecdn.com/melbournerustwebdevelopment-240618121604-1d7b6b1f/85/Rust-Melbourne-MeetUp-Rust-Web-Development-19-320.jpg)
![Example: axum
#[tokio::main]
async fn main() {
let app = Router::new()
.route("/", get(root));
let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
axum::Server::bind(&addr)
.serve(app.into_make_service())
.await
.unwrap();
}
async fn root() -> &'static str {
"Hello, World!"
}
Async runtime: tokio
async/await
Web framework: axum
HTTP server: hyper](https://image.slidesharecdn.com/melbournerustwebdevelopment-240618121604-1d7b6b1f/85/Rust-Melbourne-MeetUp-Rust-Web-Development-20-320.jpg)
![No runtime overhead
Thread-safe async
pub fn main() {
let (tx, rx) = channel();
let x = Arc::new(RwLock::new(tx));
std::thread::spawn(move || {
x.read().unwrap().send(4u8).unwrap();
});
dbg!(rx.recv().unwrap());
}
error[E0277]: `Sender<u8>` cannot be shared between threads safely
--> src/main.rs:8:5
|
8 | std::thread::spawn(move || {
| ^^^^^^^^^^^^^^^^^^ `Sender<u8>` cannot be shared between threads safely
|
= help: the trait `Sync` is not implemented for `Sender<u8>`
= note: required because of the requirements on the impl of `Sync` for
`RwLock<Sender<u8>>`
= note: required because of the requirements on the impl of `Send` for
`Arc<RwLock<Sender<u8>>>`
= note: required because it appears within the type `[closure@src/main.rs:8:24:
10:6]`](https://image.slidesharecdn.com/melbournerustwebdevelopment-240618121604-1d7b6b1f/85/Rust-Melbourne-MeetUp-Rust-Web-Development-23-320.jpg)
Rust Melbourne MeetUp - Rust Web Development
- 1. The Joy and Adventures of writing Rust for the web Rust Web Development
- 2. $ whoami ★ Bastian Gruber ★ Software Engineer for ~ 15 years ★ Author of “Rust Web Development” (Manning) ★ Professional Rust experience ~3 years ★ Currently: Working on distributed Peer-to-Peer Systems in Rust ★ rustwebdevelopment.com ★ Mastodon: https://hachyderm.io/@bastian ★ Twitter: @recvonline
- 3. $ date ★ Todays talk: Rust Web Development ★ Why Rust in web development ★ How to get started ★ What to bring with you ★ Advantages ★ Things to consider
- 4. The slide for your CTO - Why Rust for your microservice/API ➔ Thread-safe concurrency ➔ No memory-leaks* ➔ Saving $$$ on AWS ➔ Used by AWS, Microsoft, Google and others ➔ Excellent free learning resources ➔ Compiler enforces high standards and correctness
- 5. But why you actually want to write it in Rust ➔ The compiler is your pair-programmer who teaches you ➔ Excellent resources to learn and grow from ➔ Code standards are easily enforced through built-in tooling ➔ Documentation and testing is built-in ➔ High-standard third-party packages (crates) ➔ Compiles to a binary ➔ Freaking good type system :)
- 6. Rust 🧡 Web …or does it?
- 7. Rust 🧡 Web …or does it?
- 8. Rust 🧡 Web …or does it?
- 9. Rust 🧡 Web …or does it?
- 10. Rust 🧡 Web …or does it?
- 11. Rust 🧡 Web …or does it? ● Rust wants to be a systems programming languages ● Least amount of overhead ● So it decided against: ○ Adding a runtime to execute asynchronous code ○ Implement HTTP ○ Add a HTTP server to the library ● besides others…
- 12. Rust 🧡 Web …or does it? BUT, It brings the baseline to ● create TCP/UDP sockets ● write asynchronous code TCP/UDP + async/await + Future trait
- 13. What do you need for asynchronous programming?
- 14. TCP behind the scenes use std::net::TcpListener; fn main() { let listener = TcpListener::bind("127.0.0.1:8080").unwrap(); for stream in listener.incoming() { let stream = stream.unwrap(); println!("stream accepted {:?}", stream); } (longer version over here)
- 15. That’s all hidden behind a framework, though
- 16. Example: axum #[tokio::main] async fn main() { let app = Router::new() .route("/", get(root)); let addr = SocketAddr::from(([127, 0, 0, 1], 3000)); axum::Server::bind(&addr) .serve(app.into_make_service()) .await .unwrap(); } async fn root() -> &'static str { "Hello, World!" }
- 17. Example: axum #[tokio::main] async fn main() { let app = Router::new() .route("/", get(root)); let addr = SocketAddr::from(([127, 0, 0, 1], 3000)); axum::Server::bind(&addr) .serve(app.into_make_service()) .await .unwrap(); } async fn root() -> &'static str { "Hello, World!" } Async runtime: tokio
- 18. Example: axum #[tokio::main] async fn main() { let app = Router::new() .route("/", get(root)); let addr = SocketAddr::from(([127, 0, 0, 1], 3000)); axum::Server::bind(&addr) .serve(app.into_make_service()) .await .unwrap(); } async fn root() -> &'static str { "Hello, World!" } Async runtime: tokio async/await
- 19. Example: axum #[tokio::main] async fn main() { let app = Router::new() .route("/", get(root)); let addr = SocketAddr::from(([127, 0, 0, 1], 3000)); axum::Server::bind(&addr) .serve(app.into_make_service()) .await .unwrap(); } async fn root() -> &'static str { "Hello, World!" } Async runtime: tokio async/await Web framework: axum
- 20. Example: axum #[tokio::main] async fn main() { let app = Router::new() .route("/", get(root)); let addr = SocketAddr::from(([127, 0, 0, 1], 3000)); axum::Server::bind(&addr) .serve(app.into_make_service()) .await .unwrap(); } async fn root() -> &'static str { "Hello, World!" } Async runtime: tokio async/await Web framework: axum HTTP server: hyper
- 21. So, why then Rust and not NodeJS, Go?
- 23. No runtime overhead Thread-safe async pub fn main() { let (tx, rx) = channel(); let x = Arc::new(RwLock::new(tx)); std::thread::spawn(move || { x.read().unwrap().send(4u8).unwrap(); }); dbg!(rx.recv().unwrap()); } error[E0277]: `Sender<u8>` cannot be shared between threads safely --> src/main.rs:8:5 | 8 | std::thread::spawn(move || { | ^^^^^^^^^^^^^^^^^^ `Sender<u8>` cannot be shared between threads safely | = help: the trait `Sync` is not implemented for `Sender<u8>` = note: required because of the requirements on the impl of `Sync` for `RwLock<Sender<u8>>` = note: required because of the requirements on the impl of `Send` for `Arc<RwLock<Sender<u8>>>` = note: required because it appears within the type `[closure@src/main.rs:8:24: 10:6]`
- 24. No runtime overhead Thread-safe async Rust compiler
- 25. No runtime overhead Thread-safe async Rust compiler Standardised tooling
- 26. And so much more… ● gRPC: tonic ● Peer-to-Peer: libp2p-rs ● Websockets: tokio-tungstenite ● In-Browser: WASM ● HTTP requests: reqwest ● Parsing JSON (besides others): serde
- 27. Example: Simple API with background task Live coding example…
- 28. Are there any downsides? ➔ Getting started with Rust takes longer ➔ Prototyping slower (strict compiler) ➔ You don’t want to go back to your previous language…
- 29. How to get started?
- 30. How to get started?
- 31. How to get started? ❖ Build something you like and use ➢ CLI ➢ Little helper web service ❖ Do the tokio tutorial ❖ Rust exercism ❖ Advanced reading
- 32. One more thing… ➢ Help creating types out of 3rd party APIs: Transform tools ➢ Use clippy to tidy up your code: cargo clippy -- -W clippy::pedantic ➢ Use cargo format rules to tidy up imports etc: Example .toml file ➢ Create documentation as part of your CI (GitHub example snippet): name: Build Documentation id: build_docs uses: actions-rs/cargo@v1 with: command: doc args: --all --no-deps