Lär dig programmera i Rust · Lektion

Projektkonfiguration

Strukturera API:t

Lektion 1 av 413 steg

Projektkonfiguration är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär dig programmera i Rust, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.

Bygga ett REST API i Rust

I den här kursen bygger Ni ett litet REST API i Rust. Vi använder webbframeworket Axum, som bygger på Tokio (asynkron runtime) och Tower (middleware). Det är ergonomiskt, typsäkert och används brett i produktion.

I den här första lektionen skapar Ni projektstrukturen, så att senare lektioner kan lägga till routes, modeller, en databas och tester.

Skapa projektet

Börja med Cargo. Ett binärt projekt ger Er en startpunkt i src/main.rs:

cargo new rest_api skapar mappen.
cd rest_api går till mappen.
cargo run bygger och kör projektet.

Det här är shell- och cargo-kommandon, inte körbara Rust-kodexempel.

// terminal
// cargo new rest_api
// cd rest_api
// cargo run

Lägga till beroenden

Ett Axum-API behöver några crates i Cargo.toml:

axum för routing och handlers.
tokio för den asynkrona runtime-miljön.
serde för JSON-serialisering.

// Cargo.toml
// [dependencies]
// axum = "0.7"
// tokio = { version = "1", features = ["full"] }
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"

Den asynkrona runtime-miljön

Webbservrar hanterar många anslutningar samtidigt, så Axum är asynkront. Attributet #[tokio::main] gör en asynkron main till en riktig startpunkt genom att starta Tokio-runtime-miljön. Alla handlers kan använda .await för icke-blockerande I/O.

// src/main.rs
use tokio;

#[tokio::main]
async fn main() {
    println!("runtime started");
}

En minimal server

Den minsta Axum-appen bygger en Router, binder en TCP-lyssnare och börjar hantera anrop. En enda route mappar GET / till en handler som returnerar en sträng. Handlers är helt enkelt asynkrona funktioner som returnerar något som implementerar IntoResponse.

use axum::{routing::get, Router};

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(root));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

async fn root() -> &'static str {
    "Hello, API!"
}

Så fungerar routing

En Router mappar en sökväg och en HTTP-metod till en handler. Kedja anrop till .route(path, method(handler)) för att registrera endpoints. Metodhjälpare som get, post, put och delete kommer från axum::routing. Ni kan kombinera metoder på samma sökväg.

use axum::{routing::{get, post}, Router};

async fn list() -> &'static str { "list" }
async fn create() -> &'static str { "created" }

fn build_router() -> Router {
    Router::new()
        .route("/items", get(list).post(create))
        .route("/health", get(|| async { "ok" }))
}

Rekommenderad modulstruktur

När API:t växer bör Ni dela upp koden i moduler i stället för att ha allt i en enda stor main.rs:

main.rs — uppstart och serverkonfiguration.
routes.rs — definition av routern.
handlers.rs — requesthandlers.
models.rs — datastrukturer.

Den här uppdelningen håller varje fil fokuserad och testbar.

// src/main.rs
mod routes;
mod handlers;
mod models;

#[tokio::main]
async fn main() {
    let app = routes::build();
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Delat applikationstillstånd

De flesta API:er behöver delat tillstånd, till exempel en databaspool eller ett lager i minnet. Axum lagrar det med .with_state(state) på routern. Handlers tar emot det via extractorn State. Tillståndet måste vara Clone; omslut muterbara data med Arc och ett lås.

use axum::{routing::get, Router, extract::State};
use std::sync::{Arc, Mutex};

type Db = Arc<Mutex<Vec<String>>>;

async fn count(State(db): State<Db>) -> String {
    let n = db.lock().unwrap().len();
    format!("{} items", n)
}

fn build(db: Db) -> Router {
    Router::new().route("/count", get(count)).with_state(db)
}

Returnera JSON

För att skicka JSON omsluter Ni ett serialiserbart värde med axum::Json. När Ni härleder Serialize med serde på Era structs anger Axum automatiskt rätt innehållstyp och body.

use axum::Json;
use serde::Serialize;

#[derive(Serialize)]
struct Status {
    service: String,
    healthy: bool,
}

async fn health() -> Json<Status> {
    Json(Status { service: "api".into(), healthy: true })
}

Konfiguration och portar

Det går bra att hårdkoda porten i demonstrationer, men riktiga tjänster läser konfiguration från miljön. Använd std::env::var med ett standardvärde. Då kan Ni ändra bindningsadressen utan att kompilera om, och tjänsten fungerar smidigt i containrar.

use std::env;

async fn main_inner() {
    let port = env::var("PORT").unwrap_or_else(|_| "3000".to_string());
    let addr = format!("0.0.0.0:{}", port);
    println!("binding to {}", addr);
    // bind and serve with addr ...
}

Sätta ihop konfigurationen

En komplett uppstart kopplar ihop allt: bygg routern med routes och delat tillstånd, läs porten, bind en lyssnare och börja hantera anrop. Med detta skelett på plats kan nästa lektioner lägga till riktiga endpoints, modeller och beständig lagring.

use axum::{routing::get, Router};
use std::sync::{Arc, Mutex};

#[tokio::main]
async fn main() {
    let db = Arc::new(Mutex::new(Vec::<String>::new()));
    let app = Router::new()
        .route("/health", get(|| async { "ok" }))
        .with_state(db);
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Snabb kontroll

Testa Er förståelse av projektets konfiguration.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har konfigurerat ett Rust REST API-projekt:

Använd cargo new och lägg till axum, tokio och serde.
#[tokio::main] tillhandahåller den asynkrona runtime-miljön.
En Router mappar sökvägar och metoder till asynkrona handlers.
Dela data med .with_state och extractorn State.
Dela upp koden i moduler för routes, handlers och modeller, och läs porten från miljön.

Gratis att börja

Lär dig Rust med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 39
Lektioner: 144

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Projektkonfiguration” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Projektkonfiguration”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.

Vad lär jag mig i ”Projektkonfiguration”?

Strukturera API:t Ni övar på Lär dig programmera i Rust med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lär dig programmera i Rust?

Du behöver inga förkunskaper. Utbildningen i Lär dig programmera i Rust på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Projektkonfiguration”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lär dig programmera i Rust-lektionen?

Ja. Varje Lär dig programmera i Rust-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lär dig programmera i Rust