Run DeepSeek V4 Flash Vision with an EcoHash GPU template

n EcoHash platform template saves the configuration you would otherwise assemble yourself: the container image, GPU count, startup command and service port. The DeepSeek GPU template also mounts publisher-provided model weights from shared storage, so you do not need to download another copy before starting the server.

This walkthrough uses deepseek-v4-flash-8gpu-instance. Check that its resource kind reads GPU Instance. A similarly named Model Instance template creates a different resource, with different access and lifecycle routes.

The template detail page shows the configuration and a quote for your account. Prices and available capacity can change.

Start in the console

1. Open Compute → Templates → Platform, then select the DeepSeek GPU template.
2. Review its resources and README. The published configuration uses eight RTX PRO 6000 GPUs, SGLang and service port 8000. Keep the preset image and startup command for your first launch.
3. Review the region, capacity and pricing breakdown. Shared model weights can determine the region; the current DeepSeek launch form selects Atlanta and locks that field. A quote does not reserve capacity.
4. Click Launch to open the prefilled GPU-instance form. Add your SSH public key if you want shell access, and review the duration and storage settings.
5. Confirm the launch only after checking the credit hold. Open the new instance's detail page to follow its status and find its access information.

The template opens the GPU launch form. Reviewing this form does not start an instance; its final Launch button does.

The container can be running while the inference engine is still loading. Wait for the model server to answer before sending a generation request. The template README provides a startup estimate; it is not a guaranteed readiness time.

Keep the template's shared model weights and HTTP port. Add persistent storage separately for results you need to retain.

Use the API

You need curl, jq and an EcoHash API key. Read-only Compute access permits template discovery and quoting; launching and terminating GPU instances requires Full Compute access. Keep the key in an environment variable. See API-key permissions.

Read the template and review its quote

Set ECOHASH_API_KEY in your shell before running these commands. They read the template and request a quote; they do not launch an instance.

set -euo pipefail
API="https://api.ecohash.com"
TEMPLATE_ID=51
: "${ECOHASH_API_KEY:?Set ECOHASH_API_KEY first}"

curl -fsS "$API/compute-templates/$TEMPLATE_ID" \
  -H "Authorization: Bearer $ECOHASH_API_KEY" -o template.json
jq -e '.template.target_kind == "gpu_instance"' template.json >/dev/null

curl -fsS -X POST "$API/compute-templates/quote" \
  -H "Authorization: Bearer $ECOHASH_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"template_id\":$TEMPLATE_ID,\"hours\":1}" -o quote.json
jq '{lines,upfront_hold_usd,recurring_daily_usd,capacity_ok,warnings}' quote.json
jq -e '.capacity_ok == true and (.region_id|length>0) and (.gpu_type|length>0)' \
  quote.json >/dev/null

The target_kind check prevents a Model Instance template from being sent to the GPU-instance endpoint. If the quote reports unavailable capacity or a warning you cannot resolve, stop before creating the instance.

Prepare the launch request

Copy the template's spec, then add its ID and the quoted region and GPU type. This example sets a one-hour duration and includes your SSH public key. Replace the public-key file path if yours differs. Never use your private-key file.

jq --slurpfile q quote.json \
  --rawfile ssh "$HOME/.ssh/id_ed25519.pub" \
  '.spec + {
    template_id: .template.id,
    name: "deepseek-template-demo",
    region_id: $q[0].region_id,
    gpu_type: $q[0].gpu_type,
    estimated_duration_hours: 1,
    ssh_enabled: true,
    ssh_public_key: ($ssh|rtrimstr("\n"))
  }' template.json > launch.json
cat launch.json

The next POST creates billable compute. Review launch.json, the quote and any warnings first. Sending only template_id is insufficient; the request must include the template's launch configuration.

curl -fsS -X POST "$API/gpu-instances" \
  -H "Authorization: Bearer $ECOHASH_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @launch.json

Keep the returned instance ID. Use it to check status and retrieve the connection details:

INSTANCE_ID="<id returned by the launch request>"
curl -fsS "$API/gpu-instances/$INSTANCE_ID" \
  -H "Authorization: Bearer $ECOHASH_API_KEY"

Send a request to the model server

Once the server is ready, list its models and use the returned model ID. The public service URL forwards requests to the container's HTTP server on port 8000 and requires authentication.

SERVICE="$API/gpu-instances/$INSTANCE_ID/service/v1"
MODEL="$(curl -fsS "$SERVICE/models" \
  -H "Authorization: Bearer $ECOHASH_API_KEY" | jq -er '.data[0].id')"

curl -fsS "$SERVICE/chat/completions" \
  -H "Authorization: Bearer $ECOHASH_API_KEY" \
  -H "Content-Type: application/json" \
  --data "$(jq -n --arg model "$MODEL" '{
    model: $model,
    messages: [{role:"user",content:"Explain tensor parallelism in two sentences."}],
    max_tokens: 1024
  }')"

A successful chat request returns an OpenAI-compatible response. If the model-list request fails while the engine is initializing, check the instance status and startup logs rather than sending repeated generation requests. For your own server configuration, the application must listen on 0.0.0.0 at the exposed port.

For a Model Instance, the documented calling convention instead uses https://api.ecohash.com/v1/chat/completions with model="<name>:<instance_id>". Do not use that routing convention for this GPU-instance walkthrough. See calling a model endpoint.

Finish the evaluation

Save your results to persistent storage before terminating the GPU instance. Its local /workspace scratch data is temporary.

curl -fsS -X POST "$API/gpu-instances/$INSTANCE_ID/terminate" \
  -H "Authorization: Bearer $ECOHASH_API_KEY"

This termination route is for GPU instances. Manage a Model Instance through its own lifecycle controls; terminating one resource type is not a substitute for stopping the other.

A reservation-backed quote may show no additional hourly compute charge because capacity is covered by a reservation agreement. This does not mean the service is free. Review your account's quote and terms; separately retained storage may continue to incur charges.

Open platform templates · GPU-instance API reference

---