Murano: Two ways of using Heat HOT snippets in Murano workflow

Murano uses Heat to orchestrate resource provisioning. How can I do this explicitly?

Murano is an Application catalog and it uses underlying orchestration layers to do actual provision for OpenStack resources and software components. Heat is a primary engine which is used to provision OpenStack infrastructure level resources. It can be also used for software provisioning via Heat Software Configs.

Most of the time, resource provisioning is hidden from the application writer by Murano Core library, where all standard resources are wrapped with Murano classes. In case, your application uses your own custom Heat resource you will need to create a workflow in Murano to provision it for your application. Murano provides two easy way to do this. The first way is to embed HOT snippet directly to the Murano workflow. Both Murano and Heat use YAML format, so this embedding will look naturally. Here is an example for a Cinder volume:

- $.environment.reporter.report($this, 'Creating a new volume ')
- $volumename: ('vol_'+$.name)
- $template:
    resources:
      $volumename:
         type: OS::Cinder::Volume
         properties:
           size: $.size            

         description: Volume for stack
- $.environment.stack.updateTemplate($template)
- $.environment.stack.push()

In this example we have a local variable $template which contains HOT resource definition for a Cinder volume resource. Please, make sure you have "resources" as a top level entry for this HOT snippet. It points to the section of the final HOT template where this new resource will be placed.

$volumename here is a local variable which contains a name of the resource. It uses class property $.name to generate a unique name for the resource as there might be multiple volumes created for different VMs. $.name property has a value entered by a user in the UI.

$.environment.stack is a reference for the Heat stack object which contains and manages Heat template which was generated for the Murano environment and updateTemplate is a method which updates a stack template with a new HOT snippet. You still need to push changes of the stack by invoking stack.push() method which will trigger Heat stack update API call.

Another way to use HOT snippets is to keep them as a separate files under Resources folder of the package definition.  There is a way to load these resources in runtime and store them in the local variable. Here is an example:

- $.environment.reporter.report($this, 'Attaching the volume 

                                        to the VM')
- $resources: new(sys:Resources)
- $volumename: ('vol_'+$.name)
- $template: $resources.yaml('attach-volume.hot').bind(dict(
     name => $.name,
     volumename => $volumename,
     instance_name => $instance.name
    ))
- $.environment.stack.updateTemplate($template)
- $.environment.stack.push()

$resources class provides an access to the content of Resource folder of an application definition. "attach-volume.hot" is a file with HOT template snippet which is also parametrized with name, volumename and instance_name parameters which reflects actual resource names for existing or previously created resources. Here is a content of the "attach-volume.hot" file:

resources:
volume_attachment_$name:
type: OS::Cinder::VolumeAttachment
properties:
volume_id: { get_resource: $volumename }
instance_uuid: { get_resource: $instance_name}

Once this snippet is loaded and all parameters are bound to the snippet via .bind() method the $template local variable will contain final version of the snippet with actual resource names. After that we proceed with stack update in the same way we did in the first example via stack.updateTemplate() and stack.push().

Happy coding with Murano!