The Murano project keeps moving forward and is now an official OpenStack project. Progress has grown apace over the last several months, starting with new developments spawned at the Murano hackathon during the OpenStack Summit in Atlanta. In addition to other changes such as the inclusion of Kubernetes as an application, the project team has successfully extended Murano to support deployment of applications defined with Heat templates.
Murano is an application catalog from which you can publish cloud-ready applications that are defined in different formats, such as the Heat templates. It provides a user interface and APIs to construct and deploy composite environments on the application abstraction level, then manages their lifecycle. Heat interacts with Murano as an OpenStack orchestration program that launches composite cloud environments using either an OpenStack-native RESTful API or an AWS CloudFormation-compatible Query API.
You can take a look at a the video below for a demonstration of how these Heat applications work and how you can create them. We discuss the details here to give you a good starting point for cloud automation.
Murano and Heat, together at last
Cloud providers have been using automation for Heat-based applications for a few years, and support for them in Murano has been a high priority. As the first step toward application provisioning with Murano, Heat delivered the HOT software configuration feature in the OpenStack Icehouse release. HOT packages provide the blueprints to orchestrate Heat-based application deployment and include:
Create a Heat template
During the Murano hackathon at the Atlanta Summit, the Murano project team added proof-of-concept-level support for applications described by Heat templates that were created with HOT DSL. Heat templates for both OpenStack and proprietary systems must be written in HOT DSL, which includes a simple RESTful API that identifies what to deploy and orchestrate rather than just how to deploy and orchestrate.
You can find Heat templates with examples of software configuration use in the heat-templates repository. Select one and use it in Heat to see if it meets your needs, then create a package with it and upload the package to the Murano application catalog as described below.
Create a package from a Heat Template
The easiest way to create a package from your Heat template is to use the python Murano client as follows:
user@machine:~$ murano package-create –template wordpress/template.yaml
Use the following optional parameters to configure more application details:
–name: Application name, copied from the template by default
–logo: Application square logo, which defaults to the generic app logo
–description: Textual application information that is copied by default from the template.
–author: Name of application author
–output: Name of the output file archive to save locally
–full-name: Fully qualified package name that specifies the exact and unique application name, such as, io.murano.apps.linux.Telnet
When you run package-create as shown above, the client takes your template and creates the application package, which you can then upload directly to Murano.
Upload the package to the Murano application catalog
You are now ready to upload the application to the Murano application catalog. See this video for a demo on the upload process in the dashboard. If uploading via the Murano CLI, use the following instructions:
Provide a category for the application. Run the following to browse all categories: murano category-list
Specify any suitable category and path to the application archive:
murano package-import –category=Web wordpress.zip
The process is easy and we encourage you to automate your applications with Heat templates in the cloud, as well as take advantage of the benefits of having your application in the Murano catalog, including:
Application sharing with other cloud users in a browsable, categorized catalog
Push-button application deployment
Coordination of application creation with others
While our first priority for Murano is integrating Heat, we are also evaluating increased support orchestration backends in Murano for TOSCA, APS, and others. In the meantime, applications based on Heat templates have all the power of Heat orchestration. The only difference between a Heat stack and a Heat application deployed in Murano is that Murano adds a small wrapper layer that hands the template, as is, to Heat to process. Murano then waits until Heat has finished deployment before reporting back to the user.