Leitfaden zur Installation von Rust und Verwendung des Cargo-Paketmanagers auf AlmaLinux 9

Rust ist eine moderne Systemprogrammiersprache, die erstmals 2010 veröffentlicht wurde. Rust wurde entwickelt, um häufige Probleme in anderen Programmiersprachen zu lösen, wie z. B. Speichersicherheit, Parallelität und Leistung. Rust wird jetzt sogar im Linux-Kernel verwendet.

Warum Rust verwenden

Speichersicherheit

Rust garantiert die Speichersicherheit durch Überprüfungen zur Kompilierzeit und strenge Eigentumsregeln. Dies vermeidet häufige Programmierfehler wie Nullzeiger-Dereferenzen, Pufferüberläufe und Datenüberläufe.

Parallelität

Rust hat eine eingebaute Unterstützung für paralleles Programmieren. Es bietet leichte Threads, die als “Tasks” bezeichnet werden, und ein leistungsfähiges Typsystem, das die Thread-Sicherheit gewährleistet.

Leistung

Rust bietet Abstraktionen auf eine Weise, die sicherstellt, dass hochgradige Programmierkonstrukte keine Laufzeitkosten verursachen. Dies erleichtert es Entwicklern, sicheren und schnellen Code zu schreiben.

Eigentumsmodell

Der Speicher wird von Rust aufgrund seines eingebauten Eigentumsmodells effizient verwaltet. Es erzwingt strenge Regeln für Eigentum, Ausleihen und Lebensdauer und verhindert häufige Fehler wie Use-after-free und Double-free.

Cargo

Rust hat einen leistungsstarken Paketmanager und ein Build-System namens Cargo. Es erleichtert die Verwaltung von Abhängigkeiten, den Aufbau von Projekten und das Ausführen von Tests.

Einfache Syntax

Rust hat eine saubere und ausdrucksstarke Syntax, die von C++ beeinflusst ist, sich jedoch auf Lesbarkeit und Einfachheit konzentriert. Es bietet Musterabgleich, Closures, Generics und andere moderne Sprachmerkmale.

Rust glänzt dort, wo Leistung, Zuverlässigkeit und Sicherheit wichtig sind, und wird häufig zur Entwicklung von Betriebssystemen (wie Linux), eingebetteten Systemen, Gerätetreibern, Netzwerkdiensten, Spiel-Engines und anderer leistungs-kritischer Software verwendet.

In diesem Leitfaden führen wir Sie durch den Installationsprozess der Rust-Programmiersprache auf AlmaLinux 9. Sie werden Rust mit zwei verschiedenen Methoden installieren und die grundlegende Verwendung des Cargo-Paketmanagers zum Erstellen und Verwalten des Rust-Projekts erlernen.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

• Eine AlmaLinux 9-Maschine - Server- oder Desktop-Version.
• Ein Nicht-Root-Benutzer mit Root-/Administratorrechten.

Installation von Rust über das AppStream-Repository

Auf AlmaLinux 9 bietet das Standard-AppStream-Repository ein Rust-Paket, das Sie einfach über DNF installieren können. Außerdem gibt es das Cargo-Paket, das der Rust-Paketmanager und die Abhängigkeitsverwaltung für Ihr Rust-Projekt ist.

Dieser Abschnitt zeigt Ihnen, wie Sie Rust und den Cargo-Paketmanager auf AlmaLinux 9 über das AppStream-Repository installieren.

Geben Sie zunächst den folgenden dnf-Befehl ein, um die detaillierten Informationen zu Rust zu überprüfen, die im AlmaLinux-Repository verfügbar sind.

sudo dnf info rust

Im folgenden Ausgabe sehen Sie die Rust v1.66, die im AlmaLinux-AppStream-Repository verfügbar ist.

Führen Sie nun den folgenden Befehl aus, um Rust und den Cargo-Paketmanager auf Ihrem System zu installieren. Geben Sie y ein, wenn Sie dazu aufgefordert werden, und drücken Sie ENTER.

sudo dnf install rust cargo

Sobald Rust und Cargo installiert sind, führen Sie den folgenden Befehl aus, um den Speicherort der Binärdateien für Rust und Cargo zu überprüfen.

which rust  
which cargo

Überprüfen Sie dann die Rust- und Cargo-Version mit dem folgenden Befehl.

rustc --version  
cargo --version

Sie sehen die folgende Ausgabe, die bestätigt, dass Rust und Cargo v1.66 über das AppStream-Repository installiert sind.

Installation von Rust über Rustup

Eine weitere Methode zur Installation von Rust ist über rustup, ein Toolchain-Multiplexer für Ihre Rust-Entwicklungsumgebung. Es ist ähnlich wie rbenv für Ruby, nvm für Node.js oder Pyenv für Python.

Sie können rustup sowohl in systemweiten Umgebungen als auch in benutzerspezifischen Umgebungen installieren. Im folgenden Abschnitt installieren Sie Rust über rustup systemweit, sodass jeder Benutzer Ihre Rust-Installation ausführen kann.

Installation der Abhängigkeiten

Bevor Sie rustup installieren, müssen Sie die Paketabhängigkeiten dafür installieren. Sie müssen das EPEL-Repository zu Ihrem System hinzufügen und einige Entwicklungstools wie gcc, make und cmake installieren.

Führen Sie zunächst den dnf-Befehl unten aus, um das EPEL-Repository zu Ihrem System hinzuzufügen.

sudo dnf install epel-release

Geben Sie y ein und drücken Sie ENTER, um zu bestätigen.

Installieren Sie dann einige Paketabhängigkeiten mit dem folgenden dnf-Befehl.

sudo dnf install cmake gcc make wget tree -y

Sobald die Abhängigkeiten installiert sind, fahren Sie mit der Installation von Rustup fort.

Installation von Rust und Rustup

rustup kann einfach installiert werden. Es bietet ein Installationsskript, das Sie auf jeder Linux-Distribution ausführen können.

Jetzt werden Sie rustup installieren, das die stabile Version von Rust und den Cargo-Paketmanager umfasst. Sie werden auch die Umgebungsvariable RUSTUP_HOME einrichten und den Binärpfad von rustup zum System PATH hinzufügen.

Führen Sie den folgenden Befehl aus, um den Rustup-Installer herunterzuladen, und installieren Sie dann Rustup im Verzeichnis /opt/rust.

wget -qO - https://sh.rustup.rs | sudo RUSTUP_HOME=/opt/rust CARGO_HOME=/opt/rust sh -s -- --no-modify-path -y

Die Ausgabe während der Rustup-Installation.

Sobald Rustup installiert ist, wird die Ausgabemeldung “ Rust ist jetzt installiert. Großartig! “ wie folgt angezeigt:

Führen Sie als Nächstes den folgenden Befehl aus, um /opt/rust einzurichten und das /opt/rust/bin-Verzeichnis zum System PATH hinzuzufügen.

echo 'export RUSTUP_HOME=/opt/rust' | sudo tee -a /etc/profile.d/rust.sh  
echo 'export PATH=$PATH:/opt/rust/bin' | sudo tee -a /etc/profile.d/rust.sh

Laden Sie die /etc/profile neu, um die neuen Systemumgebungsvariablen anzuwenden.

source /etc/profile

Überprüfen Sie danach sowohl die RUSTUP_HOME- als auch die PATH-Umgebungsvariablen mit dem folgenden Befehl.

echo $RUSTUP_HOME  
echo $PATH

Aus der Ausgabe können Sie sehen, dass RUSTUP_HOME auf das /opt/rust-Verzeichnis zeigt und das /opt/rust/bin-Verzeichnis zum System-PATH hinzugefügt wurde.

Führen Sie nun den folgenden Befehl aus, um den Speicherort der Rust-Binärdatei zu überprüfen und die Rust-Version zu verifizieren.

which rustc  
rustc -V

Führen Sie dann den folgenden Befehl aus, um den Speicherort der Cargo-Binärdatei zu überprüfen und die Cargo-Version zu verifizieren.

which cargo  
cargo -V

Die angezeigte Ausgabe sollte bestätigen, dass die Rust- und Cargo-Binärdatei im /opt/rust/bin-Verzeichnis gespeichert ist. Und die installierte Version von Rust und Cargo ist v1.69.

Verwaltung der Toolchain

In rustup gibt es einige Konzepte wie Toolchain und Channel. Ein Channel ist der Ort, an dem die Rust-Version bereitgestellt wird, Sie können aus verschiedenen Builds wie stabil, beta und nightly auswählen. Eine Toolchain ist eine einzelne Installation des Rust-Compilers, und Sie können mehrere Toolchains in Ihrer rustup-Umgebung installieren.

In diesem Abschnitt lernen Sie, wie Sie die rustup-Toolchain über den rustup-Befehl verwalten.

Führen Sie zunächst den folgenden Befehl aus, um die bas-Vervollständigung für den rustup-Befehl zu generieren und die neue bash-Vervollständigung zu laden. Dies vereinfacht die Rust-Verwaltung über rustup.

rustup completions bash > /usr/share/bash-completion/completions/rustup  
source /etc/profile.d/bash_completion.sh

Geben Sie jetzt den rustup-Befehl ein und drücken Sie TAB, um die Liste der verfügbaren Optionen für rustup zu erhalten.

rustup TAB

Wenn die rustup-Bash-Vervollständigung erfolgreich ist, sollten Sie die Ausgabe der verfügbaren Optionen für den rustup-Befehl erhalten.

Führen Sie als Nächstes den rustup-Befehl unten aus, um die Informationen zu Ihrer Rust- und rustup-Installation zu überprüfen.

rustup show

Aus der folgenden Ausgabe sollten Sie den Speicherort des rustup-Heimverzeichnisses /opt/rust und den standardmäßigen stabilen Channel von rustup sehen, der auf Ihrem System installiert ist.

Führen Sie als Nächstes den folgenden Befehl aus, um eine andere rustup-Toolchain-Version zu installieren. In diesem Beispiel installieren Sie die nightly-Version von rustup.

rustup toolchain install nightly

Nachdem rustup nightly installiert ist, führen Sie den folgenden Befehl aus, um die Liste der verfügbaren rustup-Toolchains zu überprüfen. Und Sie sollten zwei Versionen der rustup-Toolchain sehen, die stabile und nightly Versionen.

rustup toolchain list

Führen Sie nun den rustup-Befehl unten aus, um zu einer anderen Version der Toolchain zu wechseln. In diesem Beispiel wechseln Sie zur rustup nightly.

rustup default nightly

Überprüfen Sie nun die aktuelle Version von Rust und Cargo mit dem folgenden Befehl. Sie sollten sehen, dass Rust und Cargo v1.71 derzeit im System verwendet werden.

rustc -V  
cargo -V

Erstellen Sie Ihr erstes Rust-Projekt

Mit der installierten Rust-Programmiersprache und dem Cargo-Paketmanager werden Sie jetzt Ihr erstes Rust-Projekt über Cargo erstellen.

Zuerst melden Sie sich mit dem folgenden Befehl bei Ihrem Benutzer an.

su - username

Jetzt erstellen Sie ein neues Rust-Projekt mit dem folgenden Cargo-Befehl. In diesem Beispiel erstellen Sie ein neues Projekt hello_rust.

cargo new hello_rust

Nachdem der Befehl ausgeführt wurde, sollten Sie sehen, dass das neue Verzeichnis hello_rust erstellt wird.

Wechseln Sie in das hello_rust-Verzeichnis und führen Sie den folgenden tree-Befehl aus, um die Liste der verfügbaren Dateien und Verzeichnisse zu erhalten.

cd hellow_rust/  
tree .

Sie sollten die Datei Config.toml sehen, die Informationen über Ihre Anwendung und alle erforderlichen Abhängigkeiten speichert, sowie das Verzeichnis src, das den Quellcode der Rust-Anwendung enthält.

Unten finden Sie den ähnlichen Inhalt der Config.toml-Datei. Ändern Sie ihn nach Bedarf, und wenn Sie Abhängigkeiten für Ihre Rust-Anwendung haben, fügen Sie diese im Abschnitt [dependencies] hinzu.

[package]  
name = "hello_rust"  
version = "0.1.1"  
edition = "2021"  
  
[dependencies]

Öffnen Sie als Nächstes die Datei src/main.rs mit Ihrem bevorzugten Editor und ändern Sie die Standardnachricht “Hello World” in diese.

fn main() {  
    println!("Hello World, willkommen bei Rust.");  
}

Speichern Sie die Datei und beenden Sie den Editor, wenn Sie fertig sind.

Führen Sie nun den folgenden Cargo-Befehl aus, um das Rust-Projekt zu kompilieren und zu erstellen. Überprüfen Sie dann erneut die Liste der Dateien und Verzeichnisse, nachdem das Projekt kompiliert wurde.

cargo build  
tree .

Sie sollten ein neues Verzeichnis namens target sehen, das generiert wird, in dem Ihre kompilierte Anwendung gespeichert ist.

Führen Sie nun den folgenden Cargo-Befehl aus, um die Anwendung auszuführen. Sie sollten eine Ausgabe wie “ Hello World, willkommen bei Rust “ sehen.

cargo run

Zusätzlich können Sie auch die Binärdatei Ihrer Rust-Anwendung direkt so ausführen.

./target/debug/hello_rust

Und Sie sollten die gleiche Ausgabe erhalten.

Fazit

Gut gemacht! Sie haben alle Schritte befolgt und Rust auf Ihrem AlmaLinux 9-System installiert. Sie haben zwei Methoden zur Installation von Rust über das AlmaLinux-AppStream-Repository und rustup gelernt.

Darüber hinaus haben Sie auch gelernt, wie man zwischen mehreren Versionen der rustup-Toolchain wechselt und wie man die erste Rust-Anwendung/das erste Rust-Projekt über Cargo - den Rust-Paketmanager und Abhängigkeitsmanager erstellt.