Distributed notebook kernels in a containerized computing environment

Distributing kernels in a containerized computing environment includes executing, using computer hardware, a notebook server in a first container, wherein the notebook server is configured to communicate with a gateway in a second container, in response to a request for a kernel from the notebook server, the gateway requesting, using the computer hardware, a new container including the kernel from a container manager, instantiating, using the computer hardware, the new container including the kernel within a selected computing node of a plurality of computing nodes, publishing, using the computer hardware, communication port information for the new container to the gateway, and exchanging electronic messages, using the computer hardware, between the notebook server and the kernel through the gateway using the communication port information for the new container.

The following disclosure(s) are submitted under 35 U.S.C. 102(b)(1)(A):

BACKGROUND

This disclosure relates to notebook computing platforms and, more particularly, to notebook computing platforms operating in containerized computing environments.

A notebook refers to a Web-based application through which users may create and share documents. The documents may include live program code, equations, visualizations, and narrative text. Notebooks are often used by data scientists to build interactive applications. For example, notebooks may be used in fields and/or for purposes such as data cleaning and transformation, numerical simulation, statistical modeling, data visualization, and machine learning.

A notebook computing platform typically includes a notebook frontend, a notebook server, and one or more kernels. In general, the notebook frontend is capable of storing code and text notes (e.g., markdown text) in an editable document called the notebook. The notebook frontend is also capable of executing code stored in the notebook and further storing output generated from execution of that code within the notebook itself. The notebook frontend is typically implemented as a computing system executing a browser. The browser is capable of displaying a user interface for the notebook, allowing a user to interact with the notebook, and is capable of communicating with the notebook server. The notebook server is capable of saving and loading notebooks to the browser executing in the notebook frontend (e.g., a client device).

The notebook server is also capable of communicating with kernels. Kernels are similar to remote login sessions on a computing system in that kernels are capable of providing remote control for a program or code that is executing on the computing system. A kernel is capable of communicating with a process that executes code contained within the kernel. For example, a user is capable of interacting with a notebook by way of a browser and provide code and/or instructions. The notebook server may offload the code and/or instructions to a kernel for execution. Results from execution of the kernel may be provided to the notebook server and then to the browser for display to the user.

SUMMARY

In one or more embodiments, a method includes executing, using computer hardware, a notebook server in a first container, wherein the notebook server is configured to communicate with a gateway in a second container, in response to a request for a kernel from the notebook server, the gateway requesting, using the computer hardware, a new container including the kernel from a container manager, and instantiating, using the computer hardware, the new container including the kernel within a selected computing node of a plurality of computing nodes. The method can also include publishing, using the computer hardware, communication port information for the new container to the gateway and exchanging electronic messages, using the computer hardware, between the notebook server and the kernel through the gateway using the communication port information for the new container.

In one or more embodiments, a system includes computer hardware, having at least one processor, configured to initiate operations including executing a notebook server in a first container, wherein the notebook server is configured to communicate with a gateway in a second container, in response to a request for a kernel from the notebook server, the gateway requesting a new container including the kernel from a container manager, and instantiating the new container including the kernel within a selected computing node of a plurality of computing nodes. The operations can also include publishing communication port information for the new container to the gateway and exchanging electronic messages between the notebook server and the kernel through the gateway using the communication port information for the new container.

In one or more embodiments, a computer program product includes a computer readable storage medium having program code stored thereon. The program code is executable by computer hardware to perform operations. The operations include executing a notebook server in a first container, wherein the notebook server is configured to communicate with a gateway in a second container, in response to a request for a kernel from the notebook server, the gateway requesting a new container including the kernel from a container manager, and instantiating the new container including the kernel within a selected computing node of a plurality of computing nodes. The operations can also include publishing communication port information for the new container to the gateway and exchanging electronic messages between the notebook server and the kernel through the gateway using the communication port information for the new container.

DETAILED DESCRIPTION

This disclosure relates to notebook computing platforms and, more particularly, to notebook computing platforms in containerized computing environments. In accordance with the inventive arrangements described herein, a notebook computing platform is provided that can be used with a containerized computing environment to distribute and manage kernels. Conventional notebook computing platforms include a notebook server and one or more kernels. The kernels and the notebook server execute as local processes with a single computer server.

Being executed as local processes, the notebook server and the kernels impose resource constraints on the computer server. For example, though the notebook server and kernels can execute in a computing cluster, the notebook server and any kernels utilized by the notebook server are restricted to executing on a single computing node of the computing cluster despite the availability of other computing nodes in the computing cluster. The notebook server and kernels are capable of quickly consuming the available memory of the computing node. The notebook server, however, is unable to leverage the additional computing capacity of the other computing nodes in the computing cluster due to the constraint that kernels execute locally with respect to the notebook server.

In some cases, the notebook computing platform is implemented in a containerized computing environment. In such cases, the notebook server and the kernels are implemented within a single container that is stored and executed on a single computer server. Such is the case as the kernels are executed locally with respect to the notebook server, e.g., in the same container. Using this approach, the maximum amount of server resources thought to be needed by the notebook server and any/all kernels accessed by the notebook server must be allocated to the container including the notebook server and kernel(s) at startup of that container. The notebook server is only able to execute kernels up to the computing resource limits granted to the container at startup.

In accordance with the inventive arrangements described herein, the notebook server is containerized separately from the kernels. The notebook server is implemented within one container, while the kernels are implemented in one or more other containers. For example, each kernel can be implemented within a different container. By containerizing the notebook server independently from the kernels, the size of the container used for the notebook server can be significantly reduced. The container need not be created to accommodate an anticipated number of kernels. The maximum amount of server resources used by any/all kernels of a given notebook need not be pre-allocated to the container including the notebook server. When a kernel is needed, computing server resources may be allocated to a new container that is launched that includes the kernel. When the kernel is no longer needed, the computer server resources allocated to the kernel may be used for other purposes after the container is terminated.

In addition, because the kernel is implemented within a different container than the notebook server, the kernel need not execute on the same computer server. For example, in the context of a computing cluster having a plurality of networked computing nodes, the container that includes a kernel used by a notebook server can execute on a different physical computing node and/or a different virtual machine than is used to execute the notebook server. This capability can significantly improve computing performance of the computing cluster by avoiding overburdening the computing node that executes the notebook server and more efficiently distributing the workload relating to execution of a notebook by distributing kernels to different computing nodes throughout the computing cluster. As such, the notebook computing platform is able to fully leverage the computing cluster.

In addition, including kernels in individual containers that are also distinct from the container of the notebook server allows the kernels to be decoupled and executed remotely from the notebook server. The containers including kernels can be launched, started, stopped, interrupted, and terminated thereby releasing the resources allocated to the containers. In other words, the computing resources devoted to a particular kernel may be used for other purposes once the container including the kernel is terminated. As such, the computing cluster is capable of supporting greater workloads, supporting more users, and/or supporting more notebook servers.

Characteristics are as follows:

Service Models are as follows:

Deployment Models are as follows:

In one or more embodiments, containerized notebook environment96provides a notebook computing environment in which each notebook server included therein is implemented in a notebook server-specific container. Further, any kernels used by the respective containerized notebook servers are also implemented in individual kernel-specific containers. As kernels are needed by a given notebook server, the notebook server directs the kernel requests to a containerized gateway. The containerized gateway, for example, requests the creation of a container from a container manager on behalf of the notebook server. In response, the container manager instantiates a container that includes the kernel and a kernel controller. The container manager is capable of determining a location within the computing environment, e.g., a particular computing node and/or a particular virtual computing node, and instantiating the container including the kernel and the kernel controller on that computing node. Once instantiated, the kernel controller is capable of registering with the gateway. Since the gateway is aware of the particular location of the kernel within the multi-computing node environment, e.g., by virtue of interacting with the container manager, the gateway is capable of routing electronic messages between the containerized notebook server and the containerized kernel.

In particular embodiments, operations performed by kernels corresponding to a notebook server are capable of interacting with other layers and/or modules of the system illustrated inFIG. 2. For example, operations performed by one or more kernels are capable of interacting with data analytics processing94. In another example, operations performed by one or more kernels are capable of interacting with database software68. The particular examples provided are for purposes of illustration only and, as such, are not intended to be limiting. It should be appreciated that the particular layers and/or modules with which a kernel interacts will depend upon the purpose and/or functionality of that kernel.

Referring now toFIG. 3, a schematic of an example of a computing node is shown. Computing node300is only one example implementation of a computing node that may be used in a standalone capacity, as part of a computing cluster, or as a cloud computing node. The example ofFIG. 3is not intended to suggest any limitation as to the scope of use or functionality of embodiments of the invention described herein. Regardless, computing node300is capable of being implemented and/or performing any of the functionality set forth hereinabove. Computing node300is an example of computer hardware that is capable of performing the various operations described within this disclosure.

As shown inFIG. 3, computer system/server312in computing node300is shown in the form of a general-purpose computing device. The components of computer system/server312may include, but are not limited to, one or more processors316, a system memory328, and a bus318that couples various system components including system memory328to processor316.

Computer system/server312typically includes a variety of computer system readable media. Such media may be any available media that is accessible by computer system/server312and can include both volatile and non-volatile media, removable and non-removable media.

Program/utility340, having a set (at least one) of program modules342, may be stored in memory328by way of example, and not limitation, as well as an operating system, one or more application programs, other program modules, and program data. Each of the operating system, one or more application programs, other program modules, and program data or some combination thereof, may include an implementation of a networking environment. Program modules342generally carry out the functions and/or methodologies of embodiments of the invention as described herein.

For example, one or more of the program modules may implement containerized notebook environment96or portions thereof. Program/utility340is executable by processing unit316. Program/utility340and any data items used, generated, and/or operated upon by computing node300are functional data structures that impart functionality when employed by computing node300. As defined within this disclosure, a “data structure” is a physical implementation of a data model's organization of data within a physical memory. As such, a data structure is formed of specific electrical or magnetic structural elements in a memory. A data structure imposes physical organization on the data stored in the memory as used by an application program executed using a processor.

Computer system/server312may also communicate with one or more external devices314such as a keyboard, a pointing device, a display324, etc.; one or more devices that enable a user to interact with computer system/server312; and/or any devices (e.g., network card, modem, etc.) that enable computer system/server312to communicate with one or more other computing devices. Such communication can occur via Input/Output (I/O) interfaces322. Still yet, computer system/server312can communicate with one or more networks such as a local area network (LAN), a general wide area network (WAN), and/or a public network (e.g., the Internet) via network adapter320. As depicted, network adapter320communicates with the other components of computer system/server312via bus318. It should be understood that although not shown, other hardware and/or software components could be used in conjunction with computer system/server312. Examples, include, but are not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data archival storage systems, etc.

While computing node300is used to illustrate an example of a cloud computing node, as discussed, a computer system using an architecture the same as or similar to that shown inFIG. 3may be used in a non-cloud computing implementation to perform the various operations described herein. In this regard, the example embodiments described herein are not intended to be limited to a cloud computing environment.

FIG. 4illustrates an example of a computing cluster402that is capable of executing containerized computing environment96according to an embodiment of the present invention. In the example ofFIG. 4, computing cluster402includes a plurality of computing nodes404-1,404-2,404-3, through404-N. Computing nodes404may be implemented as described in connection withFIG. 3and interconnected by any of a variety of network connections and/or architectures.

Containerized computing environment96includes a container manager410and a plurality of different containers420,430,440, and450. In general, container manager410is capable of managing containers by instantiating or launching containers as requested or needed within containerized computing environment96and terminating containers when no longer needed. As defined herein, a container is a standalone, executable software package that includes the resources needed to execute a particular application. A container can be implemented as a standardized unit of software that provides a mechanism by which the application and any resources needed by the application are able to execute in a resource-isolated process. For example, a container can include the program code, runtime, system tools, system libraries, and/or settings necessary to execute a given application. As such, containers provide application portability, ease of building and deployment, and have a small footprint in terms of computing resources and runtime overhead.

As part of instantiating a container, container manager410is capable of selecting a particular computing node404in which the container will be created (e.g., instantiated) and executed. In particular embodiments, the selection of a particular computing node in which a container is implemented is determined based on the workload of each computing node404at or about the time that the container is to be instantiated. In this manner, container manager410is capable of performing load balancing among the computing nodes404, thereby allowing the notebook computing environment to leverage the capabilities of computing cluster402. For example, container manager410is capable of determining which of computing nodes404has the largest computing capacity available (e.g., a lowest workload) and selecting that computing node in which to instantiate a new container. It should be appreciated that the particular techniques used to evaluate workloads of computing nodes404and of selecting the particular computing node404in which a container is to be instantiated can vary in complexity beyond that which is described. In any case, container manager410is capable of selecting the particular location, e.g., computing node404, in which a container is instantiated.

Container420includes notebook server422. Notebook server422, which is implemented as program code, executes within container420. As an illustrative and non-limiting example, notebook server422may be implemented as a Jupyter Notebook server or as another type of other notebook server that is capable of communicating using the Jupyter Message Protocol. For example, notebook server422can be implemented as a proprietary system or as an open source system capable of communicating using the Jupyter Message Protocol.

In the example ofFIG. 4, notebook server422includes a server extension462that is capable of communicating with a gateway432. Gateway432, which is implemented as program code, executes within container430. In the example ofFIG. 4, container manager410has instantiated containers440and450. Container manager410includes kernel424and kernel controller426within container440. As such, both kernel424and kernel controller426execute within container440. Container manage410includes450includes kernel452and kernel controller454within container450. As such, both kernel452and kernel controller454execute within container450.

In the example ofFIG. 4, notebook server422is capable of providing a notebook to a client device. The client device, for example, can execute a browser that is used to execute and access the notebook. A user is capable of providing user input specifying code and/or other data to the notebook. The client device is capable of conveying the user inputs to notebook server422. Notebook server422is capable of using a kernel to perform one or more operations relating to the user provided input corresponding to the notebook. In one or more embodiments, a kernel is implemented as program code that, when executed, provides a remote login session on a data processing system. A kernel can provide a mechanism for remote control of a program (e.g., a mechanism that is responsive to user provided input to the notebook). Rather than launch a new kernel locally, e.g., within container420, notebook server422, by way of server extension462, sends a request to launch a new kernel to gateway432.

Gateway432receives the request for a new kernel from notebook server422. In response to the request for a new kernel from notebook server422, gateway432submits a request for a new container including the new kernel to container manager410on behalf of notebook server422. Container manager410, in response to the request from gateway432, is capable of determining a location within computing cluster402in which to launch a new container including the new (e.g., requested) kernel. In one or more embodiments, container manager410includes a resource manager460that determines which of computing nodes404on which to launch the new container. In particular embodiments, resource manager460is capable of determining the current workload of each of computing nodes404and selecting a particular computing node404based on the determined workload of each respective computing node404. For example, resource manager460is capable of selecting the particular computing node404that has a smallest or lowest workload in which to launch the new container, which includes the new kernel and the kernel controller therein.

In one or more embodiments, the selected computing node404in which the new container is implemented is different from the particular computing node that is executing container420. In one or more other embodiments, the selected computing node404in which the new container is implemented is also different from the particular computing node404that is executing container430.

For purposes of illustration, consider the case where container manager410launches container440within computing node404-3based on an assessment of the workload of computing nodes404. Subsequently, container manager410launches container450within computing node404-4based on another assessment of the workload of computing nodes404. In launching each container, container manager410includes the requested kernel and a kernel controller for the requested kernel within the container. In particular embodiments, the kernel controller is implemented as a wrapper for the kernel. In general, the kernel controller is capable of coordinating communication between the kernel and gateway432.

As an illustrative and non-limiting example, in response to the request for a new container, container manager410launches container450including the new kernel, e.g., kernel452, and kernel controller454. Container manager410is capable of configuring kernel controller454with the address of gateway432as part of launching container450so that kernel controller454is capable of communicating with gateway432. For example, in launching container450, container manager410is capable of passing a callback address of gateway432to kernel controller454as a parameter. Once container450is launched on a particular computing node404, kernel controller454is capable of publishing contact information for container450to the callback address corresponding to gateway432.

Gateway432is further capable of communicating with container manager410via an application programming interface (API) provided by container manager410to determine the particular location within computing cluster402in which container450is instantiated. In response to receiving the location information for container450from container manager410, gateway432starts listening for port information on the response port (e.g., the callback address) from container450. In this manner, gateway432is expecting the communication from kernel controller454, which informs gateway432of the port information needed to communicate with kernel452and kernel controller454.

In one or more embodiments, kernel controller454publishes the port information for kernel452back to gateway432. In one aspect, the port information can include port information for kernel452specifying notebook communication protocol compliant communication ports that may be used within a conventional notebook computing environment (e.g., a Jupyter notebook computing environment) that allows a notebook server to communicate with a kernel. For example, the port information can include information for the following ports or “sockets” per the Jupyter Message Protocol: Shell, IOPub, stdin, Control, Heartbeat. The port information can also include a port for kernel controller454. Using the port information and location of container450in computing cluster402, gateway432is capable of establishing a communication link with container450. More particularly, gateway432is capable of establishing a communication link with kernel452and kernel controller454. As such, gateway432is capable of exchanging messages (e.g., “kernel messages”) and/or information between notebook server422and kernel452. Notebook server422is capable of communicating with kernel452through gateway432as if kernel452is executing within container420as a local process. In other words, notebook server422is unaware that kernel452is within a different container and or possibly within a different computing node404of computing cluster402. Signaling that would be provided to kernel452from notebook server422as a local process were kernel452also implemented in container420is provided to container450and, as such, kernel452through messages conveyed through gateway432.

Using the port information for kernel controller454, gateway432is also capable of conveying messages relating to lifecycle management of kernel452. For example, messages for starting execution of kernel452, stopping execution of kernel452, and/or interrupting operation of kernel452are directed to kernel controller454. As an illustrative and nonlimiting example, notebook server422directs all communications intended for kernel452to gateway432. Gateway432conveys messages intended for kernel452to the appropriate ports corresponding to kernel452executing within container450. Gateway432directs those messages relating to lifecycle management, e.g., starting, stopping, and/or interrupting kernel452, to kernel controller454. Kernel controller454is capable of performing a signal write directly to the process executing kernel452within container450, thereby allowing kernel controller454to perform the noted lifecycle management operations on kernel452.

In conventional notebook computing environments where the kernels are launched locally with respect to the notebook server (e.g., in the same computing node and/or in the same container as the notebook server), the notebook server is capable of directly exercising control over the kernels since the kernels executed as local processes. The notebook server would simply start, stop (e.g., kill), or interrupt the process executing the kernel locally. In accordance with the inventive arrangements disclosed herein, since kernel452no longer executes as a local process of notebook server422, kernel controller454is used to exercise such control over kernel452on behalf of notebook server422. Kernel controller454is controlled via a separate communication port that is accessed by gateway432.

FIG. 5illustrates a method500of distributing kernels in a containerized computing environment according to an embodiment of the present invention. Method500can be performed by a system as described herein in connection withFIGS. 2, 3, and/or4.

Method500can begin in block502, where a container (e.g., a server container) is launched that includes a notebook server and another container (e.g., a gateway container) is launched that includes a gateway. The notebook server can begin executing in the server container. Similarly, the gateway can begin executing within the gateway container. The notebook server, as implemented within the server container, can include a server extension that is configured to communicate with the gateway.

In block504, the notebook server submits a request for a new kernel to the gateway. For example, the notebook server can receive a request from a client device executing a notebook and requesting execution of program code. The notebook server, in response to the request from the client device, is capable of generating a request for a new kernel that is capable of executing the particular type of program code provided from the client device and submitting the request to the gateway.

In block506, in response to receiving the request from the notebook server, the gateway requests a new container including the new (e.g., requested) kernel from the container manager. In block508, the container manager determines a location for the new container. For example, the container manager is capable of selecting a particular computing node or virtual computing node within a computing environment having a plurality of such nodes on which to execute the new container.

In block510, the container manager launches the new container at the determined location. The new container (e.g., kernel container) includes the new kernel and a kernel controller for the new kernel. Both the new kernel and the kernel controller are executed within the kernel container. The kernel controller is configured by the container manager upon implementation with a callback address for the gateway.

In block512, the gateway receives the location of the new container within the computing environment (e.g., the computing cluster) from the container manager. For example, the gateway can use an API of the container manager to request the location of the new container from the container manager once the new container is instantiated on a computing node or virtual computing node. In another example, the container manager is capable of providing the location of the new container to the gateway in response to instantiating the new container on a particular computing node or virtual computing node. In response to receiving location information for the new container, the gateway begins listening on the port corresponding to the callback address for port information published from the new container.

In block514, the kernel controller, once executing, publishes communication port information for the kernel container to the callback address of the gateway. As discussed, the port information can specify one or more communication ports corresponding to the kernel in accordance with the notebook communication protocol used between the notebook server and kernel in cases where the kernel is implemented as a local process within the same container as the notebook server. The port information can also include a port address for the kernel controller. The gateway already has location information for the new container obtained directly from the container manager. Using the location information and the port information, the gateway is capable of communicating with the kernel and/or the kernel manager in the new container. The gateway, in response to receiving the port information from the kernel controller, is capable of establishing communication link(s) with the kernel container. For example, the gateway is capable of establishing a communication link with the kernel and/or a communication link with the kernel controller within the kernel container.

In block516, the gateway starts execution of the kernel using the kernel controller in response to a lifecycle management message from the notebook server. For example, the notebook server, in executing the notebook, may initiate execution or a processing job by the kernel. In doing so, the notebook server sends a message by way of the server extension to the gateway. The gateway is capable of analyzing messages received from the notebook server and distinguishing lifecycle management messages from other messages that occur in the normal and ordinary course of operation of the kernel. The gateway, in recognizing that the message is a lifecycle management message, directs the message to the communication port for the kernel controller. In response to receiving the lifecycle management message, the kernel controller within the kernel container starts execution of the kernel. The kernel controller, for example, is capable of executing any lifecycle management messages that are received such as starting execution of the kernel, stopping execution of the kernel, and/or interrupting execution of the kernel.

In block518, the gateway exchanges messages between the notebook server and the kernel. For example, in executing the notebook, the notebook server continues sending kernel messages intended for the kernel to the gateway. The kernel messages are directed to the gateway by virtue of the server extension. The gateway forwards the kernel messages, e.g., messages that are not lifecycle management messages, to the appropriate port of the kernel per the Jupyter Message Protocol. Similarly, the kernel may send messages intended for the notebook server to the gateway. The gateway forwards the messages from the kernel to the notebook server.

For example, the notebook server can forward program code received from the client device to the gateway as one or more messages. An example of such a message can be an execute request message. The gateway can forward the message including program code to the kernel for execution. The kernel can send various messages back to the gateway. Example messages from the kernel that can be sent back to the gateway include, but are not limited to, a status message specifying “busy” which indicates that the kernel has received the request, an execute_input message indicating that the kernel is executing the program code, a display_data message providing results to be displayed, an execute_result message specifying results of execution, and/or a status message specifying “idle” indicating that the kernel has completed execution. The gateway can forward the messages received from the kernel to the notebook server. The notebook server further can forward any results to the client device for presentation.

In block520, gateway stops and/or interrupts the kernel using the kernel controller in response to a lifecycle management message from the notebook server. For example, the notebook server can send a lifecycle management message to the gateway. The lifecycle management message can interrupt or stop the kernel. The gateway, in detecting that the received message is a lifecycle management message, forwards the message to the kernel controller. The kernel controller, in response to receiving the lifecycle management message, executes any commands included therein such as stopping or interrupting the kernel.

In block522, the notebook server sends a message to the gateway indicating that the kernel is no longer needed. In block524, the gateway, in response to receiving the message from the notebook server, sends a message to the container manager indicating that the new container is no longer needed. In block526, the container manager terminates, e.g., deletes, the kernel container. As such any resources within the containerized computing environment previously allocated for executing the container are released and available to execute other containers. As such, resources of the computing cluster are only tied up when a kernel is in use and are released when the kernel is no longer needed.

In accordance with the inventive arrangements described herein, use of the server extension redirects communications intended for kernels from the notebook server to the gateway. As such, the notebook server is unaware that the notebook server is communicating through a remote port with a remote kernel. Signals that were provided to the kernel(s) locally, are now conveyed by way of the gateway through electronic messages. As an illustrative and nonlimiting example, a user may provide a “break” command such as “control-c” via the client device. The notebook server submits a message including the command to the gateway. The gateway, in recognizing the message as a lifecycle management message, directs the message to the kernel controller instead of the kernel.

FIG. 6illustrates another method600of distributing kernels in a containerized computing environment according to an embodiment of the present invention. Method600may be performed by a system as described herein in connection withFIGS. 2, 3, and/or4.

In block602, computer hardware is used to execute a notebook server in a first container. The notebook server is configured to communicate with a gateway in a second container. The notebook server is also configured to communicate with a client device executing a notebook. The notebook server may execute in a computing node and/or a virtual computing node.

In block604, the gateway, executing in the computer hardware and in response to a request for a kernel from the notebook server, requests, via the computer hardware, a new container including the kernel from a container manager.

In block606, the computer hardware instantiates the new container including the kernel within a selected computing node of a plurality of computing nodes. The container manager, for example, instantiates the new container. In instantiating the new container, the kernel controller is provided a callback address for the gateway that is used to publish communication port information.

In block608, the new container publishes communication port information to the gateway. The gateway further is capable of receiving a location for the new container within the computing environment. The location can specify the particular computing node and/or virtual computing node on which the new container was instantiated. The gateway is capable of listening for the communication port information on a particular port in response to receiving the location information from the container manager.

In block610, the computer hardware exchanges electronic messages between the notebook server and the kernel through the gateway using the communication port information for the new container. The gateway further can use the location information for the new container including the kernel. The gateway, for example, is capable of receiving messages sent by the notebook server and intended for the kernel and forwarding the messages to the kernel. The gateway is also capable of receiving messages sent by the kernel and intended for the notebook server and forwarding the messages to the notebook server.

In exchanging messages, the gateway is further capable of distinguishing between lifecycle management messages and messages that are not lifecycle management messages (e.g., kernel messages per the Jupyter Messaging Protocol). The containerized gateway forwards those messages from the notebook server determined to be lifecycle management messages to a communication port corresponding to the kernel controller and forwards those messages from the notebook server that are not lifecycle management messages to a communication port or ports corresponding to the kernel.

The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting. Notwithstanding, several definitions that apply throughout this document now will be presented.

The term “approximately” means nearly correct or exact, close in value or amount but not precise. For example, the term “approximately” may mean that the recited characteristic, parameter, or value is within a predetermined amount of the exact characteristic, parameter, or value.

As defined herein, the terms “one embodiment,” “an embodiment,” or similar language mean that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment described within this disclosure. Thus, appearances of the phrases “in one embodiment,” “in an embodiment,” and similar language throughout this disclosure may, but do not necessarily, all refer to the same embodiment.

As defined herein, the term “processor” means at least one hardware circuit configured to carry out instructions. The instructions may be contained in program code. The hardware circuit may be an integrated circuit. Examples of a processor include, but are not limited to, a central processing unit (CPU), an array processor, a vector processor, a digital signal processor (DSP), a field-programmable gate array (FPGA), a programmable logic array (PLA), an application specific integrated circuit (ASIC), programmable logic circuitry, and a controller.

As defined herein, the term “responsive to” means responding or reacting readily to an action or event. Thus, if a second action is performed “responsive to” a first action, there is a causal relationship between an occurrence of the first action and an occurrence of the second action. The term “responsive to” indicates the causal relationship.