DEV Community: Ismayil Mirzali

Setting up Rust on macOS in a clean way

Ismayil Mirzali — Sun, 10 Jul 2022 13:11:19 +0000

Introduction

When I first wanted to get started with Rust, I was a bit confused about the suggested way of installation for its toolchain, at least on a Mac device. If you're not familiar, there are mainly 3 common ways that people install Rust on Mac:

A lot of people simply run the following command as suggested by the Rust website: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

My concern with this method is that it's not immediately clear how to do a clean uninstall in the future. You'd also need to read through the shell script to understand what it's exactly doing.
Another option is to install the rust formula with brew.

This is better, however, you're essentially installing a single toolchain for your given native hardware, as it looks like rustup is not part of this formula, so you cannot easily cross-compile by adding other toolchains.
The last option is to install the rustup-init formula instead, which I consider to be the best option, however, some extra manual work is needed and I will walk you through it.

Setting up your environment variables for rustup

I like to keep my $HOME directory clean, so I try to conform to the XDG Base Directory Specification as much as possible. Here are the XDG variables I've set in my ~/.zshenv.

export XDG_CONFIG_HOME="$HOME"/.config
export XDG_DATA_HOME="$HOME"/.local/share
export XDG_CACHE_HOME="$HOME"/.cache

Rust allows us to configure the location for its toolchain as well with environmental variables, here I've set the two most important ones like so.

export CARGO_HOME="$XDG_DATA_HOME"/cargo
export RUSTUP_HOME="$XDG_DATA_HOME"/rustup

Installation

We can now install rustup-init and run it

brew install rustup-init
rustup-init

We will be greeted with the rust installation process

Welcome to Rust!

This will download and install the official compiler for the Rust
programming language, and its package manager, Cargo.

Rustup metadata and toolchains will be installed into the Rustup
home directory, located at:

  /Users/xs/.local/share/rustup

This can be modified with the RUSTUP_HOME environment variable.

The Cargo home directory located at:

  /Users/xs/.local/share/cargo

This can be modified with the CARGO_HOME environment variable.

The cargo, rustc, rustup and other commands will be added to
Cargo's bin directory, located at:

  /Users/xs/.local/share/cargo/bin

This path will then be added to your PATH environment variable by
modifying the profile files located at:

  /Users/xs/.profile
  /Users/xs/.zshenv

You can uninstall at any time with rustup self uninstall and
these changes will be reverted.

Current installation options:


   default host triple: aarch64-apple-darwin
     default toolchain: stable (default)
               profile: default
  modify PATH variable: yes

1) Proceed with installation (default)
2) Customize installation
3) Cancel installation

Confirm that the suggested directories line up with directories that you set using the env vars. I personally like to disable the PATH var modification since I like to control that manually. Here's my current PATH in my .zshrc

path=(
    "$HOME"/go/bin
    "$XDG_DATA_HOME"/cargo/bin
    "$HOME"/.krew/bin
    /opt/homebrew/opt/make/libexec/gnubin
    /opt/homebrew/opt/man-db/libexec/bin
    /opt/homebrew/opt/grep/libexec/gnubin
    /opt/homebrew/opt/gnu-tar/libexec/gnubin
    /opt/homebrew/opt/gnu-sed/libexec/gnubin
    /opt/homebrew/opt/findutils/libexec/gnubin
    /opt/homebrew/opt/coreutils/libexec/gnubin
    $path
)

Setting up shell completion

By default, most formulae will install the shell completion into the $(brew --prefix)/share/zsh/site-functions. I'd prefer not to do manual changes on the Homebrew directory, so we can set up another directory in our home dir. I like to set the $fpath variable in my .zshrc like so:

fpath=(
    /opt/homebrew/share/zsh/site-functions
    "$XDG_DATA_HOME"/zsh/site-functions
    $fpath
)

So I simply create the directory in "$XDG_DATA_HOME"/zsh/site-functions and write my shell completion files there like so.

rustup completion zsh cargo > $XDG_DATA_HOME/zsh/site-functions/_cargo
rustup completion zsh rustup > "$XDG_DATA_HOME"/zsh/site-functions/_rustup

Note: If you use bash or fish, you can simply just read more using rustup completions --help

Relaunch your shell and your shell completion should work as intended. And now you can finally manage all your toolchains easily with rustup toolchain command. I consider this to be the "cleanest" way to install and manage Rust on Mac and hope this was helpful for some.

Kubernetes: Minikube with QEMU/KVM on Arch

Ismayil Mirzali — Mon, 24 Aug 2020 23:28:32 +0000

Minikube is a tool for easily creating Kubernetes clusters locally.

It boasts features like supporting multiple container runtimes and even Load Balancers so you can easily test your deployments/services locally.

Minikube lets you deploy your node as a VM, container or even bare metal. The default driver is VirtualBox, however KVM/QEMU usually performs better on Linux machines.

I assume that you'll be using Docker as your CRI. On Arch Linux, you'll need to get the following packages using Pacman:

🐺 ~ ⚡ ➜ sudo pacman -S minikube libvirt qemu dnsmasq ebtables dmidecode

You then need to add your user to the libvirt group and start the service:

🐺 ~ ⚡ ➜ sudo usermod -aG libvirt $(whoami)
🐺 ~ ⚡ ➜ sudo systemctl start libvirtd.service
🐺 ~ ⚡ ➜ sudo systemctl enable libvirtd.service

The libvirtd service may fail due to certain missing binaries, be sure to check the status and resolve any issues you may have.

🐺 ~ ⚡ ➜ sudo systemctl status libvirtd.service

You can then run the validation tool:

🐺 ~ ⚡ ➜ virt-host-validate
  QEMU: Checking for hardware virtualization                                 : PASS
  QEMU: Checking if device /dev/kvm exists                                   : PASS
  QEMU: Checking if device /dev/kvm is accessible                            : PASS
  QEMU: Checking if device /dev/vhost-net exists                             : PASS
  QEMU: Checking if device /dev/net/tun exists                               : PASS
  QEMU: Checking for cgroup 'cpu' controller support                         : PASS
  QEMU: Checking for cgroup 'cpuacct' controller support                     : PASS
  QEMU: Checking for cgroup 'cpuset' controller support                      : PASS
  QEMU: Checking for cgroup 'memory' controller support                      : PASS
  QEMU: Checking for cgroup 'devices' controller support                     : PASS
  QEMU: Checking for cgroup 'blkio' controller support                       : PASS
  QEMU: Checking for device assignment IOMMU support                         : PASS
  QEMU: Checking if IOMMU is enabled by kernel                               : PASS
  QEMU: Checking for secure guest support                                    : WARN (AMD Secure Encrypted Virtualization appears to be disabled in kernel. Add kvm_amd.sev=1 to the kernel cmdline arguments)
  LXC: Checking for Linux >= 2.6.26                                          : PASS
  LXC: Checking for namespace ipc                                            : PASS
  LXC: Checking for namespace mnt                                            : PASS
  LXC: Checking for namespace pid                                            : PASS
  LXC: Checking for namespace uts                                            : PASS
  LXC: Checking for namespace net                                            : PASS
  LXC: Checking for namespace user                                           : PASS
  LXC: Checking for cgroup 'cpu' controller  support                         : PASS
  LXC: Checking for cgroup 'cpuacct'  controller support                     : PASS
  LXC: Checking for cgroup 'cpuset'  controller support                      : PASS
  LXC: Checking for cgroup 'memory'  controller support                      : PASS
  LXC: Checking for cgroup 'devices'  controller support                     : PASS
  LXC: Checking for cgroup 'freezer'  controller support                     : PASS
  LXC: Checking for cgroup 'blkio'  controller support                       : PASS
  LXC: Checking if device  /sys/fs/fuse/connections exists                   : PASS

Change the Minikube driver to kvm2:

🐺 ~ ⚡ ➜ minikube config set driver kvm2

It's nice to create a seperate kubeconfig file for Minikube to use for the cluster:

🐺 ~ ⚡ ➜ touch config && export KUBECONFIG=$(pwd)/config

Finally, run minikube:

🐺 ~/repos ➜ minikube start
😄  minikube v1.12.2 on Arch
    ▪ KUBECONFIG=/home/lemagicien/repos/config
✨  Using the kvm2 driver based on user configuration
👍  Starting control plane node minikube in cluster minikube
🔥  Creating kvm2 VM (CPUs=2, Memory=4000MB, Disk=20000MB) ...
🐳  Preparing Kubernetes v1.18.3 on Docker 19.03.12 ...
🔎  Verifying Kubernetes components...
🌟  Enabled addons: default-storageclass, storage-provisioner
🏄  Done! kubectl is now configured to use "minikube"

Your kubectl should now be talking to the minikube cluster! If you run into any issues, you can check Minikube Docs and ArchWiki.