<div class="row">
	<div class="col-lg-12">
		<div class="page-header">
			<h1 id="indicators">Apache CloudStack: About</h1>
		</div>

	</div>
</div>

<h1 id="what-is-apache-cloudstack">What is Apache CloudStack?</h1>

<p>Apache CloudStack is a top-level project of the Apache Software Foundation (ASF). The project develops open source software for deploying public and private Infrastructure-as-a-Service (IaaS) clouds.</p>

<p>CloudStack provides an open and flexible cloud orchestration platform to deliver reliable and scalable private and public clouds. What's that <em>mean</em>, exactly?</p>

<h1 id="features-and-functionality">Features and Functionality</h1>

<p>Apache CloudStack is a Java-based project that provides a management server and agents (if needed) for hypervisor hosts so that you can run an IaaS cloud. Some, but not all, of the features and functionality provided by CloudStack:</p>

<ul>
  <li>Works with hosts running XenServer/XCP, KVM, Hyper-V, and/or VMware ESXi with vSphere</li>
  <li>Provides a friendly Web-based UI for managing the cloud</li>
  <li>Provides a native <a href="/docs/api/">API</a></li>
  <li>May provide an Amazon S3/EC2 compatible API (optional)</li>
  <li>Manages storage for instances running on the hypervisors (primary storage) as well as templates, snapshots, and ISO images (secondary storage)</li>
  <li>Orchestrates network services from the data link layer (L2) to some application layer (L7) services, such as DHCP, NAT, firewall, VPN, and so on</li>
  <li>Accounting of network, compute, and storage resources</li>
  <li>Multi-tenancy/account separation</li>
  <li>User management</li>
</ul>

<p>In short, organizations can use Apache CloudStack to deploy a full-featured public or private IaaS cloud.</p>

<h1 id="people-of-apache-cloudstack">People of Apache CloudStack</h1>

<p>Apache projects are managed by a <a href="http://www.apache.org/dev/pmc.html#what-is-a-pmc">Project Management Committee</a> (PMC), and much of the work is done by the project's <a href="http://www.apache.org/dev/committers.html">committers</a>. Note that committer status is <em>not</em> limited to developers, but is conferred to individuals who have made sustained contributions of high quality, and have shown a committment to mentoring other contributors and following <a href="http://theapacheway.com">The Apache Way</a>.</p>

<p>The current Vice President of Apache CloudStack and chair of the PMC is Sebastien Goasguen, a full list of PMC members and contributors is available on the page <em><a href="/who.html">Who We Are</a></em>.</p>
