<!--
Verify first that your issue/request is not already reported on GitHub.
Also test if the latest release and main branch are affected too.
Always add information AFTER of these HTML comments, but no need to delete the comments.
-->

##### ISSUE TYPE
<!-- Pick one below and delete the rest -->
 * Bug Report
 * Improvement Request
 * Enhancement Request
 * Feature Idea
 * Documentation Report
 * Other

##### COMPONENT NAME
<!--
Categorize the issue, e.g. API, VR, VPN, UI, etc.
-->
~~~

~~~

##### CLOUDSTACK VERSION
<!--
New line separated list of affected versions, commit ID for issues on main branch.
-->

~~~

~~~

##### CONFIGURATION
<!--
Information about the configuration if relevant, e.g. basic network, advanced networking, etc.  N/A otherwise
-->

##### OS / ENVIRONMENT
<!--
Information about the environment if relevant, N/A otherwise
-->

##### SUMMARY
<!-- Explain the problem/feature briefly -->

##### STEPS TO REPRODUCE
<!--
For bugs, show exactly how to reproduce the problem, using a minimal test-case. Use Screenshots if accurate.

For new features, show how the feature would be used.
-->

<!-- Paste example playbooks or commands between quotes below -->
~~~

~~~

<!-- You can also paste gist.github.com links for larger files -->

##### EXPECTED RESULTS
<!-- What did you expect to happen when running the steps above? -->

~~~

~~~

##### ACTUAL RESULTS
<!-- What actually happened? -->

<!-- Paste verbatim command output between quotes below -->
~~~

~~~
