Turing Pi

https://docs.turingpi.com
Admin
Turing Pi is an innovative multi-node computing board platform designed for building scalable...
Tokens:55,638
Snippets:755
Trust Score:9.4
Update:4 months ago
Show doc for...
Tokens:
Raw
### Start and Enable GlusterFS Service

Source: https://docs.turingpi.com/docs/docker-swarm-storage-glusterfs

Starts the GlusterFS daemon service and configures it to start automatically on system boot. Ensure this is run after installing the server package.

```bash
sudo systemctl start glusterd
sudo systemctl enable glusterd
```

--------------------------------

### Download and Install Helm

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-helm-and-arkade

Navigates to the home directory, creates a Helm directory, downloads the Helm installer script, and installs Helm 3.

```bash
# Switch to home directory
cd

# Create a directory for Helm and navigate into it
mkdir helm  
cd helm  

# Download Helm installer
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3  

# Modify permissions for execution
chmod 700 get_helm.sh  

# Install Helm
./get_helm.sh  
```

--------------------------------

### Install Docker Swarm Software IDs

Source: https://docs.turingpi.com/docs/docker-swarm-setup-os

Include these software IDs in the dietpi.txt file to automatically install Docker Compose, Docker, and Git during OS setup.

```bash
AUTO_SETUP_INSTALL_SOFTWARE_ID=134
AUTO_SETUP_INSTALL_SOFTWARE_ID=162
AUTO_SETUP_INSTALL_SOFTWARE_ID=17
```

--------------------------------

### rpiboot Output Example

Source: https://docs.turingpi.com/docs/turing-pi1-flashing-compute-modules

This is an example of the expected output when the rpiboot command is successfully executed.

```text
sudo ./rpiboot
Password:
Waiting for BCM2835/6/7/2711...
Sending bootcode.bin
Successful read 4 bytes 
Waiting for BCM2835/6/7/2711...
Second stage boot server
File read: start.elf
Second stage boot server done
```

--------------------------------

### Install Required Libraries

Source: https://docs.turingpi.com/docs/orin-nxnano-flashing-os

Installs essential libraries for the flashing process, including QEMU, nano, and SSH.

```shell
sudo apt install -y qemu-user-static nano ssh
```

--------------------------------

### Set up virtual environment and install Python requirements

Source: https://docs.turingpi.com/docs/turing-rk1-neural-processing-unit-npu

Creates a Python virtual environment and installs project dependencies from a requirements file.

```bash
virtualenv -p /usr/bin/python3 venv
source venv/bin/activate
pip3 install -r doc/requirements_cp36-*.txt
```

--------------------------------

### Full cmdline.txt example with cgroup settings

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-os-setup

An example of the complete cmdline.txt file after appending the cgroup settings. Ensure this line is appended, not replaced.

```bash
root=PARTUUID=a97c7839-02 rootfstype=ext4 rootwait fsck.repair=yes net.ifnames=0 logo.nologo console=serial0,115200 console=tty1 group_enable=cpuset cgroup_enable=memory cgroup_memory=1
```

--------------------------------

### Install rkdeveloptool on Ubuntu 22.04

Source: https://docs.turingpi.com/docs/turing-rk1-flashing-os

Install the rkdeveloptool utility on Ubuntu 22.04 for flashing nodes via USB. This includes installing dependencies, cloning the repository, applying a hotfix, and compiling the tool.

```shell
sudo apt update
# install dependencies
sudo apt -y install make g++ libudev-dev libusb-1.0-0-dev dh-autoreconf pkg-config libusb-1.0 git

# clone repository
git clone https://github.com/rockchip-linux/rkdeveloptool.git
cd rkdeveloptool

#hotfix a bug
sed -i 's/snprintf(buffer, sizeof(buffer), "%s", chip);/snprintf(buffer, sizeof(buffer), "%.*s", static_cast<int>(sizeof(buffer) - 1), chip);/g' main.cpp

# install
aclocal
autoreconf -i
./configure
make
sudo make install
```

--------------------------------

### DietPi Configuration for Automated Setup

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-os-setup

This configuration file automates the DietPi OS setup process, including network configuration, SSH access, and initial software installations. Adjust variables like IP addresses, timezone, and hostname to match your network environment.

```yaml
AUTO_SETUP_ACCEPT_LICENSE=1
AUTO_SETUP_LOCALE=C.UTF-8
AUTO_SETUP_KEYBOARD_LAYOUT=us
AUTO_SETUP_TIMEZONE=Europe/Bratislava
AUTO_SETUP_NET_ETHERNET_ENABLED=1
AUTO_SETUP_NET_WIFI_ENABLED=0
AUTO_SETUP_NET_ETH_FORCE_SPEED=0
AUTO_SETUP_NET_WIFI_COUNTRY_CODE=SK

AUTO_SETUP_NET_USESTATIC=1
AUTO_SETUP_NET_STATIC_IP=10.0.0.60
AUTO_SETUP_NET_STATIC_MASK=255.255.255.0
AUTO_SETUP_NET_STATIC_GATEWAY=10.0.0.254
AUTO_SETUP_NET_STATIC_DNS=1.1.1.1 8.8.8.8

AUTO_SETUP_DHCP_TO_STATIC=0

AUTO_SETUP_NET_HOSTNAME=cube01

AUTO_SETUP_BOOT_WAIT_FOR_NETWORK=1
AUTO_SETUP_SWAPFILE_SIZE=1
AUTO_SETUP_SWAPFILE_LOCATION=/var/swap
AUTO_SETUP_HEADLESS=1
AUTO_UNMASK_LOGIND=0
AUTO_SETUP_CUSTOM_SCRIPT_EXEC=0
AUTO_SETUP_BACKUP_RESTORE=0
AUTO_SETUP_SSH_SERVER_INDEX=-2
AUTO_SETUP_LOGGING_INDEX=-1
AUTO_SETUP_RAMLOG_MAXSIZE=50

AUTO_SETUP_WEB_SERVER_INDEX=0
AUTO_SETUP_DESKTOP_INDEX=0
AUTO_SETUP_BROWSER_INDEX=0
AUTO_SETUP_AUTOSTART_TARGET_INDEX=7
AUTO_SETUP_AUTOSTART_LOGIN_USER=root
AUTO_SETUP_GLOBAL_PASSWORD=dietpi
AUTO_SETUP_AUTOMATED=1
SURVEY_OPTED_IN=0

#OpenSSH Client
AUTO_SETUP_INSTALL_SOFTWARE_ID=0
#Samba Client
AUTO_SETUP_INSTALL_SOFTWARE_ID=1
#vim
AUTO_SETUP_INSTALL_SOFTWARE_ID=20
#RPi.GPIO
AUTO_SETUP_INSTALL_SOFTWARE_ID=69
#OpenSSH Server
AUTO_SETUP_INSTALL_SOFTWARE

_ID=105
#Python 3 pip
AUTO_SETUP_INSTALL_SOFTWARE_ID=130

CONFIG_CPU_GOVERNOR=schedutil
CONFIG_CPU_ONDEMAND_SAMPLE_RATE=25000
CONFIG_CPU_ONDEMAND_SAMPLE_DOWNFACTOR=40
CONFIG_CPU_USAGE_THROTTLE_UP=50

CONFIG_CPU_MAX_FREQ=Disabled
CONFIG_CPU_MIN_FREQ=Disabled

CONFIG_CPU_DISABLE_TURBO=0

CONFIG_PROXY_ADDRESS=MyProxyServer.com
CONFIG_PROXY_PORT=8080
CONFIG_PROXY_USERNAME=
CONFIG_PROXY_PASSWORD=

CONFIG_G_CHECK_URL_TIMEOUT=10
CONFIG_G_CHECK_URL_ATTEMPTS=5
CONFIG_CHECK_CONNECTION_IP=8.8.8.8
CONFIG_CHECK_CONNECTION_IPV6=2620:fe::fe
CONFIG_CHECK_DNS_DOMAIN=google.com

CONFIG_CHECK_DIETPI_UPDATES=1
CONFIG_CHECK_APT_UPDATES=1
CONFIG_NTP_MODE=2
CONFIG_SERIAL_CONSOLE_ENABLE=1
CONFIG_SOUNDCARD=none
CONFIG_LCDPANEL=none
CONFIG_ENABLE_IPV6=0

CONFIG_APT_RASPBIAN_MIRROR=http://raspbian.raspberrypi.org/raspbian/
CONFIG_APT_DEBIAN_MIRROR=https://deb.debian.org/debian/
CONFIG_NTP_MIRROR=debian.pool.ntp.org

#------------------------------------------------------------------------------------------------------
##### DietPi-Software settings #####
#------------------------------------------------------------------------------------------------------
SOFTWARE_DISABLE_SSH_PASSWORD_LOGINS=0

#------------------------------------------------------------------------------------------------------
##### Dev settings #####
#------------------------------------------------------------------------------------------------------
DEV_GITBRANCH=master
DEV_GITOWNER=MichaIng

#------------------------------------------------------------------------------------------------------

```

--------------------------------

### Example dd command for flashing

Source: https://docs.turingpi.com/docs/turing-pi2-bmc-v1x-to-v2x

An example of the dd command with specific paths for flashing the firmware image to an SD card identified as '/dev/sde'.

```bash
sudo dd if=~/Downloads/tp2-firmware-sdcard-v2.0.4.img of=/dev/sde bs=1M
```

--------------------------------

### Example: Create Default User

Source: https://docs.turingpi.com/docs/orin-nxnano-flashing-os

An example of creating a default user with username 'daniel', password 'topsecretpasswd', autologin enabled, and hostname 'orinnx'.

```shell
sudo ./tools/l4t_create_default_user.sh -u daniel -p topsecretpasswd -a -n orinnx
```

--------------------------------

### Install Stress Utility

Source: https://docs.turingpi.com/docs/orin-nxnano-configuring-installing-jetpack-and-other-machine-learning-software-testing

Installs the 'stress' utility for CPU load testing. This command should be run with sudo privileges.

```shell
sudo apt -y install stress
```

--------------------------------

### Install Git and Configure Kubeconfig for Helm

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-helm-and-arkade

Installs Git, sets up the KUBECONFIG environment variable, and configures it for Helm usage on the master node.

```bash
# Ensure GIT is installed
apt -y install git  

# Fix kubeconfig file to prevent Helm errors
export KUBECONFIG=~/.kube/config  
mkdir ~/.kube 2> /dev/null  
sudo k3s kubectl config view --raw > "$KUBECONFIG"  
chmod 600 "$KUBECONFIG"  
echo "KUBECONFIG=$KUBECONFIG" >> /etc/environment  
```

--------------------------------

### Start and Enable Keepalived Service

Source: https://docs.turingpi.com/docs/docker-swarm-network-keepalived

Start the Keepalived service and ensure it automatically starts on boot. This should be executed on every node after configuration.

```bash
systemctl start keepalived
systemctl enable keepalived
```

--------------------------------

### Install RKNN-Toolkit2 wheel package

Source: https://docs.turingpi.com/docs/turing-rk1-neural-processing-unit-npu

Installs the RKNN-Toolkit2 Python package from a provided wheel file.

```bash
sudo pip3 install packages/rknn_toolkit2*cp36*.whl
```

--------------------------------

### Install virtualenv and Python dependencies

Source: https://docs.turingpi.com/docs/turing-rk1-neural-processing-unit-npu

Installs virtualenv and necessary Python development packages using apt.

```bash
sudo apt install virtualenv
sudo apt-get install python3 python3-dev python3-pip
```

--------------------------------

### Install TuringPi using Cargo

Source: https://docs.turingpi.com/docs/tpi-installation

Use this command to automatically download, build, and install the TuringPi from source. Requires the Rust toolchain to be installed.

```bash
cargo install tpi
```

--------------------------------

### Install Arkade

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-helm-and-arkade

Installs Arkade using a curl command piped to sh, simplifying the process of installing Kubernetes applications.

```bash
# Install Arkade
curl -sLS https://get.arkade.dev | sudo sh 
```

--------------------------------

### Install NVIDIA Device Plugin

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-nvidia-jetson

Installs the NVIDIA device plugin using kubectl. Ensure you are on the master control node.

```bash
kubectl create -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v0.13.0/nvidia-device-plugin.yml
```

--------------------------------

### Install GlusterFS Server

Source: https://docs.turingpi.com/docs/docker-swarm-storage-glusterfs

Installs the GlusterFS server package on all nodes in the cluster. This is a prerequisite for setting up GlusterFS storage.

```bash
apt-get -y install glusterfs-server
```

--------------------------------

### Install and Configure NFS Server

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-storage

Install the NFS server package, configure the /etc/exports file to share the /data directory with read-write access, and enable/start the NFS service. Reload exports to apply changes.

```bash
# Install NFS server  
apt install -y nfs-server  
  
# Tell NFS what to export  
echo "/data \*(rw,no\_subtree\_check,no\_root\_squash)" | tee -a /etc/exports  
  
# Enable and start NFS server  
systemctl enable --now nfs-server  
  
# Tell NFS server to reload and re-export what's in /etc/exports (just in case)  
exportfs -ar  
  
# Check if the /data is exported  
root@cube03:~# showmount -e localhost  
Export list for localhost:  
/data \*  

```

--------------------------------

### rpiboot output example on Windows

Source: https://docs.turingpi.com/docs/raspberry-pi-cm4-flashing-os

Example output from the rpiboot command on Windows, indicating successful detection and loading of Raspberry Pi boot files.

```batch
C:\Program Files (x86)\Raspberry Pi>rpiboot -d .\msd  
RPIBOOT: build-date Dec 16 2022 version 20221215~105525 1afa26c5  
Loading: .\msd/bootcode.bin  
Loading: .\msd/bootcode4.bin  
Waiting for BCM2835/6/7/2711...  
Loading: .\msd/bootcode4.bin  
Loading: .\msd/bootcode4.bin  
Sending bootcode.bin  
Successful read 4 bytes  
Waiting for BCM2835/6/7/2711...  
Loading: .\msd/bootcode4.bin  
Second stage boot server  
Cannot open file config.txt  
Cannot open file pieeprom.sig  
Loading: .\msd/start4.elf  
File read: start4.elf  
Cannot open file fixup4.dat  
Second stage boot server done
```

--------------------------------

### Install NFS Client Utilities

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-storage

Installs necessary packages for NFS client functionality on each node. This is a prerequisite for using NFS-based storage.

```bash
apt -y install nfs-common open-iscsi util-linux
```

--------------------------------

### Install I2C Tools

Source: https://docs.turingpi.com/docs/turing-pi1-cluster-management-bus-i2c

Install the necessary i2c-tools package to interact with I2C devices. Update package lists first if the command fails.

```bash
sudo apt-get install i2c-tools
```

--------------------------------

### Docker Network Configuration Example

Source: https://docs.turingpi.com/docs/deploy

An example JSON snippet showing network configuration, specifically the subnet and gateway. This is relevant when troubleshooting overlay network issues.

```json
{
"Subnet": "10.0.0.0/8",
"Gateway": "10.0.0.1"
}
```

--------------------------------

### Install NFS Client on Nodes

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-storage

Install the nfs-common package on all nodes in the cluster to enable them to mount NFS shares.

```bash
apt install -y nfs-common
```

--------------------------------

### Install iptables

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-os-setup

Install the iptables package on all nodes. This is a prerequisite for certain network configurations in Kubernetes.

```bash
apt -y install iptables
```

--------------------------------

### Verify Arkade Installation

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-helm-and-arkade

Confirms the Arkade installation by checking its version.

```bash
arkade version
```

--------------------------------

### Install Python Pip and Jetson Stats

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-nvidia-jetson

Install the Python 3 package installer (pip) and the jetson-stats library. Jetson Stats is useful for monitoring and managing Jetson hardware.

```bash
apt-get -y install python3-pip curl
pip3 install -U jetson-stats
```

--------------------------------

### Start GlusterFS Volume

Source: https://docs.turingpi.com/docs/docker-swarm-storage-glusterfs

Starts the specified GlusterFS volume, making it available for mounting and use. This command should be run on the master node.

```bash
root@cube01:~# gluster volume start dockervol2  
volume start: dockervol2: success
```

--------------------------------

### Install ML Prerequisites

Source: https://docs.turingpi.com/docs/orin-nxnano-configuring-installing-jetpack-and-other-machine-learning-software-testing

Installs essential development tools and libraries required for building and running machine learning frameworks like TensorFlow and PyTorch on Orin modules. Requires root privileges.

```shell
sudo apt -y install autoconf bc build-essential g++-8 gcc-8 clang-8 lld-8 gettext-base gfortran-8 iputils-ping libbz2-dev libc++-dev libcgal-dev libffi-dev libfreetype6-dev libhdf5-dev libjpeg-dev liblzma-dev libncurses5-dev libncursesw5-dev libpng-dev libreadline-dev libssl-dev libsqlite3-dev libxml2-dev libxslt-dev locales moreutils openssl python-openssl rsync scons python3-pip libopenblas-dev curl wget
```

--------------------------------

### Verify Helm Installation

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-helm-and-arkade

Checks the installed Helm version to confirm a successful installation.

```bash
helm version
```

--------------------------------

### Verify Jetson CUDA Device Output

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-nvidia-jetson

Example output from the deviceQuery utility, confirming the detection of a CUDA-capable device on the NVIDIA Jetson. This output is crucial for validating the GPU setup.

```text
./deviceQuery Starting...

CUDA Device Query (Runtime API) version (CUDART static linking)

Detected 1 CUDA Capable device(s)

Device 0: "NVIDIA Tegra X1"
CUDA Driver Version / Runtime Version            10.2 / 10.2
CUDA Capability Major/Minor version number:      5.3
Total amount of global memory:                   3963 MBytes (4155203584 bytes)
( 1) Multiprocessors, (128) CUDA Cores/MP:       128 CUDA Cores
GPU Max Clock rate:                              922 MHz (0.92 GHz)
Memory Clock rate:                               13 Mhz
Memory Bus Width:                                64-bit
L2 Cache Size:                                   262144 bytes
Maximum Texture Dimension Size (x,y,z)           1D=(65536), 2D=(65536, 65535), 3D=(4096, 4096, 4096)
Maximum Layered 1D Texture Size, (num) layers    1D=(16384), 2048 layers
Maximum Layered 2D Texture Size, (num) layers    2D=(16384, 16384), 2048 layers
Total amount of constant memory:                 65536 bytes
Total amount of shared memory per block:         49152 bytes
Total number of registers available per block:   32768
Warp size:                                       32
Maximum number of threads per multiprocessor:    2048
Maximum number of threads per block:             1024
Max dimension size of a thread block (x,y,z):    (1024, 1024, 64)
Max dimension size of a grid size (x,y,z):       (2147483647, 65535, 65535)
Maximum memory pitch:                            2147483647 bytes
Texture alignment:                               512 bytes
Concurrent copy and kernel execution:            Yes with 1 copy engine(s)
Run time limit on kernels:                       Yes
Integrated GPU sharing Host Memory:              Yes
Support host page-locked memory mapping:         Yes
Alignment requirement for Surfaces:              Yes
Device has ECC support:                          Disabled
Device supports Unified Addressing (UVA):        Yes
Device supports Compute Preemption:              No
Supports Cooperative Kernel Launch:              No
Supports MultiDevice Co-op Kernel Launch:        No
Device PCI Domain ID / Bus ID / location ID: 0 / 0 / 0
deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 10.2, CUDA Runtime Version = 10.2, NumDevs = 1
Result = PASS
```

--------------------------------

### Install MetalLB with Helm

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-network-configuration

Installs MetalLB into the Kubernetes cluster using Helm. It creates the 'metallb-system' namespace and waits for the deployment to complete.

```bash
helm upgrade --install metallb metallb/metallb --create-namespace
--namespace metallb-system --wait
```

--------------------------------

### Create Default User for Headless Installation

Source: https://docs.turingpi.com/docs/orin-nxnano-flashing-os

Sets up a default username, password, and hostname for the operating system, enabling autologin if the '-a' flag is used.

```shell
sudo ./tools/l4t_create_default_user.sh -u <username> -p <password> -a -n <hostname>
```

--------------------------------

### Install Longhorn with LoadBalancer Service (Option 2)

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-storage

Installs Longhorn using Helm, creating a LoadBalancer service for the UI accessible via a specific IP. This option assumes MetalLB is pre-configured.

```bash
helm install longhorn longhorn/longhorn --namespace longhorn-system --create-namespace --set defaultSettings.defaultDataPath="/storage" --set service.ui.loadBalancerIP="10.0.0.71" --set service.ui.type="LoadBalancer"
```

--------------------------------

### Install libusb Dependency

Source: https://docs.turingpi.com/docs/turing-pi1-flashing-compute-modules

Install the libusb dependency required for the usbboot tool using Homebrew.

```shell
brew install libusb
```

--------------------------------

### Start GlusterFS Volume

Source: https://docs.turingpi.com/docs/docker-swarm-storage-glusterfs

Starts the created GlusterFS volume, making it accessible for mounting and data operations. This command must be executed after volume creation.

```bash
root@cube01:~# gluster volume start dockervol1  
volume start: dockervol1: success
```

--------------------------------

### Install RKNN-Toolkit2 dependent libraries

Source: https://docs.turingpi.com/docs/turing-rk1-neural-processing-unit-npu

Installs essential libraries required for RKNN-Toolkit2 compilation and operation.

```bash
sudo apt-get install libxslt1-dev zlib1g zlib1g-dev libglib2.0-0 libsm6 libgl1-mesa-glx libprotobuf-dev gcc
```

--------------------------------

### Example: Set Orin Power Mode to 0

Source: https://docs.turingpi.com/docs/orin-nxnano-configuring-installing-jetpack-and-other-machine-learning-software-testing

An example command to set the Orin module's power mode to ID 0.

```shell
sudo /usr/sbin/nvpmodel -m 0
```

--------------------------------

### Check nvidia-jetpack Installation

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-nvidia-jetson

Verifies if the 'nvidia-jetpack' package is installed on the system. This package is typically pre-installed on Jetson devices.

```bash
apt-cache show nvidia-jetpack
```

--------------------------------

### Turn on power to a node

Source: https://docs.turingpi.com/docs/raspberry-pi-cm4-flashing-os

Use this command to start power to a specific node managed by the tpi tool.

```bash
tpi power --node 1 on
```

--------------------------------

### Install PyTorch on Orin

Source: https://docs.turingpi.com/docs/orin-nxnano-configuring-installing-jetpack-and-other-machine-learning-software-testing

Installs the PyTorch library using pip3. It dynamically determines the correct wheel file URL based on the detected JetPack version. Requires root privileges and prerequisites.

```shell
export REPO_URL=https://developer.download.nvidia.cn/compute/redist/jp/
export JETPACK_VERSION=$(curl -s $REPO_URL | grep -oP 'v\K[0-9]+(?=/)' | sed 's/./&\./g' | rev | cut -c2- | rev | sort -V | sed 's/\.//g' | tail -n 1)
export JETPACK_VERSION=$(sudo apt-cache show nvidia-jetpack | grep "Version" | grep -oP '(?<=: ).*?(?=-)' | tr -d '.')
export TORCH_REPO_URL=https://developer.download.nvidia.cn/compute/redist/jp/v$JETPACK_VERSION/pytorch/
export TORCH_INSTALL=$TORCH_REPO_URL$(curl -s $TORCH_REPO_URL | grep -oP 'torch-.*?\.whl' | sort -V | tail -n 1)
sudo pip3 install --upgrade --no-cache $TORCH_INSTALL
```

--------------------------------

### Describe Node for GPU Capacity

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-nvidia-jetson

Verifies that the node has the 'nvidia.com/gpu' resource available after the plugin installation.

```bash
kubectl describe node cube04
.
.
Capacity:
cpu: 4
ephemeral-storage: 14384136Ki
hugepages-2Mi: 0
memory: 4057816Ki
nvidia.com/gpu: 1
pods: 110
Allocatable:
cpu: 4
ephemeral-storage: 13992887490
hugepages-2Mi: 0
memory: 4057816Ki
nvidia.com/gpu: 1
pods: 110
.
.
.
```

--------------------------------

### Power On All Nodes at Startup

Source: https://docs.turingpi.com/docs/turing-pi2-automating-node-and-usb-settings

Add this script to /etc/init.d/S99zallnodeson.sh to ensure all nodes power on automatically when the BMC starts. The script waits for the BMC to be ready before executing the 'tpi -p on' command.

```shell
#!/bin/sh  

while ! netstat -tuln | grep LISTEN | grep ':80 '; do sleep 1; done

# Turn on all nodes  
tpi -p on
```

--------------------------------

### Install NFS Subdir External Provisioner via Helm

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-storage

Install the nfs-subdir-external-provisioner using Helm on the master node. Configure it with the NFS server's IP address (10.0.0.62) and the exported path (/data). This creates a StorageClass for dynamic provisioning.

```bash
# Add repo to helm  
helm repo add nfs-subdir-external-provisioner <https://kubernetes-sigs.github.io/nfs-subdir-external-provisioner/>  
# Install  
helm install nfs-subdir-external-provisioner nfs-subdir-external-provisioner/nfs-subdir-external-provisioner \  
--set nfs.server=10.0.0.62 \  
--set nfs.path=/data \  
--create-namespace \  
--namespace nfs-system
```

--------------------------------

### Install JetPack on Orin Module

Source: https://docs.turingpi.com/docs/orin-nxnano-configuring-installing-jetpack-and-other-machine-learning-software-testing

Installs the NVIDIA JetPack software development kit on the Orin module. Requires root privileges and a prior system update/reboot.

```shell
sudo apt -y install nvidia-jetpack
sudo reboot
```

--------------------------------

### Perform Filesystem Operations

Source: https://docs.turingpi.com/docs/tpi-accessing-nodes-filesystems

Allows read and write operations on the mounted filesystem. This example shows editing a configuration file.

```bash
vi /mnt/raspios/config.txt
```

--------------------------------

### Install Argo CD

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-argo-cd

Installs Argo CD into the specified namespace using the official manifest. This command applies the Argo CD deployment to the cluster.

```bash
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
```

--------------------------------

### Install TensorFlow on Orin

Source: https://docs.turingpi.com/docs/orin-nxnano-configuring-installing-jetpack-and-other-machine-learning-software-testing

Installs the TensorFlow library using pip3. It dynamically determines the correct wheel file URL based on the detected JetPack version. Requires root privileges and prerequisites.

```shell
export REPO_URL=https://developer.download.nvidia.cn/compute/redist/jp/
export JETPACK_VERSION=$(curl -s $REPO_URL | grep -oP 'v\K[0-9]+(?=/)' | sed 's/./&\./g' | rev | cut -c2- | rev | sort -V | sed 's/\.//g' | tail -n 1)
export JETPACK_VERSION=$(sudo apt-cache show nvidia-jetpack | grep "Version" | grep -oP '(?<=: ).*?(?=-)' | tr -d '.')
export TENSORFLOW_REPO_URL=https://developer.download.nvidia.cn/compute/redist/jp/v$JETPACK_VERSION/tensorflow/
export TENSORFLOW_INSTALL=$TENSORFLOW_REPO_URL$(curl -s $TENSORFLOW_REPO_URL | grep -oP 'tensorflow-.*?\.whl' | sort -V | tail -n 1)
sudo pip3 install --upgrade --no-cache $TENSORFLOW_INSTALL
```

--------------------------------

### Update and upgrade system packages

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-os-setup

Run these commands via SSH after booting to ensure your OS is up-to-date. This is a standard procedure before installing new software.

```bash
apt update   
apt upgrade
```

--------------------------------

### Install Longhorn using Helm

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-storage

Installs Longhorn on the Kubernetes cluster using Helm. It specifies the namespace and sets the default data path for Longhorn volumes.

```bash
# Install Option1  
helm install longhorn longhorn/longhorn --namespace longhorn-system --create-namespace --set defaultSettings.defaultDataPath="/storage"
```

--------------------------------

### Copy eMMC Installation to External Block Device

Source: https://docs.turingpi.com/docs/turing-rk1-flashing-os

Use the `ubuntu-rockchip-install` command to copy the current eMMC firmware installation to an external block device. This is useful when direct flashing is not feasible.

```shell
sudo ubuntu-rockchip-install /dev/disk_device
```

```shell
sudo ubuntu-rockchip-install /dev/nvme0n1
```

```shell
sudo ubuntu-rockchip-install /dev/sda
```

--------------------------------

### Run rpiboot on Windows

Source: https://docs.turingpi.com/docs/raspberry-pi-cm4-flashing-os

Launch the rpiboot command-line tool on Windows from its installation directory to enable storage mode for Raspberry Pi devices.

```batch
cd "C:\Program Files (x86)\Raspberry Pi"  
rpiboot -d .\msd
```

--------------------------------

### Update and Upgrade Orin OS

Source: https://docs.turingpi.com/docs/orin-nxnano-configuring-installing-jetpack-and-other-machine-learning-software-testing

Updates the package list, upgrades installed packages, and handles potential dependency issues before installing JetPack. Requires root privileges.

```shell
sudo apt update
sudo apt -y upgrade
sudo apt -y dist-upgrade
sudo apt install --fix-broken -o Dpkg::Options::="--force-overwrite"
sudo reboot
```

--------------------------------

### Set Fixed IP Address Configuration

Source: https://docs.turingpi.com/docs/turing-pi2-bmc-how-to-get-started

Example configuration for setting a static IP address, netmask, and gateway for the eth0 interface in the /etc/network/interfaces file. This is typically done using a text editor like vi or nano.

```text
auto eth0
iface eth0 inet static
address 192.168.1.100
netmask 255.255.255.0
gateway 192.168.1.1
```

--------------------------------

### Get Detailed System Information

Source: https://docs.turingpi.com/docs/turing-pi2-bmc-api

Fetch comprehensive system details, including network interface information (IP, MAC addresses) and storage space for the BMC and microSD card.

```bash
/api/bmc?opt=get&type=info
```

--------------------------------

### Initialize K3s Master Node

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-installation

Installs K3s on the master node (Node1) with specific configurations like disabling servicelb and local storage, and setting the node IP. This command prepares the primary control plane for the Kubernetes cluster.

```bash
curl -sfL https://get.k3s.io | sh -s - --write-kubeconfig-mode 644 --disable servicelb --token myrandompassword --node-ip 10.0.0.60 --disable-cloud-controller --disable local-storage
```

--------------------------------

### Configure /etc/hosts for Kubernetes Environment

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-nvidia-jetson

Ensures consistent hostnames and IP addresses across all nodes in the Kubernetes environment. This example maps IP addresses to hostnames like 'cube04' for the Jetson module.

```bash
127.0.0.1 localhost
10.0.0.60 cube01 cube01.local
10.0.0.61 cube02 cube02.local
10.0.0.62 cube03 cube03.local
10.0.0.63 cube04 cube04.local
```

--------------------------------

### Configure Node USB Settings at Startup

Source: https://docs.turingpi.com/docs/turing-pi2-automating-node-and-usb-settings

Add this script to /etc/init.d/S92usb.sh to automatically set NODE 3 to HOST MODE for USB at startup. This is useful because the default HOST MODE for NODE 1 can hide USB devices connected via Mini PCI-Express.

```shell
#!/bin/sh  
  
# Change USB to HOST MODE for NODE 3  
tpi -u host -n 3
```

--------------------------------

### Verify Master Node Installation

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-installation

Checks the status of the Kubernetes cluster after the master node initialization. It should show the master node as ready with the control-plane and master roles.

```bash
kubectl get nodes
```

--------------------------------

### Check nvidia-container-toolkit Version

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-nvidia-jetson

Checks the installed version of the nvidia-container-toolkit. Versions prior to 1.12 may have issues in Kubernetes environments on Jetson.

```bash
dpkg -l nvidia-container-toolkit
```

--------------------------------

### Make Startup Script Executable

Source: https://docs.turingpi.com/docs/turing-pi2-automating-node-and-usb-settings

After creating a startup script in /etc/init.d, make it executable using the chmod command.

```shell
chmod +x /etc/init.d/S99zallnodeson.sh
```

--------------------------------

### Authenticate API Request with Basic Authentication

Source: https://docs.turingpi.com/docs/turing-pi2-bmc-api

Use the base64 encoded credentials in the Authorization header for Basic authentication. This example retrieves USB information.

```bash
curl 'https://turingpi.local/api/bmc?opt=get&type=usb' --header 'Authorization: Basic base64digest' -k
```

--------------------------------

### Update System and Upgrade Packages

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-nvidia-jetson

Updates the package list and upgrades installed packages, including the newly added NVIDIA container toolkit. A reboot is recommended after upgrades.

```bash
apt update
apt upgrade
reboot
# just to be sure, try again
apt upgrade
```

--------------------------------

### Configure /etc/hosts for node name resolution

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-os-setup

Modify the /etc/hosts file on each node to map IP addresses to hostnames. Replace the example IPs with your actual network configuration.

```bash
127.0.0.1 localhost  
10.0.0.60 cube01 cube01.local  
10.0.0.61 cube02 cube02.local  
10.0.0.62 cube03 cube03.local  
10.0.0.63 cube04 cube04.local
```

--------------------------------

### Example output of network scan script

Source: https://docs.turingpi.com/docs/raspberry-pi-cm4-flashing-os

This shows the typical output when the network scan script detects a new device with an open SSH port after a reboot.

```bash
vladoportos@DESKTOP-7BCS3LE:~$ range="10.0.0.*"); echo "Please wait, starting scan..."; \
nmap -PN -p 22 --open -oG - "$range" | grep -E '22/open' | \
awk '{print $2}' | sort -V > initial_scan.txt; \
 echo "Start RPi, waiting 60sec..."; sleep 60; \
nmap -PN -p 22 --open -oG - "$range" | \
grep -E '22/open' | awk '{print $2}' | \
sort -V | diff initial_scan.txt - 
Please wait, starting scan... 
Start RPi, waiting 60sec... 
10a11
> 10.0.0.167
```

--------------------------------

### Prepare Firmware

Source: https://docs.turingpi.com/docs/orin-nxnano-flashing-os

Navigates to the Linux_for_Tegra directory and runs scripts to apply binaries and prepare for flashing.

```shell
cd Linux_for_Tegra/
sudo ./apply_binaries.sh
sudo ./tools/l4t_flash_prerequisites.sh
```

--------------------------------

### Add I2C and RTC Overlays to config.txt

Source: https://docs.turingpi.com/docs/turing-pi1-cluster-management-bus-i2c

Add these lines to /boot/config.txt to enable I2C and an RTC device.

```text
dtoverlay=i2c1,pins_44_45
dtoverlay=i2c-rtc,mcp7940x
```

--------------------------------

### Update OS Packages

Source: https://docs.turingpi.com/docs/turing-rk1-flashing-os

Updates the package list and upgrades installed packages on the system. Recommended after OS installation.

```shell
sudo apt update
sudo apt -y upgrade
```

--------------------------------

### Install Keepalived on All Nodes

Source: https://docs.turingpi.com/docs/docker-swarm-network-keepalived

Install the Keepalived package on every node in your Docker Swarm cluster. This command should be run on each node.

```bash
apt-get -y install keepalived
```

--------------------------------

### Download Bootloader using rkdeveloptool

Source: https://docs.turingpi.com/docs/turing-rk1-flashing-os

Uploads the MiniLoaderAll.bin bootloader to the device. This is a necessary step before writing the OS image.

```shell
~$ sudo rkdeveloptool db /path/to/MiniLoaderAll.bin 
Downloading bootloader succeeded.
```

--------------------------------

### Run rpiboot with sudo

Source: https://docs.turingpi.com/docs/turing-pi1-flashing-compute-modules

Execute the rpiboot command with sudo privileges to prepare the compute module for flashing. Connect the Turing Pi to your computer via micro USB and power on the board.

```shell
sudo ./rpiboot
```

--------------------------------

### Create Mount Directory

Source: https://docs.turingpi.com/docs/tpi-accessing-nodes-filesystems

Creates a directory on the host system where the node's partition will be mounted. This is a prerequisite for mounting.

```bash
mkdir /mnt/raspios
```

--------------------------------

### Clone and Build usbboot Tool

Source: https://docs.turingpi.com/docs/turing-pi1-flashing-compute-modules

Clone the usbboot repository from GitHub and build the tool using make.

```shell
# Clone the `usbboot` repository.
git clone --depth=1 https://github.com/raspberrypi/usbboot
cd usbboot
make
```

--------------------------------

### Build TuringPi from Source

Source: https://docs.turingpi.com/docs/tpi-installation

Clone the repository and use Cargo to build the release version of the TuringPi software.

```bash
cargo build --release
```

--------------------------------

### Boot Node as Mass Storage Device (MSD)

Source: https://docs.turingpi.com/docs/tpi-accessing-nodes-filesystems

Initiates the process of booting a specified node as a Mass Storage Device (MSD). This allows direct access to its filesystem.

```bash
tpi advanced msd --node 1
```

--------------------------------

### Apply Redis Deployment

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-sample-app-deployment

Apply the deployment configuration to create the Redis server pod.

```bash
kubectl apply -f deployment.yaml
```

--------------------------------

### Format and Mount Disk for NFS

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-storage

Format the identified disk (e.g., /dev/sda) with ext4, create a mount point, configure fstab for auto-mounting, and mount the disk. This prepares the disk for use as an NFS export.

```bash
# Formating the new disk  
mkfs.ext4 /dev/sda  
  
# Create /data folder  
mkdir /data  
  
# Add line to /etc/fstab to auto mount this disk to /data on boot  
echo "/dev/sda /data ext4 defaults 0 0" | tee -a /etc/fstab  
  
# Mount the disk to /data folder  
mount -a  
  
# Confirm the /data is mounted with  
df -h /data  
  
# Above should return something similar to this:  
Filesystem Size Used Avail Use% Mounted on  
/dev/sda 458G 28K 435G 1% /data  

```

--------------------------------

### Format and Mount Disk for GlusterFS Brick

Source: https://docs.turingpi.com/docs/docker-swarm-storage-glusterfs

Formats a disk with XFS, creates a directory for the GlusterFS brick, adds an entry to fstab for auto-mounting, and mounts the disk. This prepares a physical disk to be used as a storage brick.

```bash
# Format your disk (If you decided to use your internal storage, just ignore the mount and format steps)  
mkfs.xfs -f /dev/sda  

# Create brick folder location  
mkdir -p /data/glusterfs/myvol1/brick1  

# Add line to /etc/fstab to auto mount this disk to /data on boot  
echo "/dev/sda /data/glusterfs/myvol1/brick1 xfs defaults 0 0" | tee -a /etc/fstab  

# Create brick folder   
mkdir -p /data/glusterfs/myvol1/brick1/brick  

# Mount  
mount -a  

# Check   
df -h /data/glusterfs/myvol1/brick1  
```

--------------------------------

### Read Compute Module Installation and Power Status

Source: https://docs.turingpi.com/docs/turing-pi1-cluster-management-bus-i2c

Retrieves the status of compute modules, indicating if they are installed and powered on, from register 0xF8h. The output is a hexadecimal value representing the status bits.

```bash
sudo i2cget -y 1 0x57 0xf8
```

--------------------------------

### Create Redis Deployment Directory

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-sample-app-deployment

Create a directory to store configuration files for the Redis deployment and navigate into it.

```bash
mkdir redis-deployment
cd redis-deployment
```

--------------------------------

### Make USB Settings Script Executable

Source: https://docs.turingpi.com/docs/turing-pi2-automating-node-and-usb-settings

Make the script for configuring USB settings executable.

```shell
chmod +x /etc/init.d/S92usb.sh
```

--------------------------------

### Update and Upgrade Ubuntu

Source: https://docs.turingpi.com/docs/orin-nxnano-flashing-os

Run these commands sequentially to update the operating system packages.

```shell
sudo apt update
sudo apt -y upgrade
sudo apt -y dist-upgrade
sudo reboot
```

--------------------------------

### Describe PersistentVolumeClaim

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-sample-app-deployment

Get detailed information about the PersistentVolumeClaim, useful for troubleshooting.

```bash
kubectl describe pvc redis-pvc -n redis-server
```

--------------------------------

### Verify RKNN-Toolkit2 installation

Source: https://docs.turingpi.com/docs/turing-rk1-neural-processing-unit-npu

Checks if the RKNN module can be imported successfully in a Python interactive session.

```python
(venv) turing@T-chip:~/rknn-toolkit2$ python3
>>> from rknn.api import RKNN
>>> 
```

--------------------------------

### Get Node Power Status

Source: https://docs.turingpi.com/docs/turing-pi2-bmc-api

Query the current power status for nodes 1 through 4.

```bash
/api/bmc?opt=get&type=power
```

--------------------------------

### Create Docker Volumes Folder

Source: https://docs.turingpi.com/docs/docker-swarm-portainer

Ensures the necessary folder for Docker volumes exists on each node to prevent installation failures.

```bash
mkdir -p /var/lib/docker/volumes
```

--------------------------------

### Turing-Pi USB Command Help

Source: https://docs.turingpi.com/docs/tpi-usage

Displays the help message for the 'usb' command, detailing its usage, arguments, and options for configuring USB routing.

```shell
$ tpi usb
Change the USB device/host configuration. The USB-bus can only be routed to one node simultaneously

Usage: tpi usb [OPTIONS] <MODE>

Arguments:
  <MODE>  specify which mode to set the given node in [possible values: device, host, status]

Options:
  -b, --bmc              instead of USB-A, route the USB-bus to the BMC chip
  -n, --node <NODE>      [possible values: 1-4]
      --host <HOST>      Specify the Turing-pi host to connect to. Note: IPv6 addresses must be
                         wrapped in square brackets e.g. `[::1]` [default: turingpi.local]
      --port <PORT>      Specify a custom port to connect to
      --user <USER>      Specify a user name to log in as. If unused, an interactive prompt will ask
                         for credentials unless a cached token file is present
      --password <PASS>  Same as `--username`
      --json             Print results formatted as JSON
  -a <API_VERSION>       Force which version of the BMC API to use. Try lower the version if you are
                         running older BMC firmware [default: v1-1] [possible values: v1, v1-1]
  -h, --help             Print help (see more with '--help')
  -V, --version          Print version

```

--------------------------------

### Power On a Specific Node at Startup

Source: https://docs.turingpi.com/docs/turing-pi2-automating-node-and-usb-settings

Use this script to power on a specific node (e.g., NODE 1) at startup by making a POST request to the BMC API using curl. A 10-second sleep is included to wait for the API to be ready.

```shell
#!/bin/sh  
  
# Wait for the API to be ready to accept requests  
sleep 10  
  
# Power on NODE 1  
curl --location --request POST 'http://127.0.0.1/api/bmc?opt=set&type=power&node1=1'
```

--------------------------------

### Disable IPv6 Configuration

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-nvidia-jetson

Disables IPv6 on all network interfaces. This is often a prerequisite for stable networking in certain cluster setups.

```bash
net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1
net.ipv6.conf.lo.disable_ipv6 = 1
```

--------------------------------

### Read UART Data with tpi

Source: https://docs.turingpi.com/docs/tpi-uart

Retrieve serial output from a specified node using the `tpi uart get` command.

```bash
$ tpi uart --node 1 get
[    0.008458] CPU1: Booted secondary processor 0x0000000001 [0x410fd083]
[..]
[    5.610444] systemd[1]: Started Journal Service.
Debian GNU/Linux 11 raspberrypi ttyS0
raspberrypi login:
```

--------------------------------

### Check NVIDIA Device Plugin Logs

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-nvidia-jetson

Inspects the logs of an NVIDIA device plugin pod to confirm successful registration with the Kubelet. Look for 'Registered device plugin for 'nvidia.com/gpu' with Kubelet'.

```bash
root@cube01:~# kubectl logs nvidia-device-plugin-daemonset-cn7zf -n kube-system
2023/02/03 12:08:05 Starting FS watcher.
2023/02/03 12:08:05 Starting OS watcher.
2023/02/03 12:08:05 Starting Plugins.
2023/02/03 12:08:05 Loading configuration.
2023/02/03 12:08:05 Updating config with default resource matching patterns.
2023/02/03 12:08:05 
Running with config:
{
"version": "v1",
"flags": {
"migStrategy": "none",
"failOnInitError": false,
"nvidiaDriverRoot": "/",
"gdsEnabled": false,
"mofedEnabled": false,
"plugin": {
"passDeviceSpecs": false,
"deviceListStrategy": "envvar",
"deviceIDStrategy": "uuid"
}
},
"resources": {
"gpus": [
{
"pattern": "*",
"name": "nvidia.com/gpu"
}
]
},
"sharing": {
"timeSlicing": {}
}
}
2023/02/03 12:08:05 Retreiving plugins.
2023/02/03 12:08:05 Detected non-NVML platform: could not load NVML: libnvidia-ml.so.1: cannot open shared object file: No such file or directory
2023/02/03 12:08:05 Detected Tegra platform: /etc/nv_tegra_release found
2023/02/03 12:08:05 Starting GRPC server for 'nvidia.com/gpu'
2023/02/03 12:08:05 Starting to serve 'nvidia.com/gpu' on /var/lib/kubelet/device-plugins/nvidia-gpu.sock
2023/02/03 12:08:05 Registered device plugin for 'nvidia.com/gpu' with Kubelet
```

--------------------------------

### TPI Commands from Personal Computer

Source: https://docs.turingpi.com/docs/tpi-overview

Run tpi commands from your PC, connecting to the default 'turingpi.local' host or a custom host/IP address using the --host option.

```shell
$ tpi power on                          # will try to connect to `turingpi.local`
$ tpi --host mycluster2.local power on  # custom hostname
$ tpi --host 192.168.1.42 power on      # explicit IP address
```

--------------------------------

### Get MicroSD Card Information

Source: https://docs.turingpi.com/docs/turing-pi2-bmc-api

Retrieve information about the microSD card, including total, used, and free storage space in bytes.

```bash
/api/bmc?opt=get&type=sdcard
```

--------------------------------

### Get Worker Join Token

Source: https://docs.turingpi.com/docs/deploy

Use this command on a manager node to retrieve the command for joining new worker nodes to the swarm.

```bash
docker swarm join-token worker
```

--------------------------------

### Create Portainer Data Directory on Primary Node

Source: https://docs.turingpi.com/docs/docker-swarm-portainer

Prepares the directory on the primary node for persistent Portainer data storage using GlusterFS.

```bash
mkdir -p /mnt/docker-storage/portainer
```

--------------------------------

### Check Disk Space Usage

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-nvidia-jetson

Displays the current disk space usage on the root filesystem. Useful for monitoring storage after installations or before cleanup.

```bash
df -h
```

--------------------------------

### Add Longhorn Helm Repository

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-storage

Adds the Longhorn Helm repository to your Helm client configuration. This allows you to install Longhorn using Helm.

```bash
# Add longhorn to the helm  
helm repo add longhorn https://charts.longhorn.io
```

--------------------------------

### Add MetalLB Repository to Helm

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-network-configuration

Adds the official MetalLB Helm repository to your Helm client. This command must be run before installing MetalLB.

```bash
helm repo add metallb https://metallb.github.io/metallb
```

--------------------------------

### Set Node Power Status

Source: https://docs.turingpi.com/docs/turing-pi2-bmc-api

Control the power status of specified nodes. Node 1 is turned off, and Node 3 is turned on in this example.

```bash
/api/bmc?opt=power&type=set&node1=0&node3=1
```

--------------------------------

### Enable SSH and Set User Credentials for Raspbian

Source: https://docs.turingpi.com/docs/raspberry-pi-cm4-flashing-os

After flashing Raspbian, create an empty file named 'ssh' to enable SSH and set the default username and password using a hashed password. Ensure the system has enough time to generate SSH host keys before powering off.

```bash
touch /mnt/bootfs/ssh
echo 'pi:$6$c70VpvPsVNCG0YR5$l5vWWLsLko9Kj65gcQ8qvMkuOoRkEagI90qi3F/Y7rm8eNYZHW8CY6BOIKwMH7a3YYzZYL90zf304cAHLFaZE0' > /mnt/bootfs/userconf
```

--------------------------------

### Get USB Mode and Routing

Source: https://docs.turingpi.com/docs/turing-pi2-bmc-api

Retrieve the current USB mode, the active node, and the USB routing destination (BMC or USB-A connector).

```bash
/api/bmc?opt=get&type=usb
```

--------------------------------

### Unpack Sample Root Filesystem

Source: https://docs.turingpi.com/docs/orin-nxnano-flashing-os

Extracts the Sample Root Filesystem into the Linux_for_Tegra directory. 'sudo' is required for this operation.

```shell
sudo tar xpf Downloads/Tegra_Linux_Sample-Root-Filesystem_R35.3.1_aarch64.tbz2 \
  -C Linux_for_Tegra/rootfs/
```

--------------------------------

### Get GlusterFS Volume Information

Source: https://docs.turingpi.com/docs/docker-swarm-storage-glusterfs

Displays detailed information about the 'dockervol2' GlusterFS volume, including its type, status, bricks, and configured options.

```bash
root@cube01:~# gluster volume info dockervol2  

Volume Name: dockervol2
Type: Disperse
Volume ID: 27c79497-848e-4fe4-80c5-18b7d5471001
Status: Started
Snapshot Count: 0
Number of Bricks: 1 x (2 + 1) = 3
Transport-type: tcp
Bricks:
Brick1: cube01:/data/glusterfs/myvol1/brick2
Brick2: cube02:/data/glusterfs/myvol1/brick2
Brick3: cube03:/data/glusterfs/myvol1/brick2
Options Reconfigured:
storage.fips-mode-rchecksum: on
transport.address-family: inet
nfs.disable: on
```

--------------------------------

### Apply PersistentVolumeClaim

Source: https://docs.turingpi.com/docs/turing-pi2-kubernetes-cluster-sample-app-deployment

Apply the PersistentVolumeClaim configuration to create persistent storage for the Redis server.

```bash
kubectl apply -f pvc.yaml
```
Tokens:
Raw