<!doctype html>
<html lang="en" dir="ltr" class="blog-wrapper blog-tags-post-list-page plugin-blog plugin-id-default" data-has-hydrated="false">
<head>
<meta charset="UTF-8">
<meta name="generator" content="Docusaurus v2.4.3">
<title data-rh="true">57 posts tagged with &quot;announcement&quot; | 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/blog/tags/announcement/page/3"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" property="og:title" content="57 posts tagged with &quot;announcement&quot; | Apache CloudStack"><meta data-rh="true" name="docusaurus_tag" content="blog_tags_posts"><meta data-rh="true" name="docsearch:docusaurus_tag" content="blog_tags_posts"><link data-rh="true" rel="icon" href="/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://cloudstack.apache.org/blog/tags/announcement/page/3"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/tags/announcement/page/3" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/tags/announcement/page/3" 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/announcement/page/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"><div class="container margin-vert--lg blog-container"><div class="row"><aside class="col col--3"><nav class="sidebar thin-scrollbar"><div class="sidebarItemTitle margin-bottom--md">CloudStack Blog</div><ul class="sidebarItemList clean-list"><li class="sidebarItem"><a class="sidebarItemLink" href="/blog">All Posts</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/news">News</a></li><li class="sidebarItem"><a aria-current="page" class="sidebarItemLink sidebarItemLinkActive" href="/blog/tags/announcement">Announcements</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/roundup">Past Events</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/case-studies">Case Studies &amp; Integrations</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/community">Meet the Community</a></li></ul></nav></aside><main class="col col--7" itemscope="" itemtype="http://schema.org/Blog"><header class="margin-bottom--xl"><h1>57 posts tagged with &quot;announcement&quot;</h1><a href="/blog/tags">View All Tags</a></header><article class="margin-bottom--xl" itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="The Apache Software Foundation Announces Apache® CloudStack® v4.16"><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/the-apache-software-foundation-announces3">The Apache Software Foundation Announces Apache® CloudStack® v4.16</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2021-11-15T00:00:00.000Z" itemprop="datePublished">November 15, 2021</time></div></header><div class="markdown" itemprop="articleBody"><b>The Apache Software Foundation Announces Apache® CloudStack® v4.16</b><p>&quot;In the past years, CloudStack has been proving a mature and
easy-to-use platform. The released 4.16.0.0 LTS adds new features,
enhancements, and bug fixes that will help tech-savy companies stay up
to date.&quot; said Gabriel Brascher, Vice President of Apache CloudStack.</p></div><footer class="row docusaurus-mt-lg"><div class="col col--9"><b>Tags:</b><ul class="tags_jXut padding--none margin-left--sm"><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/announcement">announcement</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about The Apache Software Foundation Announces Apache® CloudStack® v4.16" href="/blog/the-apache-software-foundation-announces3"><b>Read More</b></a></div></footer></article><article class="margin-bottom--xl" itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="Apache CloudStack, proven as one of the most scalable, free, and open source cloud computing operating system for large scale private, public, and hybrid clouds, today announced the availability of the latest release of Apache CloudMonkey v6.2.0, the latest version of the turnkey enterprise Cloud orchestration platform&#x27;s command line interface tool."><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/apache-cloudstack-cloudmonkey-v6-2">Apache CloudStack CloudMonkey v6.2.0 Release</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2021-10-05T00:00:00.000Z" itemprop="datePublished">October 5, 2021</time></div></header><div class="markdown" itemprop="articleBody"><p>Apache CloudStack, proven as one of the most scalable, free, and open source cloud computing operating system for large scale private, public, and hybrid clouds, today announced the availability of the latest release of Apache CloudMonkey v6.2.0, the latest version of the turnkey enterprise Cloud orchestration platform&#x27;s command line interface tool.</p></div><footer class="row docusaurus-mt-lg"><div class="col col--9"><b>Tags:</b><ul class="tags_jXut padding--none margin-left--sm"><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/announcement">announcement</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about Apache CloudStack CloudMonkey v6.2.0 Release" href="/blog/apache-cloudstack-cloudmonkey-v6-2"><b>Read More</b></a></div></footer></article><article class="margin-bottom--xl" itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="The Apache CloudStack project is pleased to announce the release ofCloudStack 4.15.2.0."><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/apache-cloudstack-lts-maintenance-release2">Apache CloudStack LTS Maintenance Release 4.15.2.0</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2021-09-20T00:00:00.000Z" itemprop="datePublished">September 20, 2021</time></div><div class="margin-top--md margin-bottom--sm row"><div class="col col--6 authorCol_Hf19"><div class="avatar margin-bottom--sm"><a href="https://github.com/rohityadavcloud" target="_blank" rel="noopener noreferrer" class="avatar__photo-link"><img class="avatar__photo" src="https://github.com/rohityadavcloud.png" alt="Rohit Yadav" itemprop="image"></a><div class="avatar__intro" itemprop="author" itemscope="" itemtype="https://schema.org/Person"><div class="avatar__name"><a href="https://github.com/rohityadavcloud" target="_blank" rel="noopener noreferrer" itemprop="url"><span itemprop="name">Rohit Yadav</span></a></div><small class="avatar__subtitle" itemprop="description">PMC Member</small></div></div></div></div></header><div class="markdown" itemprop="articleBody"><p>The Apache CloudStack project is pleased to announce the release ofCloudStack 4.15.2.0.</p><p>The CloudStack 4.15.2.0 release is a maintenance release as part of its
4.15.x  LTS branch and contains more than 75 fixes and improvements since
the CloudStack 4.15.0.0 release.</p></div><footer class="row docusaurus-mt-lg"><div class="col col--9"><b>Tags:</b><ul class="tags_jXut padding--none margin-left--sm"><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/announcement">announcement</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about Apache CloudStack LTS Maintenance Release 4.15.2.0" href="/blog/apache-cloudstack-lts-maintenance-release2"><b>Read More</b></a></div></footer></article><article class="margin-bottom--xl" itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="The Apache CloudStack project is pleased to announce the release of CloudStack 4.15.1.0."><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/apache-cloudstack-lts-maintenance-release1">Apache CloudStack LTS Maintenance Release 4.15.1.0</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2021-07-08T00:00:00.000Z" itemprop="datePublished">July 8, 2021</time></div><div class="margin-top--md margin-bottom--sm row"><div class="col col--6 authorCol_Hf19"><div class="avatar margin-bottom--sm"><a href="https://github.com/rohityadavcloud" target="_blank" rel="noopener noreferrer" class="avatar__photo-link"><img class="avatar__photo" src="https://github.com/rohityadavcloud.png" alt="Rohit Yadav" itemprop="image"></a><div class="avatar__intro" itemprop="author" itemscope="" itemtype="https://schema.org/Person"><div class="avatar__name"><a href="https://github.com/rohityadavcloud" target="_blank" rel="noopener noreferrer" itemprop="url"><span itemprop="name">Rohit Yadav</span></a></div><small class="avatar__subtitle" itemprop="description">PMC Member</small></div></div></div></div></header><div class="markdown" itemprop="articleBody"><p>The Apache CloudStack project is pleased to announce the release of CloudStack 4.15.1.0.
The CloudStack 4.15.1.0 release is a maintenance release as part of its 4.15.x  LTS branch and contains more than 350  fixes and improvements since the CloudStack 4.15.0.0 release.</p></div><footer class="row docusaurus-mt-lg"><div class="col col--9"><b>Tags:</b><ul class="tags_jXut padding--none margin-left--sm"><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/announcement">announcement</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about Apache CloudStack LTS Maintenance Release 4.15.1.0" href="/blog/apache-cloudstack-lts-maintenance-release1"><b>Read More</b></a></div></footer></article><article class="margin-bottom--xl" itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="The Apache CloudStack project is pleased to announce the release of"><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/apache-cloudstack-lts-maintenance-release">Apache CloudStack LTS Maintenance Release 4.14.1.0</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2021-03-03T00:00:00.000Z" itemprop="datePublished">March 3, 2021</time></div></header><div class="markdown" itemprop="articleBody"><p>The Apache CloudStack project is pleased to announce the release of
CloudStack 4.14.1.0 as part of its LTS 4.14.x releases. The CloudStack
4.14.1.0 release is a maintenance release and contains more than
100 fixes and improvements since the CloudStack 4.14.0.0 release.</p></div><footer class="row docusaurus-mt-lg"><div class="col col--9"><b>Tags:</b><ul class="tags_jXut padding--none margin-left--sm"><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/announcement">announcement</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about Apache CloudStack LTS Maintenance Release 4.14.1.0" href="/blog/apache-cloudstack-lts-maintenance-release"><b>Read More</b></a></div></footer></article><article class="margin-bottom--xl" itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="The Apache CloudStack Project Releases Apache® CloudStack® v4.15"><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/the-apache-software-foundation-announces2">The Apache Software Foundation Announces Apache® CloudStack® v4.15</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2021-01-19T00:00:00.000Z" itemprop="datePublished">January 19, 2021</time></div><div class="margin-top--md margin-bottom--sm row"><div class="col col--6 authorCol_Hf19"><div class="avatar margin-bottom--sm"><a href="https://github.com/rohityadavcloud" target="_blank" rel="noopener noreferrer" class="avatar__photo-link"><img class="avatar__photo" src="https://github.com/rohityadavcloud.png" alt="Rohit Yadav" itemprop="image"></a><div class="avatar__intro" itemprop="author" itemscope="" itemtype="https://schema.org/Person"><div class="avatar__name"><a href="https://github.com/rohityadavcloud" target="_blank" rel="noopener noreferrer" itemprop="url"><span itemprop="name">Rohit Yadav</span></a></div><small class="avatar__subtitle" itemprop="description">PMC Member</small></div></div></div></div></header><div class="markdown" itemprop="articleBody"><p>The Apache CloudStack Project Releases Apache® CloudStack® v4.15</p><p>Mature Open Source Enterprise Cloud platform powers billions of dollars in transactions for the world&#x27;s largest Cloud providers, Fortune 5 multinationals, educational institutions, and more.</p><p>Wilmington, DE —19 January 2021— The Apache CloudStack Project announced today v4.15 of Apache® CloudStack®, the mature, turnkey Open Source enterprise Cloud orchestration platform.</p><p>Apache CloudStack is the proven, highly scalable IaaS platform of choice to rapidly and easily create private, public, and hybrid Cloud environments: it &quot;just works&quot;.</p></div><footer class="row docusaurus-mt-lg"><div class="col col--9"><b>Tags:</b><ul class="tags_jXut padding--none margin-left--sm"><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/announcement">announcement</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about The Apache Software Foundation Announces Apache® CloudStack® v4.15" href="/blog/the-apache-software-foundation-announces2"><b>Read More</b></a></div></footer></article><article class="margin-bottom--xl" itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="The Apache Software Foundation Announces Apache® CloudStack® v 4.14"><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/the-apache-software-foundation-announces1">The Apache Software Foundation Announces Apache® CloudStack® v4.14</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2020-05-26T00:00:00.000Z" itemprop="datePublished">May 26, 2020</time></div></header><div class="markdown" itemprop="articleBody"><p>The Apache Software Foundation Announces Apache® CloudStack® v 4.14</p><p>ature Open Source Enterprise Cloud platform powers billions of dollars in transactions for the world&#x27;s largest Cloud providers, Fortune 5 multinationals, educational institutions, and more.</p><p>Wakefield, MA —NN May 2020— The Apache Software Foundation (ASF), the all-volunteer developers, stewards, and incubators of more than 350 Open Source projects and initiatives, announced today Apache® CloudStack® 4.14, the latest version of the mature, turnkey enterprise Cloud orchestration platform.</p></div><footer class="row docusaurus-mt-lg"><div class="col col--9"><b>Tags:</b><ul class="tags_jXut padding--none margin-left--sm"><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/announcement">announcement</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about The Apache Software Foundation Announces Apache® CloudStack® v4.14" href="/blog/the-apache-software-foundation-announces1"><b>Read More</b></a></div></footer></article><article class="margin-bottom--xl" itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="The Apache CloudStack project is pleased to announce the release of CloudStack 4.13.1.0 as part of its LTS 4.13.x releases. The CloudStack 4.13.1.0 release contains c. 80 fixes on top of the CloudStack 4.13.0.0 release. CloudStack LTS branches are supported for 20 months and will receive updates for the first 14 months. For the final six months, only security updates are provided."><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/announcing-apache-cloudstack-lts-maintenance3">Announcing Apache CloudStack LTS Maintenance Release 4.13.1.0</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2020-05-11T00:00:00.000Z" itemprop="datePublished">May 11, 2020</time></div></header><div class="markdown" itemprop="articleBody"><p>The Apache CloudStack project is pleased to announce the release of CloudStack 4.13.1.0 as part of its LTS 4.13.x releases. The CloudStack 4.13.1.0 release contains c. 80 fixes on top of the CloudStack 4.13.0.0 release. CloudStack LTS branches are supported for 20 months and will receive updates for the first 14 months. For the final six months, only security updates are provided.</p></div><footer class="row docusaurus-mt-lg"><div class="col col--9"><b>Tags:</b><ul class="tags_jXut padding--none margin-left--sm"><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/announcement">announcement</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about Announcing Apache CloudStack LTS Maintenance Release 4.13.1.0" href="/blog/announcing-apache-cloudstack-lts-maintenance3"><b>Read More</b></a></div></footer></article><article class="margin-bottom--xl" itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="Mature Open Source Enterprise Cloud platform powers billions of dollars in transactions for the world&#x27;s largest Cloud providers."><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/the-apache-software-foundation-announces">The Apache Software Foundation Announces Apache® CloudStack® v4.13</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2019-09-24T00:00:00.000Z" itemprop="datePublished">September 24, 2019</time></div></header><div class="markdown" itemprop="articleBody"><p>Mature Open Source Enterprise Cloud platform powers billions of dollars in transactions for the world&#x27;s largest Cloud providers.</p><p>Wakefield, MA - 24 Sept 2019.  The Apache Software Foundation (ASF), the all-volunteer developers, stewards, and incubators of more than 350 Open Source projects and initiatives, announced today Apache® CloudStack® v4.13, the latest version of the turnkey enterprise Cloud orchestration platform.</p></div><footer class="row docusaurus-mt-lg"><div class="col col--9"><b>Tags:</b><ul class="tags_jXut padding--none margin-left--sm"><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/announcement">announcement</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about The Apache Software Foundation Announces Apache® CloudStack® v4.13" href="/blog/the-apache-software-foundation-announces"><b>Read More</b></a></div></footer></article><article class="margin-bottom--xl" itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="The Apache CloudStack project is pleased to announce the release of CloudStack 4.11.3.0 as part of its LTS 4.11.x releases. The CloudStack"><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/announcing-apache-cloudstack-lts-maintenance2">Announcing Apache CloudStack LTS Maintenance Release 4.11.3.0</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2019-07-13T00:00:00.000Z" itemprop="datePublished">July 13, 2019</time></div></header><div class="markdown" itemprop="articleBody"><p>The Apache CloudStack project is pleased to announce the release of CloudStack 4.11.3.0 as part of its LTS 4.11.x releases. The CloudStack
4.11.3.0 release contains c. 50 fixes on top of the CloudStack 4.11.2.0 release. CloudStack LTS branches are supported for 20 months and will receive updates for the first 14 months. For the final six months, only security updates are provided.</p></div><footer class="row docusaurus-mt-lg"><div class="col col--9"><b>Tags:</b><ul class="tags_jXut padding--none margin-left--sm"><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/announcement">announcement</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about Announcing Apache CloudStack LTS Maintenance Release 4.11.3.0" href="/blog/announcing-apache-cloudstack-lts-maintenance2"><b>Read More</b></a></div></footer></article><nav class="pagination-nav" aria-label="Blog list page navigation"><a class="pagination-nav__link pagination-nav__link--prev" href="/blog/tags/announcement/page/2"><div class="pagination-nav__label">Newer Entries</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/blog/tags/announcement/page/4"><div class="pagination-nav__label">Older Entries</div></a></nav></main></div></div></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>