# Clone and deploy the Hello World Topo Project

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/cross-platform/create-your-own-topo-project/)
- [Learn about Topo Projects](https://learn.arm.com/learning-paths/cross-platform/create-your-own-topo-project/overview/)
- [Clone and deploy the Hello World Topo Project](https://learn.arm.com/learning-paths/cross-platform/create-your-own-topo-project/hello-world-project/)
- [Modify the Hello World Topo Project](https://learn.arm.com/learning-paths/cross-platform/create-your-own-topo-project/modifying-hello-world/)
- [Create a new Topo Project from an empty directory](https://learn.arm.com/learning-paths/cross-platform/create-your-own-topo-project/creating-a-new-project/)
- [Use Agent Skills to author Topo Projects](https://learn.arm.com/learning-paths/cross-platform/create-your-own-topo-project/agent-skills/)
- [Next Steps](https://learn.arm.com/learning-paths/cross-platform/create-your-own-topo-project/_next-steps/)

## Clone the Hello World Topo Project
On your host machine, use the terminal to clone the “Hello World” Topo Project into your home directory to confirm your setup:

```
topo clone [https://github.com/Arm-Examples/topo-welcome.git](https://github.com/Arm-Examples/topo-welcome.git) ~/topo-welcome
```

The “Hello World” Topo Project follows the same deployment pattern as the “CPU LLM Chat” Topo Project covered in [Deploy containerized workloads to Arm-based Linux targets with Topo](https://learn.arm.com/learning-paths/cross-platform/deploy-containerized-workloads-with-topo/).

The output is similar to:

```
__output__
┌─ Copy files ──────────────────────────────────────────
__output__
Cloning into '/home/user/topo-welcome'...
__output__
remote: Enumerating objects: 12, done.
__output__
remote: Counting objects: 100% (12/12), done.
__output__
remote: Compressing objects: 100% (9/9), done.
__output__
remote: Total 12 (delta 0), reused 8 (delta 0), pack-reused 0 (from 0)
__output__
Receiving objects: 100% (12/12), 62.64 KiB | 2.61 MiB/s, done.
__output__
┌─ Configure project ───────────────────────────────────
__output__
Provide: The text to use in the greeting message
__output__
Example: Markus
__output__
Default: World
__output__
GREETING_NAME (required)>
```

Provide a name for the `GREETING_NAME` parameter, for example, `Tomas`, and then Press Enter.

The output is similar to:

```
__output__
┌─ Project ready ───────────────────────────────────────
__output__
Created in '/home/user/topo-welcome'
__output__

Now run:
__output__
  cd ~/topo-welcome
__output__
  topo deploy
```

## Prepare your target
Topo Projects are meant to be deployed to Arm-based Linux targets. In this Learning Path, use the Arm-based Linux target you prepared in the previous Learning Path. The target can be a Raspberry Pi, an Arm-based Amazon EC2 instance, or another Arm-based Linux target accessible over SSH.

Confirm that Topo can inspect your target, and that there are no compatibility issues:

```
topo health --target user@my-target
```

If your host machine is a Linux machine and you want to use it as the target, you can use `--target localhost`.

## Deploy the project to your target
You can now deploy the project to your target:

```
cd ~/topo-welcome
topo deploy --target user@my-target
```

Wait for the build and deploy to complete.

The output is similar to:

```
__output__
┌─ Build images ────────────────────────────────────────
__output__
[+] Building 6.4s (11/11) FINISHED
__output__
 =&gt; [internal] load local bake definitions    0.0s
__output__
 =&gt; =&gt; reading from stdin 654B    0.0s
__output__
 =&gt; [internal] load build definition from Dockerfile    0.0s
__output__
 =&gt; =&gt; transferring dockerfile: 223B    0.0s
__output__
 =&gt; [internal] load metadata for docker.io/library/nginx:alpine    1.4s
__output__
 =&gt; [internal] load .dockerignore    0.1s
__output__
 =&gt; =&gt; transferring context: 2B    0.0s
__output__
 =&gt; [internal] load build context    0.1s
__output__
 =&gt; =&gt; transferring context: 3.76kB    0.0s
__output__
 =&gt; [1/3] FROM docker.io/library/
__output__
 (...)
__output__

[+] build 1/1
 ✔ Image topo-welcome-app Built    6.4s
__output__

┌─ Pull images ─────────────────────────────────────────
__output__

┌─ Start services ──────────────────────────────────────
__output__
[+] up 2/2
__output__
┌─ Deployment Success ──────────────────────────────────  0.1s
__output__
Run `topo ps` to see deployed containers    0.2s
```

Confirm that the container is running correctly:

```
topo ps --target user@my-target
```

The `topo ps` command lists the services that Topo deployed to the target.

The output is similar to:

```
__output__
Image              Status                  Processing Domain   Address
__output__
topo-welcome-app   Up 58 seconds           Linux Host          my-target:8000, [::]:8000
```

The columns show:
- `Image`: the container image or service that Topo started
- `Status`: whether the service is running, and how long it has been running
- `Processing Domain`: where the workload is running, such as the Linux host on the target
- `Address`: the exposed address and port for the service

### View the application
If the target is reachable on your network, open `http://<target-ip-address>:8000/` in your browser.

If you prefer to forward the port over SSH, run:

```
ssh -L 8000:localhost:8000 user@my-target
```

Then open `http://localhost:8000/` in your browser.

The “Hello World” application appears as follows:

![Hello World web interface](https://learn.arm.com/learning-paths/cross-platform/create-your-own-topo-project/hello_tomas.png)
Hello World web interface

## What you’ve accomplished and what’s next
You’ve now deployed the “Hello World” Topo Project to an Arm-based Linux target and confirmed the application is accessible in your browser.

Next, you’ll modify the project to add a new configurable clone-time argument.
