Bagaimana Cara Menerapkan Aplikasi Rust?

How to Deploy an Rust Application_
How to Deploy an Rust Application_

Rust telah menjadi bahasa yang paling dikagumi dalam survei pengembang StackOverflow selama lebih dari 4 tahun karena berbagai fitur yang ditawarkannya kepada para pengguna.

Mozilla menciptakan Rust agar dapat diandalkan, berkinerja baik, dan ramah pengembang. Rust memiliki sintaks yang mirip dengan bahasa seperti C++ dan C yang merupakan target utama para pengembang.

Rust juga berfokus pada keamanan memori dan konkurensi dengan model yang menghindari jebakan terkait yang dihadapi pengembang yang menggunakan bahasa lain.

Anda akan belajar cara membuat API di Rust untuk memanfaatkan manfaat dari artikel ini. Anda akan belajar dengan membuat, mengkontainerisasi, dan menggunakan aplikasi Rust di layanan kontainerisasi gratis Back4app.

Keuntungan Menggunakan Rust

Ada banyak keuntungan yang bisa Anda dapatkan dari penggunaan Rust dalam proyek Anda. Berikut ini beberapa di antaranya yang penting:

Abstraksi Tanpa Biaya

Rust menyediakan abstraksi tingkat tinggi tanpa membebankan biaya runtime tambahan. Hal ini menunjukkan bahwa abstraksi yang Anda gunakan dalam kode Anda (fungsi, iterator, atau generik) tidak membuat program Anda menjadi lebih lambat.

Kompiler Rust mengoptimalkan abstraksi untuk kode tingkat rendah yang dikompilasi secara manual. Rust menjembatani kesenjangan antara kontrol ekspresif, tingkat rendah, dan halus atas kinerja.

Pendekatan Konkurensi Tanpa Rasa Takut untuk Keamanan Memori dalam Program Bersamaan

Rust mengambil “pendekatan tanpa rasa takut” terhadap konkurensi yang ditandai dengan keamanan dan efisiensi. Model konkurensi Rust memanfaatkan model kepemilikan dan pengecekan tipe untuk mencegah perlombaan data pada waktu kompilasi.

Fitur ini memungkinkan Anda untuk menulis aplikasi multi-threaded tanpa kekurangan konkurensi state bersama, seperti deadlock dan race condition.

Sistem Tipe Lanjutan dan Model Kepemilikan

Sistem tipe Rust dan aturan kepemilikannya adalah fitur unik yang membantu menegakkan keamanan memori.

Model kepemilikan menggunakan pemeriksa peminjam untuk memastikan bahwa setiap bagian dari data memiliki satu pemilik dan mengelola siklus hidupnya untuk mencegah masalah seperti pointer yang menggantung dan kebocoran memori.

Kompatibilitas dan Integrasi Lintas Platform

Rust adalah pilihan tepat jika Anda ingin membangun aplikasi lintas platform. Anda bisa menulis kode sekali dan mengompilasinya di berbagai platform tanpa perubahan signifikan pada basis kode yang ada.

Rust terintegrasi dengan baik dengan bahasa pemrograman lain, terutama C, membuat bahasa ini cocok untuk perakitan web dan tugas-tugas sistem tertanam.

Keterbatasan Penggunaan Rust

Anda pasti akan menemui beberapa kendala saat membangun aplikasi tingkat produksi dengan Rust.

Beberapa di antaranya adalah kurva pembelajaran Rust yang curam, waktu kompilasi yang lebih lama karena pemeriksaan memori dan lainnya, dan ekosistemnya yang baru dan kecil.

Ada beberapa kekurangan yang mungkin Anda temui saat membuat produk kelas produksi dengan Rust. Berikut adalah beberapa di antaranya:

Kurva Pembelajaran untuk Pemrograman Rust adalah Curam

Dibandingkan dengan bahasa populer lainnya (Go, Python, JavaScript, dll.), Dibutuhkan waktu yang cukup lama untuk menguasai Rust dan membuat aplikasi tingkat produksi dengan bahasa tersebut.

Hal ini seharusnya tidak membuat Anda menghindar dari penggunaan Rust. Dengan menguasai Rust, Anda akan menjadi sangat produktif dalam membangun dan menerapkan aplikasi, dan Anda akan mendapatkan semua manfaat dari penggunaan Rust.

Program Rust memiliki Waktu Kompilasi yang Lama

Pemeriksaan memori dan konkurensi pada waktu kompilasi, ditambah dengan beberapa faktor lain, menghasilkan waktu kompilasi yang lama untuk program Rust.

Tergantung pada ukuran aplikasi, waktu kompilasi yang lama dapat mengakibatkan kemacetan dalam tahap pengembangan atau produksi.

Rust memiliki Ekosistem Perpustakaan yang Lebih Kecil

Rust relatif baru dibandingkan dengan banyak bahasa populer lainnya, dan ada ekosistem perpustakaan terbatas yang dapat Anda gunakan.

Banyak pustaka (crates) yang masih dalam produksi, dan Anda bisa mengunjungi situs web seperti AreWeWebYet untuk mendapatkan gambaran umum mengenai crates siap produksi yang bisa Anda gunakan untuk membangun aplikasi web di Rust.

Opsi Penyebaran Rust

Rust sudah mendapatkan adopsi yang luas, jadi ada banyak opsi penerapan yang bisa Anda pilih untuk aplikasi Anda.

Sebagian besar opsi penerapan Rust adalah platform berbasis IaaS atau CaaS. Anda bisa memilih salah satunya berdasarkan spesifikasi proyek Anda.

Infrastruktur sebagai Layanan (IaaS) seperti AWS

Penyedia Infrastructure as a Service (IaaS) memberi Anda infrastruktur untuk menerapkan dan mengelola aplikasi Anda yang berjalan pada mesin virtual di cloud.

Anda bisa menggunakan layanan yang disediakan platform IaaS untuk menerapkan aplikasi Rust pada mesin virtual yang menjalankan sistem operasi seperti Linux, Windows, macOS, dan sistem operasi lain yang didukung Rust.

Berikut adalah daftar platform IaaS yang populer:

  • Amazon Web Services
  • Digital Ocean
  • Google Cloud
  • Linode
  • Microsoft Azure

Kontainerisasi sebagai Layanan Seperti Kontainer Back4app

Penyedia layanan kontainerisasi (CaaS) membantu Anda memfasilitasi penerapan aplikasi Anda dengan teknologi kontainerisasi.

Untuk menggunakan aplikasi Anda pada platform yang mendukung kontainerisasi, Anda akan memaketkan aplikasi Anda dan semua ketergantungannya ke dalam sebuah kontainer yang terisolasi.

Kontainer terisolasi dan portabel, tetapi Anda harus bekerja dalam batas-batas fitur penyedia CaaS.

Beberapa penyedia IaaS menyediakan fungsi CaaS. Selain itu, ada juga platform yang hanya menyediakan fungsionalitas CaaS yang fleksibel secara terpisah.

Berikut adalah daftar beberapa platform CaaS:

  • Oracle Container Service
  • Back4app
  • Mirantix
  • Docker Enterprise

Proses Penerapan Aplikasi Rust

Di bagian ini, Anda akan mempelajari bagaimana Anda dapat menggunakan aplikasi Rust ke platform CaaS Back4app.

Apa itu Back4app?

Back4app adalah platform cloud yang dapat Anda manfaatkan untuk membuat dan menggunakan semua jenis layanan backend untuk aplikasi seluler, web, dan jenis aplikasi lainnya.

Back4app menyediakan agen AI yang dapat Anda gunakan untuk merampingkan penyebaran aplikasi Anda di platform. Anda bisa menggunakannya untuk mengelola repositori GitHub Anda, menyebarkan kode di cloud dengan mudah, dan mengelola aplikasi yang sedang berjalan.

Di server backend Back4app, kontainer khusus dapat digunakan dan dijalankan melalui fungsionalitas CaaS.

Dengan menggunakan citra kontainer, Anda dapat memperluas logika aplikasi Anda tanpa perlu khawatir tentang pemeliharaan arsitektur server.

tangkapan layar dari agen AI Back4app

Membangun dan Menerapkan

Anda harus sudah menginstal Rust di komputer Anda untuk mengikuti tutorial ini. Anda bisa mengunjungi halaman instalasi Rust untuk mengetahui berbagai pilihan instalasi yang tersedia.

Setelah Anda menginstal Rust, buat sesi terminal dan jalankan perintah ini untuk menginisialisasi proyek Rust yang baru

mkdir back4app-rust-deployment && cd back4app-rust-deployment && cargo init

Ketika Anda menjalankan perintah tersebut, Anda akan melihat berkas cargo.toml di direktori baru yang baru saja Anda buat. Anda akan menggunakan cargo.toml untuk mengelola dependensi.

Selanjutnya, tambahkan arahan ini ke bagian [dependencies] pada file Cargo.toml untuk menginstal dependensi ini saat Anda membangun aplikasi.

[dependencies]
actix-web = "4.0"
serde = { version = "1.0", features = ["derive"] }
serde_derive = { version = "1.0" }
serde_json = "1.0"
lazy_static = "1.4"

Crate actix-web menyediakan perutean dan fungsi-fungsi terkait HTTP lainnya, crate serde, serde_derive, dan serde_json menyediakan fungsi-fungsi untuk operasi JSON yang berbeda, dan crate lazy_static menyediakan penyimpanan data di dalam memori untuk API pada saat runtime.

Tambahkan impor ini di bagian atas file [main.rs]() Anda:

use serde::{Serialize, Deserialize};
use actix_web::{web, App, HttpServer, HttpResponse, Error};
use std::sync::Mutex;
extern crate lazy_static;
use lazy_static::lazy_static;

Anda dapat menggunakan struct untuk mendefinisikan struktur data untuk API Anda berdasarkan bidang yang Anda butuhkan. Berikut ini struktur yang menggambarkan seseorang dengan ID, nama pengguna, dan email.

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Person {
    pub id: i32,
    pub username: String,
    pub email: String,
}

Fungsi #[derive(Serialize, Deserialize, Debug, Clone)] adalah implementasi dari peti serde_derive untuk mengakses dan menggunakan fungsi-fungsinya.

Berikut ini cara menggunakan crate lazy_static untuk menyiapkan penyimpanan data dalam memori untuk API Anda berdasarkan tipe struct Person:

lazy_static! {
    static ref DATA_STORE: Mutex<Vec<Person>> = Mutex::new(Vec::new());
}

Anda telah membuat penyimpanan bersama yang diinisialisasi dengan aman dari thread untuk struktur People. Anda akan menggunakannya dalam fungsi-fungsi penangan untuk menyimpan dan mengambil data.

Fungsi POST Handler

Fungsi penangan permintaan POST menerima representasi JSON dari struktur Person sebagai masukan Anda. Fungsi ini kemudian akan mengembalikan respons HTTP dan kesalahan kepada klien sesuai permintaan.

Tambahkan blok kode ini ke file [main.rs]() Anda untuk mengimplementasikan fungsionalitas penangan permintaan POST.

async fn create_person(new_person: web::Json<Person>) -> Result<HttpResponse, Error> {
    let mut data_store = DATA_STORE.lock().unwrap();
    let new_id = data_store.len() as i32 + 1;
    let mut person = new_person.into_inner();
    person.id = new_id;
    data_store.push(person.clone());

    Ok(HttpResponse::Ok().json(person))
}

Create_person adalah fungsi asinkron yang mengakses penyimpanan data bersama, menghasilkan ID baru untuk struktur Person, mengubah representasi JSON Person menjadi sebuah struktur, dan mendorongnya ke dalam penyimpanan data.

Setelah permintaan berhasil, fungsi ini memberikan data yang dimasukkan ke dalam database bersama dengan kode status 200 kepada klien.

Fungsi Penangan GET

Di sini, fungsi GET handler mendemonstrasikan pembacaan semua data dalam penyimpanan data dan mengembalikannya ke klien sebagai JSON.

Tambahkan blok kode ini ke proyek Anda untuk mengimplementasikan fungsi GET handler

async fn get_people() -> Result<HttpResponse, Error> {
    let data_store = DATA_STORE.lock().unwrap();
    let people: Vec<Person> = data_store.clone();

    Ok(HttpResponse::Ok().json(people))
}

Fungsi get_people adalah fungsi asinkron yang mengakses penyimpanan data dan menulis konten ke klien sebagai respons.

Pada permintaan yang berhasil, fungsi merespons dengan kode status 200 kepada klien dengan semua data dalam penyimpanan data.

Fungsi Penangan PUT

Fungsi penangan permintaan PUT Anda harus memperbarui entri dalam penyimpanan data berdasarkan bidang objek.

Berikut ini cara mengimplementasikan fungsi penangan PUT untuk API Anda:

async fn update_person(
    id: web::Path<i32>,
    person_update: web::Json<Person>,
) -> Result<HttpResponse, Error> {
    let mut data_store = DATA_STORE.lock().unwrap();

    if let Some(person) = data_store.iter_mut().find(|p| p.id == *id) {
        *person = person_update.into_inner();
        Ok(HttpResponse::Ok().json("Person updated successfully"))
    } else {
        Ok(HttpResponse::NotFound().json("Person not found"))
    }
}

Fungsi update_person mengambil ID dan entri baru dari permintaan. Fungsi ini kemudian menelusuri penyimpanan data dan mengganti entri dengan entri yang baru jika ada.

Fungsi Penangan DELETE Handler

Fungsi permintaan DELETE akan mengambil satu argumen; bidang ID dari permintaan yang dibuat. Pada saat fungsi dijalankan, fungsi ini akan menghapus entri dengan ID tersebut dari penyimpanan data.

Tambahkan implementasi fungsi penangan DELETE ini ke program Anda.

// DELETE
pub async fn delete_person(id: web::Path<i32>) -> Result<HttpResponse, Error> {
    let mut data_store = DATA_STORE.lock().unwrap();

    if let Some(index) = data_store.iter().position(|p| p.id == *id) {
        data_store.remove(index);
        Ok(HttpResponse::Ok().json("Deleted successfully"))
    } else {
        Ok(HttpResponse::NotFound().json("Person not found"))
    }
}

Fungsi hapus_orang menghapus entri dengan ID yang ditentukan dari penyimpanan data. Bergantung pada status operasi, fungsi mengembalikan sebuah string dan kode status kepada klien.

Memetakan Fungsi-fungsi Handler ke Rute

Setelah menentukan titik akhir, Anda harus memetakan rute ke fungsi handler untuk mengakses fungsionalitas fungsi handler.

Berikut ini adalah cara untuk menetapkan rute ke fungsi handler:

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/person", web::post().to(create_person))
            .route("/people", web::get().to(get_people))
            .route("/person/{id}", web::put().to(update_person))
            .route("/person/{id}", web::delete().to(delete_person))
    })
        .bind("0.0.0.0:8000")?
        .run()
        .await
}

Fungsi utama adalah fungsi asinkron yang mengatur server setelah memetakan rute ke fungsi handler.

Fungsi HttpServer::new menginstansiasi server HTTP, fungsi App::new() membuat contoh aplikasi baru, dan fungsi rute memetakan rute ke fungsi handler.

Fungsi bind menentukan alamat untuk aplikasi baru, dan fungsi run menjalankan aplikasi.

Menampung aplikasi Rust dengan Docker

Docker adalah teknologi kontainerisasi yang paling populer di pasaran. Anda bisa mengkontainerisasi aplikasi Rust Anda dengan Docker untuk portabilitas dan menerapkannya ke Back4app dengan beberapa klik.

Jalankan perintah ini untuk membuat berkas Docker baru di proyek Anda:

touch Dockerfile

Buka Dockerfile dan tambahkan instruksi build ini ke Dockerfile:

# Use Rust Nightly as the base image
FROM rustlang/rust:nightly

# Set the working directory inside the container
WORKDIR /usr/src/myapp

# Copy the current directory contents into the container
COPY . .

# Build the application
RUN cargo build --release

# Expose port 8000
EXPOSE 8000

# Define the command to run the application
CMD ["./target/release/back4app-rust-deployment"]

Instruksi ini menentukan citra dasar dan instruksi pembangunan untuk mengkontainerisasi aplikasi Rust Anda dengan Docker.

Berikut ini adalah rincian isi dari Dockerfile:

  1. Arahan FROM rustlang/rust:nightly menentukan citra dasar untuk berkas Docker. Docker menarik citra ini dari repositori dan membangun program Anda di atasnya.
  2. Arahan WORKDIR /usr/src/myapp menetapkan direktori kerja untuk aplikasi Anda di dalam kontainer.
  3. Arahan COPY . . menyalin semua konten direktori kerja Anda ke dalam direktori kerja kontainer saat ini.
  4. Arahan RUN cargo build --release mengeksekusi perintah untuk membangun aplikasi Anda di dalam kontainer.
  5. Arahan EXPOSE 8000 mengekspos port 8000 dari kontainer untuk permintaan yang masuk.
  6. CMD ["./target/release/back4app-rust-deployment"] menjalankan program (yang dapat dieksekusi dari operasi build).

Setelah Anda menulis Dockerfile, Anda dapat melanjutkan untuk men-deploy kontainer pada layanan kontainer Back4app.

Menyebarkan Kontainer di Back4app

Anda perlu membuat akun di Back4app untuk menggunakan kontainer.

Berikut adalah langkah-langkah untuk membuat akun Back4app.

  1. Kunjungi situs web Back4app
  2. Klik tombol Daftar di sudut kanan atas halaman.
  3. Lengkapi formulir pendaftaran dan kirimkan untuk membuat akun.

Sekarang setelah Anda berhasil membuat akun Back4app, masuk dan klik tombol APLIKASI BARU yang terletak di sudut kanan atas halaman arahan.

Anda akan diberikan opsi untuk memilih bagaimana Anda ingin membangun aplikasi Anda. Pilih opsi Container sebagai Layanan.

Memilih layanan back4app

Sekarang, hubungkan akun Github Anda ke akun Back4app dan konfigurasikan akses ke repositori di akun Anda atau proyek tertentu.

Konfigurasikan akun GitHub Anda untuk memberikan akses Back4app untuk mengimpor repo

Pilih aplikasi yang ingin Anda terapkan (salah satu dari tutorial ini) dan klik pilih.

memilih dan mengonfigurasi repo yang dapat diakses

Dengan mengklik pilih, tombol akan membawa Anda ke halaman di mana Anda dapat mengisi informasi tentang aplikasi Anda, termasuk nama cabang, direktori root, dan variabel lingkungan.

Proses penyebaran dimulai secara otomatis,

Menyebarkan Dengan Agen AI Back4app

Untuk meningkatkan alur kerja pengembangan Anda, Anda juga dapat menyebarkan aplikasi Anda menggunakan agen AI Back4app, seperti yang dapat Anda lihat pada gambar di bawah ini:

Meminta agen AI dengan perintah penyebaran

Ikuti tautan ini untuk menginstal aplikasi kontainer Back4app di akun GitHub Anda, dan ikuti langkah-langkah pada gambar di atas untuk mengonfigurasinya.

Setelah menyelesaikan penyiapan aplikasi, Anda dapat melanjutkan dengan menerapkan aplikasi Anda dengan agen AI.

Penempatan kontainer Anda telah diinisialisasi dengan pesan

Ikuti tautan yang disediakan untuk memantau kemajuan penerapan aplikasi Anda.

Tangkapan layar dasbor Container Anda untuk memantau penerapan

Kesimpulan

Anda telah mempelajari cara membangun dan menggunakan aplikasi Rust yang terkontainerisasi dengan Docker di Back4app.

Menerapkan aplikasi Anda ke Back4app adalah cara terbaik untuk menyederhanakan manajemen infrastruktur backend.

Back4App menyediakan alat yang kuat untuk mengelola data Anda, menskalakan aplikasi Anda, dan memantau kinerjanya.

Ini adalah pilihan yang sangat baik bagi para pengembang yang ingin membangun aplikasi hebat daripada mengelola server.


Noble Okafor

Leave a reply

Your email address will not be published.