> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/aerial/aodt/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/aerial/aodt/_mcp/server.

# Verify Installation

Use this page to confirm that the client, worker, and supporting services are working correctly. Choose the test that matches your deployment type and how you plan to run the client.

Complete [Client Installation](/client-installation), [Worker Installation](/worker-installation), and the relevant prerequisites before running these tests.

## Overview

| Test                                                        | Deployment        | Client install                                             | When to use                                                   |
| ----------------------------------------------------------- | ----------------- | ---------------------------------------------------------- | ------------------------------------------------------------- |
| [1. Colocated container](#1-colocated-container-test)       | Same server       | [Container](/client-installation#quickstart-via-container) | When the client is started from the container                 |
| [2. Colocated source build](#2-colocated-source-build-test) | Same server       | [Source build](/client-installation#source-build-on-linux) | When the client is built from source and started from the CLI |
| [3. Non-colocated](#3-non-colocated-test)                   | Separate machines | Source build or container on client machine                | Validate remote worker connectivity                           |

In all cases, the **worker must be running before the client starts**. The worker is always started as a separate step on the host — even when the client runs inside a container.

***

## 1. Colocated container test

Use this test when the client and worker run on the **same server** and the **client is started from the container**. See [Quickstart via container](/client-installation#quickstart-via-container).

### Start the worker

From the package root on the host (outside the container):

```bash
cd aodt_1.5.0
./worker/up.sh
```

Wait until the worker, MinIO, and Iceberg catalog are ready.

### Copy maps and assets to the S3 bucket

The example client expects the demo map at `test_data/maps/tokyo` and supporting assets under `test_data/assets/` in the MinIO `aerial-data` bucket. Load these files before running the test below.

Run the following steps on the host where the worker is running, after `./worker/up.sh` has started MinIO.

#### Download assets from NGC

**From the NGC website:**

[AODT assets on NVIDIA NGC](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/aerial/resources/aodt-assets)

**Using the NGC CLI:**

1. Download and install the [NGC CLI](https://org.ngc.nvidia.com/setup/installers/cli).
2. Download the asset bundle:

```bash
ngc registry resource download-version "nvidia/aerial/aodt-assets:1.5.0"
```

#### Prepare the map and assets

1. Unzip `demo.zip`. This creates a map folder named `tokyo_flat-1`. Rename it to `tokyo`.
2. Unzip `assets.zip`. This creates an `assets` folder.

#### Upload to MinIO

**Option 1 — `copy_to_s3.sh` (recommended)**

From the package root, use the helper script to upload each folder. MinIO must already be running (`./worker/up.sh`).

```bash
cd aodt_1.5.0

# Upload assets
./worker/copy_to_s3.sh <path_to_unzipped_assets>/assets test_data

# Upload map
./worker/copy_to_s3.sh <path_to_unzipped_map>/tokyo test_data/maps
```

Replace the placeholder paths with the directories you prepared in the previous step. The script copies files into the `aerial-data` bucket under the given S3 prefix.

To upload from a remote machine, set `MINIO_ENDPOINT` to the worker host:

```bash
MINIO_ENDPOINT=http://<worker_ip>:9000 ./worker/copy_to_s3.sh <source_dir> test_data
```

**Option 2 — MinIO web console**

Use this option when you prefer a browser upload or are working from another machine on the network.

1. Download and unzip the assets and map on your local machine.
2. Open the MinIO console at [http://localhost:9001](http://localhost:9001/) on a colocated system, or `http://worker_ip:9001` on a remote system.
3. Sign in with username `minioadmin` and password `minioadmin`.
4. Open the `aerial-data` bucket (create it if prompted).
5. Create a folder named `test_data`, then upload the contents of the `assets` folder into it.
6. Inside `test_data`, create a folder named `maps`, then upload the `tokyo` map folder into it.

When finished, the bucket should contain `test_data/assets/` and `test_data/maps/tokyo/`.

### Run the test from within the client container

From the package root:

```bash
./container/run.sh python3 client/examples/example_client.py --s3_provider minio
```

The console prints `All tests completed successfully!`

***

## 2. Colocated source build test

Use this test when the client and worker run on the **same server**, the **client is built from source**, and you **start it from the CLI**. See [Source build on Linux](/client-installation#source-build-on-linux) (or the platform-specific section for WSL2, macOS, or Windows).

### Start the worker

From the package root:

```bash
cd aodt_1.5.0
./worker/up.sh
```

### Run the client example

From the `client/` directory on the host:

```bash
cd aodt_1.5.0/client
source .venv/bin/activate
export PYTHONPATH=build/:build/config/   # omit if you ran cmake --install
python3 examples/example_client.py --s3_provider minio
```

The console prints `All tests completed successfully!`

**Note**: If you installed the client with `cmake --install`, omit the `PYTHONPATH` line.

***

## 3. Non-colocated test

Use this test when the **worker runs on a GPU server** and the **client runs on a separate machine** (laptop, CI node, or another host without a GPU).

### Start the worker

On the remote worker host:

```bash
cd aodt_1.5.0
./worker/up.sh
```

Note the worker host IP address reachable from the client machine.

### Run the client from a separate machine

On the client machine:

```bash
cd aodt_1.5.0/client
python examples/example_client.py \
  --server_address <worker_ip>:50051 \
  --s3_endpoint http://<s3_endpoint_ip>:9002 \
  --s3_bucket aerial-data \
  --s3_provider minio \
  --iceberg_uri http://<iceberg_catalog_ip>:19120/iceberg \
  --iceberg_catalog_type rest
```

| Argument               | Description                                                       |
| ---------------------- | ----------------------------------------------------------------- |
| `<worker_ip>`          | IP or hostname of the worker for gRPC (port `50051`)              |
| `<s3_endpoint_ip>`     | IP where MinIO is reachable from the client. Leave empty for AWS. |
| `<iceberg_catalog_ip>` | IP where the Iceberg catalog is reachable from the client         |

Use the worker's internal IP when the client is on the same network, or the external IP when it is not.

### What to check

* The client connects to the remote worker over gRPC.
* S3 and Iceberg endpoints are reachable from the client machine.
* The console prints `All tests completed successfully!`.

## Next steps

* [Quickstart](/quickstart) — overview of EM, RAN, and GIS workflows
* [Runtime Workflow](/runtime-workflow) — production-like runs with prebuilt binaries
* [Development Workflow](/dev-workflow) — modify and rebuild from source