<!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">CloudStack Collaboration Conference 2022 Roundup | 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/cloudstack-collaboration-conference-2022-roundup"><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="CloudStack Collaboration Conference 2022 Roundup | Apache CloudStack"><meta data-rh="true" name="description" content="CloudStack Collaboration Conference 2022 took place on 14th-16th November. The event, which is organised by a team of volunteers from the Apache CloudStack Community, was held in the Capital Fort Business centre in Sofia, Bulgaria."><meta data-rh="true" property="og:description" content="CloudStack Collaboration Conference 2022 took place on 14th-16th November. The event, which is organised by a team of volunteers from the Apache CloudStack Community, was held in the Capital Fort Business centre in Sofia, Bulgaria."><meta data-rh="true" property="og:type" content="article"><meta data-rh="true" property="article:published_time" content="2022-11-30T00:00:00.000Z"><meta data-rh="true" property="article:author" content="https://github.com/IvetPM"><meta data-rh="true" property="article:tag" content="news"><link data-rh="true" rel="icon" href="/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2022-roundup"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2022-roundup" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2022-roundup" 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.60ecdf28.js" as="script">
<link rel="preload" href="/assets/js/main.2d60fa8d.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="CloudStack Collaboration Conference 2022 took place on 14th-16th November. The event, which is organised by a team of volunteers from the Apache CloudStack Community, was held in the Capital Fort Business centre in Sofia, Bulgaria."><header><h1 class="title_f1Hy" itemprop="headline">CloudStack Collaboration Conference 2022 Roundup</h1><div class="container_mt6G margin-vert--md"><time datetime="2022-11-30T00:00:00.000Z" itemprop="datePublished">November 30, 2022</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"><a href="/blog/cloudstack-collaboration-conference-2022-roundup"><img loading="lazy" src="/img/imported/f434e02a-eb78-481e-bc5c-070ceeb6acba" alt="banner.png" width="750" height="393" class="img_ev3q"></a><br>CloudStack Collaboration Conference 2022 took place on 14th-16th November. The event, which is organised by a team of volunteers from the Apache CloudStack Community, was held in the Capital Fort Business centre in Sofia, Bulgaria.<p>For the first time, the CloudStack Collaboration Conference was held as a hybrid event. It was streamed live on Hubilo for those who were not able to attend in-person. As it was the first time the community had collaborated in-person since the pandemic, we managed to collect a record number of physical attendees!</p><p>The conference hosted over 370 participants and 48 speakers from 32 countries. In total, there were 38 sessions from leading CloudStack experts, users and skilful engineers from the open-source world. These sessions included: technical talks, user stories, new features and integrations presentations and more.</p><p>The Apache CloudStack community is grateful to the event’s sponsors, for helping make the event a reality - <a href="http://www.shapeblue.com/" target="_blank" rel="noopener noreferrer" data-cke-saved-href="http://www.shapeblue.com/">ShapeBlue,</a> <a href="https://linbit.com/" target="_blank" rel="noopener" data-cke-saved-href="https://linbit.com/">LINBIT</a>, <a href="https://cloud.dimsi.io/#/" target="_blank" rel="noopener" data-cke-saved-href="https://cloud.dimsi.io/#/">DIMSI</a>, <a href="https://storpool.com/" target="_blank" rel="noopener" data-cke-saved-href="https://storpool.com/">StorPool</a>, <a href="https://www.indiqus.com/" target="_blank" rel="noopener" data-cke-saved-href="https://www.indiqus.com/">Apiculus by IndiQus</a>, <a href="https://www.stackbill.com/" target="_blank" rel="noopener" data-cke-saved-href="https://www.stackbill.com/">StackBill</a>, <a href="https://www.stackconsole.io/" target="_blank" rel="noopener" data-cke-saved-href="https://www.stackconsole.io/">Stack Console</a>, <a href="https://www.cldin.eu/" target="_blank" rel="noopener" data-cke-saved-href="https://www.cldin.eu/">CLDIN</a> and <a href="https://www.hubilo.com/" target="_blank" rel="noopener" data-cke-saved-href="https://www.hubilo.com/">Hubilo. </a></p><p>This blog shares the event highlights including session recordings, slides and speaker information for anybody who was not able to make it.</p><h2><span>Day 1 Sessions:</span></h2><span><strong><a href="https://www.slideshare.net/ShapeBlue/keynote-talk-apache-cloudstack-charting-a-path-for-the-next-10-years-and-beyond" target="_blank" rel="noopener">Keynote talk: Apache CloudStack - Charting a Path for the Next 10 years and Beyond</a> - Simon Weller</strong></span><p>CloudStack since its inception has been a significant player in the cloud market, enabling service providers and enterprise customers to drive success, while controlling their own destinies. With the constant evolution of technology and rapidly changing market dynamics, join Simon as he reflects on an exciting 10 years of innovation and looks to the future.</p><p><a href="https://www.youtube.com/watch?v=vu3p0JDe830&amp;t=1120s" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/6a12e690-ed32-457a-9927-7ef28b2d2935" alt="Screenshot 2022-12-14 at 12.53.32.png" width="750" height="393" class="img_ev3q"></a></p><iframe src="https://www.slideshare.net/slideshow/embed_code/key/C4xo9eTit6s2tK" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe> <strong>About Simon Weller:</strong><p>Simon Weller is the new VP of Apache CloudStack announced in late March 2022. Simon has been an Apache CloudStack PMC member for the last few years. He has a strong technology background in multiple competencies, including networking and systems.</p><strong><span><a href="https://www.slideshare.net/ShapeBlue/whats-new-in-apache-cloudstack-417" target="_blank" rel="noopener">What&#x27;s New In Apache CloudStack 4.17</a> - Nicolas Vazquez </span></strong><p>4.17.0 is the latest Apache CloudStack major release. In this talk, Nicolas goes through the new features introduced in this version from an administrator/user perspective, explaining their benefits and the problems those features resolve. He also ran a live demo to see the new features in action.</p><a href="https://www.youtube.com/watch?v=vLA0jpxr7OM&amp;t=1s" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/d7189bd1-c171-49f9-8ee6-219fe2081bc8" alt="Nicolas vid.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/oth1Po8Wm8NuTD" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe> <strong>About Nicolas Vazquez:</strong><p>Nicolas Vazquez is a Senior Software Engineer at ShapeBlue and is a PMC member of the Apache CloudStack project. He spends his time designing and implementing features in Apache CloudStack and can be seen acting as a release manager also. Nicolas is based in Uruguay and is a father of a young girl. He is a fan of sports, enjoys playing tennis and football. In his free time, he also enjoys reading and listening to economic and political materials.</p><strong><span><a href="https://www.slideshare.net/ShapeBlue/cloudinit-how-does-it-really-work" target="_blank" rel="noopener">cloud-init: How Does It Really Work?</a> - Wido den Hollander</span></strong><p>cloud-init is the standard for provisioning Virtual Machines in almost all cloud platforms. CloudStack is supported as a DataSource in cloud-init. How does this process actually work and how does this data magically provision the virtual machine? Find out by watching this talk!</p><a href="https://www.youtube.com/watch?v=seknX44Ktfc&amp;t=6s" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/34319c64-4c81-4fba-adba-cf9c86f3b808" alt="Wido vid.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/mmfKScl6L8q9Oj" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><strong>Wido den Hollander:</strong>Wido den Hollander has been a part of the CloudStack community since 2012. Ever since he has contributed various parts of code like Ceph/RBD, IPv6, KVM and many other parts.  <br><br><strong><span><a href="https://www.slideshare.net/ShapeBlue/new-networking-capabilities-in-acs-and-how-to-leverage-them-for-vnf-deployments/ShapeBlue/new-networking-capabilities-in-acs-and-how-to-leverage-them-for-vnf-deployments" target="_blank" rel="noopener">New Networking Capabilities In ACS And How To Leverage Them For VNF Deployments</a> - Alexandre Mattioli</span></strong><p>Several new networking capabilities such as IPv6 support, fully routed Virtual Router, user-driven shared networks and others have been added to CloudStack since its 4.17 release. In this talk, Alex looks at how to use these new capabilities together in order to seamlessly enable the deployment of Virtual Network Functions via ACS.</p><a href="https://www.youtube.com/watch?v=02nWtACMqjg&amp;t=1197s=" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/8d37af53-5f06-4432-bb51-ddfb01febd4a" alt="alex.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/LwuMIgKz1pqpi" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><div><strong>About Alexandre Mattioli:</strong></div><div>Alexandre Mattioli is a highly experienced Infrastructure Architect who has been working with Apache CloudStack since 2015, he has designed, built and operated one of the largest ACS clouds in existence and led a team to design and productise many diverse solutions on top of ACS. He&#x27;s currently a Cloud Architect at ShapeBlue.</div> <br><div><span><strong><a href="https://www.slideshare.net/ShapeBlue/automated-cloudstack-deployment" target="_blank" rel="noopener" title="Automated CloudStack Deployment">Automated CloudStack Deployment</a> - Kaloyan Kotlarski</strong></span></div><div>Dev and test environments require the frequent and repeatable deployment of the CloudStack setup. This can be time-consuming and prone to errors. In this presentation, Kaloyan shows how StorPool uses Ansible for automatic deployment and setting up complete CloudStack clouds.</div><a href="https://www.youtube.com/watch?v=vXmEF2Z0aXI&amp;t=26s" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/181fe059-5a04-47ee-ac66-93dcbefba7a8" alt="kaloyan.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/wM9jOM06FETpIm" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><div><strong>About Kaloyan Kotlarski:</strong></div><div>Kaloyan Kotlarski is a system administrator in StorPools&#x27; support team. He&#x27;s been in the company for two years. He&#x27;s responsible for building CI/CD automation and helping clients integrate StorPool Storage in their cloud deployments.</div><br><div><strong><span><a href="https://www.slideshare.net/ShapeBlue/stackbill-workshop" target="_blank" rel="noopener">StackBill Workshop</a> - Amal Ranjith</span></strong></div><div><p>StackBill is a complete self-service intuitive Cloud Management Portal with extensive features leveraging Apache CloudStack® with state of the art tools and years of expertise. Stackbill helps datacenter and cloud providers to build their own public cloud business powered by Apache CloudStack.</p><p>In this workshop session, Amal Ranjith talks about how StackBill offers a great solution for cloud service providers with simplified user experience and packed with 3&#x27;rd party plugins to provide users with a live demo.</p><a href="https://www.youtube.com/watch?v=rOQ5SdNgu-Q" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/48df8c4d-f5eb-4a29-b4be-b3b5f37c80e3" alt="amal.png" width="750" height="393" class="img_ev3q"></a></div><iframe src="https://www.slideshare.net/slideshow/embed_code/key/HekHmZVZJbQIMX" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><strong>About Amal Ranjith:</strong><p>A Big fan of Linux - enjoyed working with server round the clock. A Techie with 25 Years of experience, Co-founder of Assistanz Networks Pvt. Ltd. and logged in over 10,000+ servers for helping clients, teams, datacenters, web hosts and enterprise companies. Less expressive and more action-oriented in nature co-founded FogPanel which was acquired in 2015. Now working on a mission to make StackBill - one of the most preferred CMP by 2025. Founder of StackWatch - an AI-based server monitoring system. Towards his hobby over innovative cosmetics and Fragrance oils. Founded GlamBella - a company producing and trading cosmetics and fragrance oils.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/vm-autoscaling-with-cloudstack-vr-as-network-provider" target="_blank" rel="noopener" title="VM Autoscaling With CloudStack VR As Network Provider">VM Autoscaling With CloudStack VR As Network Provider</a> - Wei Zhou</strong></span><p>In this talk, Wei looks at the new VM autoscaling functionality in CloudStack (due for the 4.18 release) that gives VM autoscaling without relying on any external devices.</p><a href="https://www.youtube.com/watch?v=k2zSp2j39TM" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/47785de9-5281-40db-a820-719d4fdd0c58" alt="wei.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/LAw4zTMMlTuDt8" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><div><strong>About Wei Zhou:</strong></div><div>Wei Zhou is a committer and PMC member of Apache CloudStack project, and works for ShapeBlue as a Software Architect.</div><div></div><div><span><strong><a href="https://www.slideshare.net/ShapeBlue/monitoring-in-cloudstack" target="_blank" rel="noopener" title="Monitoring in CloudStack">Monitoring in CloudStack</a> - Lucian Burlacu</strong></span></div><div>In this session, Lucian talks about monitoring CloudStack and its related components. What are the best practices and what do you need to track closely to ensure your cloud reliability.</div><a href="https://www.youtube.com/watch?v=DeTTZQhgbS0" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/018d697d-28c2-4883-aba2-917c048de921" alt="lucian.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/4wtJuAZmWs30lG" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><div><strong>About Lucian Burlacu:</strong></div><div>Lucian is a long-time sysadmin and Apache Cloustack user and contributor. He has a background in hosting, virtualisation and datacentre operations, but is now working full time on CloudStack.</div><div><span><strong><a href="https://www.slideshare.net/ShapeBlue/edge-zones-in-cloudstack" target="_blank" rel="noopener" title="Edge Zones In CloudStack">Edge Zones In CloudStack </a>- Abhishek Kumar</strong></span></div><div>Edge computing has been gaining popularity as it defines a model that brings compute and storage closer to where they are consumed by the end-user. By being closer to the end-user a better experience can be provided with a reduction in overall latency, lower bandwidth requirements, lower TCO, more flexible hardware/software model, while also ensuring security and reliability. In this talk, Abhishek discusses aligning Apache CloudStack with this evolving cloud computing model and supporting Edge Zones, which can be also looked upon as lightweight zones, with minimal resources.</div><a href="https://www.youtube.com/watch?v=61TOECZJWog&amp;t=24s" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/4498faca-c7d8-4985-b79b-052489c98d9c" alt="abhishek.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/DtlETy3jNBPmvJ" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><strong>About Abhishek Kumar: </strong><p>Abhishek Kumar is a committer of the Apache CloudStack project and has worked on the notable features such as VM ingestion, CloudStack Kubernetes Service, IPv6 support, etc. He works as a Software Engineer at ShapeBlue.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/how-to-monetise-bill-cloudstack-a-practical-open-approach" target="_blank" rel="noopener" title="How To Monetise &amp; Bill CloudStack - A Practical Open Approach">How To Monetise &amp; Bill CloudStack - A Practical Open Approach</a> - K B Shiv Kumar</strong></span><p>This talk is for ISPs looking to bill CloudStack resources, and for software developers looking to build a billing solution around CloudStack. This talk looks at covering multiple business and technical use cases (for example: plans, catalogues, flexible billing, tiered offerings, account management, etc.) for running a public cloud and how the same can be achieved using CloudStack. It does not delve into any specific billing system but instead focuses on an open approach to how ACS features can be leveraged to implement billing and monetise CloudStack.</p><a href="https://www.youtube.com/watch?v=dnWChu6MROo" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/37114c5b-b767-4d78-9c84-6724bc73fb20" alt="shiv.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/1bxeVTh7wVCFho" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><strong>About K B Shiv Kumar:</strong><p>Shiv is the Co-Founder and CTO of IndiQus Technologies Pvt. Ltd. and a CloudStack user turned evangelist since 2013. He loves tinkering on CloudStack and the possibilities it offers. He has deployed multiple public and private clouds running CloudStack in the South Asian region and has also integrated legacy systems with CloudStack. He would love to share his experiences with like-minded professionals.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/choosing-a-kubernetes-integration-technology-thats-right-for-you" target="_blank" rel="noopener" title="Choosing A Kubernetes Integration Technology That&#x27;s Right For You">Choosing A Kubernetes Integration Technology That&#x27;s Right For You</a> - David Jumani</strong></span><p>Apache CloudStack has two different ways of integrating with Kubernetes:</p><ul><li>The CloudStack Kubernetes services</li><li>The CloudStack Cluster API provider (CAPI)</li></ul><p>In this talk, David compares the two different technologies, their use cases and their approach. He goes into detail on the architecture of each approach and what drove their development.</p><a href="https://www.youtube.com/watch?v=BNng6ZPImNo&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=12" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/efcae191-bbc9-4ccc-9a8e-eadba3baab61" alt="Screenshot 2023-01-06 at 15.10.33.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/59Qrb9wJIPv9nF" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start"></span> </iframe><div><strong>About David Jumani:</strong></div>David is a CloudStack committer, a member of the Kubernetes Org and a Software Engineer at ShapeBlue.  <span><strong><a href="https://www.slideshare.net/ShapeBlue/the-best-storage-solution-for-cloudstack-linstor" target="_blank" rel="noopener" title="The Best Storage Solution For CloudStack: LINSTOR">The Best Storage Solution For CloudStack: LINSTOR</a> - Yusuf Yıldız</strong></span><p>This session was an interactive session on extending Apache CloudStack with LINSTOR. LINSTOR is Open source Software Defined Storage designed to manage block storage devices for large clusters. The unique structure of LINSTOR helps you overcome countless roadblocks when you want to set up reliable storage. This demo covered; The steps to building a reliable and high-performance SDS for your CloudStack environment, The benefits of the stack Comparing LINSTOR with other SDS offerings – what you should know.</p><a href="https://www.youtube.com/watch?v=i3rEaBwLQVI&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=13&amp;t=13s" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/c439ef38-374c-4185-b0b7-c50c71289308" alt="yusuf.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/iKCjeGyBHV942p" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><strong>About Yusuf Yıldız:</strong><div>Yusuf Yıldız, Solutions Architect. After many years spending hands on experience for system and storage management, Yusuf started to work as a Solution Architect at LINBIT 3 years ago. His main focus is customer success and contributing to product development and testing. As part of the solution architects team, he is one of the backbone and supporters of the sales team.</div><div></div><div><span><strong><a href="https://www.slideshare.net/ShapeBlue/introducing-amazon-eks-anywhere-on-apache-cloudstack" target="_blank" rel="noopener" title="Introducing Amazon EKS Anywhere On Apache CloudStack">Introducing Amazon EKS Anywhere On Apache CloudStack</a> - Vipin Mohan, Max Dribinsky</strong></span></div>Amazon EKS Anywhere is a deployment option for Amazon EKS that enables customers to create and operate Kubernetes clusters on customer-managed infrastructure, supported by AWS. Customers can already run Amazon EKS Anywhere on their own on-premises infrastructure on bare metal servers or using VMware vSphere. In this session, you will learn about the Cluster API provider for Apache CloudStack, and how customers can now create and operate Amazon EKS Anywhere clusters on Apache CloudStack environments on-premises.<a href="https://www.youtube.com/watch?v=BqySTVS0o2c&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=14&amp;t=163s" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/e0c438b3-ad68-47d6-962a-ef185501e4ef" alt="Screenshot 2023-01-06 at 15.17.15.png" width="750" height="393" class="img_ev3q"></a><div></div><div><iframe src="https://www.slideshare.net/slideshow/embed_code/key/3tSJb9HVS6v6hN" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe></div><div><strong>About the speakers:</strong>Vipin Mohan is a Principal Product Manager in the Kubernetes team at Amazon Web Services. He enjoys building products and delivering delightful customer experiences. Outside of work, he loves reading about financial investing and entrepreneurship and exploring the world through the eyes of his two kids.</div><div></div>ax is a CAPC and EKS-Anywhere developer, avid hiker and rock climber, and enjoys playing Rocket League and exploring the world with his wife and dog. He&#x27;s personally interested in self-driving technology and wants to eventually retire in a cabin in the mountains with a wood burning stove and a hot tub.<div></div><div></div><h2><span>Day 2 Sessions:</span></h2><span><strong><a href="https://www.slideshare.net/ShapeBlue/empowering-digital-india-with-cloudstack" target="_blank" rel="noopener" title="Empowering Digital India With CloudStack">Empowering Digital India With CloudStack</a> - Abhishek Ranjan</strong></span><p>CSC E-Governance India is leading the game in bringing G2C <!-- -->&amp;<!-- --> B2C services across the nation on a digital marketplace that enables citizens to avail services from the comfort of their neighbourhood kiosk called Common Service Centers. The digital platform enables and empowers the lives of millions of Indians to access services in the modern digital world. In this talk, Abhishek shares insights on how CSC harnesses the power of CloudStack to underpin the services delivery and build a government community cloud for powering applications which aid in building a digitally inclusive ecosystem.</p><a href="https://www.youtube.com/watch?v=xq2LVY18GU8&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=15" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/903e0080-483b-450f-83d1-ead8ae80ab3b" alt="Screenshot 2023-01-06 at 15.19.48.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/4WwAn6rd5BJdWR" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><strong>About Abhishek Ranjan:</strong><p>Abhishek is the CTO with CSC e-Governance Services India a special purpose vehicle under the Ministry of Electronics <!-- -->&amp;<!-- --> Information Technology, Govt of India. He runs the technology behind CSC which drives the world’s largest front end service delivery points to deliver government <!-- -->&amp;<!-- --> business services across the nation reaching the remotest of the country on a digital format. CSC&#x27;s Digital platform supports multi domain products <!-- -->&amp;<!-- --> services ranging from government, business, aadhaar, insurance, travel, education, utilities, bill payments, fintech apps for banking services delivery. Prior to CSC he worked with the UIDAI, where he was engaged as member of the technology team that built Aadhaar, during his Aadhaar days he was involved in building the Aadhaar Biometric Attendance system, Digital Life Certificate <!-- -->&amp;<!-- --> several other exciting and challenging projects which were widely adopted across the nation. He previously did his bachelors in engineering from BITS Mesra and passionately participates in Application Architecture, Product Design <!-- -->&amp;<!-- --> Development, Big Data Analysis and specializes in Product Strategy, Strategic Tech Planning <!-- -->&amp;<!-- --> Technology Leadership.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/vm-console-enhancements" target="_blank" rel="noopener" title="VM Console Enhancements">VM Console Enhancements</a> - Nicolas Vazquez</strong></span><p>In this talk, Nicolas introduces a new model for console access to instances in CloudStack. He explains both “how” and “why” CloudStack has moved from an embedded HTML client iframe to an API-driven generated console. He also delves into recent enhancements to the security and access to the console, including an extra security client validation approach.</p><a href="https://www.youtube.com/watch?v=AViBkapPTK4&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=16&amp;t=1ss" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/95bb19e3-d710-4cce-92a9-63df9983e850" alt="Screenshot 2023-01-10 at 09.25.52 1.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/dso2DQLjmTnBaH" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><strong>About Nicolas Vazquez:</strong><p>Nicolas Vazquez is a Senior Software Engineer at ShapeBlue and is a PMC member of the Apache CloudStack project. He spends his time designing and implementing features in Apache CloudStack and can be seen acting as a release manager also. Nicolas is based in Uruguay and is a father of a young girl. He is a fan of sports, enjoys playing tennis and football. In his free time, he also enjoys reading and listening to economic and political materials.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/providing-microsoft-azure-functions-and-microsoft-dataverse-resources-with-cloudstack" target="_blank" rel="noopener" title="Providing Microsoft Azure Functions And Microsoft Dataverse Resources With CloudStack">Providing Microsoft Azure Functions And Microsoft Dataverse Resources With CloudStack</a> - Quentin Roccia, Christophe Gondouin, Pierre Charton</strong></span><p>any business projects (CRM, ERP, etc) are using proprietary cloud solutions that may be available outside these major clouds. Christophe, Pierre and Quentin will demonstrate the possibilities to use Apache CloudStack when working on the Microsoft Azure and Microsoft Dataverse world, providing the same features on an open-source cloud solution.</p><a href="https://www.youtube.com/watch?v=ta4bQ1-DUw0&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=17&amp;t=6s" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/dd59ea36-159c-4cc5-9641-a8ee200151de" alt="Screenshot 2023-01-10 at 11.22.11.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/sDFvYJ7wTYentK" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><strong>About the speakers:</strong><p>Christophe Senior code and platform architect, DIMSI partner, Christophe is helping all technical teams to choose best patterns and implementations to deliver fast, reliable and clean software solutions When not trashing and re-coding software developed by our team, you may find him playing with his 2 children, drinking beers with his friends or on his computer watching Series</p><p>Pierre Senior back-end developer, Pierre is in charge of Backroll integration inside CloudStack. Pierre has a proven track record of successful c# and Java projects. When not playing with his keyboard, Pierre is surfing, WingFoiling or bodyboarding on the Brittany coast.</p><p>Quentin Senior DevOps engineer <!-- -->&amp;<!-- --> Cloud enabler, DIMSI partner Quentin is in charge of DIMSI custom developments on Apache CloudStack deployment : customer portal, backup solution. On a daily basis, he helps our customers and our developers to use and embrace Devops methodology, by building CI/CD pipelines (GitLab, Azure Devops), dockerizing apps and automate things as much as possible... When not DevOps&#x27;ing, Quentin loves to binge watch series and movies, play with his cat &quot;Boogie&quot; and is a crazy fan of street food.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/our-journey-developing-kubernetes-capi-provider-for-apache-cloudstack" target="_blank" rel="noopener" title="Our Journey Developing Kubernetes CAPI Provider For Apache CloudStack">Our Journey Developing Kubernetes CAPI Provider For Apache CloudStack</a> - David Jumani</strong></span><p>The Kubernetes Cluster API (CAPI) sub-project aims to simplify and unify the Kubernetes cluster lifecycle management. With almost a dozen provider implementations, we decided to add our own provider implementation for Apache CloudStack. But how simple was it? With several CRDs, controllers, API versions, and even experimental features, and e2e tests to develop, it’s easy to get lost in the details and can seem quite overwhelming. Join us to discover how we did it! We detail our journey, from building an initial prototype over a weekend to a full-fledged, production-ready application, and deployed in an environment with over 10s of 1000s of hosts! We share the pitfalls, hacks, learnings, and key takeaways from our journey to develop CAPC – the CAPI Provider for Apache CloudStack.</p><a href="https://www.youtube.com/watch?v=AR8JXotMir8&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=29" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/c0b3a35f-e51e-401e-bc47-393bbc3701ad" alt="Screenshot 2023-01-10 at 11.25.12.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/1DYYVsXmkfQqzS" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><strong>David Jumani:</strong><p>David is a CloudStack committer, member of the Kubernetes Org and Software Engineer at ShapeBlue.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/cloudstack-at-ntt-data-business-solutions" target="_blank" rel="noopener" title="CloudStack At NTT DATA Business Solutions">CloudStack At NTT DATA Business Solutions</a> - Andre Walter</strong></span><p>Learn more about the Implementation and use of Apache CloudStack at NTT DATA Business Solutions GMS.</p><a href="https://www.youtube.com/watch?v=jL4sQoFF3CY&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=18" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/226343c5-4eb9-4ae4-84e9-746ec6cf320d" alt="Screenshot 2023-01-10 at 11.27.57.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/CZZYJBo4XFsJtS" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><strong>About Andre Walter:</strong><p>Andre Walter has been with NTT DATA for 10 years now, previously engaged at SAP focusing on Software on Demand Solutions and bringing it into production. He leads Cloud Infrastructure Services, which runs 24×7 Infrastructure Services <!-- -->&amp;<!-- --> Data Center operations globally and has been implementing CloudStack successfully since 2014. When not at work, you might see him training for a Marathon.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/volume-encryption-in-cloudstack" target="_blank" rel="noopener" title="Volume Encryption In CloudStack">Volume Encryption In CloudStack</a> - Vladimir Petrov</strong></span><p>In this talk, Vladi looks at the new Volume encryption option (due in CloudStack 4.18). He presents the new ability to use encrypted root and data volumes on different storage types, the benefits and the current limitations of the implementation.</p><a href="https://www.youtube.com/watch?v=92mtFk4XMaY&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=19" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/14788ebe-fdb1-4895-8838-3890aaee79d3" alt="Screenshot 2023-01-10 at 11.31.46.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/dBZcOPO6INQ1Ye" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><div><strong>About Vladimir Petrov:</strong></div><div>Vladimir Petrov is a QA engineer with more than 20 years of experience in the IT field. He is using and testing Apache CloudStack for almost 3 years now. Currently working as a QA Engineer in ShapeBlue.</div><div></div><div><span><strong><a href="https://www.slideshare.net/ShapeBlue/storpool-storage-verview-and-integration-with-cloudstack" target="_blank" rel="noopener" title="StorPool Storage Оverview and Integration with CloudStack">StorPool Storage Оverview and Integration with CloudStack</a> - Slavka Peleva, Venko Moyankov, Alex Ivanov </strong></span></div><div>StorPool is a leading software provider that develops the most reliable and speedy storage platform on the market. The software comes as an utterly hands-off solution – StorPool’s team architects, deploys, tunes, monitors, and maintains the system. The software has a native plug-in for CloudStack, and it is the ideal solution for companies that aim to optimize and grow their business, eliminate data storage issues, or secure fast and reliable access to data to achieve their business goals. In this talk, you’ll find out more about StorPool’s functionality, architecture, and use cases. You’ll also learn about the new features of the product and its deeper integration into CloudStack.</div><a href="https://www.youtube.com/watch?v=045dkTHlcf8&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=20" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/f4e2c5db-8664-497c-bf2e-835276fb0595" alt="Screenshot 2023-01-10 at 11.34.50.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/vvBEIU8sivkvjF" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><strong>About the speakers:</strong><p>Slavka Peleva is a software developer at StorPool Storage and has been a passionate CloudStack Committer since 2021. She is part of the CloudStack community and is excited to work on new features and capabilities to improve the open-source cloud management solution. At StorPool Slavka is responsible for the product integration with CloudStack and is working on its native implementation in the technology. With her dedication and efforts in creating the StorPool’s plugin for CloudStack, companies can build reliable and speedy storage that is powered by the two technologies.</p><p>Venko Moyankov is the Solutions Lead at StorPool Storage, a fully managed data storage solution that transforms commodity hardware into a shared, powerful, highly available, and reliable storage system. He has experience with managing large virtualizations, working in telcos, designing and supporting the infrastructure of large enterprises. In the last year his focus has been in helping companies globally to build the best storage solution according to their needs and projects.</p><p>Alex Ivanov is the Product Lead at StorPool Storage and is responsible for the product strategy and tactics at the company. He has experience in the storage market and a deep understanding of the needs and priorities of businesses managing large-scale clouds to run diverse, mission-critical workloads. At StorPool, he works closely with the team to evolve the StorPool primary storage platform and expand its capabilities and usefulness for various use cases. His goal - ensure StorPool cost-effectively delivers above and beyond what is possible with other primary storage products to help customers achieve their commercial and technical goals.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/backroll-production-grade-kvm-backup-solution-integrated-in-cloudstack" target="_blank" rel="noopener" title="Backroll: Production Grade KVM Backup Solution Integrated in CloudStack">Backroll: Production Grade KVM Backup Solution Integrated in CloudStack</a> - Grégoire Lamodière, Quentin Roccia, Pierre Charton</strong></span><p>Backroll is not only a production-grade KVM backup solution. It is also being integrated inside Apache CloudStack using the Backup and restore framework. Pierre and Quentin show how it works, the feature list, and how the integration has been made.</p><a href="https://www.youtube.com/watch?v=SuHy8vtj7mw&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=21" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/181660e1-d093-4892-909a-e29a780ac602" alt="Screenshot 2023-01-10 at 11.37.42.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/2ewme3mjI4KyL5" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><div><strong>About the speakers:</strong></div><div>Grégoire is a software architect who spends most of his time designing infrastructure applications and CRM systems, on-premise or multi-cloud based. He’s been using Apache CloudStack for many years, and likes to keep knowledge and data outside black-boxes Father of 4 children, you can meet him in Southern Brittany, sailing Hobbie Cat or supporting Lorient football club at Moustoir stadium.</div><div><p>Quentin is in charge of DIMSI custom developments on Apache CloudStack deployment : customer portal, backup solution. On a daily basis, he helps our customers and our developers to use and embrace Devops methodology, by building CI/CD pipelines (GitLab, Azure Devops), dockerizing apps and automate things as much as possible... When not DevOps&#x27;ing, Quentin loves to binge watch series and movies, play with his cat &quot;Boogie&quot; and is a crazy fan of street food.</p><p>Pierre is in charge of Backroll integration inside CloudStack. Pierre has a proven track record of successful c# and Java projects. When not playing with his keyboard, Pierre is surfing, WingFoiling or bodyboarding on Brittany coast.</p></div><div><span><strong><a href="https://www.slideshare.net/ShapeBlue/what-cloudstackers-need-to-know-about-linstordrbd" target="_blank" rel="noopener" title="What CloudStackers Need To Know About LINSTOR/DRBD">What CloudStackers Need To Know About LINSTOR/DRBD</a> - Philipp Reisner</strong></span></div><div>Philipp explains the best performing Open Source software-defined storage software available to Apache CloudStack today. It consists of two well-concerted components. LINSTOR and DRBD. Each of them also has its independent use cases, where it is deployed alone. In this presentation, the combination of these two is examined. They form the control plane and the data plane of the SDS. We will touch on: Performance, scalability, hyper-convergence (data-locality for high IO performance), resiliency through data replication (synchronous within a site, 2-way, 3-way, or more), snapshots, backup (to S3), encryption at rest, deduplication, compression, placement policies (regarding failure domains), management CLI and webGUI, monitoring interface, self-healing (restoring redundancy after device/node failure), the federation of multiple sites (async mirroring and repeatedly snapshot difference shipping), QoS control (noisy neighbors limitation) and of course: complete integration with CloudStack for KVM guests. It is Open Source software following the Unix philosophy. Each component solves one task, made for maximal re-usability. The solution leverages the Linux kernel, LVM and/or ZFS, and many Open Source software libraries. Building on these giant Open Source foundations, not only saves LINBIT from re-inventing the wheels, it also empowers your day 2 operation teams since they are already familiar with these technologies.</div><a href="https://www.youtube.com/watch?v=xEWjocVhzno&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=22" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/3a720046-c093-4636-83bb-e48f4f64da92" alt="Screenshot 2023-01-10 at 11.41.03.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/a81uXODtt3KItT" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><div><strong>About Phillip Reisner:</strong></div><div>Philipp Reisner is one of the founders and CEO of LINBIT in Vienna/Austria. He holds a Dipl.-Ing. (comparable to MSc) degree in computer science from Technical University in Vienna. His professional career has been dominated by developing DRBD, a storage replication software for Linux. While in the early years (2001) this was writing kernel code, today he leads a company of 30 employees with locations in Austria and the USA. LINBIT is an Open Source company offering enterprise-level support subscriptions for its Open Source technologies.</div><div></div><div><span><strong><a href="https://www.slideshare.net/ShapeBlue/mentored-gsoc-projects-at-apache-cloudstack" target="_blank" rel="noopener" title="Mentored GSoC Projects At Apache (CloudStack)">Mentored GSoC Projects At Apache (CloudStack)</a> - Daan Hoogland</strong></span></div><div>Google Summer of Code is a global, online program focused on bringing new contributors into open-source software development. Apache CloudStack has worked with a number of GSoC students for a number of years. But how successful has that been? In this talk, Daan reviews the involvement of CloudStack in GSoC and takes a look at some of the work done by the GSoC students.</div><a href="https://www.youtube.com/watch?v=tDDoxFwhIvw&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=23" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/42398084-c5f1-40a7-90f2-74ef658440d3" alt="Screenshot 2023-01-10 at 11.43.57.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/Fuq8qNUVR2FP4" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><strong>About Daan Hoogland:</strong><p>Daan Hoogland has been a software developer in about all roles available in the field, starting in 1991. Provisioning has been a recurring theme in his career. Functional design, Programming, Testing and also Functional Management and Operations, have been his main responsibilities over the years. At present He works as a software engineer at Shapeblue Ltd. and as a Technical Official at World Triathlon and the NTB (Dutch triathlon organisation) and is a Pilates - and Triathlon trainer.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/10x-your-cloud-business-with-stack-console-cloudstack" target="_blank" rel="noopener" title="10x Your Cloud Business With Stack Console &amp; CloudStack">10x Your Cloud Business With Stack Console &amp; CloudStack</a> - Saurabh Rapatwar</strong></span><p>Every cloud service provider wants to boost their sales, but how? With the help of Stack Console’s reseller management module and CloudStack, a data center or cloud service provider can build resellers/partners and provide them with an automated white-label cloud management platform so they can sell cloud services under their own brand, such as compute, Kubernetes, load balancer, block storage, and so on. Many of resellers are likely to be small and medium-sized businesses that want to get into the cloud market, so this is great news for them. Service providers will still make money whether a customer buys a service directly from them or through one of their resellers.</p><a href="https://www.youtube.com/watch?v=T_nhzY3-QZs&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=24" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/6b18b8d7-3faf-4f2d-87cc-2ea5686f305e" alt="Screenshot 2023-01-10 at 11.46.25.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/hLfHYS9nzHSnt9" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><div><strong>About Saurabh Rapatwar:</strong></div><div>Saurabh is a leader, an innovator, and a technology pioneer with more than 13 years of experience in the SaaS, IaaS, and technology domains. He is the CEO of Stack Console, a cloud management platform built on top of Apache CloudStack for datacenters and web hosting providers.</div><div></div><div><span><strong><a href="https://www.slideshare.net/ShapeBlue/extending-cloudstack-to-deliver-a-multi-availability-zone-public-cloud" target="_blank" rel="noopener" title="Extending CloudStack To Deliver a Multi Availability Zone Public Cloud">Extending CloudStack To Deliver a Multi Availability Zone Public Cloud</a> - Kshitish Purohit</strong></span></div><div>This session covers how 2 or more disparate CloudStack environments can be unified together to set up a cloud across multiple availability zones (AZ). This unification, achieved using the Apiculus solution, can add tremendous value to service providers who, along with operating multiple CloudStack environments, wish to add a business life cycle element (billing, marketing, customer management, support) to their public cloud offering. This is not a technical session and includes a demonstration of a multi-AZ cloud set-up using CloudStack and Apiculus.</div><a href="https://www.youtube.com/watch?v=eNLSmnzpMr4&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=25" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/2fc24938-1eb0-45ed-8731-a7bf850935f0" alt="Screenshot 2023-01-10 at 11.49.54.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/LGb1mCtsMuhRuB" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><div><strong>About Kshitish Purohit:</strong></div><div>Kshitish is the Co-Founder and Chief Product Officer at IndiQus. Kshitish has over 15 years of experience in the user experience, product management and startup domains, and has been an entrepreneur for all his career. Kshitish is also a trail and mountain athlete, and can be found exploring and mapping new trails, or running a mountain race, when not working.</div><div></div><div><span><strong>Cloud Services in the Core of a Multi-business Company - Gustavo Rossi, Esteban Tissera, Nicolas Furman</strong></span></div><div>*Pending slides.</div><a href="https://www.youtube.com/watch?v=1NLtsJtV3xk&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=26" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/79033ade-81a3-4bc2-a2e3-259fbaf23146" alt="Screenshot 2023-01-10 at 11.53.33.png" width="750" height="393" class="img_ev3q"></a><div><span><strong><a href="https://www.slideshare.net/ShapeBlue/block-device-performance-tuning-using-iothreads" target="_blank" rel="noopener" title="Block Device Performance Tuning Using iothreads">Block Device Performance Tuning Using iothreads</a> - Venko Moyankov</strong></span></div><div>Block device IO performance can be substantially improved by employing libvirtd iothreards to handle IO operations. In this presentation, Venko discusses the problem with poor IO performance in QEMU/KVM virtual machines and how it could be resolved using libvirtd iothreards to offload IO tasks and improve the VM stability and block IO performance.</div><a href="https://www.youtube.com/watch?v=mA0K4NcY8OA&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=27" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/e0c156ba-002d-4c25-99ba-53c1de9f297d" alt="Screenshot 2023-01-10 at 11.56.53.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/sTrbIGSVNrSpdn" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><strong>About Venko Moyankov:</strong><p>Venko Moyankov is a solution architect at StorPool Storage. He has experience with managing large virtualizations, working in telcos, designing and supporting the infrastructure of large enterprises. In the last year his focus has been in helping companies globally to build the best storage solution according to their needs and projects.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/the-curious-case-of-cloud-repatriation" target="_blank" rel="noopener" title="The Curious Case Of Cloud Repatriation">The Curious Case Of Cloud Repatriation</a> - Sunando Bhattacharya</strong></span><p>In this session, we examine how enterprises are realising that Hyperscaler clouds are not the best solution for all their cloud needs and are now repatriating a large part of their workloads to various private cloud platforms. We also examine how CloudStack is best placed to address the needs of these enterprises.</p><a href="https://www.youtube.com/watch?v=EyUeqtE9-i4&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=28" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/906ffba3-5523-4ff4-b65c-684153977ac9" alt="Screenshot 2023-01-10 at 11.59.13.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/HMm5QHTj33LbNT" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><div><strong>About Sunando Bhattacharya :</strong></div><div>Sunando is the Co-Founder and CEO at IndiQus Technologies. With over 20 years of experience in the internet, telecom and cloud domains, Sunando drives the overall business vision at IndiQus. Outside of work, Sunando is a motorcycle enthusiast who rides along the highways and high mountain roads of India.</div><div></div><div><h2><span>Day 3 Sessions:</span></h2></div><span><strong><a href="https://www.slideshare.net/ShapeBlue/whats-coming-in-cloudstack-418" target="_blank" rel="noopener" title="What&#x27;s Coming In CloudStack 4.18">What&#x27;s Coming In CloudStack 4.18</a> - Boris Stoyanov</strong></span><p>A first look at some of the work-in-progress features due in the upcoming CloudStack 4.18 release.</p><a href="https://www.youtube.com/watch?v=8Ep9_WXi10Q&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=30" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/674d0427-79b8-44bc-ae9a-660e4e70072d" alt="bobby.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/mxXDohqMIMIiLt" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><strong>About Boris Stoyanov:</strong><p>Boris is a committer and PMC at Apache CloudStack also works at ShapeBlue and is devoted to testing CloudStack.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/beating-the-hyperscalers-with-a-highperformance-costefficient-cloud-with-apiculus-and-storpool" target="_blank" rel="noopener" title="Beating The Hyperscalers With A High-performance, Cost-efficient Cloud With Apiculus And StorPool">Beating The Hyperscalers With A High-performance, Cost-efficient Cloud With Apiculus And StorPool</a> - Alex Ivanov, Sunando Bhattacharya, Kshitish Purohit</strong></span><p>Setting up and operating a public cloud that is not only hyperscale-grade, but can actually beat the hyperscalers, requires a unique combination of a high-performance, cost-efficient and UX-first approach. In this workshop, IndiQus and StorPool showcase how the Apiculus and StorPool solutions, together with CloudStack, can create that winning formula for local, domestic and regional cloud providers.</p><a href="https://www.youtube.com/watch?v=RzQRpg6HKRY&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=31" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/b3271841-0529-496e-bf4a-50297c8e79d7" alt="Screenshot 2023-01-10 at 12.05.08.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/uEZF2jj71IRVS3" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><strong>About the speakers:</strong><p>Alex Ivanov, Product Lead at StorPool Storage Alex Ivanov is the Product Lead at StorPool Storage and is responsible for the product strategy and tactics at the company. He has experience in the storage market and a deep understanding of the needs and priorities of businesses managing large-scale clouds to run diverse, mission-critical workloads. At StorPool, he works closely with the team to evolve the StorPool primary storage platform and expand its capabilities and usefulness for various use cases. His goal - ensure StorPool cost-effectively delivers above and beyond what is possible with other primary storage products to help customers achieve their commercial and technical goals. Venko Moyankov, Solutions Architect at StorPool Storage Venko Moyankov is the Solutions Lead at StorPool Storage, a fully managed data storage solution that transforms commodity hardware into a shared, powerful, highly available, and reliable storage system. He has experience with managing large virtualizations, working in telcos, designing and supporting the infrastructure of large enterprises. In the last year his focus has been in helping companies globally to build the best storage solution according to their needs and projects.</p><p>Sunando is the Co-Founder and CEO at IndiQus Technologies. With over 20 years of experience in the internet, telecom and cloud domains, Sunando drives the overall business vision at IndiQus. Outside of work, Sunando is a motorcycle enthusiast who rides along the highways and high mountain roads of India.</p><p>Kshitish is the Co-Founder and Chief Product Officer at IndiQus. Kshitish has over 15 years of experience in the user experience, product management and startup domains, and has been an entrepreneur for all his career. Kshitish is also a trail and mountain athlete, and can be found exploring and mapping new trails, or running a mountain race, when not working.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/ui-test-cases-with-cloudstack" target="_blank" rel="noopener" title="UI Test Cases With CloudStack">UI Test Cases With CloudStack</a> - Magali Pervan, Navid Abdoul</strong></span><p>Each CloudStack update is a critical process to prevent production issues. At DIMSI, we aim to reduce downtimes and regressions as much as possible for our end users. We are now implementing automated UI Tests to cover all main use cases whenever a new release is published. Navid and Magali give an overview of how it is being done, and the next steps, including potential integration inside the code project.</p><a href="https://www.youtube.com/watch?v=0IckKZK7_YA&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=32" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/36d7634f-ad64-49e2-bb9d-0909bb28ae80" alt="magali.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/NMQzpIKDQ6fwVs" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start"></span> </iframe><div><strong>About the speakers:</strong></div><div>Magali Pervan - Senior Scrumaster, DIMSI partner, Magali is in charge of agility at DIMSI. She helps all project teams to work together in a smooth and efficient atmosphere When not delivering projects on track and on time, she loves traveling around the world to discover other cultures.</div><div><p>Navid Abdoul - Junior platform engineer, Navid joined DIMSI last summer to help us provide maximum performance and uptime to our customers He is dedicated to guaranteeing fast and reliable customer VM’s backup When not playing with video games, Navid is watching action movies.</p></div><span><strong><a href="https://www.slideshare.net/ShapeBlue/using-ai-to-place-vms-on-hypervisors" target="_blank" rel="noopener" title="Using AI To Place VMs On Hypervisors">Using AI To Place VMs On Hypervisors</a> - Sina Kashipazha</strong></span><p>CloudStack’s VM placement policies don’t fit the current need of the industry. We have to create external tools to load balance VMs on hosts. We have an idea (which is under heavy development) to implement an AI algorithm to manage VM placement on a host. The algorithm is triggered based on a criteria (like when there is no place for a VM with 64G Ram and 32 core), which results in changing the placement of the VMs on a system.</p><a href="https://www.youtube.com/watch?v=Cd00S3d5rBY&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=33" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/7afccd2a-544a-479e-be58-e22e9e5de427" alt="sina.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/asGCivOi2s0RC2" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start"></span> </iframe><strong>About Sina Kashipazha:</strong><p>y name is Sina, I&#x27;m a software engineer with a passion for distributed applications, computer networks, and the cloud. To turn my passion into a career, I joined Computer Network Lab at my university as a research assistant and developed various network and cloud tools. After that, I joined the LeaseWeb company to expand my knowledge of complex production cloud environments. Currently, I am the Software Engineer in the CloudStack team of LeaseWeb. I’m responsible for all the infrastructure and management tasks for our public and private cloud, which runs in 8 regions in 7 different countries on 3 different continents.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/upgrading-from-rovius-cloudplatform-to-apache-cloudstack" target="_blank" rel="noopener" title="Upgrading From Rovius CloudPlatform to Apache CloudStack">Upgrading From Rovius CloudPlatform to Apache CloudStack</a> - Andrija Panic</strong></span><p>As many organizations prefer the freedom of open-source Apache CloudStack to commercial distributions, the need to migrate seamlessly to CloudStack is increasing. In this practical, demo-led talk, Andrija will look at the steps required to make a reliable migration from Accelerite’s Rovius Cloud platform to Apache CloudStack.</p><a href="https://www.youtube.com/watch?v=dJEf3y-embs&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=34" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/ba53e1d0-ddfd-4162-9b5a-4d82a43bab90" alt="andrija.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/3sXvumVhWR3jaJ" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><strong>About Andrija Panic:</strong><p>Andrija Panic is a Cloud Architect at ShapeBlue, the Cloud Specialists, and is a committer and PMC member of Apache CloudStack. Andrija spends most of his time designing and implementing IaaS solutions based on Apache CloudStack.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/nextgen-virtual-routers-and-zero-downtime-upgrades" target="_blank" rel="noopener" title="Next-Gen Virtual Routers And Zero Downtime Upgrades">Next-Gen Virtual Routers And Zero Downtime Upgrades</a> - Rohit Yadav</strong></span><p>CloudStack 4.17 finally reached a point where upgrades can be performed with zero network downtime. In this talk, Rohit:</p><p>– looks at the history of CloudStack virtual router upgrades and how they have evolved towards this point</p><p>– looks in detail at the new “Live patching” functionality in CloudStack 4.17 which enables zero downtime upgrades</p><p>– discusses the limitations of the new functionality</p><p>– demo&#x27;s the new upgrade process</p><p>The talk also discusses the design and implementation of other recent changes in the virtual router, such as:</p><p>– systemvmtemplate improvements</p><p>– turn-key bundling of systemvmtemplates for automatic setup and upgrades</p><p>– deprecation of systemvm.iso</p><p>And discusses the future roadmap of VR and related next-gen networking features, the new VR agent and further improvements.</p><a href="https://www.youtube.com/watch?v=NFphf0CyBYs&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=35" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/a5a969e5-4a6d-4fb3-b64a-e4be2e33e8b7" alt="rohit.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/oPPmy5LD2IyGP8" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start"></span> </iframe><strong>About Rohit Yadav:</strong><p>Rohit Yadav is a committer and PMC member of Apache CloudStack project, and oversees the Software Engineering function at ShapeBlue, providing leadership and mentorship to our ever-growing Engineering Team.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/news-and-development-update-of-the-cloudstack-tungsten-fabric-sdn-plugin" target="_blank" rel="noopener" title="News And Development Update Of The CloudStack Tungsten Fabric SDN Plug-in">News And Development Update Of The CloudStack Tungsten Fabric SDN Plug-in</a> - Sven Vogel, Huy Le Minh</strong></span><p>This talk involved a demo of the Tungsten Fabric Plugin and details what the important features are.</p><a href="https://www.youtube.com/watch?v=AHWH-kZmjfU&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=36" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/8fffab61-bb89-44b3-b934-e1670583eb4b" alt="sven.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/i8jygpf535JEVv" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><strong>About Sven Vogel:</strong><p>Sven Vogel is a German IT-Specialist with 15+ years experience in IT and member of the Apache Software Foundation. Before he got invited to join the mother foundation, he has been the Chairman / VP of Apache CloudStack and an active Committer for a few years. He is well-known for driving various projects and supporting everyone who needs technological exchange, advise or upskilling. His interest in cloud-technologies is both - his professional and personal passion and he looks forward meeting you to talk about why system-relevant institutions need our help as open source technologists.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/adding-new-data-sources-and-resources-to-cloudstack-terraform-provider" target="_blank" rel="noopener" title="Adding New Data Sources And Resources To CloudStack Terraform Provider">Adding New Data Sources And Resources To CloudStack Terraform Provider</a> - Daman Arora</strong></span><p>As of today, CloudStack-Terraform Provider v0.4.0 supports 25 resource types, and 1 data source type. It is the first release of CloudStack’s own provider, named CloudStack-Terraform Provider. The following link provides a complete list of Resources and Data Sources: <a href="https://registry.terraform.io/providers/cloudstack/cloudstack/latest/docs" target="_blank" rel="noopener noreferrer">https://registry.terraform.io/providers/cloudstack/cloudstack/latest/docs</a> I am a GSoC contributor for 2022 and am extending the list of Terraform Data Sources and Resources offered by CloudStack Terraform. I am currently working on the following project: CloudStack Terraform Provider – Add datasources for the existing resources <a href="https://summerofcode.withgoogle.com/programs/2022/projects/ZVraist1" target="_blank" rel="noopener noreferrer">https://summerofcode.withgoogle.com/programs/2022/projects/ZVraist1</a> I would like to present a tutorial/workshop as a knowledge transfer session. As CloudStack continues to grow in terms of resources, an explanation of how to extend Terraform provider will be beneficial to anyone who is interested in this area. In addition, I will share technical details regarding the provider during the presentation.</p><a href="https://www.youtube.com/watch?v=WdA2epTfu7k&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=37" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/0342b432-2672-49e4-bbd7-7578536d720a" alt="Daman.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/f8FIToyKAkVfCD" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start">﻿</span> </iframe><div><strong>About Daman Arora:</strong></div><div>Daman Arora is a GSoC 2022 student, as well as an Apache CloudStack Contributor.</div><div></div><div><span><strong><a href="https://www.slideshare.net/ShapeBlue/productize-invoice-cloudstack-usage" target="_blank" rel="noopener" title="Productize &amp; Invoice CloudStack Usage">Productize &amp; Invoice CloudStack Usage</a> - Will Stevens, Daniel Murray</strong></span></div><div>CloudMC is an edge orchestration platform which allows for the productization of backend services, such as Apache CloudStack. In this presentation, Will and Daniel demonstrate the use of CloudMC’s integration with CloudStack to deliver a suite of monetised self-serve products. The demo includes; pricing, taxation, invoicing, and credit card payments, along with extensive reporting capabilities.</div><a href="https://www.youtube.com/watch?v=szYm6P1DKdM&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=38" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/41ba68f1-b97c-4720-b290-019401fd48c4" alt="Will.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/ctlYOgQfCjwGTO" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start"></span> </iframe><strong>About the speakers:</strong><p>Will Stevens is CloudOps&#x27; CTO and has been involved in CloudStack for many years. He was much more active in previous years, as the ACS VP and release manager, and still remains on the PMC.</p><p>Daniel Murray is a Developer at CloudOps and is focused on the CloudMC product. He has worked on the integration between Apache CloudStack and CloudMC.</p><span><strong><a href="https://www.slideshare.net/ShapeBlue/stackbill-simplified-cloud-management-platform" target="_blank" rel="noopener" title="StackBill - Simplified Cloud Management Platform">StackBill - Simplified Cloud Management Platform</a> - Rafi Md</strong></span><p>In this talk, Rafi shares the vision of StackBill and how they simplified cloud management with Apache CloudStack. Key challenges of Datacenters on becoming a Cloud Datacenter and how stackbill solves it. New Features of StackBill added 2022 which would help datacenter, enterprises and telcos on measuring and maximizing their business.</p><a href="https://www.youtube.com/watch?v=avGJLrOCVu0&amp;list=PLnIKk7GjgFlYcKNbhYSgWGbJ8nJ0g496V&amp;index=39" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/4f33a5fd-515f-4b21-8500-0e1bdfe9b264" alt="Rafi.png" width="750" height="393" class="img_ev3q"></a><iframe src="https://www.slideshare.net/slideshow/embed_code/key/BTGbkhqCpZgY8d" width="854" height="712" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"><span data-mce-type="bookmark" class="mce_SELRES_start"></span> </iframe><div><strong>About Rafi Md:</strong><p>Rafi joined Assistanz Networks Pvt. Ltd. as a Sales Associate in 2005 and is now serving as a Marketing Director at Assistanz. Founder - Inway Communications (<a href="http://www.Inway.in" target="_blank" rel="noopener noreferrer">www.Inway.in</a>) serving PAN India since 2008 and India&#x27;s First Certified Guerrilla Marketer <!-- -->&amp;<!-- --> Coach, Digital Marketer <!-- -->&amp;<!-- --> Certified Trainer. Head of Global Marketing of StackBill.com - A Cloud Management Platform.</p><p>While serving Assistanz - assisted Datacenters over USA, UK, Switzerland, UAE, Australia, Italy and Canada on their Sales, Marketing <!-- -->&amp;<!-- --> operations from India. Had done various projects for Corporate in advance strategies of Online Marketing, Sales and marketing automation. Completely passionate about Domains, Websites and Online Marketing.</p></div></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/news">news</a></li></ul></div><div class="col margin-top--sm"><a href="https://github.com/apache/cloudstack-www/tree/main/blog/2022-11-30-cloudstack-collaboration-conference-2022-roundup.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-use-cases-benefits"><div class="pagination-nav__sublabel">Newer Post</div><div class="pagination-nav__label">Apache CloudStack Use Cases, Benefits and its Projected Future</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/blog/cloudstack-integrations-storpool-storage"><div class="pagination-nav__sublabel">Older Post</div><div class="pagination-nav__label">CloudStack Integrations: StorPool Storage - High-performance primary storage platform</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.60ecdf28.js"></script>
<script src="/assets/js/main.2d60fa8d.js"></script>
</body>
</html>