0Pricing
Learn Rust Coding · Pelajaran

API REST dengan Actix-web/Rocket

Kembangkan API bergaya REST menggunakan kerangka kerja web Rust modern seperti Actix-web atau Rocket, dengan menangani rute, permintaan, dan respons.

API REST dengan Actix-web/Rocket adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 1 dari 3. 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 3 pelajaran total.

Apa Itu API REST?

REST, atau REpresentational State Transfer, adalah gaya arsitektur untuk aplikasi berjaringan. REST mendefinisikan sekumpulan prinsip tentang cara layanan web berkomunikasi.

Anggaplah REST sebagai sekumpulan panduan untuk membangun layanan web yang tidak menyimpan status, dapat menggunakan cache, dan memakai metode HTTP standar untuk berinteraksi dengan sumber daya.

  • Sumber daya: Segala sesuatu yang dapat diberi nama, seperti pengguna, produk, atau pesanan.
  • URI: Pengenal unik untuk sumber daya (misalnya, /users/123).
  • Metode HTTP: Tindakan standar yang dilakukan pada sumber daya (GET, POST, PUT, DELETE).

Mengapa Menggunakan Rust untuk Layanan Web?

Rust memberikan keunggulan unik dalam pengembangan layanan web, sehingga menjadi pilihan yang kuat untuk API berkinerja tinggi dan andal:

  • Kinerja: Abstraksi tanpa biaya Rust menghasilkan kode yang sangat efisien, sering kali sebanding dengan C/C++.
  • Keamanan Memori: Sistem kepemilikan mencegah bug umum seperti dereferensi penunjuk null dan kondisi balapan data, sehingga menghasilkan layanan yang lebih tangguh.
  • Konkurensi: Model async/await Rust, dipadukan dengan jaminan keamanannya, memudahkan pembangunan layanan web konkuren tanpa rasa khawatir.
  • Keandalan: Sistem tipe yang kuat dan pemeriksaan pada waktu kompilasi mendeteksi banyak kesalahan sejak dini.

Berkenalan dengan Actix-web

Untuk membangun layanan web dalam Rust, kita sering menggunakan kerangka kerja. Actix-web adalah kerangka kerja web Rust yang andal, pragmatis, dan sangat cepat.

Actix-web dibangun di atas Actix, yaitu kerangka kerja berbasis aktor, tetapi Anda tidak perlu memahami aktor untuk menggunakan Actix-web secara efektif. Actix-web dirancang untuk operasi asinkron, sehingga ideal untuk tugas yang terikat I/O seperti menangani banyak permintaan API secara bersamaan.

Actix-web menyediakan alat untuk perutean, penanganan permintaan/respons, middleware, dan masih banyak lagi, sehingga menyederhanakan pembuatan API yang kompleks.

Penyiapan Proyek & Dependensi

Untuk memulai, kita akan membuat proyek Rust baru dan menambahkan dependensi yang diperlukan. Kita akan menggunakan actix-web sebagai kerangka kerja dan serde untuk melakukan serialisasi/deserialisasi data JSON.

Pertama, buat proyek baru:

cargo new my_rest_api --bin

Kemudian, tambahkan baris-baris berikut ke file Cargo.toml Anda di bawah bagian [dependencies]:

[dependencies]
actix-web = "4"
serde = { version = "1.0", features = ["derive"] }

Server Actix-web Pertama Anda

Mari kita tulis server Actix-web minimal. Kode ini menyiapkan struktur dasar untuk mendengarkan permintaan HTTP masuk pada porta 8080. Kode ini belum menangani rute tertentu, tetapi menjadi fondasinya.

Makro #[actix_web::main] membuat async fn main kita kompatibel dengan waktu proses Actix-web.

use actix_web::{App, HttpServer};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        // Our application instance, where we'll add routes
        App::new()
    })
    .bind(("127.0.0.1", 8080))? // Bind to an IP address and port
    .run() // Start the server
    .await // Await its completion
}

Mendefinisikan Rute GET

Sekarang, mari tambahkan rute sederhana ke server kita. Sebuah rute memetakan jalur dan metode permintaan HTTP masuk (seperti GET /hello) ke fungsi penangan tertentu.

Fungsi penangan kita, hello_world, hanya akan mengembalikan sebuah string. web::get().to() mendaftarkan penangan ini untuk permintaan GET ke jalur /hello.

use actix_web::{web, App, HttpServer, Responder};

// A handler function that returns a simple string response
async fn hello_world() -> impl Responder {
    "Hello, Actix-web!"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // Register our route: GET /hello maps to hello_world()
            .route("/hello", web::get().to(hello_world))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Parameter Jalur untuk Rute Dinamis

API sering kali perlu menangani bagian dinamis dalam URL, seperti ID atau nama. Actix-web menggunakan parameter jalur untuk menangkap nilai-nilai tersebut.

Kita mendefinisikan tempat penampung dalam rute (misalnya, /{name}). Dalam penangan, kita menggunakan web::Path<String> (atau tipe lain yang dapat dideserialisasi) untuk mengambil nilainya.

use actix_web::{web, App, HttpServer, Responder};

// Handler function with a path parameter 'name'
async fn greet_name(name: web::Path<String>) -> impl Responder {
    format!("Hello, {}!", name.into_inner())
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // Route with a dynamic path segment for a name
            .route("/greet/{name}", web::get().to(greet_name))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Menangani Permintaan POST & JSON

Untuk membuat atau memperbarui sumber daya, kita menggunakan permintaan POST atau PUT, yang sering kali mengirimkan data dalam isi permintaan sebagai JSON.

Actix-web memudahkan penanganan JSON dengan web::Json<T>. Kita mendefinisikan struct Rust yang sesuai dengan struktur JSON yang diharapkan, menerapkan Deserialize dari serde, lalu Actix-web secara otomatis mengurai JSON masuk ke dalam struct kita.

use actix_web::{web, App, HttpServer, Responder};
use serde::{Deserialize, Serialize};

// Define a struct to represent our incoming JSON data
#[derive(Deserialize, Serialize)]
struct User {
    username: String,
    email: String,
}

// Handler for POST requests that accepts a JSON User object
async fn create_user(user: web::Json<User>) -> impl Responder {
    // In a real app, you'd save this user to a database
    format!("User created: {} ({})", user.username, user.email)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // POST /users expects a JSON body and maps to create_user()
            .route("/users", web::post().to(create_user))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Membangun API Sederhana dengan Status

Mari gabungkan hal-hal yang telah kita pelajari untuk membangun API kecil yang mengelola daftar pengguna di memori. Kita akan menggunakan web::Data untuk membagikan status khusus aplikasi (daftar pengguna kita) ke seluruh penangan.

std::sync::Mutex digunakan untuk memungkinkan akses yang dapat diubah secara aman ke Vec<User> dari beberapa permintaan konkuren. Kita akan memiliki titik akhir GET /users dan POST /users.

use actix_web::{web, App, HttpServer, Responder, HttpResponse};
use serde::{Deserialize, Serialize};
use std::sync::Mutex; // For shared mutable state

// Define a User struct that can be serialized/deserialized and cloned
#[derive(Deserialize, Serialize, Clone)]
struct User {
    id: u32,
    username: String,
    email: String,
}

// Application state to hold our users and track next ID
struct AppState {
    users: Mutex<Vec<User>>,
    next_id: Mutex<u32>,
}

// Handler to get all users
async fn get_users(data: web::Data<AppState>) -> impl Responder {
    let users = data.users.lock().unwrap(); // Acquire a lock
    web::Json(users.clone()) // Return users as JSON
}

// Handler to create a new user
async fn create_user(
    data: web::Data<AppState>,
    new_user: web::Json<User>,
) -> impl Responder {
    let mut users = data.users.lock().unwrap();
    let mut next_id = data.next_id.lock().unwrap();

    let user = User {
        id: *next_id,
        username: new_user.username.clone(),
        email: new_user.email.clone(),
    };
    users.push(user.clone());
    *next_id += 1; // Increment for the next user
    HttpResponse::Created().json(user) // Return 201 Created status and user
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    // Create shared application state
    let app_state = web::Data::new(AppState {
        users: Mutex::new(vec![]), // Initialize with an empty user list
        next_id: Mutex::new(1),    // Start IDs from 1
    });

    HttpServer::new(move || { // 'move' closure to capture app_state
        App::new()
            .app_data(app_state.clone()) // Register shared state with the app
            .route("/users", web::get().to(get_users))
            .route("/users", web::post().to(create_user))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Pemeriksaan Cepat Konsep API

Anda telah mempelajari cara menyiapkan server Actix-web dasar dan menangani berbagai permintaan HTTP. Mari uji pemahaman Anda!

Rangkuman & Langkah Berikutnya

Bagus! Anda telah mengambil langkah pertama dalam membangun API RESTful dengan Rust dan Actix-web.

  • Kita telah mempelajari dasar-dasar REST API dan alasan Rust sangat cocok untuknya.
  • Anda telah mempelajari cara menyiapkan proyek Actix-web dasar.
  • Kita telah membahas pendefinisian rute GET dan POST.
  • Anda telah melihat cara mengekstrak parameter jalur dan menangani muatan JSON.
  • Terakhir, Anda membangun API sederhana yang mengelola status dalam memori menggunakan web::Data.

Selanjutnya, Anda akan mempelajari lebih dalam integrasi basis data dan penanganan kesalahan yang tangguh untuk membangun layanan web yang lebih kuat dan siap produksi!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “API REST dengan Actix-web/Rocket” gratis?

Ya — teks lengkap “API REST dengan Actix-web/Rocket” 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 3 pelajaran total.

Apa yang akan aku pelajari di “API REST dengan Actix-web/Rocket”?

Kembangkan API bergaya REST menggunakan kerangka kerja web Rust modern seperti Actix-web atau Rocket, dengan menangani rute, permintaan, dan respons. 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 3.

Berapa lama pelajaran “API REST dengan Actix-web/Rocket” 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

  1. API REST dengan Actix-web/Rocket
  2. Integrasi Basis Data (SQLx/Diesel)
  3. Autentikasi dan Otorisasi
← Kembali ke Learn Rust Coding