> ## Documentation Index
> Fetch the complete documentation index at: https://otoyinc.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Temp

## Example: Job Configuration (job.json)

* `docker_user`: Sets the execution context to `model-runner`. This follows the standard security best practice of ensuring that the container does not run as **root**. The user `model-runner` in the example below must exist inside the image you are using (e.g.`otoy/dispersed-base`). If the image doesn't have that user defined, the job will fail to start.
* `secrets`: Demonstrates how to inject sensitive environment variables (like API tokens) while keeping them safely out of the JSON file. This ensures security by preventing your credentials from being committed to version control systems such as Git.
* `ports`: Maps the internal application port (`8080`) to a public-facing port (`443`). This allows the Service Consumer to access their model's API from the internet.

```json theme={null}
{
  "job_name": "gpu-inference-service",
  "image": "otoy/dispersed-base",
  
  "docker_user": "model-runner",
  
  "resources": {
    "gpu_count": 1,
    "gpu_type": "NVIDIA-RTX-3090",
    "cpu_cores": 4,
    "memory_gb": 16
  },
  
  "secrets": [
    {
      "key": "HF_AUTH_TOKEN",
      "value_from": "vault/user-secrets/dispersed-token"
    },
    {
      "key": "DB_PASSWORD",
      "value_from": "vault/project-alpha/db-pass"
    }
  ],
  
  "networking": {
    "ports": [
      {
        "container_port": 8080,
        "public_port": 443,
        "protocol": "TCP"
      }
    ],
    "expose_publicly": true
  },
  
  "command": ["python", "main.py", "--port", "8080"]
}
```

***

<Warning>
  Windows WSL is **not officially supported**. The steps below may work but are provided as-is without guarantees.
</Warning>

**Windows Subsystem for Linux** (**WSL**) simply lets you use Linux programs like normal command-line tools directly within Windows. It works quickly without needing a separate, full-blown virtual machine or having to restart your computer to switch operating systems. You can find more details and setup instructions on the official Microsoft Learn [WSL Documentation](https://learn.microsoft.com/en-us/windows/wsl/install).

### 1. Install WSL with Ubuntu

Open PowerShell as Administrator:

```powershell theme={null}
wsl --install -d Ubuntu
```

To verify if a Linux distribution has actually been installed along with WSL:

```powershell theme={null}
wsl --list --verbose
```

If the list is empty, this means you have the "engine" (WSL) but no "car" (Ubuntu). If you want to install a specific linux distribution such as Ubuntu-24.04:

```powershell theme={null}
wsl --install -d Ubuntu-20.04 
```

Follow the prompts to complete installation and create a user.

<Tip>
  WSL assigns only half the RAM on the machine to WSL VMs by default. If you would like to change this amount, refer to [Advanced Settings Configuration](https://learn.microsoft.com/en-us/windows/wsl/wsl-config#configuration-settings-for-wslconfig) in WSL from Microsoft Learn.
</Tip>

### 2. Verify GPU Access in WSL

Inside your WSL Ubuntu terminal:

```bash theme={null}
nvidia-smi
```

If the command is "not found," try running `/usr/lib/wsl/lib/nvidia-smi` in the Linux terminal or simply `nvidia-smi.exe`in the Windows Powershell terminal (WSL can run Windows executables). If this fails, see the [CUDA on WSL User Guide](https://docs.nvidia.com/cuda/wsl-user-guide/index.html).

### 3. Install Docker and NVIDIA Container Toolkit

Steps to install the Docker are laid out at [Install Docker Engine on Ubuntu](https://docs.docker.com/engine/install/ubuntu/) documentation. Run all commands inside your WSL Ubuntu terminal. For more details and in-depth understanding of Docker, refer to their official pages for a thorough introduction to [Docker](https://docs.docker.com/get-started/docker-overview/) and consult their [Docker Engine](https://docs.docker.com/engine/) Manual.

Once successfully installed, you can check the status of the docker engine:

```bash theme={null}
sudo systemctl status docker
```

Steps to install the Nvidia Container Toolkit are laid out at [Installing the NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html) guide from NVIDIA. Run all commands inside your WSL Ubuntu terminal.

### 4. Verify Container GPU Access

```bash theme={null}
sudo docker run --rm --runtime=nvidia --gpus all ubuntu nvidia-smi
```

You should see your GPU information displayed.

***

When running the `disNet` client, pass your keys as command line arguments.

**First time registration:**

```shellscript theme={null}
disNet --pubkey=pk_your_public_key --secretkey=sk_your_secret_key --register
```

**After registration:**

```shellscript theme={null}
disNet --pubkey=pk_your_public_key --secretkey=sk_your_secret_key
```

### [​](https://otoyinc.mintlify.app/node-operators/node-operators-create-api-key#for-programmatic-api-access)

For Programmatic API Access If you’re building your own API client or scripts, requests require HMAC signature authentication with four headers:

* `X-API-Key` — Your public key
* `X-Time` — Current timestamp in **milliseconds**
* `X-Nonce` — Random 32-byte hex string
* `X-Signature` — HMAC-SHA256 signature

For implementation details and code examples, see [Authenticate API Requests](https://otoyinc.mintlify.app/service-consumers/service-consumers-authenticate-requests).

What’s Next? With your API Key ready, proceed to [Register Your Node](https://otoyinc.mintlify.app/node-operators/node-operators-register-node) to connect your machine to the network.