Positron

Instructions for using Positron with NowWhat.

This page describes how to start a Positron Remote SSH session on NowWhat.

Positron Remote SSH runs the Positron user interface on your local machine while files, terminals, R sessions, and Python sessions run on the remote host reached through SSH.

On NowWhat, Positron must run on a compute node allocated by SLURM. Do not start Positron sessions, R sessions, Python sessions, or other interactive workloads on the login node.

Step 1: Add an SSH Host Alias

On your local machine, edit your SSH configuration file:

nano ~/.ssh/config

Add one alias for the login node and one alias for each compute node. The compute-node aliases must route the SSH connection through the login node. This is required because compute-node ports are not reachable directly from your local machine.

Host nowwhat-login
  HostName nowwhat.stat.unipd.it
  User your_username
  Port 22
 
Host nowwhat-wn01
  HostName wn01
  User your_username
  Port 22
  ProxyCommand ssh nowwhat-login -W %h:%p
 
Host nowwhat-gn01
  HostName gn01
  User your_username
  Port 22
  ProxyCommand ssh nowwhat-login -W %h:%p

Replace your_username with your NowWhat username.

If you use an SSH key, add the identity file to the login alias:

Host nowwhat-login
  HostName nowwhat.stat.unipd.it
  User your_username
  Port 22
  IdentityFile ~/.ssh/id_ed25519
 
Host nowwhat-wn01
  HostName wn01
  User your_username
  Port 22
  ProxyCommand ssh nowwhat-login -W %h:%p
 
Host nowwhat-gn01
  HostName gn01
  User your_username
  Port 22
  ProxyCommand ssh nowwhat-login -W %h:%p

If you use a ProxyJump (LISA):

Host lisa
  HostName lisa.stat.unipd.it
  User your_username
  ControlMaster auto
  ControlPersist 12h
  ControlPath ~/.ssh/cm-%r@%h:%p
 
Host nowwhat
  HostName nowwhat.stat.unipd.it
  User your_username
  Port 22
  ProxyCommand ssh -W %h:%p lisa
 
Host gn01
  HostName gn01
  User your_username
  Port 22
  ProxyCommand ssh nowwhat -W %h:%p
 
Host wn01
  HostName wn01
  User your_username
  Port 22
  ProxyCommand ssh nowwhat -W %h:%p

Test the login alias from your local terminal:

ssh nowwhat-login

Do not test nowwhat-wn01 or nowwhat-gn01 yet unless you already have an active SLURM allocation on that node.

ProxyCommand ssh nowwhat-login -W %h:%p means: connect to the login node first, then ask the login node to open the final SSH connection to wn01 or gn01.

Step 2: Configure Positron Remote SSH Settings

Before connecting to a compute node, configure Positron's Remote SSH behavior for the NowWhat topology. Compute-node ports are reachable only through the login node, so Positron must use a socket-based remote server and avoid its local-server connection mode.

These settings go in Positron's local User Settings on your computer. They do not go in Remote Settings and they do not go in ~/.ssh/config.

Optional: Create a NowWhat Profile

Before changing the settings, you can create a dedicated Positron profile for NowWhat. This is optional, but recommended if you also use Positron for other local or remote projects, because the Remote SSH settings below are specific to the NowWhat topology.

In Positron, open the profile menu and create a new profile named:

NowWhat

Then switch to the NowWhat profile before continuing with the User Settings JSON below.

Open Positron locally, before starting a Remote SSH session, then open the Command Palette:

Ctrl + Shift + P

Search for:

Preferences: Open User Settings (JSON)

Add:

{
  "remoteSSH.remoteServerListenOnSocket": true,
  "remoteSSH.useLocalServer": false
}

If your User Settings JSON already contains other settings, add only these properties inside the existing JSON object.

The two required settings are:

remoteSSH.remoteServerListenOnSocket: makes the remote server listen on a Unix socket instead of exposing a TCP port on the compute node
remoteSSH.useLocalServer: disables Positron's local-server connection mode, which can fail when compute-node ports are reachable only through the login node

After changing this setting, close any open Remote SSH windows before reconnecting.

Step 3: Add NowWhat Environment Modules

In the Positron window connected to NowWhat, open:

Preferences: Open Remote Settings (JSON)

Paste this setting:

{
  "positron.environmentModules.environments": {
    "Hugging Face": {
      "languages": ["python"],
      "modules": ["micromamba/huggingface"]
    },
    "PyTDC": {
      "languages": ["python"],
      "modules": ["micromamba/pyTDC"]
    },
    "RAPIDS": {
      "languages": ["python"],
      "modules": ["micromamba/rapids"]
    },
    "R/Python ML": {
      "languages": ["r", "python"],
      "modules": ["micromamba/rpy-ml"]
    },
    "R/Python Single Cell": {
      "languages": ["r", "python"],
      "modules": ["micromamba/rpy-sc"]
    },
    "scGPT": {
      "languages": ["python"],
      "modules": ["micromamba/scGPT"]
    },
    "Bioc3.22": {
      "languages": ["r"],
      "modules": ["micromamba/bioc-3.22"]
    },
    "Bioc3.23": {
      "languages": ["r"],
      "modules": ["micromamba/bioc-3.23"]
    }
 
  }
}

Step 4: Start a SLURM Allocation for Positron

Before connecting Positron to a compute node, start a SLURM job that keeps the node allocated. This job is only used to reserve the node for your remote IDE session.

Connect to the login node:

ssh nowwhat-login

Option A: Interactive `srun`

For a CPU session on wn01:

srun --partition=cpu --nodelist=wn01 --time=02:00:00 --ntasks=1 --cpus-per-task=4 --mem=8G sleep 2h

For a GPU session on gn01:

srun --partition=gpu --nodelist=gn01 --time=02:00:00 --ntasks=1 --cpus-per-task=4 --mem=16G --gres=gpu:nvidia_h200_nvl_1g.35gb:1 sleep 2h

Keep this terminal open. The allocation ends when you exit the shell, and Positron will lose the remote backend.

Option B: Batch `sbatch`

If you prefer a detached allocation, submit a batch job that sleeps for the duration of your Positron session.

For wn01, save a file named positron-wn01.sbatch on the login node:

#!/bin/bash
#SBATCH --job-name=positron-wn01
#SBATCH --partition=cpu
#SBATCH --nodelist=wn01
#SBATCH --time=02:00:00
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=4
#SBATCH --mem=8G
#SBATCH --output=positron-%j.out
#SBATCH --error=positron-%j.err
 
echo "Positron allocation running on $(hostname)"
sleep 2h

Submit it:

sbatch positron-wn01.sbatch

For gn01, use:

#!/bin/bash
#SBATCH --job-name=positron-gn01
#SBATCH --partition=gpu
#SBATCH --nodelist=gn01
#SBATCH --gres=gpu:nvidia_h200_nvl_1g.35gb:1
#SBATCH --time=02:00:00
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=4
#SBATCH --mem=16G
#SBATCH --output=positron-%j.out
#SBATCH --error=positron-%j.err
 
echo "Positron allocation running on $(hostname)"
sleep 2h

Check that the job is running before connecting Positron:

squeue -u your_username

The job must be in the RUNNING state on the node you want to use.

Test SSH to the Allocated Compute Node

After the SLURM allocation is running, open a new terminal on your local machine and test the compute-node SSH alias.

For wn01:

ssh nowwhat-wn01

For gn01:

ssh nowwhat-gn01

Then check the hostname:

hostname

It should print wn01 or gn01. If SSH fails, check that the SLURM allocation is still running on that node and that your SSH config uses ProxyCommand ssh nowwhat-login -W %h:%p.

Step 5: Connect from Positron

Open Positron on your local machine.

Open the Command Palette and run:

Remote SSH: Show Remote Menu

Then choose:

Connect to Host

Select the compute-node host from your SSH configuration:

nowwhat-wn01

or:

nowwhat-gn01

Do not select nowwhat-login for a Positron working session. The login-node host is useful for basic SSH testing only.

During the first connection, Positron installs a matching Positron server in your remote home directory. Wait until the remote window opens. The bottom-left status indicator should show that Positron is connected to the remote SSH host.

The remote host shown by Positron should be wn01 or gn01, not the login node.

Step 6: Open a Remote Folder

Once connected, open a folder from the remote filesystem.

For example:

/home/your_username

or a project directory:

/home/your_username/projects/my-project

The Explorer, terminal, R sessions, and Python sessions now refer to the remote NowWhat environment, not to files on your laptop.

The Positron session remains valid only while the SLURM allocation is active. When the srun shell exits or the sbatch sleep job finishes, the compute allocation ends and the Positron remote backend should be considered invalid.