# Deploy containerized workloads to Arm-based Linux targets with Topo

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/cross-platform/deploy-containerized-workloads-with-topo/)
- [Install Topo on your host machine](https://learn.arm.com/learning-paths/cross-platform/deploy-containerized-workloads-with-topo/overview-and-setup/)
- [Use Topo to assess target compatibility](https://learn.arm.com/learning-paths/cross-platform/deploy-containerized-workloads-with-topo/assess-compatibility/)
- [Deploy a compatible containerized workload with Topo](https://learn.arm.com/learning-paths/cross-platform/deploy-containerized-workloads-with-topo/deploy-workload/)
- [(Optional) Use the Topo VS Code extension](https://learn.arm.com/learning-paths/cross-platform/deploy-containerized-workloads-with-topo/topo-vscode-extension/)
- [Next Steps](https://learn.arm.com/learning-paths/cross-platform/deploy-containerized-workloads-with-topo/_next-steps/)

## About this Learning Path

| Skill level: | Introductory |
|--------------|--------------|
| Reading time: | 30 min |
| Last updated: | 03 Aug 2026 |

| Author: | Matt Cossins, Arm [GitHub](https://github.com/matt-cossins) |
|----------|-------------------------------------------------------|
| Arm IP: | [Neoverse](https://support.arm.com/?tab=compute-ip&Product%20Type=Infrastructure%20Processors) [Cortex-A](https://support.arm.com/?tab=compute-ip&Product%20Type=Application%20Processors) [Cortex-M](https://support.arm.com/?tab=compute-ip&Product%20Type=Microcontrollers) |
| Tags: | [Containers and Virtualization](https://learn.arm.com/tag/containers-and-virtualization) [Linux](https://learn.arm.com/tag/linux) [macOS](https://learn.arm.com/tag/macos) [Windows](https://learn.arm.com/tag/windows) [Topo](https://learn.arm.com/tag/topo) [Docker](https://learn.arm.com/tag/docker) [SSH](https://learn.arm.com/tag/ssh) [Visual Studio Code](https://learn.arm.com/tag/visual-studio-code) |

### Who is this for?

This is an introductory topic for embedded, edge, and cloud software developers who want to deploy containerized workloads to Arm-based Linux targets using Topo.

### What will you learn?

Upon completion of this Learning Path, you will be able to:

- Install Topo and verify that the host and target environments are ready for deployment
- Run health checks and list compatible projects for your target
- Clone a Topo Project and deploy a containerized workload to an Arm-based Linux target
- (Optional) Use the Topo VS Code extension to run the same target, project, and deployment workflow from Visual Studio Code
- (Optional) Deploy firmware and applications to heterogeneous Cortex-A + Cortex-M devices using remoteproc-runtime

### Prerequisites

Before starting, you will need the following:

- A host machine (x86 or Arm) with Linux, macOS, or Windows
- An Arm-based Linux target accessible over SSH, for example an Arm-based Linux VM, Raspberry Pi, DGX Spark, or NXP i.MX 93
- Docker installed on the host and target. For installation steps, see [Install Docker](https://learn.arm.com/install-guides/docker/).
- lscpu installed on the target (pre-installed on most Linux distributions)
- (Optional) Visual Studio Code installed if you want to use the Topo VS Code extension
- Basic familiarity with containers and CLI tools

### Summary

You’ll use Topo to deploy containerized workloads to Arm-based Linux targets over SSH. You’ll install Topo on a host machine, run a health check to validate host and target readiness, and list projects compatible with the target’s Arm CPU features and hardware capabilities. You’ll then clone a starter project using an LLM chat example and deploy. Topo builds the container image on the host, transfers it to the target, and starts the services on the target; it can also build directly on the target. You’ll also see how to run the same workflow using the Topo Visual Studio Code extension.

### Frequently asked questions

<details>
<summary>How do I verify that my host and target are ready before deploying?</summary>
Run `topo health` on the host to confirm Topo, SSH, and the container engine are available. To include the target in the check, provide `--target` or set the `TOPO_TARGET` environment variable.
</details>

<details>
<summary>How do I tell Topo which target to use for health checks and deployment?</summary>
Pass `--target` to the Topo command or set `TOPO_TARGET` in your environment. The health check output prompts you when a target is not specified.
</details>

<details>
<summary>How does Topo determine if a project is compatible with my Arm target?</summary>
Topo detects hardware capabilities on the target, including Arm CPU features such as Neon and SVE, and uses them to identify compatible projects when you run `topo projects --target`.
</details>

<details>
<summary>What should I expect when cloning the example project and responding to prompts?</summary>
Clone the LLM chat project with `topo clone`. The default configuration uses the `unsloth/SmolLM2-135M-Instruct-GGUF` model and can be deployed immediately.
</details>

<details>
<summary>Where are images built and what happens after deployment starts?</summary>
Topo builds container images on the host, transfers them to the target over SSH, and starts the services on the target. It can also build and deploy directly on the target if you choose that workflow.
</details>