<!doctype html>
<html lang="en" dir="ltr" class="mdx-wrapper mdx-page plugin-pages plugin-id-default" data-has-hydrated="false">
<head>
<meta charset="UTF-8">
<meta name="generator" content="Docusaurus v2.4.3">
<title data-rh="true">Apache CloudStack Features | Apache CloudStack</title><meta data-rh="true" name="viewport" content="width=device-width,initial-scale=1"><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:url" content="https://cloudstack.apache.org/features"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docusaurus_tag" content="default"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docsearch:docusaurus_tag" content="default"><meta data-rh="true" property="og:title" content="Apache CloudStack Features | Apache CloudStack"><meta data-rh="true" name="description" content="As a mature and turnkey Infrastructure-as-a-Service (IaaS) platform, Apache CloudStack has a comprehensive set of features. This is an extensive, but not exhaustive, set of features."><meta data-rh="true" property="og:description" content="As a mature and turnkey Infrastructure-as-a-Service (IaaS) platform, Apache CloudStack has a comprehensive set of features. This is an extensive, but not exhaustive, set of features."><link data-rh="true" rel="icon" href="/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://cloudstack.apache.org/features"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/features" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/features" hreflang="x-default"><link rel="alternate" type="application/rss+xml" href="/blog/rss.xml" title="Apache CloudStack RSS Feed">
<link rel="alternate" type="application/atom+xml" href="/blog/atom.xml" title="Apache CloudStack Atom Feed">






<script src="scripts/bootstrap.bundle.min.js" async></script><link rel="stylesheet" href="/assets/css/styles.e12efb83.css">
<link rel="preload" href="/assets/js/runtime~main.d78c67af.js" as="script">
<link rel="preload" href="/assets/js/main.8e0276ef.js" as="script">
</head>
<body class="navigation-with-keyboard">
<script>!function(){function t(t){document.documentElement.setAttribute("data-theme",t)}var e=function(){var t=null;try{t=new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}return t}()||function(){var t=null;try{t=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}()</script><div id="__docusaurus">
<div role="region" aria-label="Skip to main content"><a class="skipToContent_fXgn" href="#__docusaurus_skipToContent_fallback">Skip to main content</a></div><nav aria-label="Main" class="navbar navbar--fixed-top"><div class="navbar__inner"><div class="navbar__items"><button aria-label="Toggle navigation bar" aria-expanded="false" class="navbar__toggle clean-btn" type="button"><svg width="30" height="30" viewBox="0 0 30 30" aria-hidden="true"><path stroke="currentColor" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M4 7h22M4 15h22M4 23h22"></path></svg></button><a class="navbar__brand" href="/"><div class="navbar__logo"><img src="/img/navlogo.png" alt="apache-cloudstack" class="themedImage_ToTc themedImage--light_HNdA"><img src="/img/navlogo.png" alt="apache-cloudstack" class="themedImage_ToTc themedImage--dark_i4oU"></div><b class="navbar__title text--truncate"></b></a></div><div class="navbar__items navbar__items--right"><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">About</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/about">About</a></li><li><a class="dropdown__link" href="/history">History</a></li><li><a class="dropdown__link" href="/features">Features</a></li><li><a class="dropdown__link" href="/who">Who We Are</a></li><li><a class="dropdown__link" href="/bylaws">Community Bylaws</a></li><li><a class="dropdown__link" href="/trademark-guidelines">Trademark Guidelines</a></li><li><a class="dropdown__link" href="/security">Security</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Community</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/contribute">Get Involved</a></li><li><a class="dropdown__link" href="/developers">Developer Resources</a></li><li><a class="dropdown__link" href="/mailing-lists">Join Mailing Lists</a></li><li><a href="https://github.com/apache/cloudstack/issues" target="_blank" rel="noopener noreferrer" class="dropdown__link">Issues Tracker<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://join.slack.com/t/apachecloudstack/shared_invite/zt-1u8qwbivp-u16HRI~LWioLmF1G2D3Iyg" target="_blank" rel="noopener noreferrer" class="dropdown__link">Community Slack<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a class="dropdown__link" href="/events">Events and Meetups</a></li><li><a href="https://www.cloudstackcollab.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Collab Conference<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Use Cases</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/cloud-builders">Cloud Builders</a></li><li><a class="dropdown__link" href="/kubernetes">Kubernetes</a></li><li><a class="dropdown__link" href="/integrations">Integrations</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Users</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/users">Known Users</a></li><li><a class="dropdown__link" href="/blog/tags/case-studies">Case Studies</a></li><li><a href="https://docs.google.com/forms/d/e/1FAIpQLScPHIRetdt-pxPT62IesXMoQUmhQ8ATGKcYZa507mB9uwzn-Q/viewform" target="_blank" rel="noopener noreferrer" class="dropdown__link">Take Survey<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Documentation</a><ul class="dropdown__menu"><li><a href="https://docs.cloudstack.apache.org" target="_blank" rel="noopener noreferrer" class="dropdown__link">CloudStack Documentation<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Home" target="_blank" rel="noopener noreferrer" class="dropdown__link">Project Wiki<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Books" target="_blank" rel="noopener noreferrer" class="dropdown__link">CloudStack Books<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a class="dropdown__link" href="/api/">API Documentation</a></li></ul></div><a class="navbar__item navbar__link" href="/downloads">Download</a><a class="navbar__item navbar__link" href="/blog">Blog</a><a href="https://github.com/apache/cloudstack" target="_blank" rel="noopener noreferrer" class="navbar__item navbar__link header-github-link" aria-label="GitHub repository"></a><div class="searchBox_ZlJk"><div class="navbar__search searchBarContainer_NW3z"><input placeholder="Search" aria-label="Search" class="navbar__search-input"><div class="loadingRing_RJI3 searchBarLoadingRing_YnHq"><div></div><div></div><div></div><div></div></div><div class="searchHintContainer_Pkmr"><kbd class="searchHint_iIMx">ctrl</kbd><kbd class="searchHint_iIMx">K</kbd></div></div></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">ASF</a><ul class="dropdown__menu"><li><a href="https://www.apache.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Foundation</a></li><li><a href="https://www.apache.org/licenses/" target="_blank" rel="noopener noreferrer" class="dropdown__link">License</a></li><li><a href="https://www.apache.org/events/current-event" target="_blank" rel="noopener noreferrer" class="dropdown__link">Events</a></li><li><a href="https://www.apache.org/security/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Security</a></li><li><a href="https://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Sponsorship</a></li><li><a href="https://www.apache.org/foundation/policies/privacy.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Privacy</a></li><li><a href="https://www.apache.org/foundation/thanks.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Thanks</a></li></ul></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div id="__docusaurus_skipToContent_fallback" class="main-wrapper mainWrapper_z2l0"><main class="container container--fluid margin-vert--lg"><div class="row mdxPageWrapper_j9I6"><div class="col col--8"><article><h1>☁️ Apache CloudStack Features</h1><p>As a mature and turnkey Infrastructure-as-a-Service (IaaS) platform, Apache CloudStack has a comprehensive set of features. This is an extensive, but not exhaustive, set of features. </p><p>Have a feature request? We&#x27;d invite you to <a href="/mailing-lists">bring it up on the mailing list</a>, and consider <a href="https://github.com/apache/cloudstack/issues" target="_blank" rel="noopener noreferrer">filing a feature request in our issue tracker</a>.</p><h2>Rich Management User Interface</h2><p>CloudStack provides a feature-rich out-of-the-box user interface implemented on
top of the CloudStack API to manage the cloud infrastructure. It is a fully AJAX
based solution compatible with most of the latest internet browsers and can also
be easily integrated with your existing portal.</p><h2>Brand-able Self Service User Interface</h2><p>Our out-of-the-box user interface was built using standard HTML and CSS with
jQuery as our standard JavaScript library. It can be easily customized and
branded to mirror your company’s existing look and feel.</p><h2>Secure Console Access</h2><p>A noVNC based client that allows users to access their virtual machine using any
of the latest internet browsers without the need of any external add-on such as
a JRE, ActiveX, or Flash.</p><h2>Powerful API</h2><p>Easily build, integrate, and use applications built on top of the CloudStack
API. The CloudStack API is well-documented and extensible. CloudStack also
includes support for the Amazon EC2 and S3 APIs.</p><h2>Secure Single Sign On</h2><p>Aggregate and integrate your existing applications with our management user
interface via our secure single sign-on for a better user experience.</p><h2>Multi-role Support</h2><p>Three distinct account roles for user interface and API access are supported out-of-the-box:</p><ul><li>Admin: can manage both the virtual and physical resources of the cloud</li><li>Domain-Admin: can manage only the virtual resources owned by the accounts within their domain</li><li>User: can manage their own virtual resources</li></ul><p>In addition, CloudStack allows operators to define dynamic roles based on these core role types.</p><h2>On Demand Virtual Data center Hosting</h2><p>Provides users with virtually unlimited amount of computing resources – on
demand, as required and billed by actual usage.</p><h2>Dynamic Workload Management</h2><p>Completely automates the distribution of compute, network, and storage resource
across the physical infrastructure while adhering to defined policies on load
balancing, data security, and compliance.</p><h2>Broad network Virtualization Capabilities</h2><p>Support for embedded software-based network management as well as VLAN. Our
Direct Attached IP enables you to integrate with a virtual network architecture
that best fits your needs.</p><h2>MPLS Support in the Cloud</h2><p>CloudStack allows you to dedicate an entire VLAN to a specific account for MPLS
support between network nodes.</p><h2>Secure Cloud Deployments</h2><p>Ensures that all memory, CPU, network, and storage resources are both available
and isolated from one user account to another within the cloud.</p><h2>Hypervisor Agnostic</h2><p>CloudStack provides you with the flexibility to allow you to integrate with the
major hypervisors in the market today including KVM, VMware, Citrix
XenServer, XCP-ng.</p><h2>Easy Template Creation Process</h2><p>The CloudStack User Interface allows you to easily create pre-defined templates
for efficient virtual machine deployments. Templates can be created by attaching
a guest OS ISO to a blank VM or directly from existing VMs in the cloud.</p><h2>Rich Template and ISO Management</h2><p>Both users and administrators will be able to upload and manage their OS
templates and ISO images from within the cloud. A few management features
include the ability to allow others to use the templates/ISOs either on a global
public level or on a per-account basis, and to allow the management of templates
across multiple zones. CloudStack will ensure that templates are automatically
copied to the appropriate storage servers.</p><h2>Domains and Delegated Administration</h2><p>The support for domains allows you to segregate your cloud resources and
delegate the management of these domains to other administrators.</p><h2>Snapshot Management</h2><p>To help mitigate data loss and a way of disaster recovery, users are given the
capability of either taking ad hoc snapshots of their disk volumes or setting up
a comprehensive schedule for taking periodic snapshots of their data. Users can
set limits to the number of snapshots taken to creating new data disk volumes
from existing snapshots.</p><h2>Comprehensive Service Management</h2><p>Administrators can define, meter, deploy, and manage multiple service and disk
offerings within the cloud.</p><h2>VM Sync and High Availability</h2><p>Our custom VM Sync technology constantly monitors and maintains the state of all
virtual machines within the cloud from notifications of individual VM status to
the ability to automatically ensure that the VM remains running.</p><h2>Resource Over Provisioning and Limits</h2><p>By leveraging existing hypervisor, storage, and network technologies, you can
configure the cloud to allow over provisioning of physical resources to optimize
the allocation of your virtual machines.</p><p>CloudStack also provides administrators the capability of limiting virtual
resources (such as the number of VMs that an account can create to the number of
public IP addresses an account can own).</p><h2>Usage Metering</h2><p>Be able to deliver real-time visibility, produce historical usage reports, and
create billing invoices by integrating with metering data generated by the
CloudStack Usage Engine.</p><h2>Alerts and Notifications</h2><p>With built-in cloud system monitoring processes, you will be able to receive
up-to-the-minute alerts such as reaching a certain physical resource threshold
or detecting machine failures through the CloudStack API and/or via email using
SMTP.</p><h2>Virtual Routers, Firewalls and Load Balancers</h2><p>CloudStack supports integration with both software and hardware firewalls and
load balancers to provide additional security and scalability to a user’s cloud
environment. Including F5 and Netscaler.</p><h2>Multiple Storage Solutions</h2><p>CloudStack supports many storage solutions with  iSCSI and NFS being preferred,
but anything that can have multiple nodes mount it simultaneously will work.
Ceph RBD is also supported in combination with the KVM hypervisor. This gives
you the ultimate freedom in deciding your storage servers from using commodity
hardware to integrating with enterprise-grade solutions such as Dell EqualLogic,
NetApp, Dell/EMC PowerFlex, Linbit, Storpool.</p><h2>Storage Tiering</h2><p>As part of the CloudStack’s ability to integrate with multiple storage
solutions, you will also be able to target specific storage servers to be used
for VM deployments. This can be extremely beneficial when you have storage
servers built with commodity hardware to support non disk intensive applications
and dedicate fast and robust hardware for disk intensive applications such as
databases.</p><h2>Block Storage Volumes</h2><p>CloudStack supports the creation of block storage volumes of arbitrary size on
both network attached storage (NAS) or local disk that can be attached and
detached to and from your virtual machine.</p><h2>Wide Range Guest VM OS Support</h2><p>Depending on the configured hypervisor, CloudStack supports a wide range of
guest operating system including Windows®, Linux®, and various versions of BSD®.</p><h2>Event/Audit Logs</h2><p>All user interactions via the CloudStack UI or API are recorded as events. Each
event will indicate the type, severity level, description, owner of the
resource, the user that initiated the action, and when the event occurred.</p><h2>User Data Support</h2><p>CloudStack supports the notion of allowing a user to submit any type of binary
user data when deploying a new virtual machine. This gives you the flexibility
of giving each virtual machine created from the same OS template its own
identity in the cloud.</p><h2>Guest OS Preferences</h2><p>To take advantage of today’s hardware and OS licensing models, CloudStack allows
administrators to identify physical hosts to “prefer” specific operating
systems. For example this means that whenever possible, your Windows based
operating systems will be instantiated on all hosts that have been identified as
Windows “preferred.”</p><h2>Host Maintenance with Live Migration</h2><p>Upgrades and hardware maintenance can be achieved on the cloud with no downtime
for guest VMs. CloudStack will live-migrate any VMs from hosts that have been
targeted for maintenance to prevent any disruption of service.</p><h2>Flexible Adapter Framework</h2><p>The CloudStack was built from the ground up to support integration with a
variety of hypervisors, storage, network, and authentication solutions. Due to
this flexibility, we have created an Adapter Framework that will easily allow
you to further customize the cloud to suit your business needs.</p><h2>Random Password for Guest OS</h2><p>You can further enhance your guest OS templates to include our custom random
password feature that will automatically generate a unique password upon the
creation of a VM. This will allow your customers to securely log in and change
their password. Both Windows and Linux based OS platforms are currently
supported.</p><h2>OpenStack Swift Integration for Secondary Storage</h2><p>Secondary storage (templates and VM snapshots) can be stored in OpenStack Swift
as an alternative to NFS.</p><h2>Projects</h2><p>Allow users to collaborate and share resources within a defined group or
&quot;project&quot;. When a user creates an a project all usage under the project is
attributed to the account who becomes the project owner.</p><h2>Clustered LVM Support</h2><p>CloudStack can utilize clustered Logical Volume Manager (LVM) storage
configurations starting with version 3.0.</p><h2>NetScaler Support</h2><p>CloudStack supports MPX, VPX &amp; SDX devices. Users can set up Layer-4 load
balancing rules. Supported protocols: HTTP, TCP &amp; UDP; Algorithms: least loaded
and round robin; Persistent sessions: source IP based, cookie based.</p><h2>Network As a Service</h2><p>Admin can compose network offerings with different network behaviors. For
example, a basic network offering with CloudStack Virtual Router offering
network services and a high-performance network offering with physical devices
such as NetScaler and Juniper SRX. Users can select the network offering of
choice while deploying a VM and also migrate VMs from one network offering to
another.</p><h2>SAML and LDAP Integration with 2FA</h2><p>CloudStack supports SAML LDAP authentication as a built-in optional AUTH adapter.
CloudStack also supports two-factor authentication.</p><h2>Notification &amp; Capacity Thresholds</h2><p>Admin can set notification threshold to receive an alert when resource pool
crosses the notification threshold. Capacity threshold prevents CloudStack from
allocating further resources to that pool.</p></article></div></div></main></div><footer class="footer footer--dark"><div class="container container-fluid"><div class="footer__bottom text--center"><div class="margin-bottom--sm"><a href="https://cloudstack.apache.org/" rel="noopener noreferrer" class="footerLogoLink_BH7S"><img src="/img/ACS_logo_slogan.svg" alt="Apache CloudStack logo" class="themedImage_ToTc themedImage--light_HNdA footer__logo"><img src="/img/ACS_logo_slogan.svg" alt="Apache CloudStack logo" class="themedImage_ToTc themedImage--dark_i4oU footer__logo"></a></div><div class="footer__copyright">
            <div class="social">
                <a href="mailto:dev-subscribe@cloudstack.apache.org">
		  <img src="/img/mail_mini_icon.svg" alt="">
		</a>
                <a href="https://join.slack.com/t/apachecloudstack/shared_invite/zt-2aegc22z7-tPCxpptfcebTBtd59qcZSQ">
		  <img src="/img/slack_mini_icon.svg" alt="">
		</a>
                <a href="https://github.com/apache/cloudstack">
		  <img src="/img/git_mini_icon.svg" alt="">
		</a>
                <a href="https://twitter.com/CloudStack">
		  <img src="/img/twitter_X_mini_icon.svg" alt="">
		</a>
                <a href="https://www.youtube.com/@ApacheCloudStack">
		  <img src="/img/youtube_mini_icon.svg" alt="">
		</a>
                <a href="https://www.linkedin.com/company/apachecloudstack/posts/">
		  <img src="/img/linkedin_icon.svg" alt="">
		</a>
            </div>
            <div class="footer-bottom">Copyright © 2023 The Apache
Software Foundation, Licensed under the Apache License, Version 2.0.
“Apache”, “CloudStack”, “Apache CloudStack”, the Apache CloudStack logo,
 the Apache CloudStack Cloud Monkey logo and the Apache feather logos
are registered trademarks or trademarks of The Apache Software
Foundation.
            <p class="footer-blue"><a href="/trademark-guidelines">Apache CloudStack Trademark Usage</a> - <a href="/bylaws">Apache CloudStack Community ByLaws</a> - <a href="https://github.com/apache/cloudstack-www">Website Source Code</a></p></div>
            </div>
          <br>
          </div></div></footer></div>
<script src="/assets/js/runtime~main.d78c67af.js"></script>
<script src="/assets/js/main.8e0276ef.js"></script>
</body>
</html>