Bir Rust Uygulaması Nasıl Dağıtılır?

Rust, benimseyenlere sunduğu çok sayıda özellik nedeniyle 4 yıldan uzun bir süredir StackOverflow geliştirici anketinde en beğenilen dil olmuştur.

Mozilla Rust’ı güvenilir, performanslı ve geliştirici dostu olması için yarattı. Rust, geliştiricilerin ana hedefi olan C++ ve C gibi dillere benzer bir sözdizimine sahiptir.

Rust ayrıca, diğer dilleri kullanan geliştiricilerin karşılaştığı ilgili tuzaklardan kaçınan modellerle bellek güvenliği ve eşzamanlılığa odaklanır.

Bu makalenin avantajlarından yararlanmak için Rust’ta API’leri nasıl oluşturacağınızı öğreneceksiniz. Back4app’in ücretsiz konteynerleştirme hizmetinde bir Rust uygulaması hazırlayarak, konteynerleştirerek ve dağıtarak öğreneceksiniz.

Rust Kullanmanın Avantajları

Projelerinizde Rust kullanmanın size sağlayacağı pek çok avantaj vardır. İşte önemli olanlardan bazıları:

Sıfır Maliyetli Soyutlamalar

Rust, ek çalışma zamanı maliyetleri getirmeden üst düzey soyutlamalar sağlar. Bu, kodunuzda kullandığınız soyutlamaların (fonksiyonlar, yineleyiciler veya jenerikler) programlarınızı yavaşlatmadığını ima eder.

Rust derleyicisi, derlenen düşük seviyeli kod için soyutlamaları manuel olarak optimize eder. Rust, performans üzerinde etkileyici, düşük seviyeli, ince taneli kontrol arasındaki boşluğu doldurur.

Eşzamanlı Programlarda Bellek Güvenliği için Korkusuz Eşzamanlılık Yaklaşımı

Rust, güvenlik ve verimlilik ile karakterize edilen eşzamanlılığa “korkusuz bir yaklaşım” benimser. Rust’ın eşzamanlılık modeli, derleme zamanında veri yarışlarını önlemek için sahiplik modelinden ve tip kontrolünden yararlanır.

Bu özellik, kilitlenmeler ve yarış koşulları gibi paylaşılan durum eşzamanlılığının dezavantajları olmadan çok iş parçacıklı uygulamalar yazmanıza olanak tanır.

Gelişmiş Tip Sistemi ve Sahiplik Modeli

Rust’ın tip sistemi ve sahiplik kuralları, bellek güvenliğini sağlamaya yardımcı olan benzersiz özelliklerdir.

Sahiplik modeli, her bir veri parçasının tek bir sahibi olduğundan emin olmak için ödünç denetleyicisini kullanır ve sarkan işaretçiler ve bellek sızıntıları gibi sorunları önlemek için yaşam döngüsünü yönetir.

Platformlar Arası Uyumluluk ve Entegrasyon

Platformlar arası uygulamalar oluşturmak istiyorsanız Rust harika bir seçimdir. Kodu bir kez yazabilir ve mevcut kod tabanında önemli değişiklikler yapmadan birden fazla platformda derleyebilirsiniz.

Rust, diğer programlama dilleriyle, özellikle de C ile iyi bir şekilde bütünleşerek dili web montajı ve gömülü sistem görevleri için uygun hale getirir.

Rust Kullanmanın Sınırlamaları

Rust ile üretim sınıfı uygulamalar oluştururken bazı aksaklıklarla karşılaşmanız kaçınılmazdır.

Bunlardan bazıları Rust’ın dik öğrenme eğrisi, bellek ve diğer kontroller nedeniyle daha uzun derleme süresi ve yeni, küçük ekosistemi olabilir.

Rust ile üretim sınıfı ürünler oluştururken karşılaşabileceğiniz bazı dezavantajlar vardır. İşte bunlardan bazıları:

Rust Programlama için Öğrenme Eğrisi Diktir

Diğer popüler dillerle (Go, Python, JavaScript vb.) karşılaştırıldığında, Rust’ta uzmanlaşmak ve bu dille üretim sınıfı uygulamalar oluşturmak önemli ölçüde zaman alır.

Bu sizi Rust kullanmaktan alıkoymamalı. Rust’ta ustalaştığınızda, uygulamaları gerçekten verimli bir şekilde oluşturacak ve dağıtacaksınız ve Rust kullanmanın tüm avantajlarından yararlanacaksınız.

Rust Programları Uzun Derleme Süresine Sahiptir

Derleme zamanındaki bellek ve eşzamanlılık kontrolleri, diğer bazı faktörlerle birleştiğinde Rust programları için uzun derleme sürelerine neden olur.

Uygulamanın boyutuna bağlı olarak, uzun derleme süreleri geliştirme veya üretim aşamalarında darboğazlara neden olabilir.

Rust Daha Küçük Bir Kütüphane Ekosistemine Sahiptir

Rust, diğer birçok popüler dile kıyasla nispeten yenidir ve kullanabileceğiniz sınırlı bir kütüphane ekosistemi vardır.

Birçok kütüphane (crate) hala üretim aşamasındadır ve Rust’ta web uygulamaları oluşturmak için kullanabileceğiniz üretime hazır crate’lere genel bir bakış için AreWeWebYet gibi web sitelerine göz atabilirsiniz.

Rust Dağıtım Seçenekleri

Rust zaten geniş çapta benimseniyor, bu nedenle uygulamalarınız için seçebileceğiniz birçok dağıtım seçeneği var.

Rust dağıtım seçeneklerinin çoğu IaaS veya CaaS tabanlı platformlardır. Proje özelliklerinize göre birini seçebilirsiniz.

AWS gibi Hizmet Olarak Altyapı (IaaS)

Hizmet Olarak Altyapı (IaaS) sağlayıcıları, buluttaki sanal makinelerde çalışan uygulamalarınızı dağıtmanız ve yönetmeniz için size altyapı sağlar.

Rust uygulamalarınızı Linux, Windows, macOS ve diğer Rust destekli işletim sistemlerini çalıştıran sanal makinelere dağıtmak için IaaS platformlarının sağladığı hizmetleri kullanabilirsiniz.

İşte popüler IaaS platformlarının bir listesi:

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

Back4app Konteynerleri Gibi Hizmet Olarak Konteynerleştirme

Konteynerleştirme hizmetleri (CaaS) sağlayıcıları, konteynerleştirme teknolojileriyle uygulamanızın dağıtımını kolaylaştırmanıza yardımcı olur.

Uygulamanızı konteynerleştirmeyi destekleyen platformlara dağıtmak için, uygulamanızı ve tüm bağımlılıklarını izole edilmiş bir konteynerde paketleyeceksiniz.

Konteynerler yalıtılmış ve taşınabilirdir, ancak CaaS sağlayıcısının özelliklerinin sınırları içinde çalışmanız gerekecektir.

Bazı IaaS sağlayıcıları CaaS işlevleri sağlar. Ayrıca, tek başına yalnızca esnek CaaS işlevselliği sağlayan platformlar da vardır.

İşte bazı CaaS platformlarının bir listesi:

• Oracle Container Service
• Back4app
• Mirantix
• Docker Enterprise

Rust Uygulama Dağıtım Süreci

Bu bölümde, Rust uygulamanızı Back4app’in CaaS platformuna nasıl dağıtabileceğinizi öğreneceksiniz.

Back4app Nedir?

Back4app, mobil, web ve diğer uygulama türleriniz için her türlü arka uç hizmetini oluşturmak ve dağıtmak için yararlanabileceğiniz bir bulut platformudur.

Back4app, uygulamanızın platformdaki dağıtımını kolaylaştırmak için kullanabileceğiniz bir AI aracısı sağlar. GitHub depolarınızı yönetmek, buluta kolayca kod dağıtmak ve çalışan uygulamalarınızı yönetmek için kullanabilirsiniz.

Back4app’in arka uç sunucularında, özel konteynerler CaaS işlevi aracılığıyla dağıtılabilir ve çalıştırılabilir.

Konteyner imajlarınızı kullanarak, sunucu mimarinizi sürdürme konusunda endişelenmeden uygulamanızın mantığını genişletebilirsiniz.

Oluşturma ve Dağıtma

Bu öğreticiyi takip etmek için bilgisayarınızda Rust kurulu olmalıdır. Mevcut farklı kurulum seçenekleri için Rust kurulumları sayfasını ziyaret edebilirsiniz.

Rust’ı kurduktan sonra, bir terminal oturumu oluşturun ve yeni bir Rust projesini başlatmak için şu komutu çalıştırın

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

Komutu çalıştırdığınızda, yeni oluşturduğunuz dizinde bir cargo.toml dosyası görmelisiniz. Bağımlılıkları yönetmek için cargo.toml dosyasını kullanacaksınız.

Ardından, uygulamanızı derlerken bu bağımlılıkları yüklemek için bu yönergeleri Cargo.toml dosyanızın [dependencies] bölümüne ekleyin.

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

actix-web crate’i yönlendirme ve HTTP ile ilgili diğer işlevleri sağlar, serde, serde_derive ve serde_json crate’leri farklı JSON işlemleri için işlevler sağlar ve lazy_static crate’i çalışma zamanında API için bellek içi veri depolama sağlar.

Bu içe aktarmaları [main.rs]() dosyanızın en üstüne ekleyin:

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;

İhtiyacınız olan alanlara dayalı olarak API’nizin veri yapısını tanımlamak için bir struct kullanabilirsiniz. İşte ID, kullanıcı adı ve e-postası olan bir kişiyi gösteren bir yapı.

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

Derive(Serialize, Deserialize, Debug, Clone)], serde_derive crate’in Person yapısının işlevlerine erişmek ve bunları kullanmak için kullandığı uygulamalardır.

Person struct türüne dayalı olarak API’niz için bellek içi bir veri deposu oluşturmak üzere lazy_static crate’i nasıl kullanabileceğiniz aşağıda açıklanmıştır:

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

People struct için lazily initialized, thread-safe shared storage oluşturdunuz. Verileri saklamak ve almak için işleyici işlevlerinizde bunu kullanacaksınız.

POST İşleyici İşlevi

POST istek işleyici işlevi, girdi olarak Person yapısının bir JSON temsilini kabul eder. Ardından, istek üzerine istemciye bir HTTP yanıtı ve bir hata döndürür.

POST istek işleyicisi işlevini uygulamak için bu kod bloğunu [main.rs]() dosyanıza ekleyin.

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, paylaşılan veri deposuna erişen, Person yapısı için yeni bir kimlik oluşturan, JSON temsili Person ‘ı bir yapıya dönüştüren ve veri deposuna iten zaman uyumsuz bir işlevdir.

Başarılı bir isteğin ardından, işlev istemciye veritabanına girilen verileri 200 durum koduyla birlikte sağlar.

GET İşleyici İşlevi

Burada bir GET işleyici işlevi, veri deposundaki tüm verileri okumayı ve bunları istemciye JSON olarak döndürmeyi göstermektedir.

Bir GET işleyici işlevi uygulamak için bu kod bloğunu projenize ekleyin

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

get_people işlevi, veri deposuna erişen ve içeriği istemciye yanıt olarak yazan zaman uyumsuz bir işlevdir.

Başarılı bir istek üzerine, işlev veri deposundaki tüm verilerle birlikte istemciye 200 durum koduyla yanıt verir.

PUT İşleyici İşlevi

PUT istek işleyici işleviniz, nesnenin bir alanına bağlı olarak veri deposundaki bir girişi güncellemelidir.

API’niz için bir PUT işleyici işlevini nasıl uygulayabileceğiniz aşağıda açıklanmıştır:

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

update_person işlevi istekten ID’yi ve yeni girişi alır. Daha sonra veri deposunu dolaşır ve varsa girişi yenisiyle değiştirir.

DELETE İşleyici İşlevi

DELETE istek fonksiyonu bir argüman alacaktır; yapılan istekten ID alanı. Fonksiyon çalıştırıldığında, veri deposundan ID ile girişi silecektir.

DELETE işleyici işlevinin bu uygulamasını programınıza ekleyin.

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

delete_person fonksiyonu, belirtilen ID’ye sahip girişi veri deposundan siler. İşlemin durumuna bağlı olarak, fonksiyon istemciye bir dize ve bir durum kodu döndürür.

İşleyici İşlevlerini Rotalara Eşleme

Uç noktaları tanımladıktan sonra, işleyici işlevlerinin işlevselliğine erişim için rotaları işleyici işlevleriyle eşleştirmeniz gerekir.

İşleyici işlevlerine nasıl rota atayabileceğiniz aşağıda açıklanmıştır:

#[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
}

Ana işlev, rotaları işleyici işlevlerle eşledikten sonra sunucuyu kuran eşzamansız bir işlevdir.

HttpServer::new işlevi bir HTTP sunucusunu örneklendirir, App::new() işlevi yeni bir uygulama örneği oluşturur ve route işlevi rotaları işleyici işleviyle eşler.

bind işlevi yeni uygulamanın adresini belirtir ve run işlevi uygulamayı çalıştırır.

Docker ile Rust uygulamalarını konteynerleştirme

Docker, piyasadaki en popüler konteynerizasyon teknolojisidir. Taşınabilirlik için Rust uygulamalarınızı Docker ile konteynerleştirebilir ve birkaç tıklamayla Back4app’e dağıtabilirsiniz.

Projenizde yeni bir Dockerfile oluşturmak için bu komutu çalıştırın:

touch Dockerfile

Dockerfile’ı açın ve bu derleme talimatlarını Dockerfile’a ekleyin:

# 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"]

Bu talimatlar, Rust uygulamanızı Docker ile konteynerleştirmek için temel görüntüyü ve derleme talimatlarını belirtir.

İşte Dockerfile’ın içeriğinin bir dökümü:

1. FROM rustlang/rust:nightly yönergesi Dockerfile için temel imajı belirtir. Docker bu imajı depodan çeker ve programlarınızı bunun üzerine inşa eder.
2. WORKDIR /usr/src/myapp yönergesi konteyner içindeki uygulamanız için çalışma dizinini belirler.
3. COPY . . yönergesi çalışma dizininizin tüm içeriğini konteynerin geçerli çalışma dizinine kopyalar.
4. RUN cargo build --release yönergesi, uygulamanızı kapsayıcıda oluşturmak için komutu çalıştırır.
5. EXPOSE 8000 yönergesi konteynerin 8000 portunu gelen istekler için açık hale getirir.
6. CMD ["./target/release/back4app-rust-deployment"] programı çalıştırır (derleme işleminden elde edilen yürütülebilir dosya).

Docker dosyasını yazdıktan sonra, konteyneri Back4app’in konteyner hizmetine dağıtmaya devam edebilirsiniz.

Back4app üzerinde Konteyner Dağıtma

Kapsayıcıları dağıtmak için Back4app üzerinde bir hesap oluşturmanız gerekir.

Back4app hesabı oluşturma adımları aşağıda verilmiştir.

1. Back4app web sitesini ziyaret edin
2. Sayfanın sağ üst köşesindeki Kaydol düğmesine tıklayın.
3. Kayıt formunu doldurun ve hesabı oluşturmak için gönderin.

Artık başarılı bir şekilde Back4app hesabı oluşturduğunuza göre, giriş yapın ve açılış sayfasının sağ üst köşesinde bulunan YENİ UYGULAMA düğmesine tıklayın.

Uygulamanızı nasıl oluşturmak istediğinizi seçmeniz için size seçenekler sunulacaktır. Container as a Service seçeneğini seçin.

Şimdi, Github hesabınızı Back4app hesabınıza bağlayın ve hesabınızdaki veya belirli bir projedeki depolara erişimi yapılandırın.

Dağıtmak istediğiniz uygulamayı seçin (bu dersteki uygulama) ve seç’e tıklayın.

Seç düğmesine tıkladığınızda, düğme sizi dalın adı, kök dizin ve ortam değişkenleri de dahil olmak üzere uygulamanızla ilgili bilgileri doldurabileceğiniz bir sayfaya götürecektir.

Dağıtım işlemi otomatik olarak başlar,

Back4app AI Agent ile Dağıtım

Geliştirme iş akışınızı güçlendirmek için, aşağıdaki resimde görebileceğiniz gibi uygulamanızı Back4app AI aracısını kullanarak da dağıtabilirsiniz:

GitHub hesabınıza Back4app konteyner uygulamasını yüklemek için bu bağlantıyı takip edin ve yapılandırmak için yukarıdaki görüntüdeki adımları izleyin.

Uygulama kurulumunu tamamladıktan sonra, uygulamanızı AI aracısı ile dağıtmaya devam edebilirsiniz.

Uygulamanızın dağıtım ilerlemesini izlemek için sağlanan bağlantıyı izleyin.

Sonuç

Back4app üzerinde Docker konteynerli bir Rust uygulamasının nasıl oluşturulacağını ve dağıtılacağını öğrendiniz.

Uygulamalarınızı Back4app’e dağıtmak, arka uç altyapı yönetimini basitleştirmenin harika bir yoludur.

Back4App, verilerinizi yönetmek, uygulamanızı ölçeklendirmek ve performansını izlemek için güçlü araçlar sağlar.

Sunucuları yönetmek yerine harika uygulamalar oluşturmak isteyen geliştiriciler için mükemmel bir seçimdir.