Using Containers to Create More Interactive Online Training and Education Materials
UUsing Containers to Create More Interactive Online Training and EducationMaterials
BRANDON BARKER and SUSAN MEHRINGER,
Cornell University Center for Advanced Computing
Containers are excellent hands-on learning environments for computing topics because they are customizable, portable, and repro-ducible. The Cornell University Center for Advanced Computing has developed the Cornell Virtual Workshop in high performancecomputing topics for many years, and we have always sought to make the materials as rich and interactive as possible. Toward the goalof building a more hands-on experimental learning experience directly into web-based online training environments, we developed theCornell Container Runner Service, which allows online content developers to build container-based interactive edit and run commandsdirectly into their web pages. Using containers along with CCRS has the potential to increase learner engagement and outcomes.CCS Concepts: •
Applied computing → Interactive learning environments ; Distance learning ; •
Software and its engineer-ing → Software design engineering; •
Information systems → Web applications ; •
Social and professional topics → Computingeducation .Additional Key Words and Phrases: Training, Scientific Computing, HPC, Containers
ACM Reference Format:
Brandon Barker and Susan Mehringer. 2020. Using Containers to Create More Interactive Online Training and Education Materials. In
Practice and Experience in Advanced Research Computing (PEARC ’20), July 26–30, 2020, Portland, OR, USA.
ACM, New York, NY, USA,10 pages. https://doi.org/10.1145/3311790.3396641
Online training materials must be more than glorified documents to engage and teach learners. Learning by doingand experimenting is critical to gain understanding and skills in computing and programming. Integrating computingenvironments directly into online training web pages removes real and perceived access barriers. While this capabilityexists for specific environments, e.g. Jupyter Notebook, we sought to develop a more flexible tool to support learning tocode and the understanding of concepts that cover the full array of large-scale computing topics. The tool we originallyenvisioned and developed, the Cornell Job Runner Service (CJRS), has been redesigned to use containers and now existsas the Cornell Container Runner Service (CCRS). Our intention is to implement CCRS widely in our online materials(Cornell Virtual Workshop), and then offer CCRS to the broader HPC training and education community as an API.
Containers [7], as the name implies, allow packaging an application or environment in a portable way - a desirableproperty to have for integrating computational material into an educational service shared across multiple courses andinstructors. In particular, containers are a form of OS-level virtualization where a single OS kernel can host multiple
Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are notmade or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for componentsof this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post onservers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected].© 2020 Copyright held by the owner/author(s). Publication rights licensed to ACM.Manuscript submitted to ACM 1 a r X i v : . [ c s . C Y ] M a y EARC ’20, July 26–30, 2020, Portland, OR, USA Barker and Mehringer isolated environments. They are lighter weight than using hypervisor-based virtual machines wherein each VM runs aseparate kernel, but comes with the obvious restriction that all containers on the host must use the same OS kerneland the same version of the kernel. In many cases, this is an acceptable trade off, and while the roots of containertechnology originated in the likes of Solaris Zones [28] and FreeBSD Jails [23], the prevalence of Linux on commoditycloud hardware has helped to create a convergence of Linux containerization technology.While the above definition remains true, more recently Docker [17] has popularized the use of Linux containersin many communities and expanded, at least colloquially, the definition of a container. The definition now includesthe ability to distribute and deploy applications with minimal configuration: i.e., everything is self-contained withinthe container itself. Singularity [25], another Linux container technology, targeted HPC users by inverting securityconcerns and requiring the user to grant an application container access to all of the user’s files rather than running aservice as the root user, as is the case with Docker. In so doing, many of the traditional notions of a container werefurther broken down, though Singularity has optional parameters to enable isolation [12].Other container technologies exist for Linux as well, including that which is provided by a core service of mostLinux distributions, systemd [14]. However, systemd-nspawn containers typically do not include the more modernconnotation of a container being a packaged application. But, it has been used by other technologies for this purpose,such as nix-containers [10], a container technology for the NixOS [16, 20] Linux distribution that allows packages to beshared from the host’s package-store.
CJRS (Cornell Job Runner Service [26]) is the predecessor to CCRS (Cornell Container Runner Service) but has beenlargely redesigned and rewritten. CJRS employed the Slurm Workload Manager [31]. and relied on extensions toSlurm which were non-trivial to install and sometimes error-prone. CJRS was developed just before containers as anenvironment packaging technology became prevalent, and once containers in this form became widespread, it was clearthat pairing CJRS with container technologies would be extremely useful by providing the same front-end features andcourse-integration flexibility as CJRS with the flexibility and low maintenance cost of containers.
CCRS provides several interactive job-runner elements that instructors can use out of the box, e.g. an editors coupled tocode compilers or code runners and one-shot, in-line commands. Coupled with its support of a popular HPC containertype and a container type with low-disk utilization, CCRS provides a low-cost, cloud-friendly solution for HPC and CSinstructors who want to integrate their exercises into an online platform or site of their choice. CCRS takes the ideasand some of the architecture of CJRS and replaces the job lifecycle management of Slurm with containers. While thisinvolves managing life-cycle explicitly, this was on the same order of effort needed to tailor Slurm to manage jobs onvirtual nodes in CJRS. CCRS provides an API that instructors can use to incorporate their examples, as well as allowingthe creation of exercises in novel formats that go beyond what we envisaged.
CCRS has several different job types that may be employed for exercises and examples. Currently,the two prominent job types are one-shot commands and an editor-based job launch application . The one-shot command sing Containers to Create More Interactive Online Training and Education Materials PEARC ’20, July 26–30, 2020, Portland, OR, USA allows a single command to be entered or modified and run under whatever language the instructor has specified.For job-launch applications, typically an editor is employed. The instructor can add various actions to the editor asdesired, such as "run" or "compile and run." Interactive shell support is also planned. In the case of both the job launchapplication and interactive shell, CCRS has taken the approach of using third-party libraries, such as Ace editor [5],which includes syntax highlighting for many languages; CJRS took the alternative approach of using minimal code thathad few features but was also smaller in size. If the demand arises, we will integrate these lighter-weight alternativesinto CCRS as well.While these features encompass what was originally provided by CJRS, additional features are under consideration,including graphical and file-based interaction, where images generated by a job may be previewed and images andother generated files may be downloaded by the user. Currently, CCRS supports Singularity and systemd-nspawn containers; we anticipate support-ing others in the future, including Docker, though Docker has lower priority due to current and historical security issues[30]. Nix containers are also employed via systemd-nspawn support; they provide a light-weight container approachwhen building up specific environments for instructors since there is no package storage overhead. Singularity is alsosupported primarily due to its popularity in HPC and the number of instructors who may have an existing Singularitycontainer they wish to use. Generally, the overhead of adding a new container type should not be that large, as CCRSabstracts the container management lifecycle as much as possible.
A diagram of the container and job management approach taken by CCRS is shown inFigure 1. Generally, containers are environments determined by an image , which is a snapshot of a filesystem built froma specification (e.g. Dockerfile, Singularity definition file, or Nix expression). Multiple containers can then be launchedfrom the same image, which in CCRS can be done on a per-user basis or a per-job basis.For Singularity, CCRS will create a host user when valid login credentials are provided from the training site. Theuser’s login will be specific to the course site the user is coming from, rather than global across all CCRS courses, thoughthis should not generally be relevant to the student. To achieve true containerization, we pass the --containall optionto singularity exec , which will then contain not only file systems, but also PID, IPC, and environment [13]. If Dockersupport were to be added, it would likely follow a model similar to this, but with the added need to garbage-collectimage layers generated by running containers. In the case of Nix containers, images are not employed, but we still makeuse of the abstractions; instead, all jobs for a specific container specification are run in the same container by default,but as different users created within the container (again, based on the supplied login credentials). The container itselfacts as a sort of image, and jobs get user accounts in that container rather than specific container invocations, which ismuch lighter weight. In this regard, we are again using the more modern connotation of containers as application orenvironment packaging platforms rather than as a means of isolated process-sets. Using the machinectl clone couldachieve process isolation, however, we believe this is largely overkill for our use case.Within CCRS, each job is given a unique ID (the job ID ). The job ID is in one-to-one correspondence with the jobcontext (which is taken from CJRS); the job context is essentially the path where the job’s user can write files andincludes the identifier as part of the path. The job contexts are not garbage-collected when a job completes, thougheventually they can be (for instance, by default we have configured CCRS to use a folder under /tmp [1] which mayhave site-specific persistence policy, e.g., files are cleared after a reboot or after a certain period). Instead, they are keptaround to diagnose any possible issues that may arise. Sometimes the ID — and thus job context — will persist across EARC ’20, July 26–30, 2020, Portland, OR, USA Barker and Mehringer
New Job or Job Action
Container 1 Container 2 Container 3
Create userCreate Job Context: /tmp/.../job-context-dir
Course Web Page
CCRS Element
CCRS
15 2 3 4
DisplayResultsSpawnContainers Read ResultsRun Job
Image specification Image
Fig. 1.
CCRS container lifecycle . Not shown is the container-type-dependent handling of garbage collection for of job contexts,users, and containers. multiple user actions, as is the case for editor-based examples. On the other hand, for single commands, a new job id andcontext will be created each time, though the CCRS API (see below) allows the instructor some flexibility in this regard.Since the job context resides on the host filesystem to be managed by CCRS more readily, all container typessupported by CCRS must support a way to mount directories on the host. Since this is a fairly standard feature, allcontainer types we’ve come across so far support some version of host-filesystem mounts.
The CCRS web service is implemented in Scala and Scala.js (which compiles Scala toJavaScript), allowing a uniform language and RPC (remote procedure call) API for the front-end and back-end; thereis no need to use JavaScript directly, though JavaScript libraries are used in some cases, like Ace editor. As much aspossible, the design has been purely functional and uses the ZIO [15] library to track effects and errors, and to simplifyconcurrency, which improves code reliability and allows for simpler refactors [19, 29].Logging has been implemented for CCRS so that tracking occurs for malicious users’ jobs or any errors that occur inthe container lifecycle, either in the user’s code or in CCRS itself. In the case of errors or normal actions occurring inthe CCRS life cycle, the log contains the job ID, so that the job’s context may be later associated with the relevant logs. sing Containers to Create More Interactive Online Training and Education Materials PEARC ’20, July 26–30, 2020, Portland, OR, USA Instructor’s sites are considered privileged, in that they may create users with a site-specific user prefix and launchjobs. If any aberrant behavior is noticed from an instructor’s site, the site can be temporarily disabled until the issue isresolved.
Instructors may use one of two CCRS APIs to add this functionality to their sites: the JavaScriptAPI or the Scala.js API. We anticipate almost all users will use the JavaScript API, as most users are more familiar withJavaScript, and it requires no additional infrastructure. The JavaScript API simply wraps the Scala.js API, which isthe native implementation of the API. The Scala.js API is still helpful for debugging and development of the API, asexamples can be directly included using dynamically-generated HTML in the CCRS product. If an example is written inScala.js, a corresponding JavaScript example can then be added.To use the API, the page must load the requisite JavaScript code, optionally including ace.js if an editor-basedexample is used on the page: < s c r i p t type = " a p p l i c a t i o n / j a v a s c r i p t " src = " http : / / w. x . y . z : port / ace / ace . j s " charset = " utf − s c r i p t >< s c r i p t type = " a p p l i c a t i o n / j a v a s c r i p t " src = " http : / / w. x . y . z : port / t a r g e t / web − c l i e n t − j s d e p s . j s " >< / s c r i p t >< s c r i p t type = " a p p l i c a t i o n / j a v a s c r i p t " src = " http : / / w. x . y . z : port / t a r g e t / web − c l i e n t − opt . j s " >< / s c r i p t > Implementation of a one-shot command in a web page might look like this: < h2 >Free − form s i n g l e − command i n p u t < / h2 >< input type = " t e x t "p l a c e h o l d e r = " E n t e r ␣ a ␣ command : " value = " pwd " onkeydown = " oneShotHandler ( ev ent ) " / >< / body >< div id = " one − shot − demo " >< / div > First, the input form is created. Then, a div element is created where CCRS will display output information to theuser, such as standard output and standard error.Next, the metadata and input form handler are specified in a script element: < s c r i p t type = " a p p l i c a t i o n / j a v a s c r i p t " >var ccrsApiNamespace =" org . xsede . j o b r u n n e r . model . ModelApi " ;var pythonExampleMetaJson = {" $type " : ccrsApiNamespace + " . SysJobMetaData " ," s h e l l " : [ " bash " ] ," c o n t a i n e r T y p e " : {" $type " : ccrsApiNamespace + " . S i n g u l a r i t y "} ," c o n t a i n e r I d " : [ ] ," image " : [ " vsoch − master − l a t e s t . simg " ] ," b i n d s " : [ ] ," o v e r l a y " : [ ] ," u s e r " : " ccrsdemo " ," a d d r e s s " : [ ] , EARC ’20, July 26–30, 2020, Portland, OR, USA Barker and Mehringer " hostname " : [ ] ," u r l " : window . l o c a t i o n . h r e f} ;var pythonExampleMeta =CCRS . sysJobMetaData ( pythonExampleMetaJson ) ;var o n e S h o t I d = CCRS . makeJobId ( ) ;var oneShotCommand = CCRS . makeOneShotCommand (document . getElementById ( " one − shot − demo " )) ;var oneShotHandler = CCRS . makeCmdHandler (oneShotCommand ,pythonExampleMeta ,o n e S h o t I d) ;< / s c r i p t > The metadata specification includes important coordinates such as the system shell to use in the container, containertype, container id (potentially used when resuming an existing job, such as in a guided session), container image, anduser. In practice, some fields will be filled in by the CCRS client code automatically, such as the address , hostname and url .After the metadata specification, a command output view is created with oneShotCommand , which takes the div element mentioned above as an argument so that it may write job-related information to that div element. Thiscommand handle is then passed to the handler creation makeCmdHandler utility function. Note that creating a joblaunch application using an editor pane is very similar, except that in addition, another script element can be usedto embed code in any given language. Often, the same metadata can be shared between examples, so it need only bedefined once if the same container is used throughout a site. Detailed examples are available in the CCRS repository.An example of a one-shot command application, i.e. an instructional web page with an input box to run a singlecommand, is shown in Figure 2. This application is useful when the instructor wants to walk the student through aseries of commands, or to allow the student to experiment with a list of commands. This could be used when learning anew operating system, compiling code, or for tasks such as file transfer. The example shown demonstrates compiling,then running, a simple MPI program, Hello.c ; in this case we are using && to enter two commands into the one-shotcommand box.Figure 3 is an example of a job launch application, i.e. an instructional web page with an embedded editor pageand code run capability. This example is from instruction on functional programming. The instructor can supply codewhich may be complete, incomplete, or intentionally broken. The student can experiment with the code by editing andrunning in line, learning by experimentation and observation, and following the instructor’s written guidance.In practice, an instructor who wants to implement custom behavior could look at the source of makeOneShotHandler and add custom modifications to create their own job type to interact with CCRS. An example of this is a customguided-session. This admittedly requires some knowledge of JavaScript, but as the usage of CCRS increases, we plan tocreate a higher-level API, primarily for JavaScript users, that provides commonly used job types out of the box, and sing Containers to Create More Interactive Online Training and Education Materials PEARC ’20, July 26–30, 2020, Portland, OR, USA Fig. 2. Implementation of a one-shot command application, showing MPI compile and run of Hello.cFig. 3. Implementation of a job launch application, showing an edit box and run command embedded in the web page with less boiler-plate than what is seen above. This would essentially remove the need to specify the metadata structureexcept for a few necessary fields.
We believe CCRS is best used as a cloud virtual machine. In the case of a compro-mised VM, we can quickly spin up another VM and grant it the floating IP used by the compromised system. At the sametime, we can perform a post-mortem check of the compromised instance while monitoring the live instance for aberrantbehavior. Currently, we host an instance on Cornell’s Red Cloud [24]. A complete template of the system is madeavailable as a configuration.nix file, allowing the system to easily be rebuilt without distributing and hosting a costlyimage, or allowing further customization of the system for parties interested in hosting their own CCRS installation. EARC ’20, July 26–30, 2020, Portland, OR, USA Barker and Mehringer
In rare cases, instructors may wish to go fairly low-level and discuss topics thatare specific to certain architectures. While there is a limit to what can be achieved, if emulators for the platform areavailable (e.g. POWER9 [11] or Intel AVX-512 [8]), then a container that houses the emulator and abstracts away usageof the emulator could be constructed. Since most learning exercises are not intended to be compute-intensive, using anemulator should not typically be a problem. Furthermore, this makes the course materials still accessible and interactiveafter a particular resource is decommissioned or, in rare cases, an emulator may be provided before the HPC resource isbrought online, allowing instructors and students a head start on working with the architecture.
A tool that many in education are familiar with is Jupyter, or its predecessor,iPython Notebook [27, 32]. Jupyter can certainly be an effective tool for learning in the classroom [22] or online. BothCCRS and Jupyter aim to provide a simple and interactive experience for the student. However, there are significantdifferences in Jupyter and in CCRS and, in many cases, CCRS may be the ideal solution, especially when developingcustom courses or training materials. CCRS caters to specialization in two regards: user interface and customizedcontainers.Jupyter presents a convenient notebook-style interface, where results for an in-depth demo can be evaluated, modified,and evaluated again in an iterative fashion. We feel that this is great for a tutorial and can also be useful for some partsof a course, particularly if the course is running one of the standard kernels. While Jupyter’s notebook-style interface isa combination of an editor and REPL, CCRS supports several more standard UI elements that can also be customized byan instructor if desired, as described in Secs 2.2.2 & 2.2.5. It is completely up to the instructor which of the UI elementsto use for each example. JupyterLab [9] presents a customizable MATLAB-like user interface, which is likely suitablefor data exploration and analysis but still doesn’t offer embeddable and customizable UI elements.Unlike Jupyter, CCRS will require the instructor to use a very simple JavaScript API to create interactive examples intheir web pages. We don’t expect this to be much of a burden, especially for what we anticipate to be our most typicalexamples: an editor coupled with some action (e.g. run for Python, or compile and run for C++). We plan to includeample examples so instructors can get up and running with minimum effort.As for customized environments, Jupyter has made great strides over the original IPython, but this flexibility involvesinstalling a custom kernel (which is not a standardized procedure), and in some cases, becoming familiar with creatinga custom kernel, which is much more involved than just creating a container. An example might be creating a kernelthat supports more than one language, which while technically possible, seems to be an ongoing issue as of this writing[6], though BeakerX [2] appears to address the issue for some languages. CCRS supports a variety of container formats.At the time of this writing, there is no Jupyter kernel for running MPI with C, which is one of the prerequisitesfor the MPI course and online book which will utilize CCRS. A goal of CCRS is to provide tests and autograding forsuch environments. Autograding can be accomplished via nbgrader [3] in Jupyter, but it involves the installation ofthird-party software with Jupyter, which in our experience, can result in significant maintenance overhead and does notalways proceed smoothly. In contrast, CCRS is intended to be a single self-contained system; it will be open-source, soextensions can easily be added directly into the codebase, either by forking or hopefully by passing the core developers’review and becoming integrated into the standard CCRS distribution. sing Containers to Create More Interactive Online Training and Education Materials PEARC ’20, July 26–30, 2020, Portland, OR, USA Neither Jupyter nor CCRS inherently addresses the issue of how to install the software being used in a course, whichis often a valuable skill to have. However, if we take, for instance, MPI, many users will never need to install or configureMPI themselves as they may just be running code on HPC clusters where they have access. Other users will wantto learn more about installing their software stack so they can have it on their personal system. For this reason, weadvocate publishing all container types so that users can easily use the container directly, or inspect the containerspecification file so they can see how the environment was constructed; all courses in the pilot will have their containerspecifications made public both through the CCRS GitHub repository and through the associated course.
Apache Zeppelin [18] is similar in its user interface to Jupyter, and is focused on data scienceand primarily is known for Python and Scala notebooks, but much like with Jupyter’s kernels, a custom Interpreterneeds to be created when adding a new programming language or environment (like Apache Spark).
MOOCs (Massive Open Online Courses) often have their own systems in place for running exercises.While we are not competing with MOOCs directly, CCRS provides a technology that could be used by MOOCs underthe hood, just as it could be integrated with almost any site. While many computer science MOOCs exist, some HPCexamples include
Fundamentals of Parallelism on Intel Architecture [4] and
Future Learn: Supercomputing [21].
Additional features are planned for CCRS, including a shell (terminal) emulator, a high-level API to reduce boilerplatefor common examples, improved security features, and the ability to interact with images and other files that may bepart of an example. Security features would include items such as time-to-live, CPU, filesystem, and memory restrictionpolicies, as well as run-time container checks and improved logging. Once the APIs are solidified and known securityfeatures completed, we plan to release CCRS as open-source, allowing CCRS to be hosted at other sites as well as onsystems with exotic hardware.
This work was in part supported by the Extreme Science and Engineering Discovery Environment (XSEDE), which issupported by National Science Foundation grant number ACI-1548562.We also thank Victor Eijkhout at the Texas Advanced Computing Center for being an early user of CCRS in hiscourse.
REFERENCES [1] 2015. . https://refspecs.linuxfoundation.org/FHS_3.0/fhs/ch03s18.html[2] 2018.
BeakerX . http://beakerx.com/[3] 2019. nbgrader âĂŤ nbgrader 0.6.1 documentation . https://nbgrader.readthedocs.io/en/stable/[4] 2020.
Ace - The High Performance Code Editor for the Web . https://ace.c9.io/[6] 2020.
Allowing multiple languages in one notebook Âů Issue . https://github.com/jupyterlab/jupyterlab/issues/2815[7] 2020.
Cornell Virtual Workshop: Containers with C/R . https://cvw.cac.cornell.edu/Checkpoint/containers[8] 2020.
IntelÂő Software Development Emulator | IntelÂő Software . https://software.intel.com/en-us/articles/intel-software-development-emulator[9] 2020. jupyterlab/jupyterlab: JupyterLab computational environment. https://github.com/jupyterlab/jupyterlab[10] 2020.
NixOS manual . https://nixos.org/nixos/manual/
EARC ’20, July 26–30, 2020, Portland, OR, USA Barker and Mehringer [11] 2020.
OpenPOWER Foundation | Introducing IBMÂő POWER9 Functional Simulator . https://openpowerfoundation.org/introducing-ibm-power9-functional-simulator/[12] 2020.
Running Services âĂŤ Singularity container 3.0 documentation . https://sylabs.io/guides/3.0/user-guide/running_services.html?highlight=instance[13] 2020. singularity exec âĂŤ Singularity container 3.5 documentation . https://sylabs.io/guides/3.5/user-guide/cli/singularity_exec.html?highlight=exec[14] 2020. systemd-nspawn zio/zio: ZIO âĂŤ A type-safe, composable library for asynchronous and concurrent programming in Scala . https://github.com/zio/zio[16] Bruno Bzeznik, Oliver Henriot, Valentin Reis, Olivier Richard, and Laure Tavard. 2017. Nix as HPC Package Management System. In
Proceedings ofthe Fourth International Workshop on HPC User Support Tools (Denver, CO, USA) (HUST’17) . Association for Computing Machinery, New York, NY,USA, Article 4, 6 pages. https://doi.org/10.1145/3152493.3152556[17] Ryan Chamberlain and Jennifer Schommer. 2014. Using Docker to Support Reproducible Research. (7 2014). https://doi.org/10.6084/m9.figshare.1101910.v1[18] Yanzhe Cheng, Fang Cherry Liu, Shan Jing, Weijia Xu, and Duen Horng Chau. 2018. Building Big Data Processing and Visualization Pipeline throughApache Zeppelin. In
Proceedings of the Practice and Experience on Advanced Research Computing (Pittsburgh, PA, USA) (PEARC ’18) . Association forComputing Machinery, New York, NY, USA, Article 57, 7 pages. https://doi.org/10.1145/3219104.3229288[19] Coursera. 2020.
Why we love Scala at Coursera - Coursera Engineering - Medium . https://medium.com/coursera-engineering/why-we-love-scala-at-coursera-80fa1fc66d74[20] EELCO DOLSTRA, ANDRES LÃŰH, and NICOLAS PIERRON. 2010. NixOS: A purely functional Linux distribution.
Journal of Functional Programming
20, 5-6 (2010), 577âĂŞ615. https://doi.org/10.1017/S0956796810000195[21] FutureLearn. 2020.
Supercomputing - Online Course
Proceedings of the Practice and Experience inAdvanced Research Computing 2017 on Sustainability, Success and Impact (New Orleans, LA, USA) (PEARC17) . Association for Computing Machinery,New York, NY, USA, Article 32, 9 pages. https://doi.org/10.1145/3093338.3093370[23] Poul Henning Kamp and Robert N. M. Watson. 2000. Jails: Confining the omnipotent root. In
In Proc. 2nd Intl. SANE Conference .[24] Richard Knepper, Susan Mehringer, Adam Brazier, Brandon Barker, and Resa Reynolds. 2019. Red Cloud and Aristotle: Campus Clouds andFederations. In
Proceedings of the Humans in the Loop: Enabling and Facilitating Research on Cloud Computing (Chicago, IL, USA) (HARC ’19) .Association for Computing Machinery, New York, NY, USA, Article 4, 6 pages. https://doi.org/10.1145/3355738.3355755[25] Gregory M. Kurtzer, Vanessa Sochat, and Michael W. Bauer. 2017. Singularity: Scientific containers for mobility of compute.
PLOS ONE
12, 5 (052017), 1–20. https://doi.org/10.1371/journal.pone.0177459[26] Susan Mehringer and Aaron Birkland. 2015. Incorporating Interactive Compute Environments into Web-Based Training Materials Using the CornellJob Runner Service. In
Proceedings of the 2015 XSEDE Conference: Scientific Advancements Enabled by Enhanced Cyberinfrastructure (St. Louis,Missouri) (XSEDE ’15) . Association for Computing Machinery, New York, NY, USA, Article 20, 6 pages. https://doi.org/10.1145/2792745.2792765[27] Michael B. Milligan. 2018. Jupyter as Common Technology Platform for Interactive HPC Services. In
Proceedings of the Practice and Experience onAdvanced Research Computing (Pittsburgh, PA, USA) (PEARC ’18) . Association for Computing Machinery, New York, NY, USA, Article 17, 6 pages.https://doi.org/10.1145/3219104.3219162[28] Daniel Price and Andrew Tucker. 2004. Solaris Zones: Operating System Support for Consolidating Commercial Workloads. In
Proceedings of the18th USENIX Conference on System Administration (Atlanta, GA) (LISA ’04) . USENIX Association, USA, 241âĂŞ254.[29] Adam Warski. 2020.
Happy eyeballs algorithm using ZIO - SoftwareMill Tech Blog . https://blog.softwaremill.com/happy-eyeballs-algorithm-using-zio-120997ba5152[30] Robail Yasrab. 2018. Mitigating Docker Security Issues.
CoRR abs/1804.05039 (2018). arXiv:1804.05039 http://arxiv.org/abs/1804.05039[31] Andy B. Yoo, Morris A. Jette, and Mark Grondona. 2003. SLURM: Simple Linux Utility for Resource Management. In
Job Scheduling Strategies forParallel Processing , Dror Feitelson, Larry Rudolph, and Uwe Schwiegelshohn (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 44–60.[32] Andrea Zonca and Robert S. Sinkovits. 2018. Deploying Jupyter Notebooks at Scale on XSEDE Resources for Science Gateways and Workshops.In
Proceedings of the Practice and Experience on Advanced Research Computing (Pittsburgh, PA, USA) (PEARC ’18)(PEARC ’18)