<!doctype html>
<html lang="en" dir="ltr" class="blog-wrapper blog-post-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">Meet Rohit Yadav - the new VP of Apache CloudStack | 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/meet-rohit-yadav-the-new"><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="Meet Rohit Yadav - the new VP of Apache CloudStack | Apache CloudStack"><meta data-rh="true" name="description" content="Rohit Yadav"><meta data-rh="true" property="og:description" content="Rohit Yadav"><meta data-rh="true" property="og:type" content="article"><meta data-rh="true" property="article:published_time" content="2023-05-03T00:00:00.000Z"><meta data-rh="true" property="article:author" content="https://github.com/IvetPM"><meta data-rh="true" property="article:tag" content="community"><link data-rh="true" rel="icon" href="/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://cloudstack.apache.org/blog/meet-rohit-yadav-the-new"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/meet-rohit-yadav-the-new" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/meet-rohit-yadav-the-new" 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/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 class="sidebarItemLink" 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"><article itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="Rohit Yadav"><header><h1 class="title_f1Hy" itemprop="headline">Meet Rohit Yadav - the new VP of Apache CloudStack</h1><div class="container_mt6G margin-vert--md"><time datetime="2023-05-03T00:00:00.000Z" itemprop="datePublished">May 3, 2023</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/IvetPM" target="_blank" rel="noopener noreferrer" class="avatar__photo-link"><img class="avatar__photo" src="https://github.com/IvetPM.png" alt="Ivet Petrova" itemprop="image"></a><div class="avatar__intro" itemprop="author" itemscope="" itemtype="https://schema.org/Person"><div class="avatar__name"><a href="https://github.com/IvetPM" target="_blank" rel="noopener noreferrer" itemprop="url"><span itemprop="name">Ivet Petrova</span></a></div><small class="avatar__subtitle" itemprop="description">PMC Member</small></div></div></div></div></header><div id="__blog-post-container" class="markdown" itemprop="articleBody"><p><a href="/blog/meet-rohit-yadav-the-new"><img loading="lazy" alt="Rohit Yadav" src="/assets/images/header-79150c9f96db9e025aa858649bc15c73.jpg" title="Rohit Yadav - the new VP of Apache CloudStack" width="1200" height="628" class="img_ev3q"></a></p><p>The CloudStack Community is happy to announce Rohit Yadav as the new VP of the
Apache CloudStack Project and PMC chair. After a year of success in which Simon
Weller chaired the project, we are now excited to welcome Rohit, who is a
long-term contributor to the project. He has a strong technology background and
has been engaged in the open-source world for more than a decade, during which
he contributed to multiple other open-source projects.</p><p>In this interview, you will be able to learn more about Rohit Yadav and see his
perspective on the VP&#x27;s role and how he can contribute to the Apache CloudStack
project evolution.</p><p><strong>Why do you believe in open-source, where and how did it all start?</strong></p><p>During my university days, I got introduced to open-source as a way of
community-driven development. Compared to proprietary and closed-source
software, I found the idea of open-source remarkable that anybody can access
source code, learn it, modify it, distribute it, and even contribute it back.</p><p>In my spare time, I started learning and contributing to a few open-source
projects as a hobby and even created some open-source side-projects. I also got
an opportunity to work with the VideoLAN project as a Google Summer of Code
student and later worked as a volunteer summer student at CERN.</p><p><img loading="lazy" alt="Rohit Yadav" src="/assets/images/small-photo-9b8dbcd568888567ae8702a46fc25b15.jpg" title="Rohit Yadav" width="800" height="800" class="img_ev3q"></p><p>All of this early experience inculcated an interest in open-source and
virtualisation, and eventually, I was hired straight out of university by Citrix
to work on open-source Apache CloudStack project that was still in the ASF
incubator at the time. This is when I learned about the ASF and how to work in
the Apache CloudStack community from my colleagues and from the community, and I
learnt how to <a href="https://infra.apache.org/contributors.html" target="_blank" rel="noopener noreferrer">contribute changes</a>.
I started lurking and interacting on the project <a href="/mailing-lists">mailing lists</a>
and IRC to understand how to work in this community.</p><p>I quickly found myself supporting users on the mailing lists and learning
real-world use of CloudStack, contributing patches such as maintaining our (new)
maven-based build system, working on some issues and making some improvements. I
also wrote the <a href="https://github.com/apache/cloudstack-cloudmonkey" target="_blank" rel="noopener noreferrer">cloudmonkey
CLI</a> because there wasn’t one
available and I also ended-up working on a large APIs refactoring project that
helped me understand CloudStack deeper and work closely with the original
creators and architects of CloudStack.</p><p>During this, I was invited to become a committer to the project and got
sponsored to participate in the first CloudStack Collaboration Conference 2012
in Las Vegas. After another few years of working on flagship CloudStack
features, frameworks, releases, maintaining CloudStack and collaborating with
the community, I eventually got invited to become a PMC member.</p><p>I’ve transitioned into a more supporting, mentoring, empowering and leadership
role in the community and at work. This allows me to find time and bandwidth to
champion and promote Apache CloudStack in all forums and platforms.</p><p><img loading="lazy" alt="Rohit Yadav" src="/assets/images/photo-6ae7501c2355ae39108c9207ea491359.jpg" title="Rohit Yadav" width="4080" height="3072" class="img_ev3q"></p><p><strong>Why should enterprises use open-source solutions?</strong></p><p>Enterprises nowadays are adopting open-source software especially when it comes
to infrastructure software. This gives them business advantage in keeping low
costs and not having to depend on a single vendor (no vendor lock-in) while have
the longevity, trust, stability, reliability, durability, flexibility, better
agility and security, and access to an ecosystem of community and commercial
offerings and support around it. There is also community and inter-organisation
collaborations on standards, frameworks and feature development that help reduce
costs for the end-consumers, including the enterprises.</p><p>Enterprises also attract better talent as it’s generally much easy to hire or
train talent on open-source software with its documentation and other types of
training materials in the form of books, blogs and videos etc., accessible to
everybody.</p><p>It’s hard to imagine any enterprise and any consumer product or service that
won’t have any open-source project used in their stacks.</p><p><strong>Who are the existing enterprise users of Apache CloudStack and how are they benefiting?</strong></p><p>Anybody looking to implement (private or public) IaaS cloud should seriously
consider CloudStack. It is easy to-use, cost-effective, very stable, massively
scalable, highly reliable battle-tested IaaS cloud computing platform,
well-known and used in production at many of the world’s largest organisations.
The project is community-driven by diverse contributors who are deeply invested
in solving real-world
<a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Case+Studies" target="_blank" rel="noopener noreferrer">use-cases</a>.</p><p>You don’t have to take my word for it - as an open-source top-level
<a href="https://apache.org/" target="_blank" rel="noopener noreferrer">ASF</a> project anybody can test drive and see it for
themselves, there is no vendor lock-in or paywall to get started. It takes a
very short amount of time and effort to set it up, perhaps a few hours or less
for a seasoned administrator. We have the <a href="https://docs.cloudstack.apache.org/en/latest/quickinstallationguide/qig.html" target="_blank" rel="noopener noreferrer">quick install
guides</a>
for anybody to get started and even a public simulator-based demo environment
for anybody with a few minutes to try it out, get the look-and-feel for it at
<a href="https://qa.cloudstack.cloud/simulator/" target="_blank" rel="noopener noreferrer">https://qa.cloudstack.cloud/simulator/</a> (using the demo-environment credentials
admin:password).</p><p>CloudStack is very easy to deploy, use and manage. Being a monolith application,
it’s easier to upgrade, can be managed by a small team. It is feature-rich, and
offers a great UI, APIs and rich tooling and libraries such as
<a href="https://github.com/apache/cloudstack-cloudmonkey" target="_blank" rel="noopener noreferrer">cloudmonkey</a> (cmk, the
official CLI), the <a href="https://github.com/apache/cloudstack-terraform-provider" target="_blank" rel="noopener noreferrer">CloudStack Terraform
provider</a>, the
<a href="https://github.com/apache/cloudstack-kubernetes-provider" target="_blank" rel="noopener noreferrer">CloudStack Kubernetes
provider</a>, the
<a href="https://cluster-api-cloudstack.sigs.k8s.io/" target="_blank" rel="noopener noreferrer">CloudStack Cluster-API Provider</a>
(CAPC), the <a href="https://github.com/apache/cloudstack-go" target="_blank" rel="noopener noreferrer">CloudStack Go-SDK</a>,
<a href="https://docs.ansible.com/ansible/latest/scenario_guides/guide_cloudstack.html" target="_blank" rel="noopener noreferrer">support for
Ansible</a>,
and countless other integration, libraries and related projects in its
ever-growing ecosystem.</p><p>As an open-source project, Apache CloudStack project does not track who uses it.
Still, we have a fair idea of our user base based on the community-maintained
and contributed <a href="https://cloudstack.apache.org/users.html" target="_blank" rel="noopener noreferrer">list of users</a> on our
project website. Also, based on activities and representation by such users and
their organisations in the community by their participation on the mailing
lists, around releases, issue reporting and code contributions on GitHub,
attendance and participation in project meetups and conferences, and other
forums such as blogs, videos, websites, press releases, social media etc. These
enterprises, organisations and users include some of the world’s largest Fortune
500 companies.</p><p>I get super motivated and content when I read CloudStack
<a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Case+Studies" target="_blank" rel="noopener noreferrer">case-studies</a>
or when I learn where and how our work on CloudStack benefits the core mission
of companies. In the most recent CloudStack Collab conference, I was delighted
to learn how CloudStack <a href="https://www.youtube.com/watch?v=xq2LVY18GU8" target="_blank" rel="noopener noreferrer">empowers the Digital India
mission</a> that helped <a href="https://www.cowin.gov.in/" target="_blank" rel="noopener noreferrer">vaccinate
billions</a> as well as delivers digital product and
services to citizens.</p><p><strong>How is Apache CloudStack project evolving and where do you see its future?</strong></p><p>Over the years, we’ve seen a steady stream of <a href="https://github.com/apache/cloudstack/graphs/contributors" target="_blank" rel="noopener noreferrer">developer
contribution</a> and
<a href="https://github.com/apache/cloudstack/releases" target="_blank" rel="noopener noreferrer">releases</a>. We’re seeing
CloudStack getting more and more polished with every release. We’ve grown into a
pedigree of PMC members, committers, contributors and power users who have been
around in the community for a long time, a decade or more now. This demonstrates
the reliability, durability and stability the project offers to the users
community and the trust of the users community who are continuing to use and
support CloudStack over the years. We’re seeing CloudStack adoption growing
steadily from users participation on mailing lists, GitHub, meetups and
conferences and release adoption. Per the hype curve, we’re in the plateau of
productivity so this isn’t surprising.</p><p>We have always been a community-driven project and that should continue. We may
also see interesting integrations, features and other changes to align with the
changing themes and trends of the industry and the users community, we may find
such use-cases in AI, data sovereignty, privacy and cloud-repatriation.</p><p>We need to ensure there’s a healthy community that feels welcome to use
CloudStack, report issues, participate on the mailing lists and in meetups and
conferences, and tell us about their use-cases and problems in all such forums.</p><p>The users community should be supported to contribute to CloudStack, and <a href="https://github.com/shapeblue/hackerbook" target="_blank" rel="noopener noreferrer">help
train</a> on CloudStack development, help
contribute fixes, enhancements and feature that solves their problems, and
invite them to become committers and PMC members of the project. As long we
support a healthy feedback loop and maintain the cycle of the project it will
continue to grow, evolve, and thrive. We also need more efforts towards project
marketing and promotion, and some work on strategic features, frameworks and
integrations that leads to more growth and adoption of CloudStack.</p><p><strong>Start contributing!</strong></p><p>Want to become a committer and join a great community? <a href="/contribute">Read on!</a></p></div><footer class="row docusaurus-mt-lg blogPostFooterDetailsFull_mRVl"><div class="col"><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/community">community</a></li></ul></div><div class="col margin-top--sm"><a href="https://github.com/apache/cloudstack-www/tree/main/blog/2023-05-03-meet-rohit-yadav-the-new-vp/index.md" target="_blank" rel="noreferrer noopener" class="theme-edit-this-page"><svg fill="currentColor" height="20" width="20" viewBox="0 0 40 40" class="iconEdit_Z9Sw" aria-hidden="true"><g><path d="m34.5 11.7l-3 3.1-6.3-6.3 3.1-3q0.5-0.5 1.2-0.5t1.1 0.5l3.9 3.9q0.5 0.4 0.5 1.1t-0.5 1.2z m-29.5 17.1l18.4-18.5 6.3 6.3-18.4 18.4h-6.3v-6.2z"></path></g></svg>Edit this page</a></div></footer></article><nav class="pagination-nav docusaurus-mt-lg" aria-label="Blog post page navigation"><a class="pagination-nav__link pagination-nav__link--prev" href="/blog/cloudmonkey-6.3-release"><div class="pagination-nav__sublabel">Newer Post</div><div class="pagination-nav__label">Apache CloudStack CloudMonkey 6.3.0 Release</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/blog/cloudstack-european-user-group-may1"><div class="pagination-nav__sublabel">Older Post</div><div class="pagination-nav__label">1 Week to Go - CloudStack European User Group - May 4th, 2023</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>