remote kernel through SSH

Here's a solution that works quite well with me and a colleague of mine in my research group.

I assume you have Mathematica installed on both your local and remote machine. The command MathKernel has to be available on the shell of the remote machine.

Short answer:

1- Install GOW if you're using Windows

2- Open command prompt, and connect to the target machine using ssh, command is: ssh hostname. Confirm and make sure the shell is accessible. Then Restart Mathematica.

3- Run that script below from the long answer after modifying the necessary variables (username, password, hostname and number of kernels):

If you're using a linux client, there's a note for you at the end.

---

Long answer:

Note: this works for clients with any operating system, but the target server has to have an ssh server. It didn't work on target servers being Windows. If you manage to get it work, I'd appreciate adding it here.

If you're under Windows (as client), install GOW (and make sure it gets added to PATH (The installer offers that as far as I remember), which will install an SSH client for you. You should test the ssh client by running ssh yourTargetMachineHostname in your Command Prompt/Terminal. Make sure it works and you enter the shell of that machine, then proceed. Make sure you restart Mathematica after this point (to give environment variables a chance to update).

Then all you have to do is run the following code, but modify the username, password, the target machine hostname, and the number of parallel kernels you'd like to launch. Modify the ssh path if you have to (in case GOW bin directory was not added to PATH), but normally you don't have to.

Needs["SubKernels`RemoteKernels`"]
Parallel`Settings`$MathLinkTimeout = 100
user = "myuser";
password = "mypassword";
ssh = "ssh"; (*ssh program name. If you install GOW on Windows, then this should work, otherwise put the path yourself*)
math = "MathKernel" <> 
   " -wstp -linkmode Connect `4` -linkname `2` -subkernel -noinit >&  \
/dev/null &";
number = 20; (*number of parallel kernels to launch*)
machine = "targetPC-Hostname";
remote = SubKernels`RemoteKernels`RemoteMachine[machine, 
  ssh <> " " <> user <> "@" <> machine <> " " <> "-pw " <> password <>
    " \"" <> math <> "\"", number]

Print[remote // InputForm]
kerns = LaunchKernels[remote]

ParallelEvaluate[$MachineName]

(*CloseKernels[]*)

How to know if it works? If launching the kernels is successful, then the execution of the command ParallelEvaluate[$MachineName] will produce the hostname of the remote machine, not the local machine.

Now everything parallel will go to the remote host!

My advice: Make good use of ParallelTable, ParallelDo and similar commands, because by using these, you don't have to define the variables from your kernel into each parallel kernel, which is the case for ParallelEvaluate.

If you have limited licensing and you work in a group, consider using the commented command CloseKernels[], to close the kernels after you're done, so that your colleagues can benefit from the remote host. It's not generally possible to start an infinite amount of kernels.

I personally love this way of using remote kernels for many reasons. Mainly because it doesn't execute everything on the remote host, but it only executes parallel calls. Meaning that you can only divert expensive calls to the remote host (which is supposedly a very powerful machine), while execute simple calls on your local machine. Consequently, if you lose connection to the host, you can reconnect without a single problem without losing data from your local kernel!

CAVEAT: Notice that your password is written there in clear text. If you feel this is not secure and you need a better way, consider using Pageant, which makes it possible to connect through ssh using private/public key pair. Here's a tutorial for how to do it on Windows, and here's a tutorial on how to do it on Linux. Of course, the remote host has to have your public key in that case.

---

For Linux users: There's a well known incompatibility problem between Mathematica and the ssh command. To fix it, you have to reset the environment in which Mathematica calls the kernels. Replace the "ssh" variable in the code above with this:

ssh = "export LD_LIBRARY_PATH=;ssh"

This will execute export LD_LIBRARY_PATH=; then connect. One more thing is that putting the password in the command to ssh in Linux doesn't work. So replace the math variable with the following:

remote = SubKernels`RemoteKernels`RemoteMachine[machine, 
  ssh <> " " <> user <> "@" <> machine <>
    " \"" <> math <> "\"", number]

And then you have to find a way to login to ssh without directly inputting the password, like public key login or sshpass. The web is filled with documentation on how to do this.

Regarding The Quantum Physicist's answer, there might be a little problem for some macOS users who use macOS as remote machine. If you get the time out error message, it's very likely that the remote machine doesn't know the path of MathKernel.

math = "MathKernel" <> 
   " -wstp -linkmode Connect `4` -linkname `2` -subkernel -noinit >&  \
/dev/null &";

You can use the full path of MathKernel instead.

math = "/Applications/Mathematica.app/Contents/MacOS/MathKernel" <> 
   " -wstp -linkmode Connect `4` -linkname `2` -subkernel -noinit >&  \
/dev/null &";