Learn Rust Coding · Pelajaran

Penyiapan Proyek

Menata API

Penyiapan Proyek adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Membangun REST API dengan Rust

Dalam kursus ini, Anda akan membangun REST API kecil dengan Rust. Kami menggunakan framework web Axum, yang dibangun di atas Tokio (runtime asinkron) dan Tower (middleware). Framework ini ergonomis, aman terhadap tipe, dan banyak digunakan dalam produksi.

Pelajaran pertama ini menyiapkan struktur proyek agar pelajaran berikutnya dapat menambahkan route, model, basis data, dan pengujian.

Membuat Proyek

Mulailah dengan Cargo. Proyek biner menyediakan titik masuk src/main.rs:

cargo new rest_api membuat folder.
cd rest_api berpindah ke folder tersebut.
cargo run membangun dan menjalankan proyek.

Semua ini adalah perintah shell dan cargo, bukan potongan kode Rust yang dapat dijalankan.

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

Menambahkan Dependensi

API Axum memerlukan beberapa crate dalam Cargo.toml:

axum untuk routing dan handler.
tokio untuk runtime asinkron.
serde untuk serialisasi JSON.

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

Runtime Asinkron

Server web menangani banyak koneksi secara bersamaan, sehingga Axum bersifat asinkron. Atribut #[tokio::main] mengubah main asinkron menjadi titik masuk nyata dengan memulai runtime Tokio. Setiap handler dapat menggunakan .await untuk I/O tanpa pemblokiran.

// src/main.rs
use tokio;

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

Server Minimal

Aplikasi Axum terkecil membuat Router, mengikat listener TCP, lalu melayani permintaan. Satu route memetakan GET / ke handler yang mengembalikan string. Handler hanyalah fungsi asinkron yang mengembalikan sesuatu yang mengimplementasikan 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!"
}

Cara Kerja Routing

Router memetakan path dan metode HTTP ke sebuah handler. Rangkai pemanggilan .route(path, method(handler)) untuk mendaftarkan endpoint. Helper metode seperti get, post, put, dan delete berasal dari axum::routing. Anda dapat menggabungkan beberapa metode pada path yang sama.

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" }))
}

Susunan Modul yang Disarankan

Saat API berkembang, pisahkan kode ke dalam beberapa modul alih-alih menaruh semuanya dalam satu main.rs besar:

main.rs — inisialisasi dan pengaitan server.
routes.rs — definisi router.
handlers.rs — handler permintaan.
models.rs — struktur data.

Pemisahan ini membuat setiap file tetap fokus dan mudah diuji.

// 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();
}

State Aplikasi Bersama

Sebagian besar API memerlukan state bersama, seperti pool basis data atau penyimpanan dalam memori. Axum menyimpannya dengan .with_state(state) pada router. Handler menerimanya melalui extractor State. State harus berupa Clone; bungkus data yang dapat diubah dengan Arc dan lock.

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)
}

Mengembalikan JSON

Untuk mengirim JSON, bungkus nilai yang dapat diserialisasi dengan axum::Json. Jika serde digunakan untuk menurunkan Serialize pada struct Anda, Axum secara otomatis menetapkan tipe konten dan body yang benar.

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 })
}

Konfigurasi dan Port

Menetapkan port secara langsung tidak masalah untuk demo, tetapi layanan nyata membaca konfigurasi dari lingkungan. Gunakan std::env::var dengan nilai bawaan. Dengan begitu, Anda dapat mengubah alamat bind tanpa mengompilasi ulang dan tetap mudah digunakan bersama container.

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 ...
}

Menggabungkan Penyiapan

Inisialisasi lengkap menghubungkan semuanya: buat router dengan route dan state bersama, baca port, ikat listener, lalu layani permintaan. Dengan kerangka ini, pelajaran berikutnya dapat menambahkan endpoint, model, dan persistensi nyata.

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();
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang penyiapan proyek.

Ringkasan

Anda telah menyiapkan proyek REST API Rust:

Gunakan cargo new dan tambahkan axum, tokio, serta serde.
#[tokio::main] menyediakan runtime asinkron.
Router memetakan path dan metode ke handler asinkron.
Bagikan data dengan .with_state dan extractor State.
Pisahkan kode ke dalam modul route, handler, dan model; baca port dari lingkungan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Penyiapan Proyek” gratis?

Ya — teks lengkap “Penyiapan Proyek” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Penyiapan Proyek”?

Menata API Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Penyiapan Proyek” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Learn Rust Coding