JuliaRun provides functionality to run and deploy Julia applications in production at scale, including running parallel computing and distributed computing on private or public clusters. JuliaRun works seamlessly with AWS, Microsoft Azure, Google Cloud and can be configured to run with any private cloud.
JuliaRun comes with production and deployment support.
JuliaRun takes the guesswork out of building scalable solutions and can be used by data scientists and engineers with little to no knowledge of how such systems need to be architected. A Julia user can develop an application using JuliaPro and deploy it into a scalable robust deployment environment with a single click.
The table below shows how JuliaRun fares in comparison to it’s contemporaries.
| Feature | JuliaRun | AWS Batch | Azure Batch |
|---|---|---|---|
| Batch Job Orchestrator |  |
|
|
| Interactive Tasks | |
 |
|
| Long running services | |
|
|
| Multi-tenancy | |
|
|
| Uniform API across cloud providers | |
|
|
| Unit of operation | Container | Container | VM |
| Cluster Autoscaling | |
|
|
| Job Autoscaling | |
|
|
| Customizable Autoscaling and Job Scheduling Rules in Julia | |
|
|
| Tools for Log and Metrics Management | Bundled | Via Other AWS Services | Via Other Azure Services |
JuliaRun architecture is designed for two kinds of workloads:
JuliaRun supports two types of cluster managers:
JuliaRun offers other mechanisms of distributed programming, apart from what is possible with core Julia. JuliaRun can revive failed worker nodes of a distributed application. Workers can be requested to join gradually and asynchronously as and when resources are available, with the available workers at any given time continuing to do the work. A distributed application communicating via a failsafe external messaging framework can also recover from failure of the master node. Different Julia applications can be connected together in flexible ways via a queue based messaging framework. That makes it possible to have long running, autoscaled, processing pipelines deployed via JuliaRun.
Making Julia easy to run, and deploy it at scale
JuliaRun provides a great interface to manage both code and packages. It also gives insight into all those packages (and code) with comprehensive application metrics and verbose log management tools.
The user can, with the help of simple and uniform platform independent APIs, use JuliaRun for authentication and multi-tenancy, choose an appropriate storage for data, and let it autoscale (processes and VMs alike), on dynamic node types (GPUs, spot instances, hi-memory, hi-CPU).
Architecture
The robust JuliaRun architecture leverages on open source technologies like Kubernetes and Docker, making it very flexible and easily accessible, via simple Julia APIs.
It is also worth noting all these components are loosely coupled, and easily pluggable anywhere.
A closer look at each of it’s features below will throw more light on how useful it is for someone looking to scale Julia code in production rapidly.
Containers:
JuliaRun lets you easily undertake tasks like building new images, pushing them to your repository, and pre-warming your nodes. All you have to do is update specifications, and fire up a new builder.
Packages:
JuliaRun makes it simple to update, install and precompile packages.
Data Storage:
JuliaRun lets you choose the type of storage (SSD, Network, or RAM) you want, and access them by names and aliases. With the file storage mounted as a drive on containers running in the cluster and optionally on your laptop when needed, accessing code, data and logs becomes easy.
Log Management:
JuliaRun provides APIs to filter, stream and search into distributed application logs at any level of granularity. JuliaRun collects and assimilates logs, and messages from stdout and stderr into a central location and makes realtime operations on it possible via the popular open source analytics tool, ElasticSearch.
Application and System Metrics:
JuliaRun can record metrics as name-value pairs and assists in visualizing, aggregating and plotting them in multiple ways.
JuliaRun uses open source tool InfluxDB as its metrics store and Heapster to collect system metrics. JuliaRun APIs help in aggregating application metrics. Metrics can be visualized in Julia, or other open source technologies like Kibana and Grafana.
Alerts / Notifications:
Alerts and events derived from metrics and logs notify abnormal or extra normal conditions, and enable scaling or powering applications accordingly up or down.
Authentication / Authorization:
OpenID based authentication enables JuliaRun to combine multiple authentication platforms, while Kubernetes enables seamless authorization and resource allocation (using RBACs, Namespaces and Quotas).
Autoscaler:
i) Cluster Autoscaler:
JuliaRun provides fully customizable cluster autoscaler, with features like selecting specific nodes while scaling down to avoid interruption of critical processes, scaling based on resource reservation instead of system load, and keeping configurable headroom to handle workload spikes predictably.
ii) Process Autoscaler:
Autoscaling isn’t just limited to clusters. JuliaRun autoscales processes as well, and makes it fully customizable in Julia. Apart from the standard metrics, it is possible to use custom application published metrics and custom Julia functions to determine scaling factor.
Exposed Services:
JuliaRun includes an authentication proxy that can be dynamically and instantaneously set up to authenticate and route external requests to HTTP services on the cluster. APIs provided as part of JuliaRun register services with the router. Authenticated credentials are passed to the downstream service.
Scheduler:
Apart from all the above features, JuliaRun equips the user to deploy a fully customizable cluster scheduler, when needed for extraordinary scheduling rules. It can be used to direct processes to specific nodes and co-locate them with required resources or other related processes.
Contact us at [email protected] for pricing options.
