Prepare A Lab For Murano

This section provides basic information about lab’s system requirements. It also contains a description of a test which you may use to check if your hardware fits the requirements. To do this, run the test and compare the results with baseline data provided.

System prerequisites

Supported Operation Systems

  • Ubuntu Server 12.04 LTS
  • RHEL/CentOS 6.4

System packages are required for Murano


  • gcc
  • python-pip
  • python-dev
  • libxml2-dev
  • libxslt-dev
  • libffi-dev
  • libmysqlclient-dev
  • libpq-dev
  • python-openssl
  • mysql-client
  • python-mysqldb


  • gcc
  • python-pip
  • python-devel
  • libxml2-devel
  • libxslt-devel
  • libffi-devel
  • postgresql-devel
  • pyOpenSSL
  • mysql
  • MySQL-python

Lab Requirements

Criteria Minimal Recommended
CPU 4 core @ 2.4 GHz 24 core @ 2.67 GHz
RAM 8 GB 24 GB or more
HDD 2 x 500 GB (7200 rpm) 4 x 500 GB (7200 rpm
RAID Software RAID-1 (use mdadm as it will improve read performance almost two times) Hardware RAID-10

Table: Hardware requirements

There are a few possible storage configurations except the shown above. All of them were tested and were working well.

  • 1x SSD 500+ GB

  • 1x HDD (7200 rpm) 500+ GB and 1x SSD 250+ GB (install the system onto

    the HDD and mount the SSD drive to folder where VM images are)

  • 1x HDD (15000 rpm) 500+ GB

Test Your Lab Host Performance

We have measured time required to boot 1 to 5 instances of Windows system simultaneously. You can use this data as the baseline to check if your system is fast enough.

You should use sysprepped images for this test, to simulate VM first boot.

Steps to reproduce test:

  1. Prepare Windows 2012 Standard (with GUI) image in QCOW2 format. Let’s assume that its name is ws-2012-std.qcow2

  2. Ensure that there is NO KVM PROCESSES on the host. To do this, run command:

    ># ps aux | grep kvm
  3. Make 5 copies of Windows image file:

    ># for i in $(seq 5); do \
    cp ws-2012-std.qcow2 ws-2012-std-$i.qcow2; done
  4. Create script in the folder with .qcow2 files:

    [ -z $1 ] || echo "VM count not provided!"; exit 1
    for i in $(seq $1); do
    echo "Starting VM $i ..."
    kvm -m 1024 -drive file=ws-2012-std-$i.qcow2,if=virtio -net user -net nic,model=virtio -nographic -usbdevice tablet -vnc :$i & done
  5. Start ONE instance with command below (as root) and measure time between VM’s launch and the moment when Server Manager window appears. To view VM’s desktop, connect with VNC viewer to your host to VNC screen :1 (port 5901):

    ># ./ 1
  6. Turn VM off. You may simply kill all KVM processes by

    ># killall kvm

7. Start FIVE instances with command below (as root) and measure time interval between ALL VM’s launch and the moment when LAST Server Manager window appears. To view VM’s desktops, connect with VNC viewer to your host to VNC screens :1 thru :5 (ports 5901-5905):

># ./ 5
  1. Turn VMs off. You may simply kill all KVM processes by

    ># killall kvm

Baseline Data

The table below provides baseline data which we’ve got in our environment.

Avg. Time refers to the lab with recommended hardware configuration, while Max. Time refers to minimal hardware configuration.

  Boot ONE instance Boot FIVE instances
Avg. Time 3m:40s 8m
Max. Time 5m 20m

Host Optimizations

Default KVM installation could be improved to provide better performance.

The following optimizations may improve host performance up to 30%:

  • change default scheduler from CFQ to Deadline
  • use ksm
  • use vhost-net

Installing and Running the Development Version

The contrib/devstack directory contains the files necessary to integrate Murano with Devstack.

  1. Follow Devstack documentation to setup a host for Devstack. Then clone Devstack source code.

  2. Copy Murano integration scripts to Devstack:

    $ cp lib/murano ${DEVSTACK_DIR}/lib
    $ cp lib/murano-dashboard ${DEVSTACK_DIR}/lib
    $ cp extras.d/ ${DEVSTACK_DIR}/extras.d
  3. Create a localrc file as input to devstack.

  4. The Murano services are not enabled by default, so they must be enabled in localrc before running This example localrc file shows all of the settings required for Murano:

    # Enable Heat
    enable_service heat h-api h-api-cfn h-api-cw h-eng
    # Enable Murano
    enable_service murano murano-api murano-engine
  5. Deploy your OpenStack Cloud with Murano:

    $ ./

Installing and Running Manually

First you need to install a number of packages with your OS package manager. The list of packages depends on the OS you use.

$ sudo apt-get install python-pip python-dev \
> libmysqlclient-dev libpq-dev \
> libxml2-dev libxslt1-dev \
> libffi-dev


Fedora support wasn’t thoroughly tested. We do not guarantee that Murano will work on Fedora.

$ sudo yum install gcc python-setuptools python-devel python-pip
$ sudo yum install gcc python-setuptools python-devel
$ sudo easy_install pip
$ sudo pip install tox

Murano can use various database types on backend. For development purposes SQLite is enough in most cases. For production installations you should use MySQL or PostgreSQL databases.


Although Murano could use PostgreSQL database on backend, it wasn’t thoroughly tested and should be used with caution.

To use MySQL database you should install it and create an empty database first:

$ apt-get install python-mysqldb mysql-server
$ mysql -u root -p
mysql> CREATE DATABASE murano;
mysql> GRANT ALL PRIVILEGES ON murano.* TO 'murano'@'localhost' \
mysql> exit;
  1. Create a folder which will hold all Murano components.

    $ mkdir ~/murano
  2. Clone the Murano git repository to the management server.

    $ cd ~/murano
    $ git clone
  3. Copy the sample configuration from the source tree to their final location.

    $ cd ~/murano/murano/etc/murano
    $ cp murano.conf.sample murano.conf
  4. Edit murano.conf with your favorite editor. Below is an example which contains basic settings your are likely need to configure.


    The example below uses SQLite database. Edit [database] section if you want to use other database type.

    debug = true
    verbose = true
    rabbit_host = %RABBITMQ_SERVER_IP%
    rabbit_userid = %RABBITMQ_USER%
    rabbit_password = %RABBITMQ_PASSWORD%
    rabbit_virtual_host = %RABBITMQ_SERVER_VIRTUAL_HOST%
    notification_driver = messagingv2
    backend = sqlalchemy
    connection = sqlite:///murano.sqlite
    auth_url = 'http://%OPENSTACK_HOST_IP%:5000/v2.0'
    auth_uri = 'http://%OPENSTACK_HOST_IP%:5000/v2.0'
    auth_host = '%OPENSTACK_HOST_IP%'
    auth_port = 5000
    auth_protocol = http
    admin_tenant_name = %OPENSTACK_ADMIN_TENANT%
    admin_user = %OPENSTACK_ADMIN_USER%
    admin_password = %OPENSTACK_ADMIN_PASSWORD%
    url = http://%YOUR_HOST_IP%:8082
    login = %RABBITMQ_USER%
    password = %RABBITMQ_PASSWORD%
  5. Create a virtual environment and install Murano prerequisites. We will use tox for that. Virtual environment will be created under .tox directory.

    $ cd ~/murano/murano
    $ tox
  6. Create database tables for Murano.

    $ cd ~/murano/murano
    $ tox -e venv -- murano-db-manage \
    > --config-file ./etc/murano/murano.conf upgrade
  7. Open a new console and launch Murano API. A separate terminal is required because the console will be locked by a running process.

    $ cd ~/murano/murano
    $ tox -e venv -- murano-api \
    > --config-file ./etc/murano/murano.conf
  8. Import Core Murano Library.

    $ cd ~/murano/murano
    $ tox -e venv -- murano-manage \
    > --config-file ./etc/murano/murano.conf \
    > import-package ./meta/io.murano
  1. Open a new console and launch Murano Engine. A separate terminal is required because the console will be locked by a running process.

    $ cd ~/murano/murano
    $ tox -e venv -- murano-engine --config-file ./etc/murano/murano.conf
Murano API & Engine services provide the core of Murano. However, your need a control plane to use it. This section decribes how to install and run Murano Dashboard.
  1. Clone the repository with Murano Dashboard.

    $ cd ~/murano
    $ git clone
  2. Create a virtual environment and install dashboard prerequisites. Again, we use tox for that.

    $ cd ~/murano/murano-dashboard
    $ tox
  3. Install the latest horizon version and all murano-dashboard requirements into the virtual environment:

    $ tox -e venv pip install horizon
It may happen, that the last release of horizon will be not capable with latest murano-dashboard code. In that case, horizon need to be installed from master branch of this repository:
  1. Copy configuration file for dashboard.

    $ cd ~/murano/murano-dashboard/muranodashboard/local
    $ cp
  2. Edit configuration file.

    $ cd ~/murano/murano-dashboard/muranodashboard/local
    $ vim ./
    # Provide OpenStack Lab credentials
    # Set secret key to prevent it's generation
    SECRET_KEY = 'random_string'
  1. Update settings file

Running Murano dashboard on developer environment implies the use of murano settings file instead of horizon. However, for the correct setup requires settings file to be synchronized with corresponding horizon release. But murano-dashboard also have parameters, that should be added to that config. So for your convenience, Murano has special script that allows to quickly synchronize Django settings file for a developer installation. file can be found here.

To display all possible options run:

./ --help


Ether output or input parameter should be specified.

  • --input={PATH/TO/HORIZON/SETTINGS/FILE} - settings file to which murano settings would be applied. If omitted, settings from horizon master branch are downloaded.
  • --output={PATH/TO/FILE} - file to store script execution result. Will be overwrite if already exist. If omitted, coincides to the input parameter.
  • --tag - horizon release tag name, applied, if no input parameter is provided.
  • --remove - if set, Murano parameters would be removed from the settings file.
  • --cache-dir={PATH/TO/DIRECTORY} - directory to store intermediate script data. Default is /tmp/muranodashboard-cache.
  • --log-file={PATH/TO/FILE} - file to store the script execution log to a separate file.
  1. Run Django server at or provide different IP and PORT parameters.
$ cd ~/murano/murano-dashboard
$ tox -e venv -- python runserver <IP:PORT>

Development server will be restarted automatically on every code change.

  1. Open dashboard using url http://localhost:8000

Murano provides excellent catalog services, but it also requires applications which to provide. This section describes how to import Murano Applications from Murano App Incubator.

  1. Clone Murano App Incubator repository.

    $ cd ~/murano
    $ git clone
  2. Import every package you need from Murano App Incubator using the command below.

    $ cd ~/murano/murano
    $ tox -e venv -- murano-manage \
    > --config-file ./etc/murano/murano.conf \
    > import-package ../murano-app-incubator/%APPLICATION_DIRECTORY_NAME%

To work with Murano, tenant network in Openstack installation should be configured in a certain way. This configuration may be set up automatically with the provision of several parameters in config file or manually.

Murano has advanced networking features that give you ability to not care about configuring networks for your application. By default it will create an isolated network for each environment and join all VMs needed by your application to that network. To install and configure application in just spawned virtual machine Murano also requires a router connected to the external network.

To create router automatically, provide the following parameters in config file:


external_network = %EXTERNAL_NETWORK_NAME%
router_name = %MURANO_ROUTER_NAME%
create_router = true

To figure out the name of the external network, perform the following command:

$ neutron net-external-list

During the first deploy, required networks and router with specified name will be created and set up.

  • Step 1. Create public network
  • First, you need to check for existence of external networks. Login as admin and go to Project -> Network -> Network Topology. And check network type in network details at Admin -> Networks -> Network name page. The same action can be done via CLI by running neutron net-external-list. To create new external network examine OpenStack documentation.
  • Step 2. Create local network
  • Go to Project -> Network -> Networks.
  • Click Create Network and fill the form.
../_images/2.png ../_images/3.png
  • Step 3. Create router
  • Go to Project -> Network -> Routers
  • Click “Create Router”
  • In the “Router Name” field, enter the murano-default-router

If you specify a name other than murano-default-router, it will be necessary to change the following settings in the config file:


router_name = %SPECIFIED_NAME%
create_router = false
  • Click on the specified router name
  • In the opened view click “Add interface”
  • Specify the subnet and IP address

And check the result in Network Topology tab.