Remote Server Attachment and Tokens

[ehvr20]

Hi all,

I’m exploring the workflow suggested by the diagram on positron.posit.co/remote-ssh and want to see if my understanding is correct.

I should be able to manually launch a Positron server instance on a remote system (matching versions, of course) and then connect my local desktop Posit IDE to that headless remote server via SSH.

My main goal is to run the headless server inside a Singularity container, like this:
singularity exec MY_IMAGE positron-server ...
so that I can use Python and R environments directly within the container.

A few questions:

1. Is this approach feasible? So far, when I SSH in, it starts a new server instance instead of attaching to the one already running—even when not using the singularity run approach.
2. If feasible, how would I handle connecting with an existing session using a connection token?
3. Would remote long-running sessions be possible with this approach?

Anyone got experience in trying this?

Thanks for the help!

[EDIT: added a third question]

[jmcphers]

Generally speaking, it is not currently possible to have headless Positron IDE sessions that you can connect to / disconnect from via remote SSH. This is a limitation of the underlying VS Code platform and also isn't supported by VS Code's remote development features. Read more about that here: microsoft/vscode-remote-release#3096

You might try setting the entry point for your Singularity container to be the SSH server rather than Positron server? In that case you'll get a new "session" every time but it'll all be in the same Singularity container so might achieve what you want.

Positron's kernel supervisor also makes it possible to have long-running Python and R sessions that Positron can attach to / detach from -- so even though you get a new server instance each time, it will be connected to the same kernel. Positron will generally manage these long-running sessions itself. That's documented here: https://positron.posit.co/remote-ssh.html#long-running-sessions

Another advanced move you could try if you're looking for long-running Python and R sessions in another environment is to start Positron's kernel supervisor manually in the environment where you want it to connect and then set the POSITRON_SUPERVISOR_CONNECTION_FILE environment variable so that Positron connects to the already-running supervisor. You can see Positron's own implementation of this for details:

positron/src/server-main.ts

Lines 322 to 355 in 4b70a78

	// --- Start Positron ---
	/**
	* Start a Positron Kernel Supervisor process. This process is shared among all
	* the windows that connect to this server. We start it here so that it'll be warm
	* when the first window connects.
	*/
	async function startKernelSupervisor() {
	// Create the connection and log file paths. We put these in the user data
	// path rather than the temporary directory since some environments clean up
	// the temporary directory aggressively.
	const userDataPath = getUserDataPath(parsedArgs, product.nameShort || 'positron');
	const connectionFile = path.join(userDataPath, `positron-supervisor-${process.pid}.json`);
	const logFile = path.join(userDataPath, `positron-supervisor-${process.pid}.log`);
	// Unlikely, but if the files already exist, delete them; they are stale.
	if (fs.existsSync(connectionFile)) {
	fs.unlinkSync(connectionFile);
	}
	if (fs.existsSync(logFile)) {
	fs.unlinkSync(logFile);
	}
	// Create the user data dir
	const userDataDir = path.dirname(connectionFile);
	if (!fs.existsSync(userDataDir)) {
	try {
	fs.mkdirSync(userDataDir, { recursive: true });
	} catch (err) {
	console.error(`Failed to create user data directory for supervisor files: ${userDataDir}`, err);
	}
	}
	// Pass the connection file path to the supervisor extension.
	process.env['POSITRON_SUPERVISOR_CONNECTION_FILE'] = connectionFile;

[ehvr20]

I appreciate the detailed response. If I understand correctly, the idea is to launch the KernelSupervisor manually inside the image environment, then attach to it when connecting remotely—this makes it possible to run sessions inside containers and also keep them alive for long-running jobs.

I tested it out, and it works! 🎉 Here’s how I set it up:

1. Download and unpack the Positron server binary

Using the URL template (adjust ${arch}, ${os}, ${version} as needed):

https://cdn.posit.co/positron/dailies/reh/${arch-long}/positron-reh-${os}-${arch}-${version}.tar.gz

2. Add environment variables to your remote .bashrc:

export POSITRON_SUPERVISOR_CONNECTION_FILE="$HOME/.config/Positron/positron-supervisor.json"
export POSITRON_SUPERVISOR_LOG_FILE="$HOME/.config/Positron/positron-supervisor.log"

3. Create a script to launch the kernel supervisor manually:

# launch_positron_supervisor.sh
#!/bin/bash

# Launch Kallichore / Kernel Supervisor
path/to/positron-server/extensions/positron-supervisor/resources/kallichore/kcserver \
  --connection-file "$POSITRON_SUPERVISOR_CONNECTION_FILE" \
  --log-file "$POSITRON_SUPERVISOR_LOG_FILE" \
  --transport 'tcp'   # optional

4. Run the kernel inside your Singularity image:

The environment variables must propagate to the container!

singularity exec --nv MYIMAGE.sif bash launch_positron_supervisor.sh

5. Connect to the remote via Positron Remote-SSH.

At this point, new sessions should spawn inside the manually launched kernel supervisor.

Other useful Positron settings: (add to USER settings JSON):

"kernelSupervisor.shutdownTimeout": "4", # long running sessions
"kernelSupervisor.transport": "tcp", # if --transport cp flag provided to kcserver

Checking it worked

1. POSITRON_SUPERVISOR_LOG_FILE:
   You should see a message like 'Heartbeat' connected in the LOG FILE on connect and session startup messages when launching a new session (R or Python)
2. From python sessions:

import os
os.environ["SINGULARITY_NAME"] # check of singularity image environment

4. From R sessions:

Sys.getenv("SINGULARITY_NAME", unset = NA) # check of singularity image environment

Thanks again!

[jmcphers]

Great, glad it's working for you!