HTTP verwendet eine Client-Server-Architektur für die Informations- und Datenübertragung. Eines der Merkmale serverseitiger Programmiersprachen wie Rust ist die Entwicklung von Servern und Client-Apps für die Interaktion mit HTTP-basierten Diensten.

Rust eignet sich aufgrund seiner Sicherheits-, Leistungs- und Zuverlässigkeitsfunktionen zum Erstellen von HTTP-Servern. Rusts Crates von Drittanbietern wie Actix und Rocket sind beliebt für den Aufbau anspruchsvoller Webserver, die hohen Datenverkehr bewältigen können.

Warum sollten Sie Rust für die Entwicklung von HTTP-Webservern verwenden?

Rust hat bei der Entwicklung von Webservern an Popularität gewonnen, da einige der Funktionen der Sprache genau die Anforderungen für die Erstellung der meisten Webserver erfüllen.

Die Verwendung von Rust stellt sicher, dass Ihre Anwendung effizient skaliert wird, wodurch die Sprache ideal für die Erstellung von Hochleistungs-Apps ist. Hier sind spezifische Gründe, warum Sie die Verwendung von Rust für Ihren Webserver und andere serverseitige Anwendungen in Betracht ziehen sollten.

Die Höchstleistung von Rust

Hohe Leistung ist einer der Gründe, warum Rust eine ausgezeichnete Wahl für den Aufbau von HTTP-Webservern ist. Rust bietet Low-Level-Zugriff auf Systemressourcen, einschließlich Arbeitsspeicher und CPU, und ermöglicht es Ihnen, Code zu schreiben, der mit weniger Ressourcen schneller läuft als andere serverseitige Sprachen.

Darüber hinaus eliminiert das Besitzsystem von Rust die Notwendigkeit der Garbage Collection zur Kompilierzeit, was einer der Gründe dafür ist, dass einige serverseitige Sprachen langsam sind.

Sicherheit und Schutz

Das Eigentumssystem von Rust für die Speicherverwaltung macht die Sprache sicher für die Entwicklung von Webservern. Sie erleben keine Null- oder hängenden Zeigerreferenzen, die zu Speicherlecks und anderen Sicherheitslücken führen können.

Das Eigentumssystem von Rust verhindert diese häufigen Fehler, um Ihren Server und Ihre Apps sicher zu halten. Rust konzentriert sich auch darauf, Pufferüberläufe und andere speicherbezogene Fehler zu verhindern.

Parallelität

Nebenläufigkeit ist die Fähigkeit, mehrere Einheiten eines Programms in einer ungeordneten Weise auszuführen, ohne die Ausgabe zu beeinflussen. Die Ausgabe eines nebenläufigen Programms sollte mit der Ausgabe eines asynchronen Programms identisch sein.

Parallelität kann die Leistung Ihrer Anwendung erheblich beeinträchtigen, da Server mehrere Anforderungen gleichzeitig verarbeiten müssen. Rust bietet Unterstützung für die Koexistenz mit einem leichtgewichtigen Threading-Modell.

Das Besondere an der gleichzeitigen Programmierung in Rust ist, dass das Besitzsystem es Ihnen ermöglicht, Thread-sicheren Code zu schreiben, ohne dass Sperren und andere Synchronisierungsprimitive erforderlich sind.

Die Rust-Standardbibliothek und Pakete von Drittanbietern im Rust-Ökosystem bieten moderne Werkzeuge für effektive Entwicklung von Webservern.

Cargo, der Paketmanager von Rust, vereinfacht das Abhängigkeitsmanagement und baut Prozesse auf. Darüber hinaus verfügt Rust über eine hervorragende IDE-Unterstützung mit Tools wie Rust Analyzer, die eine nahtlose Codevervollständigung, Fehlerhervorhebung und andere Funktionen bieten.

Überblick über die Actix- und Rocket-Bibliotheken

Die Standardbibliothek von Rust enthält die meisten Dienstprogramme, die Sie zum Erstellen von Webservern benötigen. Bibliotheken von Drittanbietern wie Rakete Und Actix Vereinfachen Sie das Erstellen serverseitiger Anwendungen mit Rust.

Actix Und Rakete sind beliebte Rust-Webframeworks, aber die Bibliotheken unterscheiden sich in Design und Funktionen.

Rocket ist ein High-Level-Web-Framework, das Produktivität und Benutzerfreundlichkeit priorisiert. Rocket bietet viele Abstraktionen und Syntaxzucker zum Erstellen von Web-Apps in Rust. Rocket ist auch wegen seiner starken Eingabe und seines intuitiven API-Designs beliebt.

Sie können Rocket als Projektabhängigkeit in Ihrer hinzufügen Fracht.toml Datei, um mit dem Erstellen von Web-Apps in Rust zu beginnen:

[Abhängigkeiten]
Rakete = "0.4.11"

Auf der anderen Seite ist Actix-web ein Low-Level-Framework, das Leistung und Skalierbarkeit priorisiert. Actix nutzt ein akteurbasiertes Parallelitätsmodell und bietet nicht blockierende E/A, wodurch das Paket ideal für die Erstellung leistungsfähiger Webanwendungen geeignet ist.

Fügen Sie Actix als Projektabhängigkeit in der Abhängigkeiten Abschnitt Ihrer Fracht.toml Datei:

[Abhängigkeiten]
actix-web= "4.3.1"

Die Auswahl einer Bibliothek für Ihr Projekt hängt von den Spezifikationen Ihres Projekts, den Funktionen der Bibliothek und Ihrer Erfahrung mit Rust und HTTP ab.

Erstellen eines einfachen Webservers in Rust

Nachdem Sie ein Rust-Projekt erstellt und eines der Rocket- oder Actix-Frameworks zu den Abhängigkeiten Ihres Projekts in der Fracht.toml -Datei sind Sie bereit, mit dem Aufbau eines Webservers in Rust zu beginnen.

Aufbau eines einfachen Webservers mit Actix

Sie können einen Serializer für Anfragen verwenden, wenn Sie Webservices in Rust erstellen.

Serde ist eine beliebte Rust-Bibliothek zum Serialisieren und Deserialisieren von Daten zwischen Rust-Typen und Datenformaten wie JSON, YAML und TOML. Serde bietet ein Framework zum Definieren der Datenkonvertierung zwischen Rust-Datenstrukturen und entsprechenden Darstellungen in anderen Datenformaten.

Hier ist die Anweisung zum Hinzufügen von Serde als Drittanbieterpaket für Ihr Projekt.

[Abhängigkeiten]
serde = {Version = "1.0.159", Funktionen = ["ableiten"] }

Sobald Sie Serde und Actix als Projektabhängigkeiten hinzugefügt haben, können Sie mit Rust einen einfachen Webserver erstellen. So können Sie ein einfaches einrichten Hallo Welt! Webserver, der mit Actix einen String an den Client schreibt:

Importieren Sie zunächst die erforderlichen Module und Typen aus der actix_web Und serde Kisten:

verwenden actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
verwenden serde::{Deserialisieren, Serialisieren};

Sie werden verwenden serde um eine Nachricht an den Client mit einer Struktur zu serialisieren. Serde konvertiert die Struktur für den Client in JSON. Hier ist die Struktur für die Nachricht:

#[ableiten (Debuggen, Serialisieren, Deserialisieren)]
StrukturNachricht {
 Nachricht: Schnur,
}

Sie können jetzt die Handler-Funktion für den Endpunkt definieren. Oben in Ihrer Handler-Funktion können Sie Decorators für benutzerdefinierte Verhaltensweisen hinzufügen:

#[erhalten("/")]
asynchronfnHallo() -> impl Antwortender {
 HTTP-Antwort::OK().json (Nachricht {
 Nachricht: "Hallo Welt!".to_own(),
 })
}

Der Hallo Die Handler-Funktion verarbeitet GET-Anforderungen. Die Funktion gibt einen Typ zurück, der die implementiert Antwortender Eigenschaft von der Actix Paket.

Der json Methode der HttpResponse:: Ok() type nimmt eine Strukturinstanz an, die Serde behandelt unter der Haube und gibt die Antwort an den Client zurück.

Nachdem Sie den Endpunkt definiert haben, können Sie eine Serverinstanz starten und den Endpunkt auf einer Route mounten.

#[actix_web:: main]
asynchronfnhauptsächlich() -> std:: io::Ergebnis {
 HttpServer:: new(|| App:: new().service (Hallo))
 .binden("127.0.0.1:8080")?
 .laufen()
 .erwarten
}

Der HTTPServer:: neu Funktion ist eine neue Serverinstanz. Der hauptsächlich Funktion startet und der Server mountet die Hallo Handler-Funktion mit der neuen App-Instanz. Der binden -Methode bindet den Server an die angegebene URL und die laufen Funktion führt den Server aus.

Aufbau eines einfachen Webservers mit Rocket

Rocket ist minimalistisch, sodass Sie einen einfachen Webserver ohne andere Abhängigkeiten als die einrichten können Rakete Kiste.

So richten Sie einen einfachen Server mit einer Hallo Welt! Endpunkt mit Rocket:

Importieren Sie zunächst die erforderlichen Abhängigkeiten für Ihren Server.

#![feature (proc_macro_hygiene, decl_macro)]
#[macro_use]
externKiste Rakete;
// Importe aus der Rocket-Kiste
verwenden Rakete:: Antwort:: Inhalt;
verwenden Rakete:: Zustand;

Der #![feature (proc_macro_hygiene, decl_macro)] -Attribut aktiviert experimentelle Rust-Funktionen für das Rocket-Framework. Der #[macro_use] -Attribut importiert Makros aus der Rakete Modul.

Hier ist eine Handler-Funktion, die HTML auf Anfrage bereitstellt:

#[erhalten("/")]
fnHallo Welt() -> Inhalt:: Html'statischStr> {
 Inhalt:: Html("
Hallo Welt!
")
}

Der Hallo Welt Funktion gibt einen statischen HTML-String mit dem zurück Inhalt:: Html Funktion.

Hier ist eine Konfigurationsstrukturdeklaration für den Server (Rocket-Framework-Konvention):

StrukturKonfig {
 Hafen: u16,
}
#[erhalten("/Hafen")]
fnHafen(Konfiguration: Zustand) -> Schnur {
Format!("Server läuft auf Port {}", config.port)
}

Wenn Sie den Server ausführen, können Sie Anforderungen an den stellen /port Endpunkt für den Portstatus.

Abschließend erstellen Sie eine Serverinstanz mit der entzünden Funktion. Fügen Sie die Konfigurationen hinzu, mounten Sie die Routen und starten Sie den Server:

fnhauptsächlich() {
lassen config = Config {port: 8000 };
 Rakete:: zünden()
 .manage (Konfiguration)
 .montieren("/", Routen![hello_world, port])
 .Start();
}

Der Konfig Variable ist eine Instanz von Konfig Struktur. Der entzünden Funktion startet eine Serverinstanz, die verwalten -Methode fügt die Konfiguration dem Server hinzu, und die montieren -Methode stellt die Handler-Funktion auf den Basisrouten bereit. Endlich, das Start -Methode startet den Server, um den angegebenen Port zu überwachen.

Mit WASM können Sie leistungsstarke Webanwendungen in Rust erstellen

WebAssembly (WASM) ist ein binäres Anweisungsformat, das für die Ausführung auf Browsern und anderen Geräten entwickelt wurde. WASM bietet ein Low-Level-Bytecode-Format, das höhere Programmiersprachen wie Rust als Kompilierungsziel verwenden können.

Mit WASM können Sie Ihren Rust-Code in ein Binärformat kompilieren, das die meisten gängigen Browser ausführen können. WASM eröffnet eine Welt voller Möglichkeiten zum Erstellen robuster Webanwendungen in Rust, einschließlich Full-Stack-Webanwendungen.