<!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">30 posts tagged with &quot;news&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/news"><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="30 posts tagged with &quot;news&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/news"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/tags/news" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/tags/news" 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/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 aria-current="page" class="sidebarItemLink sidebarItemLinkActive" 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"><header class="margin-bottom--xl"><h1>30 posts tagged with &quot;news&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="Get ready to mark your calendars and pack your bags because the"><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/ccc-2024">CloudStack Collaboration Conference 2024 – Prepare to pack for Madrid, Spain in November</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2024-04-08T00:00:00.000Z" itemprop="datePublished">April 8, 2024</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 class="markdown" itemprop="articleBody"><p><img loading="lazy" src="/assets/images/CCC-2024-6abb831c7a26ea9719436a7fed398e97.png" title="Blog Header Image" width="1384" height="715" class="img_ev3q"></p><p>Get ready to mark your calendars and pack your bags because the
CloudStack Collaboration Conference 2024 is coming to Madrid, Spain!
From November 20th to 22nd, Orense 34 will be buzzing with excitement
as we gather for three days of immersive collaboration, insightful
discussions, and cutting-edge innovation.</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/news">news</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about CloudStack Collaboration Conference 2024 – Prepare to pack for Madrid, Spain in November" href="/blog/ccc-2024"><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="CloudStack European User Group 2024 is scheduled for September 12th"><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/cseug-2024">CloudStack European User Group – September 12th, Frankfurt, Germany</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2024-04-08T00:00:00.000Z" itemprop="datePublished">April 8, 2024</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 class="markdown" itemprop="articleBody"><p><img loading="lazy" src="/assets/images/banner-a7234a01abf348d1d06c274d1d642c9c.jpg" title="Blog Header Image" width="1200" height="628" class="img_ev3q"></p><h1>Apache CloudStack is thrilled to share that the autumn edition of</h1><p>  CloudStack European User Group 2024 is scheduled for September 12th
and will happen in Frankfurt, Germany!</p><p>The event will be hosted by proIO – а German Private Cloud and Managed
Hosting Provider and a long-time CloudStack community supporter. The
venue to accommodate the CloudStack European User Group 2024 is Nio
House Frankfurt.</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/news">news</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about CloudStack European User Group – September 12th, Frankfurt, Germany" href="/blog/cseug-2024"><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="CloudFest happened last week and the CloudStack community was pleased to attend the premier event for internet infrastructure globally. Apache CloudStack has proudly showcased at the conference, with several community members representing both the technology and community."><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/cloudfest-2024-roundup">CloudStack at CloudFest 2024</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2024-03-29T00:00:00.000Z" itemprop="datePublished">March 29, 2024</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/jamiepell10" target="_blank" rel="noopener noreferrer" class="avatar__photo-link"><img class="avatar__photo" src="https://github.com/jamiepell10.png" alt="Jamie Pell" itemprop="image"></a><div class="avatar__intro" itemprop="author" itemscope="" itemtype="https://schema.org/Person"><div class="avatar__name"><a href="https://github.com/jamiepell10" target="_blank" rel="noopener noreferrer" itemprop="url"><span itemprop="name">Jamie Pell</span></a></div><small class="avatar__subtitle" itemprop="description">Community Contributor</small></div></div></div></div></header><div class="markdown" itemprop="articleBody"><p><img loading="lazy" src="/assets/images/header-1a6767b1e22057921b145f6c860274dc.png" title="Blog Header Image" width="1200" height="628" class="img_ev3q"></p><p>CloudFest happened last week and the CloudStack community was pleased to attend the premier event for internet infrastructure globally. Apache CloudStack has proudly showcased at the conference, with several community members representing both the technology and community.</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/news">news</a></li><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/roundup">roundup</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about CloudStack at CloudFest 2024" href="/blog/cloudfest-2024-roundup"><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="Meet Apache CloudStack at CloudFest 2024"><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/cloudfest-2024">Meet Apache CloudStack at CloudFest 2024</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2024-02-29T00:00:00.000Z" itemprop="datePublished">February 29, 2024</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/jamiepell10" target="_blank" rel="noopener noreferrer" class="avatar__photo-link"><img class="avatar__photo" src="https://github.com/jamiepell10.png" alt="Jamie Pell" itemprop="image"></a><div class="avatar__intro" itemprop="author" itemscope="" itemtype="https://schema.org/Person"><div class="avatar__name"><a href="https://github.com/jamiepell10" target="_blank" rel="noopener noreferrer" itemprop="url"><span itemprop="name">Jamie Pell</span></a></div><small class="avatar__subtitle" itemprop="description">Community Contributor</small></div></div></div></div></header><div class="markdown" itemprop="articleBody"><p><img loading="lazy" src="/assets/images/header-573be501cef3bc223b017fd1dceac14f.png" title="Blog Header Image" width="1200" height="628" class="img_ev3q"></p><h2>Meet Apache CloudStack at CloudFest 2024</h2><p>On March 18-21st, the #1 internet infrastructure event in the world –
<a href="https://www.cloudfest.com/" target="_blank" rel="noopener noreferrer">CloudFest</a> – will be taking place in
Rust, Germany! We are excited to share that Apache CloudStack will be
exhibiting at this year&#x27;s CloudFest. This will provide the opportunity
to share Apache CloudStack’s capabilities to the wider cloud computing
industry.</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/news">news</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about Meet Apache CloudStack at CloudFest 2024" href="/blog/cloudfest-2024"><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="On February 23rd, the CloudStack India User Group 2024 took place in Hyderabad,"><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/csiug-2024-hyd-roundup">CloudStack India User Group 2024 Hyderabad Roundup</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2024-02-28T00:00:00.000Z" itemprop="datePublished">February 28, 2024</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/jamiepell10" target="_blank" rel="noopener noreferrer" class="avatar__photo-link"><img class="avatar__photo" src="https://github.com/jamiepell10.png" alt="Jamie Pell" itemprop="image"></a><div class="avatar__intro" itemprop="author" itemscope="" itemtype="https://schema.org/Person"><div class="avatar__name"><a href="https://github.com/jamiepell10" target="_blank" rel="noopener noreferrer" itemprop="url"><span itemprop="name">Jamie Pell</span></a></div><small class="avatar__subtitle" itemprop="description">Community Contributor</small></div></div></div></div></header><div class="markdown" itemprop="articleBody"><p><a href="/blog/csiug-2024-hyd-roundup"><img loading="lazy" src="/assets/images/banner-a74192575a0719a1dbb6cdff3d6435c2.png" title="CSIUG 2024 Hyderabad Roundup" width="1384" height="721" class="img_ev3q"></a></p><p>On February 23rd, the CloudStack India User Group 2024 took place in Hyderabad,
seeing the gathering of CloudStack enthusiasts, experts, and industry leaders
across India, as they engaged in sessions about the open-source project. The
meetup provided a platform to explore Apache CloudStack in detail, with a
particular focus on the new features released in Apache CloudStack 4.19. The
user group also saw its participants exchange insights and establish new
connections.</p><p>Below you can find the session recordings and slides from the user group.</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/news">news</a></li><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/roundup">roundup</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about CloudStack India User Group 2024 Hyderabad Roundup" href="/blog/csiug-2024-hyd-roundup"><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="On 23rd February, the 2024 edition of the CloudStack India User Group will be taking place in Hyderabad. The event will be taking place at: Q-Hub 5th floor, Road No 36 &amp; 37, Jubilee Hills, Telangana, 500033."><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/india-user-group-2024">CloudStack India User Group 2024</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2024-01-08T00:00:00.000Z" itemprop="datePublished">January 8, 2024</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/jamiepell10" target="_blank" rel="noopener noreferrer" class="avatar__photo-link"><img class="avatar__photo" src="https://github.com/jamiepell10.png" alt="Jamie Pell" itemprop="image"></a><div class="avatar__intro" itemprop="author" itemscope="" itemtype="https://schema.org/Person"><div class="avatar__name"><a href="https://github.com/jamiepell10" target="_blank" rel="noopener noreferrer" itemprop="url"><span itemprop="name">Jamie Pell</span></a></div><small class="avatar__subtitle" itemprop="description">Community Contributor</small></div></div></div></div></header><div class="markdown" itemprop="articleBody"><p><a href="/blog/india-user-group-2024"><img loading="lazy" src="/assets/images/banner-855a3448cc0b819dde5fc2fbc3b60503.jpg" title="CloudStack India User group 2024" width="1200" height="628" class="img_ev3q"></a></p><p>On <strong>23rd February</strong>, the 2024 edition of the CloudStack India User Group will be taking place in Hyderabad. The event will be taking place at: <strong>Q-Hub 5th floor, Road No 36 &amp; 37, Jubilee Hills, Telangana, 500033</strong>.</p><p>Whether you&#x27;re already using Apache CloudStack or interested in learning more about this technology, we invite you to participate in the user group. The event will feature engaging tech talks, demonstrations, and user stories. Like all gatherings organised by the Apache CloudStack community, registration is free of charge.</p><a href="https://www.meetup.com/india-cloudstack-user-group/events/298324389/?isFirstPublish=true" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg">REGISTER</a><br><h2 class="anchor anchorWithStickyNavbar_LWe7" id="submit-a-session-proposal">Submit a Session Proposal<a href="#submit-a-session-proposal" class="hash-link" aria-label="Direct link to Submit a Session Proposal" title="Direct link to Submit a Session Proposal">​</a></h2><p>The Call for Presentations is open! When proposing a talk, you can choose to present technical discussions, user stories, details on new features, integration presentations, and more! Submitting a session proposal to the user group provides a chance to showcase your expertise, actively contribute to the community, and receive recognition in the field of cloud computing.</p><strong>Please note, the deadline for session proposals is January 30th.</strong><br><br><a href="https://docs.google.com/forms/d/1jqEGPG6Xf2MwR5_u0RKySkNOti-pzxvDYQBYkCAV6o0" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg">Submit a Talk</a><br></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/news">news</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about CloudStack India User Group 2024" href="/blog/india-user-group-2024"><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 [CloudStack Collaboration Conference"><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/ccc2023-roundup">CloudStack Collaboration Conference 2023 Event Roundup</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2023-12-07T00:00:00.000Z" itemprop="datePublished">December 7, 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/jamiepell10" target="_blank" rel="noopener noreferrer" class="avatar__photo-link"><img class="avatar__photo" src="https://github.com/jamiepell10.png" alt="Jamie Pell" itemprop="image"></a><div class="avatar__intro" itemprop="author" itemscope="" itemtype="https://schema.org/Person"><div class="avatar__name"><a href="https://github.com/jamiepell10" target="_blank" rel="noopener noreferrer" itemprop="url"><span itemprop="name">Jamie Pell</span></a></div><small class="avatar__subtitle" itemprop="description">Community Contributor</small></div></div></div></div></header><div class="markdown" itemprop="articleBody"><p><a href="/blog/ccc2023-roundup"><img loading="lazy" src="/assets/images/banner-ecfa210948dcd243534fb34787d23361.jpg" title="CCC 2023 Roundup" width="904" height="472" class="img_ev3q"></a></p><p>The <a href="https://www.cloudstackcollab.org/" target="_blank" rel="noopener noreferrer">CloudStack Collaboration Conference
2023</a> took place on 23-24th November. The
annual event is the largest get-together for the global Apache CloudStack
community. The hybrid event is aimed at developers, operators and users to
discuss and evolve the open-source software, its functionality and real-world
operability. It introduces attendees to the CloudStack family, community
leaders, project members and contributors.</p><p>The conference, arranged by a group of volunteers from the Apache CloudStack
Community, took place in the voco hotel, in Porte de Clichy, Paris. It hosted
over 350 attendees from 30+ countries, with 47 speakers holding sessions and
workshops.</p><p>The Apache CloudStack community would like to express their gratitude to the
sponsors of the conference, whose support made the event a reality – <a href="https://www.shapeblue.com/" target="_blank" rel="noopener noreferrer">ShapeBlue</a>,
<a href="https://storpool.com/" target="_blank" rel="noopener noreferrer">StorPool</a>, <a href="https://linbit.com/" target="_blank" rel="noopener noreferrer">LINBIT</a>, <a href="https://cloud.dimsi.io/#/" target="_blank" rel="noopener noreferrer">DIMSI</a>, <a href="https://vates.tech/" target="_blank" rel="noopener noreferrer">Vates</a>, <a href="https://mitteldeutsche-it.de/" target="_blank" rel="noopener noreferrer">mitteldeutsche IT</a>, <a href="https://www.leaseweb.com/" target="_blank" rel="noopener noreferrer">Leaseweb</a>, <a href="https://www.proio.com/" target="_blank" rel="noopener noreferrer">proIO</a> and
<a href="https://your.online/" target="_blank" rel="noopener noreferrer">Your.Online</a>.</p><p>This blog provides a summary of the event, featuring the session slides and recordings.</p><a href="https://photos.app.goo.gl/9Ke53cngVzTCS2wE7" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg">View Photo Gallery</a><br></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/news">news</a></li><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/roundup">roundup</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about CloudStack Collaboration Conference 2023 Event Roundup" href="/blog/ccc2023-roundup"><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 [CloudStack Collaboration Conference"><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/ccc2023-vp-interview">VP Apache CloudStack Thoughts on the Upcoming CloudStack Collaboration Conference 2023</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2023-11-01T00:00:00.000Z" itemprop="datePublished">November 1, 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/jamiepell10" target="_blank" rel="noopener noreferrer" class="avatar__photo-link"><img class="avatar__photo" src="https://github.com/jamiepell10.png" alt="Jamie Pell" itemprop="image"></a><div class="avatar__intro" itemprop="author" itemscope="" itemtype="https://schema.org/Person"><div class="avatar__name"><a href="https://github.com/jamiepell10" target="_blank" rel="noopener noreferrer" itemprop="url"><span itemprop="name">Jamie Pell</span></a></div><small class="avatar__subtitle" itemprop="description">Community Contributor</small></div></div></div></div></header><div class="markdown" itemprop="articleBody"><p><a href="/blog/ccc2023-vp-interview"><img loading="lazy" src="/assets/images/banner-c7e5f57a2665b2516df8e30e4bb56bda.png" title="CCC 2023 VP Interview" width="1384" height="715" class="img_ev3q"></a></p><p>The <a href="https://www.cloudstackcollab.org/" target="_blank" rel="noopener noreferrer">CloudStack Collaboration Conference
2023</a> is only a few weeks away. This year’s
event will be taking place in Paris and online, on 23-24th November.
<a href="https://events.hubilo.com/cloudstack-collaboration-conference-2023/register" target="_blank" rel="noopener noreferrer">Registration is still
open</a>,
with free tickets to anybody interested in the open-source project or cloud
technology. The event’s agenda has also been released, which you can see when
registering for the event.</p><p>I decided to interview the project’s current VP, <a href="https://www.linkedin.com/in/rohityadavcloud/" target="_blank" rel="noopener noreferrer">Rohit
Yadav</a>, to get his thoughts on the
annual event.</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/news">news</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about VP Apache CloudStack Thoughts on the Upcoming CloudStack Collaboration Conference 2023" href="/blog/ccc2023-vp-interview"><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="Are you ready for the most anticipated Apache CloudStack event of the year? The"><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/ccc2023-agenda-revealed">CloudStack Collaboration Conference Agenda is Now Live!</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2023-10-03T00:00:00.000Z" itemprop="datePublished">October 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 class="markdown" itemprop="articleBody"><p><a href="/blog/ccc2023-agenda-revealed"><img loading="lazy" src="/assets/images/banner-260090facd03442114e960512a16ac3b.jpg" title="CCC 2023 Agenda Revealed" width="1200" height="628" class="img_ev3q"></a></p><p>Are you ready for the most anticipated Apache CloudStack event of the year? The
CloudStack Collaboration Conference is back, and this time it&#x27;s happening in
Paris on November 23-24.</p><p>The wait is finally over, as the conference agenda has just been released,
giving attendees the chance to plan their schedules and make the most of this
extraordinary gathering of cloud enthusiasts, developers, and industry leaders.</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/news">news</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about CloudStack Collaboration Conference Agenda is Now Live!" href="/blog/ccc2023-agenda-revealed"><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="In the ever-evolving landscape of open-source software development, fostering"><header><h2 class="title_f1Hy" itemprop="headline"><a itemprop="url" href="/blog/gsoc-2023">Google Summer of Code 2023 Review</a></h2><div class="container_mt6G margin-vert--md"><time datetime="2023-09-25T00:00:00.000Z" itemprop="datePublished">September 25, 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/jamiepell10" target="_blank" rel="noopener noreferrer" class="avatar__photo-link"><img class="avatar__photo" src="https://github.com/jamiepell10.png" alt="Jamie Pell" itemprop="image"></a><div class="avatar__intro" itemprop="author" itemscope="" itemtype="https://schema.org/Person"><div class="avatar__name"><a href="https://github.com/jamiepell10" target="_blank" rel="noopener noreferrer" itemprop="url"><span itemprop="name">Jamie Pell</span></a></div><small class="avatar__subtitle" itemprop="description">Community Contributor</small></div></div></div></div></header><div class="markdown" itemprop="articleBody"><p><a href="/blog/gsoc-2023"><img loading="lazy" src="/assets/images/banner-a9ada434623c0c0f625ef3f67c69ebf6.png" title="Google Summer of Code 2023 Review" width="1384" height="721" class="img_ev3q"></a></p><p>In the ever-evolving landscape of open-source software development, fostering
the growth of young talents and innovators is essential. One remarkable program
that stands at the forefront of this mission is the <a href="https://summerofcode.withgoogle.com/" target="_blank" rel="noopener noreferrer">Google Summer of Code
(GSoC)</a>. For years, GSoC has been an
invaluable platform for students to collaborate with prominent open-source
organizations, and Apache CloudStack is proud to be a part of this
transformative journey.</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/news">news</a></li></ul></div><div class="col text--right col--3"><a aria-label="Read more about Google Summer of Code 2023 Review" href="/blog/gsoc-2023"><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--next" href="/blog/tags/news/page/2"><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>