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

# Built-in utility services

> Access development tools, monitoring, and ML services included with every Bnode.

Every Brightnode Bnode comes with pre-configured utility services that run automatically in your container. These services are accessible via HTTPS URLs that are created when your Bnode deploys.

## How to access services

All services are accessed through unique HTTPS URLs in this format:

```
https://{service}-{bnode-name}.{region}.brightnode.cloud
```

For example, if your Bnode is named `workload-abc123` in the `singapore` region:

* JupyterLab: `https://jupyter-workload-abc123.singapore.brightnode.cloud`
* VS Code: `https://vscode-workload-abc123.singapore.brightnode.cloud`
* System Monitor: `https://monitor-workload-abc123.singapore.brightnode.cloud`

You can find your Bnode's service URLs in the Bnode management interface after your Bnode is running.

## Available services

The services available depend on which template you're using.

### Base services (all templates)

These services are included in every Bnode regardless of template.

#### JupyterLab

Web-based interactive development environment with Python notebooks, web terminal, and file management.

**URL format:** `https://jupyter-{bnode-name}.{region}.brightnode.cloud`

**Authentication:** Password-protected (password is your user ID)

**Access from UI:** Click the Jupyter button (BookOpen icon) on your Bnode card

**Features:**

* Python notebooks with GPU support
* Integrated web terminal
* File browser and editor
* Extensions for widgets and archiving

**Example usage:**

```python theme={"system"}
# In a Jupyter notebook
import torch
print(f"CUDA available: {torch.cuda.is_available()}")
print(f"GPUs: {torch.cuda.device_count()}")
```

#### VS Code Server

Full-featured Visual Studio Code IDE running in your browser.

**URL format:** `https://vscode-{bnode-name}.{region}.brightnode.cloud`

**Authentication:** Password-protected (set via environment variable or auto-generated)

**Features:**

* Complete VS Code experience
* Extension marketplace
* Integrated terminal
* Git integration
* IntelliSense and debugging

**Set custom password:**

When deploying your Bnode, add this environment variable:

```
CODE_SERVER_PASSWORD=your-secure-password
```

#### System Monitor (Glances)

Real-time system monitoring dashboard showing CPU, GPU, memory, and network stats.

**URL format:** `https://monitor-{bnode-name}.{region}.brightnode.cloud`

**Authentication:** None (read-only)

**Features:**

* GPU utilization and temperature
* Per-core CPU usage
* Memory and swap monitoring
* Disk I/O statistics
* Network traffic
* Process list with resource usage

#### File Browser

Web-based file manager for uploading and downloading files.

**URL format:** `https://files-{bnode-name}.{region}.brightnode.cloud`

**Authentication:** None (isolated per user)

**Features:**

* Drag-and-drop file uploads
* Download files and folders
* Create/delete directories
* File preview
* Archive support

Your persistent data is in `/workspace` directory.

#### SSH Access

Terminal access via SSH gateway for command-line operations.

**Connection format:** `ssh {bnode-name}@{bnode-name}.{region}.brightnode.cloud`

**Authentication:** SSH key (add your public key when deploying)

**Access from UI:** Click the SSH button on your Bnode card to get connection details

**Example:**

```bash theme={"system"}
ssh workload-abc123@workload-abc123.singapore.brightnode.cloud -i ~/.ssh/id_ed25519
```

### PyTorch template services

Additional services when using PyTorch templates.

#### TensorBoard

Visualization toolkit for machine learning experiments.

**URL format:** `https://tensorboard-{bnode-name}.{region}.brightnode.cloud`

**Authentication:** None

**Features:**

* Training metrics visualization
* Model graph visualization
* Embedding projector
* Profiler for performance analysis

**Usage example:**

```python theme={"system"}
from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter('/workspace/logs')

for epoch in range(num_epochs):
    loss = train_one_epoch()
    writer.add_scalar('Loss/train', loss, epoch)

writer.close()
```

Then visit the TensorBoard URL to see your metrics in real-time.

#### Gradio Demo

Pre-configured Gradio app for creating ML demos.

**URL format:** `https://gradio-{bnode-name}.{region}.brightnode.cloud`

**Authentication:** None

**Demo location:** `/workspace/gradio_demo.py`

**Customize:**

```python theme={"system"}
import gradio as gr
import torch

def my_model(image):
    # Your model code here
    return processed_image

demo = gr.Interface(
    fn=my_model,
    inputs=gr.Image(type="pil"),
    outputs=gr.Image(type="pil")
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

#### Streamlit Demo

Pre-configured Streamlit app for data dashboards.

**URL format:** `https://streamlit-{bnode-name}.{region}.brightnode.cloud`

**Authentication:** None

**Demo location:** `/workspace/streamlit_demo.py`

**Customize:**

```python theme={"system"}
import streamlit as st
import torch

st.title("My ML Dashboard")

if st.button("Run Inference"):
    result = model.predict(input_data)
    st.write(result)
```

### TensorFlow template services

TensorFlow templates include the same ML tools as PyTorch (TensorBoard, Gradio, Streamlit) but with TensorFlow-specific examples.

### vLLM template services

Specialized services for large language model inference.

#### vLLM API Server

OpenAI-compatible API server for high-throughput LLM inference.

**URL format:** `https://api-{bnode-name}.{region}.brightnode.cloud`

**Authentication:** API key recommended

**Features:**

* OpenAI API compatibility
* PagedAttention for efficient memory use
* Continuous batching
* Quantization support (4-bit, 8-bit, GPTQ, AWQ)

**Usage example:**

```python theme={"system"}
from openai import OpenAI

client = OpenAI(
    base_url="https://api-workload-abc123.singapore.brightnode.cloud/v1",
    api_key="your-api-key"  # Optional
)

response = client.chat.completions.create(
    model="meta-llama/Llama-3.2-8B-Instruct",
    messages=[{"role": "user", "content": "Hello!"}]
)

print(response.choices[0].message.content)
```

#### Open WebUI

ChatGPT-style interface for interacting with your LLMs.

**URL format:** `https://chat-{bnode-name}.{region}.brightnode.cloud`

**Authentication:** Built-in user management

**Features:**

* ChatGPT-style chat interface
* Conversation history
* Markdown and code rendering
* File uploads (for vision models)

**Setup:**

1. Visit the URL and create an admin account
2. Go to Settings → Connections → OpenAI API
3. Set Base URL to `http://localhost:8000/v1`
4. Start chatting with your model

### ComfyUI template services

Services for Stable Diffusion image generation.

#### ComfyUI

Node-based interface for Stable Diffusion workflows.

**URL format:** `https://comfyui-{bnode-name}.{region}.brightnode.cloud`

**Authentication:** None

**Features:**

* Visual workflow builder
* ComfyUI Manager pre-installed
* Custom nodes support
* Civitai integration

#### Automatic1111 Web UI

Classic Stable Diffusion web interface.

**URL format:** `https://webui-{bnode-name}.{region}.brightnode.cloud`

**Authentication:** None

**Features:**

* Simple image generation
* LoRA support
* ControlNet support
* Shared models with ComfyUI

#### Image Gallery

Web gallery for viewing generated images.

**URL format:** `https://gallery-{bnode-name}.{region}.brightnode.cloud`

**Authentication:** None

Automatically displays images from `/workspace/ComfyUI/output/`.

## Quick reference

| Service            | Port  | URL Prefix     | Authentication | Available In        |
| ------------------ | ----- | -------------- | -------------- | ------------------- |
| **JupyterLab**     | 8888  | `jupyter-`     | Password       | All templates       |
| **VS Code**        | 8080  | `vscode-`      | Password       | All templates       |
| **System Monitor** | 61208 | `monitor-`     | None           | All templates       |
| **File Browser**   | 4040  | `files-`       | None           | All templates       |
| **SSH**            | 22    | N/A (special)  | SSH key        | All templates       |
| **TensorBoard**    | 6006  | `tensorboard-` | None           | PyTorch, TensorFlow |
| **Gradio**         | 7860  | `gradio-`      | None           | PyTorch, TensorFlow |
| **Streamlit**      | 8501  | `streamlit-`   | None           | PyTorch, TensorFlow |
| **vLLM API**       | 8000  | `api-`         | Optional       | vLLM                |
| **Open WebUI**     | 3000  | `chat-`        | Built-in       | vLLM                |
| **ComfyUI**        | 8188  | `comfyui-`     | None           | ComfyUI             |
| **Automatic1111**  | 7860  | `webui-`       | None           | ComfyUI             |
| **Image Gallery**  | 8765  | `gallery-`     | None           | ComfyUI             |

## Setting passwords

Some services require authentication. Set passwords using environment variables when deploying your Bnode.

### During deployment

In the deployment form, add environment variables:

| Variable               | Service    | Example                  |
| ---------------------- | ---------- | ------------------------ |
| `JUPYTER_PASSWORD`     | JupyterLab | `my-secure-password`     |
| `CODE_SERVER_PASSWORD` | VS Code    | `another-password`       |
| `PUBLIC_KEY`           | SSH        | `ssh-rsa AAAAB3NzaC1...` |

### Via API

```bash theme={"system"}
curl -X POST https://api.brightnode.cloud/v1/instances/provision \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "template_id": "pytorch",
    "gpu_option": "A100-1x",
    "environment": {
      "JUPYTER_PASSWORD": "secure-password",
      "CODE_SERVER_PASSWORD": "another-password",
      "PUBLIC_KEY": "ssh-rsa AAAAB3NzaC1..."
    }
  }'
```

<Warning>
  If you don't set passwords for JupyterLab or VS Code, they will auto-generate passwords. Check your Bnode logs to find them.
</Warning>

## Common workflows

### ML Training with TensorBoard

```python theme={"system"}
# In JupyterLab notebook
from torch.utils.tensorboard import SummaryWriter
import torch

writer = SummaryWriter('/workspace/logs')

for epoch in range(100):
    loss = train_one_epoch()
    writer.add_scalar('Loss/train', loss, epoch)

writer.close()
```

Then open your TensorBoard URL (`https://tensorboard-{bnode}.{region}.brightnode.cloud`) to watch metrics in real-time.

### LLM Inference with vLLM

1. Your vLLM Bnode automatically starts the API server
2. Access the API at `https://api-{bnode}.{region}.brightnode.cloud`
3. Use OpenAI client library to interact
4. Or use Open WebUI at `https://chat-{bnode}.{region}.brightnode.cloud` for a chat interface

### Image Generation with ComfyUI

1. Open ComfyUI at `https://comfyui-{bnode}.{region}.brightnode.cloud`
2. Load a workflow and generate images
3. View outputs at `https://gallery-{bnode}.{region}.brightnode.cloud`
4. Or use File Browser to download specific images

## Security

### Encrypted connections

All services use HTTPS with automatic TLS certificates via Let's Encrypt.

### Service isolation

Each Bnode's services are isolated - only you can access your Bnode using your unique deployment name in the URL.

### SSH keys

For SSH access, always use key-based authentication instead of passwords:

```bash theme={"system"}
# Generate SSH key
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_brightnode

# Copy public key
cat ~/.ssh/id_ed25519_brightnode.pub

# Add to PUBLIC_KEY environment variable when deploying
```

<Warning>
  Never share your Bnode service URLs publicly if they contain sensitive data. Each URL includes your unique Bnode name and provides direct access.
</Warning>

## Troubleshooting

### Service not accessible

If you can't access a service:

1. Verify your Bnode is in **Running** state
2. Wait 1-2 minutes after deployment for all services to initialize
3. Check that the URL format is correct: `https://{service}-{bnode-name}.{region}.brightnode.cloud`
4. Try accessing from an incognito/private browser window

### Finding your service URLs

Your service URLs are automatically generated when your Bnode deploys. The format is always:

```
https://{service-prefix}-{your-bnode-name}.{your-region}.brightnode.cloud
```

Where:

* `{service-prefix}` = `jupyter`, `vscode`, `monitor`, `files`, etc.
* `{your-bnode-name}` = The name shown in your Bnode list
* `{your-region}` = The region where you deployed

### Service shows blank page

1. Wait another minute - services may still be starting
2. Hard refresh your browser (Ctrl+F5 or Cmd+Shift+R)
3. Check your browser console for errors
4. SSH into your Bnode and check if the service is running:

```bash theme={"system"}
# Check if service is running
ps aux | grep jupyter  # or code-server, glances, etc.

# Check service logs
tail -f /jupyter.log
tail -f /code-server.log
```

### Forgot password

JupyterLab and VS Code passwords are auto-generated if not set. To find them:

1. SSH into your Bnode
2. Check the logs:

```bash theme={"system"}
grep -i password /jupyter.log
grep -i password /code-server.log
```

## Next steps

* Learn how to [configure your Bnode](/bnodes/manage-bnodes)
* Set up [persistent storage](/bnodes/storage/types) for your data
* Explore [templates](/bnodes/templates/overview) to find the right one for your workflow
* Connect via [SSH](/bnodes/configuration/use-ssh) for command-line access