How to launch an 8-GPU RTX PRO 6000 instance on EcoHash

An eight-GPU instance in EcoHash's Atlanta region gives you a whole node: eight RTX PRO 6000 GPUs with 96 GB of VRAM each, 200 vCPUs, 1,352 GB of RAM, and up to 5,260 GiB of temporary local scratch space. You can start with an EcoHash container image or bring the stack you already use.

This walkthrough covers the choices that matter before you launch, how to connect afterward, and where to put files you need to keep. Open GPU Instances in the console to follow along. You will need an account with enough credit for the configuration you select.

Choose Atlanta and all eight GPUs

Click Launch Instance, give the instance a name, and select atl for Atlanta. Under GPUs per Instance, choose 8x.

The configuration summary now shows the whole node dedicated to this instance. The eight GPUs provide 768 GB of total VRAM, with 96 GB on each GPU. That is memory distributed across eight devices; your serving or training software must support using multiple GPUs to take advantage of it.

Selecting eight GPUs allocates the whole node. Check the resource summary for your chosen region.

Pick a container for the work you want to run

The EcoHash Images tab offers several starting points. Their names include the installed software versions, so check the dropdown rather than relying on a tag from an old tutorial.

Use the inference image for vLLM, Jupyter for notebooks, or a base image for your own stack.

• GPU Inference: vLLM configured for the RTX PRO 6000. This is the starting point for serving an LLM. It is a large image, so the first launch on a node may spend several minutes downloading it.
• GPU Base: a CUDA and PyTorch environment for installing your own software. Choose the CUDA version your workload needs.
• CUDA Bare: a CUDA 13.0 image without a framework, for building your environment from a smaller starting point.
• GPU Jupyter: JupyterLab and an ML environment for browser-based notebook work.

The optional Startup Command runs when the instance starts. Use it to launch your application or model server. If you leave it blank, the image's default command applies. Make sure that command keeps the container running.

Bringing your own image

Open Images under Registry and click Add Image. Enter a display name and the full image reference, including its tag. For example, registry.example.com/team/eval:v1.0 is the format; replace it with your real registry and image.

A public image needs only its reference. Private images also need credentials with pull access.

For a private registry, provide its username and a read/pull access token. The form displays guidance for the registry you enter. AWS ECR login tokens expire after 12 hours and cannot be saved for this workflow; use a public ECR repository or arrange for EcoHash's account to have pull access.

Before saving the image, check these requirements:

• Architecture: build for linux/amd64. On an Apple Silicon Mac, include --platform linux/amd64 in your docker buildx build command.
• CUDA: use CUDA 13.0 or earlier for the configuration described here.
• GPU support: your framework and CUDA extensions must support Blackwell sm_120. Check the specific build you are using, especially if you compile extensions yourself.
• SSH: EcoHash configures SSH automatically for Debian, Ubuntu, and Alpine-based images. Include OpenSSH yourself for other base distributions.

Save the image, return to the launch form, and select it under Custom / Registry.

Set up SSH and an HTTP endpoint

Enable SSH access and add your public SSH key in the launch form. Keys are applied when the instance starts, so do this before launching. Keep the matching private key on your own computer.

If you want to call a model server or another HTTP application, enable Expose a public service URL and enter the port your application listens on inside the container, such as 8000.

The endpoint forwards to the HTTP port inside your container.

Your application must listen on 0.0.0.0, not only on 127.0.0.1. A process bound to localhost can run normally inside the container while remaining unreachable through the public URL.

Choose the runtime and attach storage

Select No end time if you want the instance to run until you terminate it. The form explains the credit hold and hourly deductions. This setting does not keep an instance running after the account runs out of credit.

Alternatively, choose a fixed estimated duration if you want an automatic end time. Read the billing summary before launching; it changes with the number of GPUs and the duration you select.

Attach persistent storage before starting work you need to keep.

A cloud drive attaches to one instance at a time. A shared filesystem can be attached to several instances. Both are retained after the compute instance ends. Choose a cloud drive for files used by this instance, or a shared filesystem when several instances need the same datasets, weights, or results.

Treat /workspace as temporary. Its local scratch data is erased when the instance ends, including when it stops because your account balance runs out. Write results you need to keep to an attached cloud drive or shared filesystem.

Review the GPU count, image, SSH keys, service port, duration, and storage attachments. Then click Launch. Allow extra time for the first download of a large container image.

Connect and check your application

Once the instance is running, its detail page shows the SSH command, the public URL if you enabled one, and a web terminal you can open in the browser. Copy the SSH command from that page rather than constructing the hostname or port yourself.

In the terminal, run:

nvidia-smi

For this configuration, the output should list eight RTX PRO 6000 GPUs. Check that your application can see all eight before starting a long job.

The public URL requires your console login or an EcoHash API key. To call it from a script, send the key in an Authorization: Bearer header. Paths after /service pass through to your application: /service/v1/models reaches the container as /v1/models.

For a vLLM server exposing that route, copy the instance's public URL and test it with:

export ECOHASH_SERVICE_URL="https://api.ecohash.com/gpu-instances/INSTANCE_ID/service"
# Set ECOHASH_API_KEY in your environment before running this request.
curl --fail-with-body "${ECOHASH_SERVICE_URL%/}/v1/models" \
  -H "Authorization: Bearer ${ECOHASH_API_KEY}"

Replace INSTANCE_ID with your instance ID, or use the full URL copied from the console. A ready vLLM server should return a model list. For another application, use one of its own HTTP routes instead.

If the request fails, check that the application has finished starting, listens on 0.0.0.0, and uses the same port you entered in the console. Also confirm that your request includes a valid API key.

Before ending the session, confirm that your outputs are on persistent storage. Terminate the instance when you are finished to stop compute charges.

Open GPU Instances to configure a node, or read more about launching an instance and container images.

---