<!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 the Community - Gabriel Brascher - 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-the-community-gabriel-brascher"><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 the Community - Gabriel Brascher - VP of Apache CloudStack | Apache CloudStack"><meta data-rh="true" name="description" content="Gabriel Beims Bräscher is the new VP of Apache CloudStack since March 2021. He started his journey with CloudStack when he was still a student in the university, became fast a contributor, PMC member and now he is VP of the project."><meta data-rh="true" property="og:description" content="Gabriel Beims Bräscher is the new VP of Apache CloudStack since March 2021. He started his journey with CloudStack when he was still a student in the university, became fast a contributor, PMC member and now he is VP of the project."><meta data-rh="true" property="og:type" content="article"><meta data-rh="true" property="article:published_time" content="2021-04-21T00:00:00.000Z"><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-the-community-gabriel-brascher"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/meet-the-community-gabriel-brascher" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/meet-the-community-gabriel-brascher" 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="Gabriel Beims Bräscher is the new VP of Apache CloudStack since March 2021. He started his journey with CloudStack when he was still a student in the university, became fast a contributor, PMC member and now he is VP of the project."><header><h1 class="title_f1Hy" itemprop="headline">Meet the Community - Gabriel Brascher - VP of Apache CloudStack</h1><div class="container_mt6G margin-vert--md"><time datetime="2021-04-21T00:00:00.000Z" itemprop="datePublished">April 21, 2021</time></div></header><div id="__blog-post-container" class="markdown" itemprop="articleBody"><p>Gabriel Beims Bräscher is the new VP of Apache CloudStack since March 2021. He started his journey with CloudStack when he was still a student in the university, became fast a contributor, PMC member and now he is VP of the project.</p><p>Gabriel is a quite interesting person – born and living in Brazil, but working for a Dutch company, he seems to be an international person. On the technology side, he is an experienced Java developer and has a deep knowledge in a range of other technology. On the personal side, Gabriel is excited to help CloudStack grow as a community and spread the knowledge for it as much a possible.</p><p>Meet Gabriel – the new VP of Apache CloudStack. A person, who is friendly, open-minded and ready to help everyone in the community!</p><a href="/img/imported/6d6dbf9f-d964-496f-82af-a4c764e5f865"><img loading="lazy" src="/img/imported/6d6dbf9f-d964-496f-82af-a4c764e5f865?t=true" alt="Gabriel-VPACS.jpg" class="img_ev3q"></a><b>1. What exactly is the role of VP of Apache CloudStack?</b><p>To give some context let’s start with a bit of Apache.</p><p>The Apache Software Foundation controls over 300+ Projects. Therefore, it is quite hard for a single Apache Board to stay close and manage all the projects.</p><p>With that in mind, each project holds a group of contributors capable of managing supervising the project following the Apache guidelines; this group is called Project Management Committee (PMC). A project VP is a PMC Chair appointed by the Apache Board.</p><p>The VP serves as a bridge between the ASF Board and the Project, providing reports to the Apache Board on a quarterly basis. VP also holds an important role in terms of marketing the project and orchestrating discussions.</p><br><b>2. If you look at CloudStack, it has played a critical role for many solutions providers and companies who search for ease of use and deployment. Which companies can benefit the most from CloudStack?</b><p>Any company that deploys and consumes large loads of computer resources can benefit from CloudStack. Some examples are:</p><p>· Cloud Providers: they are a perfect match as their core business is Infrastructure-as-a-service (IaaS)</p><p>· Telecommunications Companies: are transiting to large cloud infrastructures; especially with the wide change on the communication industry (migrating from traditional Telephone &amp; TV to wireless mobile and Internet technologies)</p><p>· Universities and Research Rroups: need large scale systems for running experiments and also maintaining multiple services for students, professors, and researchers</p><p>· Enterprises / Governmental Organizations: they process and store loads of data, and need elastic computer resources to comply with their demands</p><p>In summary, these companies have something in common:</p><ol><li><p>The costs with public clouds are higher than deploying and managing their own Private Cloud.</p></li><li><p>Also, some companies must control their data and will not process them on third-parties.</p></li></ol><p>In all those cases CloudStack has proven to be a competitive option.</p><br><b>3. Choosing a cloud management system is a hard thing, especially if you have a long history with specific technologies. Why should companies migrate to CloudStack?</b><p>That is true. Choosing such a system is hard and it requires evaluating many aspects, such as the goals, expectations, and technical background that the company already has.</p><p>CloudStack can handle a wide set of hypervisors, and instead of creating new components and projects, it focuses on connecting and managing solid technologies such as iSCSI, NFS, and Ceph. Additionally, it allows configuring guest networks with IPv6 protocol for VMs, which is not commonly supported by other cloud orchestration systems.</p><p>In short: a good thing from CloudStack for companies planning to migrate to Private Cloud is that it adopted technologies that are out in the industry for decades and most of the Admins and Engineers are already used to them. This can cut deployment and operation costs.</p><br><b>4. On the development side, how easy it is to implement and manage CloudStack?</b><p>CloudStack, as any other cloud orchestration platform, is a complex solution; it requires IT professionals with multidisciplinary backgrounds, such as development skills (e.g. Java, Python, MySQL, Bash, Git, Node.js), as well as experience with virtualization, networking and storage systems. So it might take some time for a new developer to learn its way. However, Apache projects work hard to help newcomers; and CloudStack is no different. There are documentations that guide users, system admins, and developers. Deploying CloudStack can be easy when compared to other options and operating it can be simple to users that are well adapted with all the technologies in CloudStack.</p><br><b>5. What would you share about the community?</b><p>The fact that the project is managed by Apache Software Foundation provides all the Apache background on building an open-source community. It is one of our core goals to encourage experienced developers and users to help newcomers.</p><p>On top of that, assembling a community where everyone has a saying is one of the foundations of Apache projects. Therefore, we are always open to new ideas and feature requests.</p><br><b>6. How do you think we can all grow the CloudStack community?</b><p>It is very important to grow our community and I strongly believe that we should connect to students, researchers and professors in a way that we can bring young and passionate talents to develop our project.</p><p>Additionally, participating in conferences and writing for technical magazines can advertise Cloud computing Infrastructure-as-a-Service model as well as the CloudStack project.</p><br><b>7. What is the direction in which CloudStack is going as a technology?</b><p>We are working hard to keep it a reliable and stable solution; but it is also key to invest on user-friendly experience. A good project is one that can be easily deployed and used. We have been continuously enhancing the documentation; additionally, CloudStack has recently migrated to a new User Interface.</p><br><b>8. Many community members notice that CloudStack is becoming more and more appealing for enterprises. What would you advise this type of organisations?</b><p>Small-medium enterprises need to determine which deployment model best suits their Cloud strategy. There are pros and cons on any of the cloud options (private, public, or hybrid clouds).</p><p>Considering the complexity and challenges of deploying a cloud infrastructure, CloudStack is reliable, easy to deploy, and can scale well. Additionally, CloudStack supports integration with public clouds; therefore it is a great option for hybrid clouds.</p><p>We have many known cases of companies that use it for a long time and have scaled their CloudStack Data Centers to huge amounts of Hosts and VMs. But there are also examples of small organizations that are benefiting from private clouds either as a key component of their core business or a tool for internal IT development and growth.</p><br><b>9. As a person, you are recognized for your contribution to CloudStack. How did you start with it?</b><p>It all started in 2013, when I was an undergrad student working at a research lab that wanted to deploy a Cloud orchestration platform. We chose CloudStack over all the options and I began my journey on the CloudStack world.</p><p>On the 1st November 2013 I sent my first mail to the CloudStack mailing list with some questions regarding the process of upgrading from CloudStack 4.1.1 to 4.2.0.</p><p>In December of 2015 I opened my first Pull Request, which led me to work closer to the community by interacting at the mailing lists, and proposing and reviewing implementations.</p><p>I became a committer in 2017 and worked as a Release Manager for CloudStack 4.12.0.0 in early 2018. By the end of 2018 I was invited to be part of the Apache CloudStack PMC.</p><br><b>10. Any advice to all developers, writing new features for CloudStack?</b><p>Open source is all about multiple developers creating and fixing code together; we must focus on maintainability, stability, and documentation.</p><p>When writing new features we should think about how other developers will debug and extend the code. In summary: write code as simple as possible.</p><p>I would recommend the following principles:</p><ol><li><p>Use clear and self-explaining variable names</p></li><li><p>Take advantage of coding libraries to use existing tools</p></li><li><p>Make it easy for other developers to work into the workflow</p></li><li><p>Keep it well documented</p></li><li><p>Make code reusable and avoid duplicated lines</p><br></li></ol><b>11. If you need to summarize CloudStack in 3 words, what would they be?</b><p>Open-source reliable clouds, or simply: it goes on!</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/2021-04-21-meet-the-community-gabriel-brascher.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/apache-cloudstack-lts-maintenance-release1"><div class="pagination-nav__sublabel">Newer Post</div><div class="pagination-nav__label">Apache CloudStack LTS Maintenance Release 4.15.1.0</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/blog/apache-cloudstack-lts-maintenance-release"><div class="pagination-nav__sublabel">Older Post</div><div class="pagination-nav__label">Apache CloudStack LTS Maintenance Release 4.14.1.0</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>