Anleitung zur Installation von Rust und zur Verwendung des Cargo Package Managers unter 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, z. B. Speichersicherheit, Gleichzeitigkeit und Leistung. Rust wird jetzt sogar im Linux-Kernel verwendet.

Warum Rust verwenden

Speichersicherheit

Rust garantiert Speichersicherheit durch Überprüfungen bei der Kompilierung und strenge Eigentumsregeln. Dadurch werden häufige Programmierfehler wie Nullzeiger-Dereferenzen, Pufferüberläufe und Datenüberläufe vermieden.

Gleichzeitigkeit

Rust hat eine eingebaute Unterstützung für nebenläufige Programmierung. Es bietet leichtgewichtige Threads, die „Tasks“ genannt werden, und ein leistungsfähiges Typsystem, das die Sicherheit von Threads gewährleistet.

Leistung

Rust bietet Abstraktionen, so dass High-Level-Programmierkonstrukte keinen Laufzeit-Overhead verursachen. Das macht es für Entwickler einfacher, sicheren und schnellen Code zu schreiben.

Ownership-Modell

Speicher wird in Rust dank des eingebauten Eigentumsmodells effizient verwaltet. Es setzt strenge Regeln für Besitz, Ausleihe und Lebensdauer durch und verhindert so häufige Fehler wie use-after-free und double-free.

Ladung

Rust hat einen leistungsstarken Paketmanager und ein Build-System namens Cargo. Es macht es einfach, Abhängigkeiten zu verwalten, Projekte zu bauen und Tests durchzuführen.

Einfache Syntax

Rust hat eine saubere und ausdrucksstarke Syntax, die von C++ beeinflusst ist, sich aber auf Lesbarkeit und Einfachheit konzentriert. Sie bietet Pattern Matching, Closures, Generics und andere moderne Sprachfunktionen.

Rust glänzt dort, wo Leistung, Zuverlässigkeit und Sicherheit wichtig sind, und wird häufig für die Entwicklung von Betriebssystemen (wie Linux), eingebetteten Systemen, Gerätetreibern, Netzwerkdiensten, Game-Engines und anderer leistungskritischer Software verwendet.

In diesem Leitfaden führen wir dich durch den Installationsprozess der Programmiersprache Rust auf AlmaLinux 9. Du wirst Rust mit zwei verschiedenen Methoden installieren und die grundlegende Verwendung des Cargo-Paketmanagers zur Erstellung und Verwaltung des Rust-Projekts kennenlernen.

Voraussetzungen

Bevor du anfängst, solltest du sicherstellen, dass du folgende Voraussetzungen hast:

• Einen AlmaLinux 9 Rechner – Server oder Desktop Version.
• Einen Nicht-Root-Benutzer mit Root-/Administrator-Rechten.

Installation von Rust über das AppStream Repository

Unter AlmaLinux 9 bietet das Standard-AppStream-Repository ein Rust-Paket, das du einfach über DNF installieren kannst. Außerdem gibt es das Cargo-Paket, das den Rust-Paketmanager und die Abhängigkeitsverwaltung für dein Rust-Projekt darstellt.

In diesem Abschnitt erfährst du, wie du Rust und den Cargo-Paketmanager über das appstream-Repository auf AlmaLinux 9 installierst.

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

sudo dnf info rust

In der folgenden Ausgabe kannst du sehen, dass Rust v1.66 im AlmaLinux appstream Repository verfügbar ist.

Führe nun den folgenden Befehl aus, um Rust und den Cargo-Paketmanager auf deinem System zu installieren. Gib y ein, wenn du dazu aufgefordert wirst, und drücke ENTER.

sudo dnf install rust cargo

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

which rust
which cargo

Überprüfe dann die Version von Rust und Cargo mit dem folgenden Befehl.

rustc --version
cargo --version

Du wirst die folgende Ausgabe sehen, die bestätigt, dass Rust und Cargo v1.66 über das appstream Repository installiert sind.

Installation von Rust über Rustup

Eine andere Methode zur Installation von Rust ist rustup, ein Toolchain-Multiplexer für deine Rust-Entwicklungsumgebung. Er ist vergleichbar mit rbenv für Ruby, nvm für Node.js oder Pyenv für Python.

Du kannst rustup sowohl in systemweiten Umgebungen als auch in benutzerspezifischen Umgebungen installieren. Im folgenden Abschnitt wirst du Rust über rustup systemweit installieren, sodass jeder Benutzer deine Rust-Installation ausführen kann.

Installieren von Abhängigkeiten

Bevor du rustup installierst, musst du die Paketabhängigkeiten für das Programm installieren. Du musst das EPEL-Repository zu deinem System hinzufügen und einige Entwicklungswerkzeuge wie gcc, make und cmake installieren.

Führe zunächst den folgenden dnf-Befehl aus, um das EPEL-Repository zu deinem System hinzuzufügen.

sudo dnf install epel-release

Gib y ein und drücke ENTER zur Bestätigung.

Dann installierst du einige Paketabhängigkeiten mit dem unten stehenden dnf-Befehl.

sudo dnf install cmake gcc make wget tree -y

Sobald die Abhängigkeiten installiert sind, kannst du mit der Installation von Rustup beginnen.

Installation von Rust und Rustup

rustup kann ganz einfach installiert werden. Es bietet ein Installationsskript, das du auf jeder Linux-Distribution ausführen kannst.

Jetzt installierst du rustup, das die stabile Version von Rust und den Cargo-Paketmanager enthält. Außerdem richtest du die Umgebungsvariable RUSTUP_HOME ein und fügst den Binärpfad von rustup zum Systempfad hinzu.

Führe den folgenden Befehl aus, um das Rustup-Installationsprogramm herunterzuladen, und installiere dann Rustup in das 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 Meldung„Rust is installed now. Großartig!“ wird wie folgt angezeigt:

Als Nächstes führst du den folgenden Befehl aus, um das Verzeichnis /opt/rust einzurichten und das Verzeichnis /opt/rust/bin zum Systempfad 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

Lade die /etc/profile neu, um die neuen Systemumgebungsvariablen zu übernehmen.

source /etc/profile

Danach überprüfst du die beiden Umgebungsvariablen RUSTUP_HOME und PATH mit dem folgenden Befehl.

echo $RUSTUP_HOME
echo $PATH

Anhand der Ausgabe kannst du sehen, dass RUSTUP_HOME auf das Verzeichnis /opt/rust zeigt und das Verzeichnis /opt/rust/bin zum Systempfad hinzugefügt wurde.

Führe 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ühre 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 sich die Rust- und Cargo-Binärdatei im Verzeichnis /opt/rust/bin befindet. Und die installierte Version von Rust und Cargo ist v1.69.

Toolchain verwalten

In Rustup gibt es ein Konzept wie Toolchain und Channel. In einem Channel steht die Rust-Version. Du kannst zwischen verschiedenen Builds wie Stable, Beta und Nightly wählen. Eine Toolchain ist eine einzelne Installation des Rust-Compilers, und du kannst mehrere Toolchains in deiner Rustup-Umgebung installieren.

In diesem Abschnitt erfährst du, wie du die Rustup-Toolchain mit dem Befehl rustup verwalten kannst.

Führe zunächst den folgenden Befehl aus, um die bas-Vervollständigung für den Befehl rustup zu erzeugen und die neue bash-Vervollständigung zu laden. Dadurch wird die Verwaltung von Rust über rustup vereinfacht.

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

Gib nun den Befehl rustup ein und drücke TAB, um die Liste der verfügbaren Optionen für rustup zu erhalten.

rustup TAB

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

Als Nächstes führst du den rustup-Befehl aus, um die Informationen über deine Rust- und rustup-Installation zu überprüfen.

rustup show

Der Ausgabe unten kannst du entnehmen, wo sich das Rustup-Home-Verzeichnis /opt/rust befindet und dass der Standard-Stable-Channel von Rustup auf deinem System installiert ist.

Als Nächstes führst du den folgenden Befehl aus, um eine andere Rustup-Toolchain-Version zu installieren. In diesem Beispiel installierst du die Nightly-Version von Rustup.

rustup toolchain install nightly

Nachdem rustup nightly installiert ist, führe den folgenden Befehl aus, um die Liste der verfügbaren Rustup-Toolchains zu überprüfen. Du solltest zwei Versionen der Rustup-Toolchain sehen, die stabile und die nightly-Version.

rustup toolchain list

Führe nun den folgenden rustup-Befehl aus, um zu einer anderen Version der Toolchain zu wechseln. In diesem Beispiel wechselst du zu rustup nightly.

rustup default nightly

Überprüfe nun die aktuelle Version von Rust und Cargo mit dem folgenden Befehl. Du solltest sehen, dass Rust und Cargo v1.71 derzeit auf dem System verwendet werden.

rustc -V
cargo -V

Erstes Rust-Projekt erstellen

Nachdem du die Programmiersprache Rust und den Cargo-Paketmanager installiert hast, wirst du nun das erste Rust-Projekt über Cargo erstellen.

Melde dich zunächst mit folgendem Befehl bei deinem Benutzer an.

su - username

Erstelle nun ein neues Rust-Projekt mit dem unten stehenden Cargo-Befehl. In dieser Demo wirst du ein neues Projekt hello_rust erstellen.

cargo new hello_rust

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

Wechsle in das Verzeichnis hello_rust und führe den unten stehenden Befehl tree aus, um die Liste der verfügbaren Dateien und Verzeichnisse zu erhalten.

cd hellow_rust/
tree .

Du solltest die Datei COnfig.toml sehen, in der Informationen über deine Anwendung und alle erforderlichen Abhängigkeiten gespeichert sind, sowie das Verzeichnis src, das den Quellcode der Rust-Anwendung enthält.

Nachfolgend siehst du den ähnlichen Inhalt der Datei Config.toml. Ändere sie nach Bedarf ab und wenn du Abhängigkeiten für deine Rust-Anwendung hast, füge sie in den Abschnitt [dependencies] ein.

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

[dependencies]

Als Nächstes öffnest du die Datei src/main.rs mit deinem bevorzugten Editor und änderst die Standardmeldung „Hello World“ in diese.

fn main() {
    println!("Hello World, welcome to Rust.");
}

Speichere die Datei und beende den Editor, wenn du fertig bist.

Führe nun den Befehl cargo aus, um das Rust-Projekt zu kompilieren und zu bauen. Überprüfe dann noch einmal die Liste der Dateien und Verzeichnisse, nachdem das Projekt kompiliert wurde.

cargo build
tree .

Du solltest sehen, dass ein neues Verzeichnis namens target erstellt wurde, in dem deine kompilierte Anwendung gespeichert wird.

Führe nun den unten stehenden cargo-Befehl aus, um die Anwendung zu starten. Du solltest eine Ausgabe wie„Hello World, welcome to Rust“ sehen.

cargo run

Außerdem kannst du die Binärdatei deiner Rust-Anwendung auch direkt so ausführen.

./target/debug/hello_rust

Dann solltest du die gleiche Ausgabe erhalten.

Fazit

Gut gemacht! Du hast alle Schritte befolgt und Rust auf deinem AlmaLinux 9 System installiert. Du hast zwei Methoden kennengelernt, um Rust über das AlmaLinux appstream Repository und rustup zu installieren.

Außerdem hast du gelernt, wie du zwischen mehreren Versionen der Rustup-Toolchain wechseln kannst und wie du die erste Rust-Anwendung/das erste Rust-Projekt mit Cargo – dem Rust-Paketmanager und dem Abhängigkeitsmanager – erstellst.