Einführung
In diesem Tutorial lernen Sie, wie Sie mit Rust und dem Actix-Webframework einen Webserver auf einem DigitalOcean Droplet erstellen. Sie richten einen Kernserver ein und erstellen Routen zur Verwaltung einer einfachen Aufgabenliste, die gängige RESTful-Operationen wie das Abrufen und Erstellen von Aufgaben unterstützt.
Voraussetzungen
Bevor Sie beginnen, stellen Sie bitte sicher, dass Sie Folgendes haben:
- Eins DigitalOcean Cloud-Konto Um einen Tropfen zu drehen.
- Ein Ubuntu-Droplet ist eingerichtet und betriebsbereit.
- Rust ist auf dem Droplet installiert.
- Kenntnisse der Rust-Prinzipien, einschließlich Variablen, Funktionen und Attribute.
Schritt 1 – Ubuntu-Droplet einrichten
Stellen Sie eine SSH-Verbindung zu Ihrem DigitalOcean Droplet her: Öffnen Sie Ihr Terminal und verwenden Sie den folgenden Befehl, um eine SSH-Verbindung zu Ihrem Droplet herzustellen. Ersetzen Sie „your_username“ durch Ihren tatsächlichen Benutzernamen und „your_droplet_ip“ durch die IP-Adresse Ihres Droplets:
ssh your_username@your_droplet_ip
Paketliste aktualisieren: Aktualisieren Sie nach dem Anmelden die Paketliste, um sicherzustellen, dass Sie über die aktuellsten Informationen zu verfügbaren Paketen verfügen:
sudo apt update
Rust installieren: Um Rust zu installieren, verwenden Sie den folgenden Befehl, der das Rust-Installationsskript herunterlädt und ausführt:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Folgen Sie den Anweisungen auf dem Bildschirm, um die Installation abzuschließen. Nach der Installation müssen Sie möglicherweise Ihr Terminal neu starten oder Folgendes ausführen:
source $HOME/.cargo/env
Installieren Sie die erforderlichen Bibliotheken: Installieren Sie die Bibliotheken, die zum Erstellen von Rust-Anwendungen benötigt werden. Sie können build-essential und libssl-dev mit folgendem Befehl installieren:
sudo apt install build-essential libssl-dev
Überprüfen Sie die Rust-Installation: Um zu überprüfen, ob Rust korrekt installiert ist, überprüfen Sie die Version:
rustc --version
Installieren Sie Cargo (Rust-Paketmanager): Cargo wird automatisch mit Rust installiert. Sie können die Installation überprüfen, indem Sie die Version prüfen:
cargo --version
Schritt 2 – Projekt starten
Lasst uns ein neues Rust-Projekt namens sammy_todos mit der Payload erstellen.
cargo new sammy_todos
Suchen Sie anschließend die Datei Cargo.toml. Wechseln Sie dazu in das Stammverzeichnis Ihres Rust-Projekts. Die Datei Cargo.toml befindet sich im selben Verzeichnis, in dem Sie Ihr Projekt erstellt haben (z. B. sammy_todos). Sie können folgenden Befehl verwenden, um in Ihr Projektverzeichnis zu wechseln:
cd sammy_todos/
lsNachfolgend sind die automatisch generierten Rust-Projektdateien aufgeführt:
Output
Cargo.toml srcFügen Sie actix-web und serde als Abhängigkeiten in Cargo.toml hinzu. Serde wird hierbei für die Serialisierung und Deserialisierung benötigt.
vi Cargo.toml
Fügen Sie unter Abhängigkeiten die folgenden Zeilen hinzu.
[dependencies]
actix-web = "4.0"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"Verwenden Sie nun den folgenden Befehl, um die Abhängigkeiten herunterzuladen und zu kompilieren:
cargo build
Schritt 3 – Erstellen eines Basisservers
Fügen Sie in der Datei main.rs die folgenden Codezeilen hinzu, um einen Hauptserver zu starten. Sie müssen dazu in das Verzeichnis src Ihres Projekts wechseln.
use actix_web::{get, App, HttpServer, HttpResponse, Responder,web};
#[get("/")]
async fn index() -> impl Responder {
HttpResponse::Ok().body("Welcome to the Sammy Todo API!")
}
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
App::new()
.service(index)
})
.bind("127.0.0.1:8080")?
.run()
.await
}Server starten:
cargo run
Um den Server zu testen, öffnen Sie eine neue Terminal-Sitzung und führen Sie folgenden Befehl aus:
curl http://127.0.0.1:8080
Sie sollten folgende Antwort erhalten:
Output
Welcome to the Sammy Todo API!Schritt 4 – Aufgabenmodell hinzufügen
Das Todo-Modell ist erforderlich, um Anfrage und Antwort zu serialisieren. Fügen Sie die folgenden Codezeilen zur Datei main.rs hinzu.
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
struct Todo {
id: i32,
title: String,
completed: bool,
}Schritt 5 – Implementieren Sie die Aufgabenerstellung.
Diese API erstellt das Todo und ist eine Dummy-API, die einfach Ihr Todo zurückgibt. Sie können sie jedoch mit Datenbanken implementieren, um es persistent zu machen.
#[get("/todos")]
async fn create_todo(todo: web::Json<Todo>) -> impl Responder {
HttpResponse::Ok().body(serde_json::to_string(&todo).unwrap())
}
Schritt 6 – Ausführen Aufgabenliste abrufen
Diese API gibt die Aufgabe mit der ID zurück:
#[get("/todos/{id}")]
async fn get_todo(id: web::Path<i32>) -> impl Responder {
let todo = Todo {
id: id.into_inner(),
title: "Learn Actix-Web".to_string(),
completed: false,
};
HttpResponse::Ok().body(serde_json::to_string(&todo).unwrap())
}Verbinden Sie den Dienst mit Ihrem Server.
Die Datei main.rs des Rust-Servers sieht folgendermaßen aus:
use actix_web::{get, App, HttpServer, HttpResponse, Responder, web};
#[get("/")]
async fn index() -> impl Responder {
HttpResponse::Ok().body("Welcome to the Sammy Todo API!")
}
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
App::new()
.service(index)
.service(get_todo)
.service(create_todo)
})
.bind("127.0.0.1:8080")?
.run()
.await
}
use serde::{Serialize, Deserialize}; // Added Deserialize to imports
#[derive(Serialize, Deserialize)] // Ensure Deserialize is imported
struct Todo {
id: i32,
title: String,
completed: bool,
}
#[get("/todos")]
async fn create_todo(todo: web::Json<Todo>) -> impl Responder {
HttpResponse::Ok().body(serde_json::to_string(&todo).unwrap())
}
#[get("/todos/{id}")]
async fn get_todo(id: web::Path<i32>) -> impl Responder {
let todo = Todo {
id: id.into_inner(),
title: "Learn Actix-Web".to_string(),
completed: false,
};
HttpResponse::Ok().body(serde_json::to_string(&todo).unwrap())
}Sie können es nun testen, indem Sie eine POST-Anfrage mit curl senden:
curl -X POST -H "Content-Type: application/json" -d '{"title": "Buy groceries"}' http://127.0.0.1:8080/todos
Ergebnis
Herzlichen Glückwunsch! Sie haben erfolgreich einen einfachen Webserver mit Rust und Actix eingerichtet. Dieses Tutorial zeigt Ihnen, wie Sie Endpunkte zum Abrufen und Erstellen von Todo-Einträgen erstellen und damit eine solide Grundlage für die Entwicklung komplexerer Anwendungen schaffen. Um Ihre Anwendung weiter zu optimieren, integrieren Sie eine Datenbanklösung zur Datenspeicherung, mit der Sie Ihre Todo-Einträge effizient speichern und verwalten können.
