Setting up the Jetson Nano and using CRI-O

Introduction

MicroShift is a research project that is exploring how OpenShift OKD Kubernetes distribution can be optimized for small form factor devices and edge computing. In the previous Part 1 of this series, we looked at the different edge computing requirements and where MicroShift fits in. We built and deployed MicroShift on a Virtual Machine in VirtualBox and in a VM using Multipass on a MacBook Pro.

In this Part 2, we will set up the Jetson Nano with Ubuntu 18.04 and install the dependencies for MicroShift on a Jetson Nano Developer Kit. When we ultimately run containers in MicroShift, we use the CRI-O container engine that is an implementation of the Kubernetes Container Runtime Interface (CRI) to use Open Container Initiative (OCI) compatible runtimes.  We will set up CRI-O to use the Nvidia container runtime with GPU. Further, we will directly use crun and crictl, a command-line interface for CRI-compatible container runtimes to manage pods and containers. In Part 3, we will build and deploy MicroShift on the Jetson Nano.

Setting up the Jetson Nano

As of this writing, the Jetpack 4.6 is available for the Jetson Nano. JetPack 4.6 includes L4T 32.6.1 Linux Driver Package. You should use at least a 64GB microSDXC card so that you have sufficient space for experimentation. We can download the 6.53GB SD card image for the Jetson Nano Developer Kit and write to microSDXC card using balenaEtcher. After your microSDXC card is flashed and validated, proceed to set up your developer kit with the ethernet cable, USB keyboard and mouse connected and a display attached. During the System Configuration, accept the license, enter the computer’s name (for example microshift) and username/password (for example dlinano), use the suggested “Maximum accepted size” of APP partition and use the default Nvpmodel Mode. The device will automatically reboot after the setup. Note down the IP address of eth0 (jetsonnano-ipaddress), we will now ssh to the Jetson Nano from the Laptop.

Attaching the Fan

Under most conditions, the large heatsink on the Jetson Nano keeps the system running within the design thermal limits. When running very GPU intensive loads or when the Jetson is in a very warm environment, a 5V cooling fan should be attached. The Waveshare Fan-4020-PWM-5V attaches via counter sunk screw holes to the Jetson Nano’s heatsink via 4 mounting points. There are 4 holes drilled into the heatsink at the factory. The screws are provided that go in one way only to make the fan fit snugly with the sticker label at the middle of the fan facing downwards towards the heat sink. If it doesn't seem long enough, the fan is upside down. The 4 pins for the reverse-proof connector are: GND, 5V, Tachometer, PWM. The fan gets power from the Jetson Nano from the GND and 5V pins. The Tachometer signal tells the Jetson Nano what the speed of the fan currently is, and the PWM signal allows the Jetson to control the fan speed.

Let’s try out the fan.

sudo /usr/bin/jetson_clocks
sudo sh -c 'echo 255 > /sys/devices/pwm-fan/target_pwm'

Instead of 255, we can set a lower number to slow down the fan and 0 to stop it.

sudo sh -c 'echo 0 > /sys/devices/pwm-fan/target_pwm'

We can get the temperature with

cat /sys/devices/virtual/thermal/thermal_zone0/temp

The Jetson Nano fan control daemon controls the fan speed based on the temperature.

git clone https://github.com/Pyrestone/jetson-fan-ctl.git
cd jetson-fan-ctl/
./install.sh
# Customize /etc/automagic-fan/config.json

watch "cat /sys/devices/virtual/thermal/thermal_zone0/temp;echo ---;cat /sys/devices/pwm-fan/target_pwm"

Testing the Jetson Nano

Install the jetson stats

The jetson-stats is a package for monitoring and control your NVIDIA Jetson

sudo su -
apt-get update
apt-get install -y python3 python3-pip
pip3 install -U jetson-stats
jetson_release -v

Output:

root@microshift:~# jetson_release -v
- NVIDIA Jetson Nano (Developer Kit Version)
* Jetpack 4.6 [L4T 32.6.1]
* NV Power Mode: MAXN - Type: 0
* jetson_stats.service: active
- Board info:
* Type: Nano (Developer Kit Version)
* SOC Family: tegra210 - ID:33
* Module: P3448-0000 - Board: P3449-0000
* Code Name: porg
* Boardids: 3448
* CUDA GPU architecture (ARCH_BIN): 5.3
* Serial Number: 1421421054431
- Libraries:
* CUDA: 10.2.300
* cuDNN: 8.2.1.32
* TensorRT: 8.0.1.6
* Visionworks: 1.6.0.501
* OpenCV: 4.1.1 compiled CUDA: NO
* VPI: ii libnvvpi1 1.1.15 arm64 NVIDIA Vision Programming Interface library
* Vulkan: 1.2.70
- jetson-stats:
* Version 3.1.1
* Works on Python 3.6.9

Output:

root@microshift:~# cat /etc/nv_tegra_release
# R32 (release), REVISION: 6.1, GCID: 27863751, BOARD: t210ref, EABI: aarch64, DATE: Mon Jul 26 19:20:30 UTC 2021

Testing the Jupyter Lab container in docker

Try out the Deep Learning Institute (DLI) course "Getting Started with AI on Jetson Nano" Course Environment Container with a USB camera attached

If you see the “error adding seccomp filter rule for syscall clone3: permission denied: unknown”, look at the Errors section below to fix it.

Connect to your Jetson Nano ip address from your Laptop and login with password dlinano http://jetsonnano-ipaddress:8888/lab?

We can run the notebook /hello_camera/usb_camera.ipynb and test the camera. After testing, release the camera resource and shutdown the kernel.

The tutorial shows how to use a USB or a CSI camera. We can attach and try out Raspberry Pi NOIR Camera Module V2. Support for the rPI camera v2 (IMX219) is built into JetPack. The v2 Pi NoIR has a Sony IMX219 8-megapixel sensor (compared to the 5-megapixel OmniVision OV5647 sensor of the original camera). The earlier V1 camera OV5647 does not work out of box with the Jetson Nano because the driver is not included. If you have the CSI-2 camera attached, you can run
docker run --runtime nvidia -it --rm --network host --volume ~/nvdli-data:/nvdli-nano/data --volume /tmp/argus_socket:/tmp/argus_socket --device /dev/video0 nvcr.io/nvidia/dli/dli-nano-ai:v2.0.1-r32.6.1

This blog will assume that an USB camera is attached.

Testing the USB camera attached to the Jetson Nano with gstreamer on Mac

These steps will allow you to view your video stream on the Mac using gstreamer. Install the jetson-inference so that you can run video-viewer.

On Mac

• Install gstreamer pkg from https://gstreamer.freedesktop.org/data/pkg/osx/1.19.2/
• Install gst-libav
  brew install gst-libav

On Jetson Nano

On Mac

Updating your Jetson Nano to new Minor Release

Jetson Nano downloads are at https://developer.nvidia.com/embedded/downloads and OS information at https://developer.nvidia.com/embedded/jetpack

If your SD card has older Jetpak, you can update the L4T as follows. The latest is JetPack 4.6 that includes L4T 32.6.1. The platform is t210 for NVIDIA® Jetson Nano™ devices. The version is set to r32.6 (Do not set to r32.6.1)

Install the dependencies for MicroShift

Setup the repositories and install libraries and firewalld

apt-get install -y curl wget
OS_VERSION=18.04
CRIOVERSION=1.22
OS=xUbuntu_$OS_VERSION
KEYRINGS_DIR=/usr/share/keyrings
# Required for containers-common
echo "deb [signed-by=$KEYRINGS_DIR/libcontainers-archive-keyring.gpg] https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/ /" | sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list > /dev/null
echo "deb [signed-by=$KEYRINGS_DIR/libcontainers-crio-archive-keyring.gpg] http://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$CRIOVERSION/$OS/ /" | sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable:cri-o:$CRIOVERSION.list > /dev/null
mkdir -p $KEYRINGS_DIR
rm -f /usr/share/keyrings/libcontainers-archive-keyring.gpg
curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/Release.key | sudo gpg --dearmor -o $KEYRINGS_DIR/libcontainers-archive-keyring.gpg
rm -f /usr/share/keyrings/libcontainers-crio-archive-keyring.gpg
curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$CRIOVERSION/$OS/Release.key | sudo gpg --dearmor -o $KEYRINGS_DIR/libcontainers-crio-archive-keyring.gpg
wget -qO - https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/Release.key | sudo apt-key add -
apt-get install -y ca-certificates # https://github.com/cri-o/cri-o/issues/5375#issuecomment-933608364
apt-get -y update
apt-get install -y btrfs-tools containers-common libassuan-dev libdevmapper-dev libglib2.0-dev libc6-dev libgpgme-dev libgpg-error-dev libseccomp-dev libsystemd-dev libselinux1-dev pkg-config go-md2man libudev-dev software-properties-common gcc make
ls /usr/include/gpgme.h
apt-get install -y policycoreutils-python-utils conntrack firewalld

Install cri-o, crictl and plugins

apt-get install -y curl jq tar
curl https://raw.githubusercontent.com/cri-o/cri-o/main/scripts/get | bash -s -- -a arm64

Setup firewalld

systemctl enable firewalld --now
firewall-cmd --zone=public --permanent --add-port=6443/tcp
firewall-cmd --zone=public --permanent --add-port=30000-32767/tcp
firewall-cmd --zone=public --permanent --add-port=2379-2380/tcp
firewall-cmd --zone=public --add-masquerade --permanent
firewall-cmd --zone=public --add-port=10250/tcp --permanent
firewall-cmd --zone=public --add-port=10251/tcp --permanent
firewall-cmd --zone=public --add-port=80/tcp --permanent # For Ingress
firewall-cmd --zone=public --add-port=443/tcp --permanent # For Ingress
firewall-cmd --zone=public --add-port=8888/tcp --permanent # For Jupyterlab Course
firewall-cmd --permanent --zone=trusted --add-source=10.42.0.0/16
firewall-cmd --reload

Setup CRI-O config to match MicroShift networking values

sh -c 'cat << EOF > /etc/cni/net.d/100-crio-bridge.conf
{
    "cniVersion": "0.4.0",
    "name": "crio",
    "type": "bridge",
    "bridge": "cni0",
    "isGateway": true,
    "ipMasq": true,
    "hairpinMode": true,
    "ipam": {
        "type": "host-local",
        "routes": [
            { "dst": "0.0.0.0/0" }
        ],
        "ranges": [
            [{ "subnet": "10.42.0.0/24" }]
        ]
    }
}
EOF'

root@jetsonnano:~# lspci -nnv |grep -i nvidia
00:02.0 PCI bridge [0604]: NVIDIA Corporation Device [10de:0faf] (rev a1) (prog-if 00 [Normal decode])
Capabilities: [40] Subsystem: NVIDIA Corporation Device [10de:0000] 

mkdir -p /usr/share/containers/oci/hooks.d/
cat << EOF > /usr/share/containers/oci/hooks.d/nvidia.json
  {
      "version": "1.0.0",
      "hook": {
          "path": "/usr/bin/nvidia-container-runtime-hook",
          "args": ["nvidia-container-runtime-hook", "prestart"],
          "env": [
              "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin              "
          ]
      },
      "when": {
          "always": true,
          "commands": [".*"]
      },
      "stages": ["prestart"]
  }
EOF

sed -i "s/^\(mountopt.*\)/#\\1/" /etc/containers/storage.conf
#sed -i 's/,metacopy=on//g' /etc/containers/storage.conf
systemctl enable crio --now
#systemctl restart crio
systemctl status crio
journalctl -u crio -f # Ctrl-C to stop the logs

This completes the installation of dependencies for MicroShift. If you want to understand and work with crun and cri-o directly, continue with the next Section. To install Microshift, go to Part 3 of this series. Do not directly use crio when MicroShift is running. If you use crictl to create pod sandboxes or containers on a running MicroShift cluster, the Kubelet will eventually delete them.

Samples using cri-o

1. Nginx sample

cat << EOF > nginx.json
{
  "metadata": {
    "name": "nginx-container",
    "attempt": 1
  },
  "image": {
    "image": "nginx"
  },
  "log_path": "nginx.log",
  "linux": {
    "security_context": {
      "namespace_options": {}
    }
  }
}
EOF

cat << EOF > net-pod.json
{
  "metadata": {
    "name": "networking",
    "uid": "networking-pod-uid",
    "namespace": "default",
    "attempt": 1
  },
  "hostname": "networking",
  "port_mappings": [
    {
      "container_port": 80
    }
  ],
  "log_directory": "/tmp/net-pod",
  "linux": {}
}
EOF

podid=$(crictl runp net-pod.json)

sed -i "s/^\(mountopt.*\)/#\\1/" /etc/containers/storage.conf
systemctl restart crio
podid=`crictl runp net-pod.json` # This should be successful now
crictl pods # Check the pods

2. Vector-add cuda sample to test the GPU

mkdir vectoradd
cd vectoradd
cp -r /usr/local/cuda/samples .

cat << EOF > Dockerfile
FROM nvcr.io/nvidia/l4t-base:r32.6.1

RUN apt-get update && apt-get install -y --no-install-recommends make g++
COPY ./samples /tmp/samples

WORKDIR /tmp/samples/0_Simple/vectorAdd/
RUN make clean && make

CMD ["./vectorAdd"]
EOF

Create the vectoradd.json

cat << EOF > vectoradd.json
{
  "metadata": {
    "name": "vectoradd-container",
    "attempt": 1
  },
  "image": {
    "image": "docker.io/karve/vector-add-sample:arm64-jetsonnano"
  },
  "log_path": "vectoradd.log",
  "linux": {
    "security_context": {
      "namespace_options": {}
    }
  }
}
EOF

cat << EOF > net-pod.json
{
  "metadata": {
    "name": "networking",
    "uid": "networking-pod-uid",
    "namespace": "default",
    "attempt": 1
  },
  "hostname": "networking",
  "port_mappings": [
    {
      "container_port": 80
    }
  ],
  "log_directory": "/tmp/net-pod",
  "linux": {}
}
EOF

docker build -t karve/vector-add-sample:arm64-jetsonnano .
docker push karve/vector-add-sample:arm64-jetsonnano

podid=`crictl runp net-pod.json`
crictl pods # Get the podid
crictl pull docker.io/karve/vector-add-sample:arm64-jetsonnano
crictl images # This will show the vector-add-sample image
containerid=`crictl create $podid vectoradd.json net-pod.json` # The container for nginx will go into Created state
crictl ps -a # List containers
crictl start $containerid # Go to Running and Exited state
crictl logs $containerid -f

root@jetsonnano:~/samples/vectoradd# crictl logs $containerid -f
[Vector addition of 50000 elements]
Copy input data from the host memory to the CUDA device
CUDA kernel launch with 196 blocks of 256 threads
Copy output data from the CUDA device to the host memory
Test PASSED
Done

Failed to allocate device vector A (error code CUDA driver version is insufficient for CUDA runtime version)!
[Vector addition of 50000 elements]

crictl ps -a
crictl rm $containerid
crictl stopp $podid # Stop the pod
crictl rmp $podid # Remove the pod

3. Device-query sample

mkdir devicequery
cd devicequery
cp -r /usr/local/cuda/samples .

cat << EOF > Dockerfile
FROM nvcr.io/nvidia/l4t-base:r32.6.1

RUN apt-get update && apt-get install -y --no-install-recommends make g++
COPY ./samples /tmp/samples

WORKDIR /tmp/samples/1_Utilities/deviceQuery
RUN make clean && make

CMD ["./deviceQuery"]
EOF

cat << EOF > devicequery.json
{
  "metadata": {
    "name": " devicequery-container",
    "attempt": 1
  },
  "image": {
    "image": "docker.io/karve/devicequery:arm64-jetsonnano"
  },
  "log_path": "devicequery.log",
  "linux": {
    "security_context": {
      "namespace_options": {}
    }
  }
}
EOF

cat << EOF > net-pod.json
{
  "metadata": {
    "name": "networking",
    "uid": "networking-pod-uid",
    "namespace": "default",
    "attempt": 1
  },
  "hostname": "networking",
  "port_mappings": [
    {
      "container_port": 80
    }
  ],
  "log_directory": "/tmp/net-pod",
  "linux": {}
}
EOF

docker build -t karve/devicequery:arm64-jetsonnano .
docker push karve/devicequery:arm64-jetsonnano

podid=`crictl runp net-pod.json`
crictl pods # Get the podid
crictl pull docker.io/karve/devicequery:arm64-jetsonnano
crictl images # This will show the devicequery image
containerid=`crictl create $podid devicequery.json net-pod.json` # The container for devicequery will go into Created state
crictl ps -a # List containers
crictl start $containerid # Go to Running and Exited state
crictl logs $containerid -f

./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:                 3956 MBytes (4148273152 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, 65536), 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
  Compute Mode:
     < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >

deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 10.2, CUDA Runtime Version = 10.2, NumDevs = 1
Result = PASS

crictl ps -a
crictl rm $containerid
crictl stopp $podid # Stop the pod
crictl rmp $podid # Remove the pod

4. Pytorch sample

cat << EOF > pytorchsample.json
 {
  "metadata": {
    "name": "pytorchsample-container",
    "attempt": 1
  },
  "image": {
    "image": "nvcr.io/nvidia/l4t-pytorch:r32.6.1-pth1.9-py3"
  },
  "log_path": "pytorchsample.log",
  "linux": {
    "security_context": {
      "namespace_options": {}
    }
  }
}
EOF

podid=`crictl runp net-pod.json`
crictl pods # Get the podid
crictl pull nvcr.io/nvidia/l4t-pytorch:r32.6.1-pth1.9-py3
crictl images # This will show the l4t-pytorch image
containerid=`crictl create $podid pytorchsample.json net-pod.json` # The container for nginx will go into Created state
crictl ps -a
crictl exec -it $containerid bash
 
echo "nameserver 8.8.8.8" > /etc/resolv.conf
DATA_URL="https://nvidia.box.com/shared/static/y1ygiahv8h75yiyh0pt50jqdqt7pohgx.gz"
DATA_NAME="ILSVRC2012_img_val_subset_5k"
DATA_PATH="test/data/$DATA_NAME"
if [ ! -d "$DATA_PATH" ]; then
 echo 'downloading data for testing torchvision...'
 if [ ! -d "test/data" ]; then
  mkdir -p test/data
 fi
 wget --quiet --show-progress --progress=bar:force:noscroll --no-check-certificate $DATA_URL -O test/data/$DATA_NAME.tar.gz
 tar -xzf test/data/$DATA_NAME.tar.gz -C test/data/
fi
wget https://raw.githubusercontent.com/dusty-nv/jetson-containers/master/test/test_pytorch.py -O test/test_pytorch.py
python3 test/test_pytorch.py
python3 test/test_torchvision.py --data=$DATA_PATH --use-cuda
wget https://raw.githubusercontent.com/dusty-nv/jetson-containers/master/test/test_torchaudio.py -O test/test_torchaudio.py
python3 test/test_torchaudio.py
exit

testing PyTorch...
PyTorch version: 1.9.0
CUDA available:  True
cuDNN version:   8201
Tensor a = tensor([0., 0.], device='cuda:0')
Tensor b = tensor([-0.5832,  0.2567], device='cuda:0')
Tensor c = tensor([-0.5832,  0.2567], device='cuda:0')
testing LAPACK (OpenBLAS)...
test/test_pytorch.py:25: UserWarning: torch.solve is deprecated in favor of torch.linalg.solve
and will be removed in a future PyTorch release.
torch.linalg.solve has its arguments reversed and does not return the LU factorization.
To get the LU factorization see torch.lu, which can be used with torch.lu_solve or torch.lu_unpack.
X = torch.solve(B, A).solution
should be replaced with
X = torch.linalg.solve(A, B) (Triggered internally at  /media/nvidia/NVME/pytorch/pytorch-v1.9.0/aten/src/ATen/native/BatchLinearAlgebra.cpp:760.)
  x, lu = torch.solve(b, a)
done testing LAPACK (OpenBLAS)
testing torch.nn (cuDNN)...
done testing torch.nn (cuDNN)
testing CPU tensor vector operations...
est/test_pytorch.py:49: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.
  cpu_y = F.softmax(cpu_x)
Tensor cpu_x = tensor([12.3450])
Tensor softmax = tensor([1.])
Tensor exp (float32) = tensor([[2.7183, 2.7183, 2.7183],
        [2.7183, 2.7183, 2.7183],
        [2.7183, 2.7183, 2.7183]])
Tensor exp (float64) = tensor([[2.7183, 2.7183, 2.7183],
        [2.7183, 2.7183, 2.7183],
        [2.7183, 2.7183, 2.7183]], dtype=torch.float64)
Tensor exp (diff) = 7.429356050359104e-07
PyTorch OK
…

crictl rm $containerid
crictl stopp $podid # Stop the pod
crictl rmp $podid # Remove the pod

Errors

1. Error response from daemon: failed to create shim: OCI runtime create failed: container_linux.go:380: starting container process caused: error adding seccomp filter rule for syscall clone3: permission denied: unknown

• Downgrading Docker:

• Installing the Experimental nvidia-docker2:

2. Error: container create failed: error executing hook `/usr/bin/nvidia-container-runtime-hook` (exit code: 1)

You might need to install older version of nvidia-container-toolkit

apt-get remove libnvidia-container-tools
apt list --installed | grep nvidia-container
apt install nvidia-container-toolkit=1.8.0~rc.1-1

Output

apt list --installed | grep nvidia-container

libnvidia-container-tools/bionic,now 1.11.0~rc.2-1 arm64 [installed,automatic]
libnvidia-container0/stable,now 0.10.0+jetpack arm64 [installed]
libnvidia-container1/bionic,now 1.11.0~rc.2-1 arm64 [installed,automatic]
nvidia-container-csv-cuda/stable,now 10.2.460-1 arm64 [installed]
nvidia-container-csv-cudnn/stable,now 8.2.1.32-1+cuda10.2 arm64 [installed]
nvidia-container-csv-tensorrt/stable,now 8.0.1.6-1+cuda10.2 arm64 [installed]
nvidia-container-csv-visionworks/stable,now 1.6.0.501 arm64 [installed]
nvidia-container-toolkit/bionic,now 1.8.0~rc.1-1 arm64 [installed,upgradable to: 1.11.0~rc.2-1]

If you get an error with flannel, create the file /run/flannel/subnet.env

FLANNEL_NETWORK=10.42.0.0/16
FLANNEL_SUBNET=10.42.0.1/24
FLANNEL_MTU=1450
FLANNEL_IPMASQ=true

Conclusion

In this Part 2, we setup the Jetson Nano and installed the dependencies for MicroShift. We setup the cri-o to use the Nvidia container runtime and worked directly with CRI-O using the CLI. We are now armed with enough knowledge to play with MicroShift. In Part 3, we will see the multiple options to build and deploy MicroShift on the Jetson Nano.  Further, in Part 4 and Part 5, we will look at the multiple options to build and deploy MicroShift on the Raspberry Pi 4 on the Raspberry Pi OS and CentOS 8 Stream respectively.

Hope you have enjoyed the article. Share your thoughts in the comments or engage in the conversation with me on Twitter @aakarve. I look forward to hearing about your use of MicroShift on ARM devices and if you would like to see something covered in more detail.

References

• Transmitting RTP https://github.com/dusty-nv/jetson-inference/blob/master/docs/aux-streaming.md#transmitting-rtp
• An introduction to crun https://www.redhat.com/sysadmin/introduction-crun
• Demystifying Containers – Part II: Container Runtimes https://www.suse.com/c/demystifying-containers-part-ii-container-runtimes/
• Setting up NVIDIA Container Toolkit Experimental https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#setting-up-nvidia-container-toolkit
• The Option metacopy=on is not supported on Ubuntu 18.04 https://github.com/containers/podman/issues/9363#issuecomment-780740032
• "Computing at the Edge for Constrained Devices with MicroShift" - Alexei Karve
  
  1. Working with MicroShift on MacBook Pro https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2021/11/23/microshift-1
  2. Setting up the Jetson Nano with Ubuntu 18.04 and CRI-O https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2021/11/23/microshift-2
  3. Building and Running MicroShift on a Jetson Nano with Ubuntu 18.04 https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2021/11/23/microshift-3
  4. MicroShift on Raspberry Pi 4 with Raspberry Pi OS (64 bit) https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2021/11/28/microshift-4
  5. MicroShift on Raspberry Pi 4 with CentOS 8 Linux Stream https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2021/12/04/microshift-5
  6. MicroShift on Raspberry Pi 4 with Ubuntu Server 20.04 https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2021/12/18/microshift-6
  7. MicroShift on Jetson Nano with Ubuntu 20.04 https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2021/12/18/microshift-7
  8. MicroShift on Raspberry Pi 4 with balenaOS https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/01/03/microshift-8
  9. Virtualization with MicroShift on Raspberry Pi 4 https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/03/02/microshift-9
  10. MicroShift and KubeVirt on Raspberry Pi 4 with Fedora IoT https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/03/07/microshift-10
  11. MicroShift and KubeVirt on Raspberry Pi 4 with Fedora 35 Server https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/03/07/microshift-11
  12. MicroShift and KubeVirt on Raspberry Pi 4 with Fedora CoreOS https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/04/17/microshift-12
  13. MicroShift and KubeVirt on Raspberry Pi 4 with Ubuntu Server 22.04 https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/04/17/microshift-13
  14. MicroShift and KubeVirt on Raspberry Pi 4 with Rocky Linux 8.5 https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/04/24/microshift-14
  15. MicroShift and KubeVirt on Raspberry Pi 4 with openSUSE https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/05/08/microshift-15
  16. MicroShift and KubeVirt on Raspberry Pi 4 with Oracle Linux 8.5 https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/05/13/microshift-16
  17. MicroShift and KubeVirt on Raspberry Pi 4 with AlmaLinux 8.5 https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/05/17/microshift-17
  18. MicroShift and KubeVirt on Raspberry Pi 4 with Manjaro 22.04 https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/05/26/microshift-18
  19. MicroShift and KubeVirt on Raspberry Pi 4 with Kali Linux https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/05/30/microshift-19
  20. MicroShift and KubeVirt on Raspberry Pi 4 with Arch Linux https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/05/30/microshift-20
  21. MicroShift and KubeVirt on Raspberry Pi 4 with Fedora 36 Silverblue https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/06/20/microshift-21
  22. MicroShift and KubeVirt on Raspberry Pi 4 with EndeavourOS https://community.ibm.com/community/user/cloud/blogs/alexei-karve/2022/06/27/microshift-22

​​​​​​