> ## Documentation Index
> Fetch the complete documentation index at: https://docs.siderolabs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Jetson Nano

> Installing Talos on Jetson Nano SBC using raw disk image.

export const release_v1_13 = 'v1.13.1';

export const VersionWarningBanner = () => {
  const latestVersion = "v1.13";
  const [latestUrl, setLatestUrl] = useState(null);
  const [currentVersion, setCurrentVersion] = useState(null);
  const [isBeta, setIsBeta] = useState(false);
  const parseVersion = v => v.replace("v", "").split(".").map(Number);
  const isGreaterVersion = (a, b) => {
    const [aMajor, aMinor] = parseVersion(a);
    const [bMajor, bMinor] = parseVersion(b);
    if (aMajor > bMajor) return true;
    if (aMajor === bMajor && aMinor > bMinor) return true;
    return false;
  };
  useEffect(() => {
    if (typeof window === "undefined") return;
    const {pathname, hash, search} = window.location;
    const match = pathname.match(/\/talos\/(v\d+\.\d+)\//);
    if (!match) return;
    const detectedVersion = match[1];
    if (detectedVersion === latestVersion) return;
    setCurrentVersion(detectedVersion);
    if (isGreaterVersion(detectedVersion, latestVersion)) {
      setIsBeta(true);
    }
    const newPath = pathname.replace(`/talos/${detectedVersion}/`, `/talos/${latestVersion}/`);
    setLatestUrl(`${newPath}${search}${hash}`);
  }, []);
  if (!latestUrl || !currentVersion) return null;
  return <div className="not-prose sticky top-6 z-50 my-6">
      <div className="border border-yellow-500/30 bg-yellow-500/10 px-4 py-3 rounded-xl">
        <div className="text-sm">
          {isBeta ? <>
              ⚠️ You are viewing a <strong>beta version</strong> of Talos ({currentVersion}).
              This version may be unstable.
              <a href={latestUrl} className="ml-2 underline text-yellow-400 hover:text-yellow-300 font-medium">
                View latest stable version {latestVersion} →
              </a>
            </> : <>
              ⚠️ You are viewing an older version of Talos ({currentVersion}).
              <a href={latestUrl} className="ml-2 underline text-yellow-400 hover:text-yellow-300 font-medium">
                View the latest version {latestVersion} →
              </a>
            </>}
        </div>
      </div>
    </div>;
};

<VersionWarningBanner />

## Prerequisites

You will need

* `talosctl`
* an SD card/USB drive
* [crane CLI](https://github.com/google/go-containerregistry/releases)

Download the latest `talosctl`.

<CodeBlock lang="sh">
  {`
    curl -Lo /usr/local/bin/talosctl https://github.com/siderolabs/talos/releases/download/${release_v1_13}/talosctl-$(uname -s | tr "[:upper:]" "[:lower:]")-amd64
    chmod +x /usr/local/bin/talosctl
    `}
</CodeBlock>

## Flashing the firmware to on-board SPI flash

> Flashing the firmware only needs to be done once.

We will use the [R32.7.2 release](https://developer.nvidia.com/embedded/l4t/r32_release_v7.1/t210/jetson-210_linux_r32.7.2_aarch64.tbz2) for the Jetson Nano.
Most of the instructions is similar to this [doc](https://nullr0ute.com/2020/11/installing-fedora-on-the-nvidia-jetson-nano/) except that we'd be using a upstream version of `u-boot` with patches from NVIDIA u-boot so that USB boot also works.

Before flashing we need the following:

* A USB-A to micro USB cable
* A jumper wire to enable recovery mode
* A HDMI monitor to view the logs if the USB serial adapter is not available
* A USB to Serial adapter with 3.3V TTL (optional)
* A 5V DC barrel jack

If you're planning to use the serial console follow the documentation [here](https://www.jetsonhacks.com/2019/04/19/jetson-nano-serial-console/)

First start by downloading the Jetson Nano L4T release.

```bash theme={null}
curl -SLO https://developer.nvidia.com/embedded/l4t/r32_release_v7.1/t210/jetson-210_linux_r32.7.2_aarch64.tbz2
```

Next we will extract the L4T release and replace the `u-boot` binary with the patched version.

```bash theme={null}
tar xf jetson-210_linux_r32.6.1_aarch64.tbz2
cd Linux_for_Tegra
crane --platform=linux/arm64 export ghcr.io/siderolabs/sbc-jetson:v0.1.0 - | tar xf - --strip-components=4 -C bootloader/t210ref/p3450-0000/ artifacts/arm64/u-boot/jetson_nano/u-boot.bin
```

Next we will flash the firmware to the Jetson Nano SPI flash.
In order to do that we need to put the Jetson Nano into Force Recovery Mode (FRC).
We will use the instructions from [here](https://developer.download.nvidia.com/embedded/L4T/r32_Release_v4.4/r32_Release_v4.4-GMC3/T210/l4t_quick_start_guide.txt)

* Ensure that the Jetson Nano is powered off.
  There is no need for the SD card/USB storage/network cable to be connected
* Connect the micro USB cable to the micro USB port on the Jetson Nano, don't plug the other end to the PC yet
* Enable Force Recovery Mode (FRC) by placing a jumper across the FRC pins on the Jetson Nano
  * For board revision *A02*, these are pins `3` and `4` of header `J40`
  * For board revision *B01*, these are pins `9` and `10` of header `J50`
* Place another jumper across `J48` to enable power from the DC jack and connect the Jetson Nano to the DC jack `J25`
* Now connect the other end of the micro USB cable to the PC and remove the jumper wire from the FRC pins

Now the Jetson Nano is in Force Recovery Mode (FRC) and can be confirmed by running the following command

```bash theme={null}
lsusb | grep -i "nvidia"
```

Now we can move on the flashing the firmware.

```bash theme={null}
sudo ./flash p3448-0000-max-spi external
```

This will flash the firmware to the Jetson Nano SPI flash and you'll see a lot of output.
If you've connected the serial console you'll also see the progress there.
Once the flashing is done you can disconnect the USB cable and power off the Jetson Nano.

## Download the image

The default schematic id for "vanilla" Jetson Nano is `c7d6f36c6bdfb45fd63178b202a67cff0dd270262269c64886b43f76880ecf1e`.
Refer to the [Image Factory](../../learn-more/image-factory) documentation for more information.

Download the image and decompress it:

<CodeBlock lang="sh">
  {`
    curl -LO https://factory.talos.dev/image/c7d6f36c6bdfb45fd63178b202a67cff0dd270262269c64886b43f76880ecf1e/${release_v1_13}/metal-arm64.raw.xz
    xz -d metal-arm64.raw.xz
    `}
</CodeBlock>

## Writing the image

Now `dd` the image to your SD card/USB storage:

```bash theme={null}
sudo dd if=metal-arm64.raw of=/dev/mmcblk0 conv=fsync bs=4M status=progress
```

\| Replace `/dev/mmcblk0` with the name of your SD card/USB storage.

## Bootstrapping the node

Insert the SD card/USB storage to your board, turn it on and wait for the console to show you the instructions for bootstrapping the node.
Following the instructions in the console output to connect to the interactive installer:

```bash theme={null}
talosctl apply-config --insecure --mode=interactive --nodes <node IP or DNS name>
```

Once the interactive installation is applied, the cluster will form and you can then use `kubectl`.

## Retrieve the `kubeconfig`

Retrieve the admin `kubeconfig` by running:

```bash theme={null}
talosctl kubeconfig
```

## Upgrading

For example, to upgrade to the latest version of Talos, you can run:

<CodeBlock lang="sh">
  {`
    talosctl -n <node IP or DNS name> upgrade --image=factory.talos.dev/installer/c7d6f36c6bdfb45fd63178b202a67cff0dd270262269c64886b43f76880ecf1e:${release_v1_13}
    `}
</CodeBlock>