So installierst du die Programmiersprache Rust unter Ubuntu 22.04

Die Programmiersprache Rust wurde bereits von Hunderten großer Unternehmen in Produktionsumgebungen eingesetzt. Von Anwendungen wie Dropbox, Firefox und Cloudflare bis hin zu eingebetteten Geräten und skalierbaren Webdiensten – Rust kann in all diesen Anwendungen und Einsatzgebieten verwendet werden.

rustup ist ein Tool des Rust-Projekts, mit dem du die Programmiersprache Rust auf deinem System installieren kannst. Mit rustup können Entwickler Rust einfach verwalten und pflegen. Außerdem kannst du damit zwischen Stable-, Beta- und Nightly-Compilern wechseln und den Cross-Compiling-Prozess vereinfachen.

Dieser Lehrgang führt dich durch die Installation der Programmiersprache Rust auf einem Ubuntu 22.04 Rechner. Du wirst zwei verschiedene Methoden kennenlernen, um Rust auf dem Ubuntu-System zu installieren. Jede Methode hat Vorteile gegenüber der anderen, so dass du entscheiden kannst, was du brauchst und welche Methode du für deinen Rechner verwenden willst.

Voraussetzungen

Für diese Anleitung brauchst du einen Ubuntu 22.04-Rechner – der auf Ubuntu Server und Desktop funktioniert – mit einem Nicht-Root-Benutzer mit sudo/root-Rechten.

Jetzt lass uns loslegen und Rust installieren!

Rust über die APT installieren

Das Standard-Repository von Ubuntu stellt das Rust-Compiler-Paket bereit. Zum Zeitpunkt der Erstellung dieses Artikels enthält das Ubuntu-Repository den Rust-Compiler v1.61. Die Installation von Rust über APT bietet sich an, wenn du eine Rust-Anwendung für ein Projekt hast und keine komplexe Umgebung für dein Projekt benötigst.

Führe zunächst den folgenden apt-Befehl aus, um deine Ubuntu-Repositories zu aktualisieren und aufzufrischen.

sudo apt update

Nachdem die Repositories aktualisiert wurden, führe den folgenden apt-Befehl aus, um Rust auf deinem System zu installieren.

sudo apt install rustc

Wenn du dazu aufgefordert wirst, gib y ein, um zu bestätigen, und drücke ENTER, um fortzufahren.

Nachdem Rust installiert ist, führe den folgenden Befehl aus, um die Rust-Binärdatei zu finden und die aktuelle Version von Rust auf deinem System zu überprüfen.

which rustc
rustc -Vv

Du erhältst eine Ausgabe ähnlich wie in diesem Screenshot – Die Rust-Binärdatei ist unter „/usr/bin/rustc“ verfügbar und die aktuelle Rust-Version auf dem System ist v1.61.0.

Nachdem du Rust installiert hast, lernst du als Nächstes, wie du das erste„Hello World„-Programm mit Rust erstellst.

Erstelle mit deinem Texteditor eine neue Datei„hello-world.rs„. Für Desktop-Nutzer kannst du schicke Code-Editoren wie vscodium oder sublime-text verwenden. Für CLI-Nutzer kannst du vim oder nano verwenden.

sudo nano hello-world.rs

Füge den folgenden Code in die Datei ein.

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

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

Als Nächstes kompilierst du die Rust-Datei„hello-world.rs“ mit dem unten stehenden ‚rustc‚ Befehl. Dadurch wird eine ausführbare Datei „hello-world“ in deinem aktuellen Arbeitsverzeichnis erzeugt.

rustc hello-world

Nachdem der Code kompiliert wurde, führe die Binärdatei „hello-world“ in deinem Terminal aus.

./hello-world

Du solltest eine Ausgabe erhalten wie‚Hello World, welcome to Rust.‚. Dies bestätigt, dass die Anwendung„hello-world“ erfolgreich kompiliert und ausgeführt wurde.

Wenn du Rust wieder von deinem Rechner entfernen möchtest, kannst du dies mit dem unten stehenden apt-Befehl tun.

sudo apt remove rustc
sudo apt autoremove -y

Installieren von Rust über rustup

Wenn du ein Rust-Entwickler sein willst, musst du dich mit dem Werkzeug rustup vertraut machen. Dies ist ein Toolchain-Multiplexer für deine Rust-Entwicklungsumgebung. Von der Funktionalität her ist rustup ähnlich wie rbenv für Ruby, nvm für Node.js oder Pyenv für Python.

Mit rustup kannst du eine isolierte Rust-Entwicklungsumgebung auf deinem System einrichten. Du kannst mehrere Versionen von Rust installieren und je nach Projekt mehrere Versionen von Entwicklungswerkzeugen, die auch Cross-Compiler für mehrere Betriebssysteme sein können.

In diesem Schritt installierst du Rust und rustup auf deinem System. Du verwendest dafür einen Nicht-Root-Benutzer, sodass sich die Installation nur auf deinen Benutzer und nicht auf das gesamte System auswirkt.

Bevor du also loslegst, melde dich mit dem unten stehenden Befehl als Benutzer an. In diesem Beispiel wird der Nicht-Root-Name ‚alice‚.

su - alice

Führe nun den folgenden apt-Befehl aus, um die Paketabhängigkeiten auf deinem Ubuntu-System zu installieren.

sudo apt install curl build-essential gcc make

Gib y ein, wenn du dazu aufgefordert wirst, und drücke ENTER, um fortzufahren.

Nachdem die Abhängigkeiten installiert sind, führe den folgenden Befehl aus, um rustup und Rust in deiner aktuellen Benutzerumgebung zu installieren. Dieser Befehl lädt das Rustup-Installationsprogramm herunter und führt es auf deinem System aus.

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

In der ersten Ausgabe solltest du eine Willkommensnachricht wie„Willkommen bei Rust!‚ und informiert dich darüber, dass das Installationsskript Rust und den Cargo-Paketmanager für Rust installiert. Außerdem wird das Rustup in das Verzeichnis „/home/username/.rustup“ installiert.

Als Nächstes wirst du aufgefordert, die Rust-Installation auf deinem System einzurichten. Dazu gehören die Standard-Rust-Toolchain(Stable-, Beta- oder Nightly-Version ) und die Installationsprofile ( Minimal, Standard oder Komplett).

Als Starter kannst du die Standardinstallation verwenden. Gib 1 ein und bestätige mit ENTER. Dann beginnt die Installation von Rustup, Rust und Cargo.

Nachdem die Installation abgeschlossen ist, erhältst du eine Meldung wie „Rust ist jetzt installiert. Großartig!“. Außerdem erhältst du die Anweisung, deine aktuelle Shell neu zu laden, um die neuen Änderungen an den PATH-Umgebungsvariablen anzuwenden. Du kannst sie aber auch manuell aus deiner aktuellen Sitzung laden.

Der folgende Befehl lädt die neuen Rustup-Umgebungsvariablen in die aktuelle Sitzung.

source "$HOME/.cargo/env"

Danach führst du den folgenden Befehl aus, um die Rust-Version, die in deiner aktuellen Umgebung installiert ist, und den Binärpfad von Rust zu überprüfen.

rustc -Vv
which rustc

Du solltest eine ähnliche Ausgabe erhalten wie diese – Du hast Rust v1.66 über rustup installiert und die Binärdatei des Rust-Compilers ist unter ‚/home/username/.cargo/bin/rustc‚ verfügbar.

Außerdem ist Rust 1.66 nur für deinen aktuellen Benutzer verfügbar, nicht systemweit.

Als Nächstes suchst du die Binärdatei für den Cargo-Paketmanager und die rustup-Software mit dem folgenden Befehl.

which cargo
which rustup

Du solltest sehen, dass sowohl die Cargo- als auch die Rustup-Binärdateien im Verzeichnis„/home/username/.cargo/bin“ verfügbar sind.

Überprüfe abschließend die Version des Cargo-Paketmanagers und die Rustup-Version mit dem folgenden Befehl.

cargo --version
rustup --version

Du erhältst eine Ausgabe ähnlich diesem Screenshot – The Cargo package manager v1.66 and rustup 1.25 is installed on your system

Damit hast du nun Rust zusammen mit den Rust-Entwicklungswerkzeugen wie dem Cargo-Paketmanager, rustc, Clippy, rustfmt und rust-docs installiert. Im nächsten Schritt erfährst du, wie du deine Rust-Installation über die rustup-Befehlszeile verwalten kannst.

Verwaltung der Rust-Umgebung mit rustup

rustup ist ein Toolchain-Multiplexer, mit dem du die Rust-Programmiersprache in deiner Umgebung installieren kannst. Dazu gehören auch die Rust-Entwicklungswerkzeuge wie der Cargo-Paketmanager, rustc, etc. Mit rustup kannst du mehrere Versionen der Rust-Programmiersprache und Entwicklungswerkzeuge installieren. So kannst du ganz einfach mehrere Projekte mit verschiedenen Versionen der Rust-Programmiersprache verwalten.

In diesen Schritten lernst du, wie du deine Rust-Umgebung mit dem Befehl rustup verwalten kannst. Du installierst mehrere Versionen von Rust und den Entwicklungswerkzeugen, richtest verschiedene Profile ein und wechselst zu ihnen und aktualisierst deine Rust-Umgebung mit rustup.

Einrichten des rustup-Befehls Autocomplete

Bevor du beginnst, richtest du eine Autovervollständigung für den Befehl rustup ein. Wenn die Autovervollständigung aktiviert ist, kannst du den Befehl rustup ausführen und dann die TAB-Taste drücken, um die Liste der verfügbaren Parameter zu erhalten. Jetzt generierst du das Skript für die Autovervollständigung von rustup, lädst das generierte Skript in deine Shell und überprüfst die Autovervollständigung.

Erstelle mit dem Befehl mkdir ein neues Verzeichnis„~/.local/share/bash-completion/completions/„.

mkdir -p ~/.local/share/bash-completion/completions/

Führe den folgenden Befehl aus, um die Autovervollständigung für den Rustup-Befehl in „~/.local/share/bash-completion/completions/rustup“ zu erstellen.

rustup completions bash > ~/.local/share/bash-completion/completions/rustup

Lade die Autovervollständigung mit dem unten stehenden Befehl in die aktuelle Sitzung.

source ~/.local/share/bash-completion/completions/rustup

Gib schließlich den Befehl„rustup“ ein und drücke TAB, um die Autovervollständigung des Befehls rustup zu erhalten.

rustup TAB

Du erhältst nun die Liste der verfügbaren Optionen für den Befehl rustup wie in diesem Screenshot.

Mehrere Versionen von Rust und Entwicklungswerkzeugen installieren

In der Rustup-Umgebung gibt es mehrere Versionen von Toolchains, darunter Stable, Beta und Nightly. Eine Toolchain ist eine Gruppe von Paketen mit der Programmiersprache Rust und Entwicklungswerkzeugen. Wenn du also mehrere Versionen von Toolchains über rustup installierst, bedeutet das, dass du auch mehrere Versionen der Rust-Programmiersprache und mehrere Versionen der Rust-Entwicklungswerkzeuge installiert hast.

Wenn mehrere Toolchains in deiner Umgebung installiert sind, kannst du mehrere Projekte mit verschiedenen Versionen der Rust-Programmiersprache verwalten.

Um zu beginnen, führe den folgenden Befehl rustup aus, um die Liste der Toolchain- oder Rust-Versionen auf deinem System zu überprüfen. Du solltest eine Ausgabe erhalten, dass diestabile Version von Rust auf deinem System installiert ist.

rustup toolchain list

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

rustup toolchain install nightly

Du erhältst nun eine Ausgabe wie in diesem Screenshot – Die Installation der nächtlichen Rust-Versionen einschließlich der Entwicklungswerkzeuge wie dem Cargo-Paketmanager, die im„Standard„-Rustup-Profil verfügbar sind.

Nachdem die neue nächtliche Version der Toolchain installiert ist, führe den folgenden Befehl aus, um die Liste der installierten Toolchains auf deinem System anzuzeigen.

rustup toolchain list

Du solltest eine Ausgabe wie diese erhalten – Es sind zwei Versionen der Toolchain auf deinem System installiert, die standardmäßige stabile Version und die neu installierte Version nightly.

Als Nächstes führst du den folgenden Befehl aus, um die Standard-Toolchain auf die Nightly-Version umzustellen. Das bedeutet, dass du auch die Entwicklungswerkzeuge auf eine neue Nightly-Version umstellst.

rustup default nightly

Überprüfe dann die Rust-Version mit dem unten stehenden Befehl. Du solltest sehen, dass die Nightly-Version von Rust v1.6x installiert ist und als Standard-Rust in deiner aktuellen Umgebung konfiguriert ist.

rustc -Vv

Außerdem kannst du die spezifische Version von Rust auch manuell mit dem Befehl rustup ausführen. Führe den folgenden Befehl aus, um die spezielle Rust-Nightly-Version über den Befehl rustup auszuführen.

rustup run nightly rustc -Vv

Du solltest die Rust-Nightly-Version 1.68 erhalten. Das bedeutet, dass du eine bestimmte Rust-Version mit dem rustup-Befehl ausgeführt hast. Du kannst auch andere Komponenten wie den Cargo-Paketmanager ausführen.

Nachdem du nun die Toolchain von Rustup kennengelernt hast, erkundest du als Nächstes die Rustup-Profile in deiner Umgebung.

Einrichten von Profilen in rustup

Ein weiteres Konzept in Rustup, das du kennenlernen wirst, ist das „Profil“, das eine Gruppe von Komponenten deiner Rust-Umgebung darstellt. Es gibt drei verschiedene Profile in Rustup, hier ist die Liste:

• minimal – enthält nur wenige Komponenten wie den rustc-Compiler, den Cargo-Paketmanager und rust-std.
• Standard – Dieses Profil enthält die Komponenten des Minimalprofils, fügt aber noch einige andere Tools wie rust-docs, rustfmt und Clippy hinzu. Dies ist das Standardprofil, wenn du Rust über rustup installiert hast.
• vollständig – Dieses Profil enthält alle Komponenten der Rust-Installation über rustup. Du solltest dieses Profil nicht verwenden, wenn du nicht weißt, was du tust. Du kannst Komponenten über Rustup immer manuell über den Befehl rustup hinzufügen.

In diesem Abschnitt lernst du, wie du mit dem Rustup-Befehl zu den verschiedenen Profilen wechseln kannst.

Führe den folgenden Befehl aus, um das aktuelle Profil in deiner Umgebung zu überprüfen. Du solltest sehen, dass das Profil„default“ aktiviert ist.

rustup show profile

Als Nächstes führst du den folgenden Befehl aus, um zum Profil„minimal“ zu wechseln. Überprüfe dann erneut dein aktuelles Profil.

rustup set profile minimal
rustup show profile

Du solltest eine Ausgabe wie diese erhalten – Das aktuelle Profil wurde auf „minimal“ geändert.

Abschließend kannst du die Änderungen mit dem folgenden Befehl rückgängig machen, um zumStandardprofil zurückzukehren.

rustup set profile default

Rust über rustup aktualisieren

Der große Vorteil von rustup als Hauptwerkzeug zur Verwaltung der Rust-Umgebung ist, dass du deine Rust-Programmiersprache und alle Komponenten der Entwicklungswerkzeuge ganz einfach auf die neuesten Versionen aktualisieren kannst.

Um deine Rust-Installation zu aktualisieren, führe den unten stehenden Befehl rustup aus. Dadurch werden alle verfügbaren Toolchains in deiner Rust-Umgebung aktualisiert, einschließlich der Komponenten der Entwicklungswerkzeuge in der Toolchain, wie z. B. der Cargo-Paketmanager, der rustc-Compiler und Clippy.

rustup update

Du solltest jetzt eine Ausgabe wie diese erhalten – Der Befehl rustup gleicht die aktuell installierte Toolchain-Version mit der neuesten Version ab, die auf der offiziellen Rust-Website verfügbar ist. Sobald ein neues Update verfügbar ist, wird es angewendet.

Rust-Projekt mit Cargo erstellen und verwalten

Jetzt hast du gelernt, wie du mit rustup deine Rust-Entwicklungsumgebung verwalten kannst. In diesem Schritt lernst du, wie du den Cargo-Paketmanager verwendest, um ein Rust-Projekt zu erstellen, zu testen, zu kompilieren und deine Rust-Anwendung auszuführen.

Erstelle ein neues Projekt„hello-world“ mit dem Befehl„cargo new“ (siehe unten). Dadurch wird ein neues Projektverzeichnis„hello-world“ in deinem aktuellen Arbeitsverzeichnis erstellt.

cargo new hello-world

Wechsle in das Arbeitsverzeichnis„hello-world“ und überprüfe die Liste der darin enthaltenen Dateien mit dem unten stehenden Befehl tree. Du solltest die Datei„Cargo.toml“ sehen, die die Hauptkonfiguration des Cargo-Paketmanagers ist, und das Verzeichnis„src„, in dem du deinen Rust-Quellcode speichern wirst.

cd hello-world/
tree .

Öffne die Datei „src/main.rs“ mit deinem Texteditor.

nano src/main.rs

Ändere den Standard-Quellcode durch die folgenden Zeilen.

fn main() {
    println!("Hello World, Rust with rustup and cargo.");
}

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

Als Nächstes führst du den folgenden Befehl aus, um das Projekt„hello-world“ zu bauen und zu kompilieren. Mit diesem Befehl wird dein„hello-world“- Projekt automatisch in das neue Verzeichnis„target“ kompiliert.

cargo build

Führe nun den unten stehenden Befehl„cargo test“ aus, um dein Rust-Projekt zu überprüfen.

cargo test

Du solltest eine Ausgabe wie diese erhalten. Wenn der Test erfolgreich war, solltest du eine Meldung wie„test result: ok“ erhalten.

Zuletzt führst du den folgenden Befehl aus, um das Projekt„hello-world“ auszuführen.

cargo run

Du solltest eine Ausgabe wie diese erhalten – Das Projekt„hello-world“ wurde erfolgreich ausgeführt.

Rust und rustup deinstallieren

Die Rustup-Installation betrifft nur deine aktuelle Benutzerentwicklungsumgebung, nicht das gesamte System. Das macht dein System sauber und die Deinstallation einfacher. Du kannst rustup mit allen Toolchains und Entwicklungswerkzeugen deinstallieren, indem du das rustup-Installationsverzeichnis ‚/home/username/.rustup‚ und das Rust-Toolchain-Verzeichnis‚/home/username.cargo‚ entfernst.

Führe den folgenden Befehl aus, um Rust und rustup aus deiner aktuellen Entwicklungsumgebung zu deinstallieren.

rm -rf ~/.cargo ~/.rustup

Als Nächstes entfernst du den Befehl autocomplete, den du mit dem unten stehenden Befehl erstellt hast.

rm -f ~/.local/share/bash-completion/completions/rustup

Damit hast du Rust und rustup deinstalliert und von deinem System entfernt.

Fazit

In dieser Anleitung hast du gelernt, wie du die Programmiersprache Rust mit zwei Methoden auf einem Ubuntu 22.04 Rechner installieren kannst. Du hast Rust über APT aus dem Ubuntu-Repository installiert, das sich eignet, wenn du nur Rust-Anwendungen kompilieren willst. Zweitens hast du Rust über rustup installiert, was geeignet und empfehlenswert ist, wenn du ein Rust-Entwickler werden willst.

Außerdem hast du gelernt, wie du mehrere Rust-Versionen über rustup installierst, mehrere Toolchains über rustup umschaltest und die grundlegende Verwendung von Cargo zum Erstellen von Rust-Projekten, Kompilieren, Testen und Ausführen von Rust-Anwendungen erlernst.