Murano Application Orchestration
and Catalog for OpenStack
ACCELERATE DEPLOYMENT AND SCALE OF MODERN CROSS-PLATFORM APPS
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 Orchestration and Catalog project that solves this problem for both constituents.
The project was pioneered by Mirantis and developed as an OpenStack community effort and is now available as a Fuel plugin. 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.
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.
Project Murano is tightly integrated with core OpenStack services, including Keystone, Glance, Heat, and Horizon.
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.
Deploy Workloads to Multiple Regions
Murano enables IT users and administrators to orchestrate OpenStack workloads in cross-region environments for application bursting, scaling with disaster recovery and multi-region high availability. When deploying a package from the Murano catalog, simply select which region(s) you want to deploy to. Each region can be configured separately, and applications can have resources in multiple regions, for example to provision a failover component to a separate area.
Achieve 99.99% Application Availability
Murano features an application development framework with the extensible base classes needed to create apps that support key lifecycle management functionalities, including: High Availability and load balancing so apps can continue to run even if an entire cloud goes down; scaling to spin up (or down) additional VMs based on utilization; and self-healing to automatically spin up new VMs if existing VMs die. Developers can build MuranoPL-based applications for on-premise or hybrid clouds using primitives that incorporate best practices.
Accelerate App Development with Validation Tools
Developers can use a set of CLI tools to quickly validate MuranoPL files and Murano packaging structures, enabling faster app development and issue resolution and improved app support. MuranoPL files can be checked for common syntax errors and typos (e.g., invalid YAML file, invalid MuranoPL statements, etc.), while Murano packaging structures can be validated for common packaging errors (e.g., zipped with no -r, missing classes, etc.).
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.
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.
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:
- 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.