Connecting to a remote IPython instance

Question:

I would like to run an IPython instance on one machine and connect to it (over LAN) from a different process (to run some python commands). I understand that it is possible with zmq : http://ipython.org/ipython-doc/dev/development/ipythonzmq.html .

However, I can not find documentation on how to do it and whether it is even possible yet.

Any help would be appreciated!

EDIT

I would like to be able to connect to IPython kernel instance and send it python commands. However, this should not be done via a graphic tool (qtconsole) , but I want to be able to connect to that kernel instance from within a different python script…

e.g.

external.py

somehow_connect_to_ipython_kernel_instance
instance.run_command("a=6")
Asked By: Ohad

||
Source

Answers:

If you want to run code in a kernel from another Python program, the easiest way is to connect a BlockingKernelManager. The best example of this right now is Paul Ivanov’s vim-ipython client, or IPython’s own terminal client.

The gist:

  • ipython kernels write JSON connection files, in IPYTHONDIR/profile_<name>/security/kernel-<id>.json, which contain information necessary for various clients to connect and execute code.
  • KernelManagers are the objects that are used to communicate with kernels (execute code, receive results, etc.).
    *

A working example:

In a shell, do ipython kernel (or ipython qtconsole, if you want to share a kernel with an already running GUI):

$> ipython kernel
[IPKernelApp] To connect another client to this kernel, use:
[IPKernelApp] --existing kernel-6759.json

This wrote the ‘kernel-6759.json’ file

Then you can run this Python snippet to connect a KernelManager, and run some code:

from IPython.lib.kernel import find_connection_file
from IPython.zmq.blockingkernelmanager import BlockingKernelManager

# this is a helper method for turning a fraction of a connection-file name
# into a full path.  If you already know the full path, you can just use that
cf = find_connection_file('6759')

km = BlockingKernelManager(connection_file=cf)
# load connection info and init communication
km.load_connection_file()
km.start_channels()

def run_cell(km, code):
    # now we can run code.  This is done on the shell channel
    shell = km.shell_channel
    print
    print "running:"
    print code

    # execution is immediate and async, returning a UUID
    msg_id = shell.execute(code)
    # get_msg can block for a reply
    reply = shell.get_msg()

    status = reply['content']['status']
    if status == 'ok':
        print 'succeeded!'
    elif status == 'error':
        print 'failed!'
        for line in reply['content']['traceback']:
            print line

run_cell(km, 'a=5')
run_cell(km, 'b=0')
run_cell(km, 'c=a/b')

The output of a run:

running:
a=5
succeeded!

running:
b=0
succeeded!

running:
c=a/b
failed!
---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
/Users/minrk/<ipython-input-11-fb3f79bd285b> in <module>()
----> 1 c=a/b

ZeroDivisionError: integer division or modulo by zero

see the message spec for more information on how to interpret the reply. If relevant, stdout/err and display data will come over km.iopub_channel, and you can use the msg_id returned by shell.execute() to associate output with a given execution.

PS: I apologize for the quality of the documentation of these new features. We have a lot of writing to do.

Answered By: minrk

If you just want to connect interactively, you can use SSH forwarding. I didn’t find this documented anywhere on Stack Overflow yet, yet this question comes closest. This answer has been tested on Ipython 0.13. I got the information from this blog post.

  1. Run ipython kernel on the remote machine:

    user@remote:~$ ipython3 kernel
[IPKernelApp] To connect another client to this kernel, use:
[IPKernelApp] --existing kernel-25333.json

  2. Look at the kernel-25333.json file:

    user@remote:~$ cat ~/.ipython/profile_default/security/kernel-25333.json 
{
  "stdin_port": 54985, 
  "ip": "127.0.0.1", 
  "hb_port": 50266, 
  "key": "da9c7ae2-02aa-47d4-8e67-e6153eb15366", 
  "shell_port": 50378, 
  "iopub_port": 49981
}

  3. Set up port-forwarding on the local machine: 

    user@local:~$ ssh user@remote -f -N -L 54985:127.0.0.1:54985
user@local:~$ ssh user@remote -f -N -L 50266:127.0.0.1:50266
user@local:~$ ssh user@remote -f -N -L 50378:127.0.0.1:50378
user@local:~$ ssh user@remote -f -N -L 49981:127.0.0.1:49981

  4. Copy the kernel-25333.json file to the local machine:

    user@local:~$ rsync -av user@remote:.ipython/profile_default/security/kernel-25333.json ~/.ipython/profile_default/security/kernel-25333.json

  5. Run ipython on the local machine using the new kernel:

    user@local:~$ ipython3 console --existing kernel-25333.json
Python 3.2.3 (default, Oct 19 2012, 19:53:16)
Type "copyright", "credits" or "license" for more information.

IPython 0.13.1.rc2 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.


In [1]: import socket; print(socket.gethostname())
remote
Answered By: gerrit

If you’re using Anaconda, in OS X the JSON file is stored at

/Users/[username]/Library/Jupyter/runtime/

In Windows:

c:Users[username]AppDataRoamingjupyterruntime

Answered By: 32768

Update to minrk’s answer after the split to jupyter. With
jupyter_client (4.1.1)
the simplest code is rather something like:

import jupyter_client

cf=jupyter_client.find_connection_file('6759')
km=jupyter_client.BlockingKernelClient(connection_file=cf)
km.load_connection_file()

km.execute('a=5')

Note that:

  • jupyter_client.BlockingKernelClient is also aliased with jupyter_client.client.BlockingKernelClient.
  • the shell (km.shell_channel) does not have the method execute() & get_msg() anymore.

Currently it is quite difficult to find an updated documentation; nothing yet on http://jupyter-client.readthedocs.org/en/latest/ for BlockingKernelClient. Some code in https://github.com/jupyter/jupyter_kernel_test. Any link welcome.

Answered By: S. Bougnoux

The above answers are a bit old. The solution for the latest version of ipython is much simpler but is not documented well at one place. So I thought I would document it here.

Solution to connect from any OS to a ipython kernel running on Windows

If either the client or server is a linux or other operating system, just change the location of kernel-1234.json appropriately based on Where is kernel-1234.json located in Jupyter under Windows?

  1. On your windows based kernel start, make sure ipykernel is installed using pip install ipykernel
  2. Start the ipykernel using ipython kernel -f kernel-1234.json
  3. Locate the kernel-1234.json file on your Windows machine. The file will probably have a different number, not 1234 and will most likely be located in ‘C:UsersmeAppDataRoamingjupyterruntimekernel-1234.json’: https://stackoverflow.com/a/48332006/4752883
  4. Install Jupyter Console (or Jupyter Qtconsole/notebook) using pip install jupyter-console or pip install qtconsole https://jupyter-console.readthedocs.io/en/latest/
  5. If you are on Windows do a ipconfig to find out the ip address of your Windows server. (On Linux do a ifconfig at the shell prompt). In the kernel-1234.json file change the ip address from 127.0.0.1 to the ip address of your server. If you are connecting from another Windows server, then copy the kernel-1234.json file to your local computer and note down the path.
  6. Navigate to the folder containing the kernel-1234.json and start Jupyter Console using jupyter console --existing kernel-1234.json
Answered By: alpha_989