Murano Application Orchestration and Catalog for OpenStack


Watch Video: Murano + TOSCA


Developers and IT users want to simply use applications as opposed to installing and managing them. Cloud administrators want to offer a well-tested set of on-demand self-service applications to dramatically reduce their support burden. Project Murano is the OpenStack Application Catalog project that solves this problem for both constituents.

The project was pioneered by Mirantis and developed as an OpenStack community effort. Murano enables IT administrators to publish cloud-ready applications in an online catalog. Developers and IT users can use the catalog to deploy these on-demand applications, reliably and consistently, with a click of a button. Applications can be arbitrarily complex: from individual vSphere or KVM-based VMs to multi-node Linux and Windows distributed applications with many dependent applications and services. Accessible via a GUI and an API, Murano also manages the application lifecycle.

Using the Murano Application Catalog

Why Murano? This new release from the industry’s pure-play OpenStack distribution vendor allows you to operate your cloud with streamlined efficiency through push-button self-service.

Deployment Example:

without Murano

User decides on the mode – stand-alone, replica-group, sharded

For sharded, user chooses shard count, nodes/ shard

IT provisions each server with the right operating system and software packages

IT sets up networking and storage and configure MongoDB to reflect user choices

IT to set up backup & restore, point-in-time recovery, snapshot retention

Users and IT monitor ongoing cluster operation and take care of scaling, healing etc.

IT manually charges the user

with Murano

IT publishes Murano application catalog that encapsulates all of the configuration logic

User answers few configuration questions

Entire multi-node application with all its services, dependent packages, operating system, software configuration and underlying infrastructure in terms of compute VMs, virtual networking, and storage is deployed with a click of a button.

Murano subsequently manages the lifecycle of MongoDB by auto-scaling, self-healing, providing usage statistics for chargeback etc.

Murano In-Depth

Murano provides tools for defining and packaging applications on preconfigured Windows and Linux VMs. Applications can be arbitrarily complex: from individual vCenter or KVM-based VMs equipped for software development, testing or small-scale website deployments, to multi-tier Linux and vCenter applications that auto-scale onto many VMs, self-heal and provide robust support for Big Data analysis and other critical work.

In addition to helping the IT users and administrators, Murano is useful to third-party application developers. The Murano application catalog offers a way to publish applications, including deployment rules and requirements, suggested configurations, output parameters and billing rules, and to track billing and usage information. As customers start to require OpenStack compatibility, third party developers can differentiate themselves by having a ready-to-consume application catalog.

Murano architecture

Project Murano is tightly integrated with core OpenStack services, including Keystone, Glance, Heat, and Horizon.

Murano Application Catalog UI

Murano features a very simple user interface, integrated with OpenStack’s standard Horizon web dashboard. The Application Catalog UI lets users find the applications they need based on category, tags and other attributes. For example, Apache Tomcat, a Java Servlet Container, can be found by searching for the tags: application service, java, servlet.

Once the desired application is found, it can be deployed immediately, or added to a Murano environment defining a multi-tier application, like a LAMP stack for web development.

Application Dynamic UI

Application creators can define and specify the form users fill out when an application is provisioned. The form is defined in a YAML-based file, describing UI entry fields, labels, hints and validation rules.

Specify Environment Configurations and Flavors via a Native OpenStack API

If you don’t want to use the Horizon UI, you also have the option of using an HTTP REST API service to create and use Windows and Linux environments, define services within them, and begin deployment. Any third-party service can use Murano to automatically deploy and dynamically update services on demand.

Provision Windows and Linux Environments with the Push of a Button

After you have selected the services and configured their properties, just push a button and Murano automatically takes care of the rest:

  • Provisioning virtual machines in OpenStack, related storage and networking
  • Installing Windows or Linux distributions
  • Deploying the requested services
  • Making all required configuration changes to make services available

Monitor Deployment Progress and Logs via the Horizon GUI

After your Applications are ready, use the logs to check events from any deployment attempt for a particular environment.

For example, if you are hosting a web application farm, you can check node creation, web server installation, domain controller creation, web application deployment, and other details.

Murano Integration with Heat

Murano deals with applications while Heat orchestrates infrastructure. In fact Murano utilizes an infrastructure orchestration layer such as Heat to provision the underlying VMs, networking and storage. With Murano it is possible to upload applications written in the HOT (Heat Orchestration Template) format. This format is supported by the Murano CLI tool, which automatically generates a proper Murano application package from the HOT template supplied by the user.

Watch a video about Murano integration with Heat Orchestration Templates (HOT).

Murano Pluggable Architecture

Murano also enables the simplified building of compound environments that include multiple interconnected applications, including allowing your application to be integrated with an external service directly and easily through Murano plugins. Murano currently supports two types of plugins. The first provides the ability to extend Murano Programming Language (MuranoPL) classes with Python counterparts, thus making it possible to implement I/O-bound functionality that may not be possible to implement only with MuranoPL. Such plugins can address the following use cases:

Murano plugins enable simplified integration with external services.

  • Providing interaction with external services, for example, a Murano plugin may interact with OpenStack Glance service during deployment to get information about images suitable for deployment.
  • Enabling connections between Murano applications and external hardware, for example, you can develop a plugin that interacts with the API of an external load balancer to enable your applications launch in OpenStack to use that load balancer.
  • Extending core-library class functionality, which is responsible for creating networks, interaction with murano-agent and so on, for example, to create networks with special parameters for all of your applications.

The second type of Murano plugin enable Murano to transparently handle non-MuranoPL packages, for example, HOT (consisting of single HOT template and accompanying files) or TOSCA packages. Such plugins include the functionality to convert non-MuranoPL package formats to MuranoPL on-the-fly.