mirrors/talos
1
0
Fork 0
mirror of https://github.com/siderolabs/talos.git synced 2025-10-29 15:31:12 +01:00
Code Issues Packages Projects Releases Wiki Activity

docs: add docs for overlays

Browse Source 
Add docs for overlays.

Signed-off-by: Noel Georgi <git@frezbo.dev>
This commit is contained in:
Noel Georgi 2024-03-20 17:09:03 +05:30
parent 9b6ec5929a
commit 6840119632
No known key found for this signature in database
GPG Key ID: 21A9F444075C9E36
16 changed files with 435 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
hack/release.toml
View File

@ -121,8 +121,13 @@ machine:
[notes.sbc]
title = "SBC"
description = """\
Talos core will drop support for SBC's and will not include the SBC binaries in the release.
*Overlays* are being developed to support SBC's.
Talos has split the SBC's (Single Board Computers) into separate repositories.
There will not be any more SBC specific release assets as part of Talos release.
The default Talos Installer image will stop working for SBC's and will fail the upgrade, if used, starting from Talos v1.7.0.
The SBC's images and installers can be generated on the fly using [Image Factory](https://factory.talos.dev) or using [Imager](https://www.talos.dev/latest/talos-guides/install/boot-assets/) for custom images.
The list of official SBC's images supported by Image Factory can be found in the [Overlays](https://github.com/siderolabs/overlays/) repository.
"""
[notes.syslog]

4
website/content/v1.7/_index.md
View File

@ -4,10 +4,10 @@ no_list: true
linkTitle: "Documentation"
cascade:
type: docs
lastRelease: v1.7.0-alpha.0
lastRelease: v1.7.0-alpha.1
kubernetesRelease: "1.30.0-beta.0"
prevKubernetesRelease: "1.28.3"
nvidiaContainerToolkitRelease: "v1.13.5"
nvidiaContainerToolkitRelease: "v1.14.5"
nvidiaDriverRelease: "535.129.03"
preRelease: true
---

45
website/content/v1.7/advanced/overlays.md Normal file
View File

@ -0,0 +1,45 @@
---
title: "Overlays"
description: "Overlays"
---
Overlays provide a way to customize Talos Linux boot image.
Overlays hook into the Talos install steps and can be used to provide additional boot assets (in the case of single board computers),
extra kernel arguments or some custom configuration that is not part of the default Talos installation and specific to a particular overlay.
## Overlays v/s Extensions
Overlays are similar to extensions, but they are used to customize the installation process, while extensions are used to customize the root filesystem.
## Official Overlays
The list of official overlays can be found in the [Overlays GitHub repository](https://github.com/siderolabs/overlays/).
## Using Overlays
Overlays can be used to generate a modified metal image or installer image with the overlay applied.
The process of generating boot assets with overlays is described in the [boot assets guide]({{< relref "../talos-guides/install/boot-assets" >}}).
### Example: Booting a Raspberry Pi 4 with an Overlay
Follow the board specific guide for [Raspberry Pi]({{< relref "../talos-guides/install/single-board-computers/rpi_generic" >}}) to download or generate the metal disk image and write to an SD card.
Boot the machine with the boot media and apply the machine configuration with the installer image that has the overlay applied.
```yaml
# Talos machine configuration patch
machine:
install:
image: factory.talos.dev/installer/fc1cceeb5711cd263877b6b808fbf4942a8deda65e8804c114a0b5bae252dc50:{{< release >}}
```
> Note: The schematic id shown in the above patch is for a vanilla `rpi_generic` overlay.
> Replace it with the schematic id of the overlay you want to apply.
## Authoring Overlays
An Overlay is a container image with the [specific folder structure](https://github.com/siderolabs/overlays#readme).
Overlays can be built and managed using any tool that produces container images, e.g. `docker build`.
Sidero Labs maintains a [repository of overlays](https://github.com/siderolabs/overlays).

34
website/content/v1.7/introduction/support-matrix.md
View File

@ -4,23 +4,23 @@ weight: 60
description: "Table of supported Talos Linux versions and respective platforms."
---
| Talos Version | 1.7 | 1.6 |
|----------------------------------------------------------------------------------------------------------------|------------------------------------|------------------------------------|
| Release Date | 2024-04-15 (TBD) | 2023-12-15 (1.6.0) |
| End of Community Support | 1.8.0 release (2024-08-15, TBD) | 1.7.0 release (2024-04-15) |
| Enterprise Support | [offered by Sidero Labs Inc.](https://www.siderolabs.com/support/) | [offered by Sidero Labs Inc.](https://www.siderolabs.com/support/) |
| Kubernetes | 1.30, 1.29, 1.28, 1.27, 1.26, 1.25 | 1.29, 1.28, 1.27, 1.26, 1.25, 1.24 |
| Architecture | amd64, arm64 | amd64, arm64 |
| **Platforms** | | |
| - cloud | AWS, GCP, Azure, Digital Ocean, Exoscale, Hetzner, OpenNebula, OpenStack, Oracle Cloud, Scaleway, Vultr, Upcloud | AWS, GCP, Azure, Digital Ocean, Exoscale, Hetzner, OpenStack, Oracle Cloud, Scaleway, Vultr, Upcloud |
| - bare metal | x86: BIOS, UEFI, SecureBoot; arm64: UEFI, SecureBoot; boot: ISO, PXE, disk image | x86: BIOS, UEFI; arm64: UEFI; boot: ISO, PXE, disk image |
| - virtualized | VMware, Hyper-V, KVM, Proxmox, Xen | VMware, Hyper-V, KVM, Proxmox, Xen |
| - SBCs | Banana Pi M64, Jetson Nano, Libre Computer Board ALL-H3-CC, Nano Pi R4S, Pine64, Pine64 Rock64, Radxa ROCK Pi 4c, Raspberry Pi 4B, Raspberry Pi Compute Module 4 | Banana Pi M64, Jetson Nano, Libre Computer Board ALL-H3-CC, Nano Pi R4S, Pine64, Pine64 Rock64, Radxa ROCK Pi 4c, Raspberry Pi 4B, Raspberry Pi Compute Module 4 |
| - local | Docker, QEMU | Docker, QEMU |
| **Cluster API** | | |
| [CAPI Bootstrap Provider Talos](https://github.com/siderolabs/cluster-api-bootstrap-provider-talos) | >= 0.6.3 | >= 0.6.3 |
| [CAPI Control Plane Provider Talos](https://github.com/siderolabs/cluster-api-control-plane-provider-talos) | >= 0.5.4 | >= 0.5.4 |
| [Sidero](https://www.sidero.dev/) | >= 0.6.2 | >= 0.6.2 |
| Talos Version | 1.7 | 1.6 |
| ----------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Release Date | 2024-04-15 (TBD) | 2023-12-15 (1.6.0) |
| End of Community Support | 1.8.0 release (2024-08-15, TBD) | 1.7.0 release (2024-04-15) |
| Enterprise Support | [offered by Sidero Labs Inc.](https://www.siderolabs.com/support/) | [offered by Sidero Labs Inc.](https://www.siderolabs.com/support/) |
| Kubernetes | 1.30, 1.29, 1.28, 1.27, 1.26, 1.25 | 1.29, 1.28, 1.27, 1.26, 1.25, 1.24 |
| Architecture | amd64, arm64 | amd64, arm64 |
| **Platforms** | | |
| - cloud | AWS, GCP, Azure, Digital Ocean, Exoscale, Hetzner, OpenNebula, OpenStack, Oracle Cloud, Scaleway, Vultr, Upcloud | AWS, GCP, Azure, Digital Ocean, Exoscale, Hetzner, OpenStack, Oracle Cloud, Scaleway, Vultr, Upcloud |
| - bare metal | x86: BIOS, UEFI, SecureBoot; arm64: UEFI, SecureBoot; boot: ISO, PXE, disk image | x86: BIOS, UEFI; arm64: UEFI; boot: ISO, PXE, disk image |
| - virtualized | VMware, Hyper-V, KVM, Proxmox, Xen | VMware, Hyper-V, KVM, Proxmox, Xen |
| - SBCs | Banana Pi M64, Jetson Nano, Libre Computer Board ALL-H3-CC, Nano Pi R4S, Pine64, Pine64 Rock64, Radxa ROCK Pi 4c, Radxa Rock4c+, Raspberry Pi 4B, Raspberry Pi Compute Module 4 | Banana Pi M64, Jetson Nano, Libre Computer Board ALL-H3-CC, Nano Pi R4S, Pine64, Pine64 Rock64, Radxa ROCK Pi 4c, Raspberry Pi 4B, Raspberry Pi Compute Module 4 |
| - local | Docker, QEMU | Docker, QEMU |
| **Cluster API** | | |
| [CAPI Bootstrap Provider Talos](https://github.com/siderolabs/cluster-api-bootstrap-provider-talos) | >= 0.6.3 | >= 0.6.3 |
| [CAPI Control Plane Provider Talos](https://github.com/siderolabs/cluster-api-control-plane-provider-talos) | >= 0.5.4 | >= 0.5.4 |
| [Sidero](https://www.sidero.dev/) | >= 0.6.2 | >= 0.6.2 |
## Platform Tiers

5
website/content/v1.7/learn-more/image-factory.md
View File

@ -48,6 +48,11 @@ customization:
officialExtensions: # optional
- siderolabs/gvisor
- siderolabs/amd-ucode
overlay: # optional
name: rpi_generic
image: siderolabs/sbc-raspberry-pi
options: # optional, any valid yaml, depends on the overlay implementation
data: "mydata"
```
The "vanilla" schematic is:

148
website/content/v1.7/talos-guides/install/boot-assets.md
View File

@ -10,19 +10,23 @@ can be customized further for a specific use case:
* updating [kernel command line arguments]({{< relref "../../reference/kernel" >}})
* using custom `META` contents, e.g. for [metal network configuration]({{< relref "../../advanced/metal-network-configuration" >}})
* generating [SecureBoot]({{< relref "../install/bare-metal-platforms/secureboot" >}}) images signed with a custom key
* generating disk images for SBC's (Single Board Computers)
There are two ways to generate Talos boot assets:
* using [Image Factory]({{< relref "#image-factory" >}}) service (recommended)
* manually using [imager]({{< relref "#imager" >}}) container image (advanced)
Image Factory is easier to use, but it only produces images for official Talos Linux releases and official Talos Linux system extensions.
Image Factory is easier to use, but it only produces images for official Talos Linux releases, official Talos Linux system extensions
and official Talos Overlays.
The `imager` container can be used to generate images from `main` branch, with local changes, or with custom system extensions.
## Image Factory
[Image Factory]({{< relref "../../learn-more/image-factory" >}}) is a service that generates Talos boot assets on-demand.
Image Factory allows to generate boot assets for the official Talos Linux releases and official Talos Linux system extensions.
Image Factory allows to generate boot assets for the official Talos Linux releases, official Talos Linux system extensions
and official Talos Overlays.
The main concept of the Image Factory is a *schematic* which defines the customization of the boot asset.
Once the schematic is configured, Image Factory can be used to pull various Talos Linux images, ISOs, installer images, PXE booting bare-metal machines across different architectures,
@ -91,6 +95,54 @@ Same way upgrade process can be used to transition to a new set of system extens
talosctl upgrade --image factory.talos.dev/installer/<new_schematic_id>:{{< release >}}
```
### Example: Raspberry Pi generic with Image Factory
Let's assume we want to boot Talos on a Raspberry Pi with `iscsi-tools` system extension.
First, let's create the schematic file `rpi_generic.yaml`:
```yaml
# rpi_generic.yaml
overlay:
name: rpi_generic
image: siderolabs/sbc-raspberrypi
customization:
systemExtensions:
officialExtensions:
- siderolabs/iscsi-tools
```
> The schematic doesn't contain any system extension or overlay versions, Image Factory will pick the correct version matching Talos Linux release.
And now we can upload the schematic to the Image Factory to retrieve its ID:
```shell
$ curl -X POST --data-binary @rpi_generic.yaml https://factory.talos.dev/schematics
{"id":"0db665edfda21c70194e7ca660955425d16cec2aa58ff031e2abf72b7c328585"}
```
The returned schematic ID `0db665edfda21c70194e7ca660955425d16cec2aa58ff031e2abf72b7c328585` we will use to generate the boot assets.
> The schematic ID is based on the schematic contents, so uploading the same schematic will return the same ID.
Now we can download the metal arm64 image:
* https://factory.talos.dev/image/0db665edfda21c70194e7ca660955425d16cec2aa58ff031e2abf72b7c328585/{{< release >}}/metal-arm64.raw.xz (download it and burn to a boot media)
> The Image Factory URL contains both schematic ID and Talos version, and both can be changed to generate different boot assets.
Once installed, the machine can be upgraded to a new version of Talos by referencing new installer image:
```shell
talosctl upgrade --image factory.talos.dev/installer/0db665edfda21c70194e7ca660955425d16cec2aa58ff031e2abf72b7c328585:<new_version>
```
Same way upgrade process can be used to transition to a new set of system extensions: generate new schematic with the new set of system extensions, and upgrade the machine to the new schematic ID:
```shell
talosctl upgrade --image factory.talos.dev/installer/<new_schematic_id>:{{< release >}}
```
### Example: AWS with Image Factory
Talos Linux is installed on AWS from a disk image (AWS AMI), so only a single boot asset is required.
@ -186,6 +238,22 @@ crane export ghcr.io/siderolabs/extensions:{{< release >}} | tar x -O image-dige
For each Talos release, the `ghcr.io/siderolabs/extensions:VERSION` image contains a pinned reference to each system extension container image.
### Overlay Image Reference
While Image Factory automatically resolves the overlay name into a matching container image for a specific version of Talos, `imager` requires the full explicit container image reference.
The `imager` also allows to install custom overlays which are not part of the official Talos overlays.
To get the official Talos overlays container image reference matching a Talos release, use the following command:
```shell
crane export ghcr.io/siderolabs/overlays:{{< release >}} | tar x -O overlays.yaml
```
> Note: this command is using [crane](https://github.com/google/go-containerregistry/blob/main/cmd/crane/README.md) tool, but any other tool which allows
> to export the image contents can be used.
For each Talos release, the `ghcr.io/siderolabs/overlays:VERSION` image contains a pinned reference to each overlay container image.
### Pulling from Private Registries
Talos Linux official images are all public, but when pulling a custom image from a private registry, the `imager` might need authentication to access the images.
@ -273,6 +341,82 @@ Now we can use the customized `installer` image to install Talos on the bare-met
When it's time to upgrade a machine, a new `installer` image can be generated using the new version of `imager`, and updating the system extension images to the matching versions.
The custom `installer` image can now be used to upgrade Talos machine.
### Example: Raspberry Pi overlay with Imager
Let's assume we want to boot Talos on Raspberry Pi with `rpi_generic` overlay and `iscsi-tools` system extension.
First, let's lookup extension images for `iscsi-tools` in the [extensions repository](https://github.com/siderolabs/extensions):
```shell
$ crane export ghcr.io/siderolabs/extensions:{{< release >}} | tar x -O image-digests | grep -E 'iscsi-tools'
ghcr.io/siderolabs/iscsi-tools:v0.1.4@sha256:548b2b121611424f6b1b6cfb72a1669421ffaf2f1560911c324a546c7cee655e
```
Next we'll lookup the overlay image for `rpi_generic` in the [overlays repository](https://github.com/siderolabs/overlays):
```shell
$ crane export ghcr.io/siderolabs/overlays:{{< release >}} | tar x -O overlays.yaml | yq '.overlays[] | select(.name=="rpi_generic")'
name: rpi_generic
image: ghcr.io/siderolabs/sbc-raspberrypi:v0.1.0
digest: sha256:849ace01b9af514d817b05a9c5963a35202e09a4807d12f8a3ea83657c76c863
```
Now we can generate the metal image with the following command:
```shell
$ docker run --rm -t -v $PWD/_out:/out ghcr.io/siderolabs/imager:{{< release >}} rpi_generic --arch arm64 --system-extension-image ghcr.io/siderolabs/iscsi-tools:v0.1.4@sha256:548b2b121611424f6b1b6cfb72a1669421ffaf2f1560911c324a546c7cee655e --overlay-image ghcr.io/siderolabs/sbc-raspberrypi:v0.1.0@sha256:849ace01b9af514d817b05a9c5963a35202e09a4807d12f8a3ea83657c76c863 --overlay-name=rpi_generic
profile ready:
arch: arm64
platform: metal
secureboot: false
version: {{< release >}}
input:
kernel:
path: /usr/install/arm64/vmlinuz
initramfs:
path: /usr/install/arm64/initramfs.xz
baseInstaller:
imageRef: ghcr.io/siderolabs/installer:{{< release >}}
systemExtensions:
- imageRef: ghcr.io/siderolabs/iscsi-tools:v0.1.4@sha256:a68c268d40694b7b93c8ac65d6b99892a6152a2ee23fdbffceb59094cc3047fc
overlay:
name: rpi_generic
image:
imageRef: ghcr.io/siderolabs/sbc-raspberrypi:v0.1.0-alpha.1@sha256:849ace01b9af514d817b05a9c5963a35202e09a4807d12f8a3ea83657c76c863
output:
kind: image
imageOptions:
diskSize: 1306525696
diskFormat: raw
outFormat: .xz
initramfs ready
kernel command line: talos.platform=metal console=tty0 console=ttyAMA0,115200 sysctl.kernel.kexec_load_disabled=1 talos.dashboard.disabled=1 init_on_alloc=1 slab_nomerge pti=on consoleblank=0 nvme_core.io_timeout=4294967295 printk.devkmsg=on ima_template=ima-ng ima_appraise=fix ima_hash=sha512
disk image ready
output asset path: /out/metal-arm64.raw
compression done: /out/metal-arm64.raw.xz
```
Now the `_out/metal-arm64.raw.xz` is the compressed disk image which can be written to a boot media.
As the next step, we should generate a custom `installer` image which contains all required system extensions (kernel args can't be specified with the installer image, but they are set in the machine configuration):
```shell
$ docker run --rm -t -v $PWD/_out:/out ghcr.io/siderolabs/imager:{{< release >}} installer --arch arm64 --system-extension-image ghcr.io/siderolabs/iscsi-tools:v0.1.4@sha256:548b2b121611424f6b1b6cfb72a1669421ffaf2f1560911c324a546c7cee655e --overlay-image ghcr.io/siderolabs/sbc-raspberrypi:v0.1.0@sha256:849ace01b9af514d817b05a9c5963a35202e09a4807d12f8a3ea83657c76c863 --overlay-name=rpi_generic
...
output asset path: /out/metal-arm64-installer.tar
```
The `installer` container image should be pushed to the container registry:
```shell
crane push _out/metal-arm64-installer.tar ghcr.io/<username></username>/installer:{{< release >}}
```
Now we can use the customized `installer` image to install Talos on Raspvberry Pi.
When it's time to upgrade a machine, a new `installer` image can be generated using the new version of `imager`, and updating the system extension and overlay images to the matching versions.
The custom `installer` image can now be used to upgrade Talos machine.
### Example: AWS with Imager
Talos is installed on AWS from a disk image (AWS AMI), so only a single boot asset is required.

21
website/content/v1.7/talos-guides/install/single-board-computers/bananapi_m64.md
View File

@ -1,7 +1,7 @@
---
title: "Banana Pi M64"
description: "Installing Talos on Banana Pi M64 SBC using raw disk image."
aliases:
aliases:
- ../../../single-board-computers/bananapi_m64
---
@ -19,13 +19,16 @@ curl -Lo /usr/local/bin/talosctl https://github.com/siderolabs/talos/releases/do
chmod +x /usr/local/bin/talosctl
```
## Download the Image
## Download the Image using Image Factory
The default schematic id for "vanilla" Banana Pi M64 is `f48c47c8a27248bc19a878c086f2cb2ed0d5aff777688af95fc88f100d1048e1`.
Refer to the [Image Factory](/../../../learn-more/image-factory) documentation for more information.
Download the image and decompress it:
```bash
curl -LO https://github.com/siderolabs/talos/releases/download/{{< release >}}/metal-bananapi_m64-arm64.raw.xz
xz -d metal-bananapi_m64-arm64.raw.xz
curl -LO https://factory.talos.dev/image/f48c47c8a27248bc19a878c086f2cb2ed0d5aff777688af95fc88f100d1048e1/{{< release >}}/metal-arm64.raw.xz
xz -d metal-arm64.raw.xz
```
## Writing the Image
@ -36,7 +39,7 @@ In this example, we will assume `/dev/mmcblk0`.
Now `dd` the image to your SD card:
```bash
sudo dd if=metal-bananapi_m64-arm64.img of=/dev/mmcblk0 conv=fsync bs=4M
sudo dd if=metal-arm64.raw of=/dev/mmcblk0 conv=fsync bs=4M
```
## Bootstrapping the Node
@ -57,3 +60,11 @@ Retrieve the admin `kubeconfig` by running:
```bash
talosctl kubeconfig
```
## Upgrading
For example, to upgrade to the latest version of Talos, you can run:
```bash
talosctl -n <node IP or DNS name> upgrade --image=factory.talos.dev/installer/f48c47c8a27248bc19a878c086f2cb2ed0d5aff777688af95fc88f100d1048e1:{{< release >}}
```

19
website/content/v1.7/talos-guides/install/single-board-computers/jetson_nano.md
View File

@ -48,7 +48,7 @@ Next we will extract the L4T release and replace the `u-boot` binary with the pa
```bash
tar xf jetson-210_linux_r32.6.1_aarch64.tbz2
cd Linux_for_Tegra
crane --platform=linux/arm64 export ghcr.io/siderolabs/u-boot:v1.3.0-alpha.0-25-g0ac7773 - | tar xf - --strip-components=1 -C bootloader/t210ref/p3450-0000/ jetson_nano/u-boot.bin
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.
@ -82,11 +82,14 @@ Once the flashing is done you can disconnect the USB cable and power off the Jet
## Download the Image
The default schematic id for "vanilla" Jetson Nano is `ef65b643766cc94c7eda6c42cb8fe009086d2b7b8066fd971950f4ef21708b5d`.
Refer to the [Image Factory](/../../../learn-more/image-factory) documentation for more information.
Download the image and decompress it:
```bash
curl -LO https://github.com/siderolabs/talos/releases/download/{{< release >}}/metal-jetson_nano-arm64.raw.xz
xz -d metal-jetson_nano-arm64.raw.xz
curl -LO https://factory.talos.dev/image/ef65b643766cc94c7eda6c42cb8fe009086d2b7b8066fd971950f4ef21708b5d/{{< release >}}/metal-arm64.raw.xz
xz -d metal-arm64.raw.xz
```
## Writing the Image
@ -94,7 +97,7 @@ xz -d metal-jetson_nano-arm64.raw.xz
Now `dd` the image to your SD card/USB storage:
```bash
sudo dd if=metal-jetson_nano-arm64.img of=/dev/mmcblk0 conv=fsync bs=4M status=progress
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.
@ -117,3 +120,11 @@ Retrieve the admin `kubeconfig` by running:
```bash
talosctl kubeconfig
```
## Upgrading
For example, to upgrade to the latest version of Talos, you can run:
```bash
talosctl -n <node IP or DNS name> upgrade --image=factory.talos.dev/installer/ef65b643766cc94c7eda6c42cb8fe009086d2b7b8066fd971950f4ef21708b5d:{{< release >}}
```

21
website/content/v1.7/talos-guides/install/single-board-computers/libretech_all_h3_cc_h5.md
View File

@ -1,7 +1,7 @@
---
title: "Libre Computer Board ALL-H3-CC"
description: "Installing Talos on Libre Computer Board ALL-H3-CC SBC using raw disk image."
aliases:
aliases:
- ../../../single-board-computers/libretech_all_h3_cc_h5
---
@ -21,11 +21,14 @@ chmod +x /usr/local/bin/talosctl
## Download the Image
The default schematic id for "vanilla" Libretech H3 CC H5 is `9e6498be873621e4a40d5bcfe67ce873d58a2e7aea1079ae27754bdedf245c8c`.
Refer to the [Image Factory](/../../../learn-more/image-factory) documentation for more information.
Download the image and decompress it:
```bash
curl -LO https://github.com/siderolabs/talos/releases/download/{{< release >}}/metal-libretech_all_h3_cc_h5-arm64.raw.xz
xz -d metal-libretech_all_h3_cc_h5-arm64.raw.xz
curl -LO https://factory.talos.dev/image/9e6498be873621e4a40d5bcfe67ce873d58a2e7aea1079ae27754bdedf245c8c/{{< release >}}/metal-arm64.raw.xz
xz -d metal-arm64.raw.xz
```
## Writing the Image
@ -36,12 +39,14 @@ In this example, we will assume `/dev/mmcblk0`.
Now `dd` the image to your SD card:
```bash
sudo dd if=metal-libretech_all_h3_cc_h5-arm64.img of=/dev/mmcblk0 conv=fsync bs=4M
sudo dd if=metal-arm64.raw of=/dev/mmcblk0 conv=fsync bs=4M
```
## Bootstrapping the Node
Insert the SD card to your board, turn it on and wait for the console to show you the instructions for bootstrapping the node.
Create a `installer-patch.yaml` containing reference to the `installer` image generated from an overlay:
Following the instructions in the console output to connect to the interactive installer:
```bash
@ -57,3 +62,11 @@ Retrieve the admin `kubeconfig` by running:
```bash
talosctl kubeconfig
```
## Upgrading
For example, to upgrade to the latest version of Talos, you can run:
```bash
talosctl -n <node IP or DNS name> upgrade --image=factory.talos.dev/installer/9e6498be873621e4a40d5bcfe67ce873d58a2e7aea1079ae27754bdedf245c8c:{{< release >}}
```

17
website/content/v1.7/talos-guides/install/single-board-computers/nanopi_r4s.md
View File

@ -21,11 +21,14 @@ chmod +x /usr/local/bin/talosctl
## Download the Image
The default schematic id for "vanilla" NanoPi R4S is `0609eb7bed621f87075729ed7c7410c3b5ee83fb42d10e2cdb1fd5c7b3a3325b`.
Refer to the [Image Factory](/../../../learn-more/image-factory) documentation for more information.
Download the image and decompress it:
```bash
curl -LO https://github.com/siderolabs/talos/releases/download/{{< release >}}/metal-rockpi_4-arm64.raw.xz
xz -d metal-nanopi_r4s-arm64.raw.xz
curl -LO https://factory.talos.dev/image/0609eb7bed621f87075729ed7c7410c3b5ee83fb42d10e2cdb1fd5c7b3a3325b/{{< release >}}/metal-arm64.raw.xz
xz -d metal-arm64.raw.xz
```
## Writing the Image
@ -36,7 +39,7 @@ In this example, we will assume `/dev/mmcblk0`.
Now `dd` the image to your SD card:
```bash
sudo dd if=metal-nanopi_r4s-arm64.img of=/dev/mmcblk0 conv=fsync bs=4M
sudo dd if=metal-arm64.raw of=/dev/mmcblk0 conv=fsync bs=4M
```
## Bootstrapping the Node
@ -57,3 +60,11 @@ Retrieve the admin `kubeconfig` by running:
```bash
talosctl kubeconfig
```
## Upgrading
For example, to upgrade to the latest version of Talos, you can run:
```bash
talosctl -n <node IP or DNS name> upgrade --image=factory.talos.dev/installer/0609eb7bed621f87075729ed7c7410c3b5ee83fb42d10e2cdb1fd5c7b3a3325b:{{< release >}}
```

19
website/content/v1.7/talos-guides/install/single-board-computers/pine64.md
View File

@ -1,7 +1,7 @@
---
title: "Pine64"
description: "Installing Talos on a Pine64 SBC using raw disk image."
aliases:
aliases:
- ../../../single-board-computers/pine64
---
@ -21,11 +21,14 @@ chmod +x /usr/local/bin/talosctl
## Download the Image
The default schematic id for "vanilla" Pine64 is `94cd4c4e285dc07059868f089f87c2437e1ed2746cc8d0fcbc0abbaf2b9a6729`.
Refer to the [Image Factory](/../../../learn-more/image-factory) documentation for more information.
Download the image and decompress it:
```bash
curl -LO https://github.com/siderolabs/talos/releases/download/{{< release >}}/metal-pine64-arm64.raw.xz
xz -d metal-pine64-arm64.raw.xz
curl -LO https://factory.talos.dev/image/94cd4c4e285dc07059868f089f87c2437e1ed2746cc8d0fcbc0abbaf2b9a6729/{{< release >}}/metal-arm64.raw.xz
xz -d metal-arm64.raw.xz
```
## Writing the Image
@ -36,7 +39,7 @@ In this example, we will assume `/dev/mmcblk0`.
Now `dd` the image to your SD card:
```bash
sudo dd if=metal-pine64-arm64.img of=/dev/mmcblk0 conv=fsync bs=4M
sudo dd if=metal-arm64.raw of=/dev/mmcblk0 conv=fsync bs=4M
```
## Bootstrapping the Node
@ -57,3 +60,11 @@ Retrieve the admin `kubeconfig` by running:
```bash
talosctl kubeconfig
```
## Upgrading
For example, to upgrade to the latest version of Talos, you can run:
```bash
talosctl -n <node IP or DNS name> upgrade --image=factory.talos.dev/installer/94cd4c4e285dc07059868f089f87c2437e1ed2746cc8d0fcbc0abbaf2b9a6729:{{< release >}}
```

76
website/content/v1.7/talos-guides/install/single-board-computers/rock4cplus.md Normal file
View File

@ -0,0 +1,76 @@
---
title: "Radxa ROCK 4C Plus"
description: "Installing Talos on Radxa ROCK 4c Plus SBC using raw disk image."
---
## Prerequisites
You will need
- `talosctl`
- an SD card or an eMMC or USB drive or an nVME drive
Download the latest `talosctl`.
```bash
curl -Lo /usr/local/bin/talosctl https://github.com/siderolabs/talos/releases/download/{{< release >}}/talosctl-$(uname -s | tr "[:upper:]" "[:lower:]")-amd64
chmod +x /usr/local/bin/talosctl
```
## Download the Image
The default schematic id for "vanilla" Rock 4c Plus is `2c086d74bbf7cc99cdac752a40990d4854f1202ac642d3c8e5171ddd22184b68`.
Refer to the [Image Factory](/../../../learn-more/image-factory) documentation for more information.
Download the image and decompress it:
```bash
curl -LO https://factory.talos.dev/image/2c086d74bbf7cc99cdac752a40990d4854f1202ac642d3c8e5171ddd22184b68/{{< release >}}/metal-arm64.raw.xz
xz -d metal-arm64.raw.xz
```
## Writing the Image
The path to your SD card/eMMC/USB/nVME can be found using `fdisk` on Linux or `diskutil` on macOS.
In this example, we will assume `/dev/mmcblk0`.
Now `dd` the image to your SD card:
```bash
sudo dd if=metal-arm64.raw of=/dev/mmcblk0 conv=fsync bs=4M
```
The user has two options to proceed:
- booting from a SD card or eMMC
### Booting from SD card or eMMC
Insert the SD card into the board, turn it on and proceed to [bootstrapping the node](#bootstrapping-the-node).
## Bootstrapping the Node
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
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
talosctl kubeconfig
```
## Upgrading
For example, to upgrade to the latest version of Talos, you can run:
```bash
talosctl -n <node IP or DNS name> upgrade --image=factory.talos.dev/installer/2c086d74bbf7cc99cdac752a40990d4854f1202ac642d3c8e5171ddd22184b68:{{< release >}}
```

19
website/content/v1.7/talos-guides/install/single-board-computers/rock64.md
View File

@ -1,7 +1,7 @@
---
title: "Pine64 Rock64"
description: "Installing Talos on Pine64 Rock64 SBC using raw disk image."
aliases:
aliases:
- ../../../single-board-computers/rock64
---
@ -21,11 +21,14 @@ chmod +x /usr/local/bin/talosctl
## Download the Image
The default schematic id for "vanilla" Pine64 Rock64 is `a9dd1a551aa4098ff3e67916055cd5aec1f918d02faf2502d069bab84b2319de`.
Refer to the [Image Factory](/../../../learn-more/image-factory) documentation for more information.
Download the image and decompress it:
```bash
curl -LO https://github.com/siderolabs/talos/releases/download/{{< release >}}/metal-rock64-arm64.raw.xz
xz -d metal-rock64-arm64.raw.xz
curl -LO https://factory.talos.dev/image/a9dd1a551aa4098ff3e67916055cd5aec1f918d02faf2502d069bab84b2319de/{{< release >}}/metal-arm64.raw.xz
xz -d metal-arm64.raw.xz
```
## Writing the Image
@ -36,7 +39,7 @@ In this example, we will assume `/dev/mmcblk0`.
Now `dd` the image to your SD card:
```bash
sudo dd if=metal-rock64-arm64.img of=/dev/mmcblk0 conv=fsync bs=4M
sudo dd if=metal-arm64.raw of=/dev/mmcblk0 conv=fsync bs=4M
```
## Bootstrapping the Node
@ -57,3 +60,11 @@ Retrieve the admin `kubeconfig` by running:
```bash
talosctl kubeconfig
```
## Upgrading
For example, to upgrade to the latest version of Talos, you can run:
```bash
talosctl -n <node IP or DNS name> upgrade --image=factory.talos.dev/installer/a9dd1a551aa4098ff3e67916055cd5aec1f918d02faf2502d069bab84b2319de:{{< release >}}
```

42
website/content/v1.7/talos-guides/install/single-board-computers/rockpi_4.md
View File

@ -21,11 +21,14 @@ chmod +x /usr/local/bin/talosctl
## Download the Image
The default schematic id for "vanilla" RockPi 4 is `2f9c727db057ab731b7193a8d78b12fdc73022a40778920504c99a5d9be3f0b6`.
Refer to the [Image Factory](/../../../learn-more/image-factory) documentation for more information.
Download the image and decompress it:
```bash
curl -LO https://github.com/siderolabs/talos/releases/download/{{< release >}}/metal-rockpi_4-arm64.raw.xz
xz -d metal-rockpi_4-arm64.raw.xz
curl -LO https://factory.talos.dev/image/2f9c727db057ab731b7193a8d78b12fdc73022a40778920504c99a5d9be3f0b6/{{< release >}}/metal-arm64.raw.xz
xz -d metal-arm64.raw.xz
```
## Writing the Image
@ -36,7 +39,7 @@ In this example, we will assume `/dev/mmcblk0`.
Now `dd` the image to your SD card:
```bash
sudo dd if=metal-rockpi_4-arm64.img of=/dev/mmcblk0 conv=fsync bs=4M
sudo dd if=metal-arm64.raw of=/dev/mmcblk0 conv=fsync bs=4M
```
The user has two options to proceed:
@ -52,30 +55,9 @@ Insert the SD card into the board, turn it on and proceed to [bootstrapping the
This requires the user to flash the RockPi SPI flash with u-boot.
This requires the user has access to [crane CLI](https://github.com/google/go-containerregistry/releases), a spare SD card and optionally access to the [RockPi serial console](https://wiki.radxa.com/Rockpi4/dev/serial-console).
Follow the Radxa docs on [Install on M.2 NVME SSD](https://wiki.radxa.com/Rockpi4/install/NVME)
- Flash the Rock PI 4c variant of [Debian](https://wiki.radxa.com/Rockpi4/downloads) to the SD card.
- Boot into the debian image
- Check that /dev/mtdblock0 exists otherwise the command will silently fail; e.g. `lsblk`.
- Download u-boot image from talos u-boot:
```bash
mkdir _out
crane --platform=linux/arm64 export ghcr.io/siderolabs/u-boot:v1.3.0-alpha.0-25-g0ac7773 - | tar xf - --strip-components=1 -C _out rockpi_4/rkspi_loader.img
sudo dd if=rkspi_loader.img of=/dev/mtdblock0 bs=4K
```
- Optionally, you can also write Talos image to the SSD drive right from your Rock PI board:
```bash
curl -LO https://github.com/siderolabs/talos/releases/download/{{< release >}}/metal-rockpi_4-arm64.raw.xz
xz -d metal-rockpi_4-arm64.raw.xz
sudo dd if=metal-rockpi_4-arm64.raw.xz of=/dev/nvme0n1
```
- remove SD card and reboot.
After these steps, Talos will boot from the nVME/USB and enter maintenance mode.
After these above steps, Talos will boot from the nVME/USB and enter maintenance mode.
Proceed to [bootstrapping the node](#bootstrapping-the-node).
## Bootstrapping the Node
@ -96,3 +78,11 @@ Retrieve the admin `kubeconfig` by running:
```bash
talosctl kubeconfig
```
## Upgrading
For example, to upgrade to the latest version of Talos, you can run:
```bash
talosctl -n <node IP or DNS name> upgrade --image=factory.talos.dev/installer/2f9c727db057ab731b7193a8d78b12fdc73022a40778920504c99a5d9be3f0b6:{{< release >}}
```

42
website/content/v1.7/talos-guides/install/single-board-computers/rockpi_4c.md
View File

@ -19,11 +19,14 @@ chmod +x /usr/local/bin/talosctl
## Download the Image
The default schematic id for "vanilla" RockPi 4c is `a291c960717f5abad9b280c4c75bf067a4e63e339124ea814cb221f6000057d6`.
Refer to the [Image Factory](/../../../learn-more/image-factory) documentation for more information.
Download the image and decompress it:
```bash
curl -LO https://github.com/siderolabs/talos/releases/download/{{< release >}}/metal-rockpi_4c-arm64.raw.xz
xz -d metal-rockpi_4c-arm64.raw.xz
curl -LO https://factory.talos.dev/image/a291c960717f5abad9b280c4c75bf067a4e63e339124ea814cb221f6000057d6/{{< release >}}/metal-arm64.raw.xz
xz -d metal-arm64.raw.xz
```
## Writing the Image
@ -34,7 +37,7 @@ In this example, we will assume `/dev/mmcblk0`.
Now `dd` the image to your SD card:
```bash
sudo dd if=metal-rockpi_4c-arm64.img of=/dev/mmcblk0 conv=fsync bs=4M
sudo dd if=metal-arm64.raw of=/dev/mmcblk0 conv=fsync bs=4M
```
The user has two options to proceed:
@ -50,30 +53,9 @@ Insert the SD card into the board, turn it on and proceed to [bootstrapping the
This requires the user to flash the RockPi SPI flash with u-boot.
This requires the user has access to [crane CLI](https://github.com/google/go-containerregistry/releases), a spare SD card and optionally access to the [RockPi serial console](https://wiki.radxa.com/Rockpi4/dev/serial-console).
Follow the Radxa docs on [Install on M.2 NVME SSD](https://wiki.radxa.com/Rockpi4/install/NVME)
- Flash the Rock PI 4c variant of [Debian](https://wiki.radxa.com/Rockpi4/downloads) to the SD card.
- Boot into the debian image
- Check that /dev/mtdblock0 exists otherwise the command will silently fail; e.g. `lsblk`.
- Download u-boot image from talos u-boot:
```bash
mkdir _out
crane --platform=linux/arm64 export ghcr.io/siderolabs/u-boot:v1.3.0-alpha.0-25-g0ac7773 - | tar xf - --strip-components=1 -C _out rockpi_4c/rkspi_loader.img
sudo dd if=rkspi_loader.img of=/dev/mtdblock0 bs=4K
```
- Optionally, you can also write Talos image to the SSD drive right from your Rock PI board:
```bash
curl -LO https://github.com/siderolabs/talos/releases/download/{{< release >}}/metal-rockpi_4c-arm64.raw.xz
xz -d metal-rockpi_4c-arm64.raw.xz
sudo dd if=metal-rockpi_4c-arm64.raw.xz of=/dev/nvme0n1
```
- remove SD card and reboot.
After these steps, Talos will boot from the nVME/USB and enter maintenance mode.
After these above steps, Talos will boot from the nVME/USB and enter maintenance mode.
Proceed to [bootstrapping the node](#bootstrapping-the-node).
## Bootstrapping the Node
@ -94,3 +76,11 @@ Retrieve the admin `kubeconfig` by running:
```bash
talosctl kubeconfig
```
## Upgrading
For example, to upgrade to the latest version of Talos, you can run:
```bash
talosctl -n <node IP or DNS name> upgrade --image=factory.talos.dev/installer/a291c960717f5abad9b280c4c75bf067a4e63e339124ea814cb221f6000057d6:{{< release >}}
```

16
website/content/v1.7/talos-guides/install/single-board-computers/rpi_generic.md
View File

@ -44,11 +44,13 @@ Power off the Raspberry Pi and remove the SD card from it.
## Download the Image
The default schematic id for "vanilla" Raspberry Pi generic image is `fc1cceeb5711cd263877b6b808fbf4942a8deda65e8804c114a0b5bae252dc50`.Refer to the [Image Factory](/../../../learn-more/image-factory) documentation for more information.
Download the image and decompress it:
```bash
curl -LO https://github.com/siderolabs/talos/releases/download/{{< release >}}/metal-rpi_generic-arm64.raw.xz
xz -d metal-rpi_generic-arm64.raw.xz
curl -LO https://factory.talos.dev/image/fc1cceeb5711cd263877b6b808fbf4942a8deda65e8804c114a0b5bae252dc50/{{< release >}}/metal-arm64.raw.xz
xz -d metal-arm64.raw.xz
```
## Writing the Image
@ -56,7 +58,7 @@ xz -d metal-rpi_generic-arm64.raw.xz
Now `dd` the image to your SD card:
```bash
sudo dd if=metal-rpi_generic-arm64.raw of=/dev/mmcblk0 conv=fsync bs=4M
sudo dd if=metal-arm64.raw of=/dev/mmcblk0 conv=fsync bs=4M
```
## Bootstrapping the Node
@ -81,6 +83,14 @@ Retrieve the admin `kubeconfig` by running:
talosctl kubeconfig
```
## Upgrading
For example, to upgrade to the latest version of Talos, you can run:
```bash
talosctl -n <node IP or DNS name> upgrade --image=factory.talos.dev/installer/fc1cceeb5711cd263877b6b808fbf4942a8deda65e8804c114a0b5bae252dc50:{{< release >}}
```
## Troubleshooting
The following table can be used to troubleshoot booting issues: